From 479c056b2cd7ece5dfdd030d9588a9428e6c3bd6 Mon Sep 17 00:00:00 2001 From: Joshua Warner Date: Thu, 1 May 2014 12:44:42 -0600 Subject: [PATCH] move Compiler::Operand to ir::Value --- include/avian/codegen/compiler.h | 122 +++++---- include/avian/codegen/ir.h | 9 + src/codegen/compiler.cpp | 115 +++++---- src/codegen/compiler/value.cpp | 2 +- src/codegen/compiler/value.h | 6 +- src/compile.cpp | 425 ++++++++++++++++--------------- 6 files changed, 351 insertions(+), 328 deletions(-) diff --git a/include/avian/codegen/compiler.h b/include/avian/codegen/compiler.h index e83e00a9f0..a86b8cb309 100644 --- a/include/avian/codegen/compiler.h +++ b/include/avian/codegen/compiler.h @@ -40,15 +40,6 @@ class Compiler { static const unsigned TailJump = 1 << 2; static const unsigned LongJumpOrCall = 1 << 3; - class Operand { - public: - ir::Type type; - - Operand(ir::Type type) : type(type) - { - } - }; - class State { }; class Subroutine { }; @@ -56,8 +47,8 @@ class Compiler { virtual void restoreState(State* state) = 0; virtual Subroutine* startSubroutine() = 0; - virtual void returnFromSubroutine(Subroutine* subroutine, Operand* address) - = 0; + virtual void returnFromSubroutine(Subroutine* subroutine, ir::Value* address) + = 0; virtual void linkSubroutine(Subroutine* subroutine) = 0; virtual void init(unsigned logicalCodeSize, unsigned parameterFootprint, @@ -71,83 +62,84 @@ class Compiler { virtual Promise* poolAppend(intptr_t value) = 0; virtual Promise* poolAppendPromise(Promise* value) = 0; - virtual Operand* constant(int64_t value, ir::Type type) = 0; - virtual Operand* promiseConstant(Promise* value, ir::Type type) = 0; - virtual Operand* address(ir::Type type, Promise* address) = 0; - virtual Operand* memory(Operand* base, - ir::Type type, - int displacement = 0, - Operand* index = 0) = 0; + virtual ir::Value* constant(int64_t value, ir::Type type) = 0; + virtual ir::Value* promiseConstant(Promise* value, ir::Type type) = 0; + virtual ir::Value* address(ir::Type type, Promise* address) = 0; + virtual ir::Value* memory(ir::Value* base, + ir::Type type, + int displacement = 0, + ir::Value* index = 0) = 0; - virtual Operand* threadRegister() = 0; + virtual ir::Value* threadRegister() = 0; - virtual void push(ir::Type type, Operand* value) = 0; - virtual void save(ir::Type type, Operand* value) = 0; - virtual Operand* pop(ir::Type type) = 0; + virtual void push(ir::Type type, ir::Value* value) = 0; + virtual void save(ir::Type type, ir::Value* value) = 0; + virtual ir::Value* pop(ir::Type type) = 0; virtual void pushed() = 0; virtual void popped(unsigned footprint) = 0; virtual unsigned topOfStack() = 0; - virtual Operand* peek(unsigned footprint, unsigned index) = 0; + virtual ir::Value* peek(unsigned footprint, unsigned index) = 0; - virtual Operand* call(Operand* address, - unsigned flags, - TraceHandler* traceHandler, - ir::Type resultType, - unsigned argumentCount, - ...) = 0; + virtual ir::Value* call(ir::Value* address, + unsigned flags, + TraceHandler* traceHandler, + ir::Type resultType, + unsigned argumentCount, + ...) = 0; - virtual Operand* stackCall(Operand* address, - unsigned flags, - TraceHandler* traceHandler, - ir::Type resultType, - unsigned argumentFootprint) = 0; + virtual ir::Value* stackCall(ir::Value* address, + unsigned flags, + TraceHandler* traceHandler, + ir::Type resultType, + unsigned argumentFootprint) = 0; - virtual void return_(ir::Type type, Operand* value) = 0; + virtual void return_(ir::Type type, ir::Value* value) = 0; virtual void return_() = 0; virtual void initLocal(unsigned size, unsigned index, ir::Type type) = 0; virtual void initLocalsFromLogicalIp(unsigned logicalIp) = 0; - virtual void storeLocal(unsigned footprint, Operand* src, - unsigned index) = 0; - virtual Operand* loadLocal(ir::Type type, unsigned index) = 0; + virtual void storeLocal(unsigned footprint, ir::Value* src, unsigned index) + = 0; + virtual ir::Value* loadLocal(ir::Type type, unsigned index) = 0; virtual void saveLocals() = 0; - virtual void checkBounds(Operand* object, unsigned lengthOffset, - Operand* index, intptr_t handler) = 0; + virtual void checkBounds(ir::Value* object, + unsigned lengthOffset, + ir::Value* index, + intptr_t handler) = 0; - virtual Operand* truncateThenExtend(ir::SignExtendMode signExtend, - ir::Type extendType, - ir::Type truncateType, - Operand* src) = 0; + virtual ir::Value* truncateThenExtend(ir::SignExtendMode signExtend, + ir::Type extendType, + ir::Type truncateType, + ir::Value* src) = 0; - virtual void store(ir::Type srcType, - Operand* src, - Operand* dst) = 0; - virtual Operand* load(ir::SignExtendMode signExtend, - ir::Type srcType, - Operand* src, - ir::Type dstType) = 0; + virtual void store(ir::Type srcType, ir::Value* src, ir::Value* dst) = 0; + virtual ir::Value* load(ir::SignExtendMode signExtend, + ir::Type srcType, + ir::Value* src, + ir::Type dstType) = 0; virtual void condJump(lir::TernaryOperation op, ir::Type type, - Operand* a, - Operand* b, - Operand* address) = 0; + ir::Value* a, + ir::Value* b, + ir::Value* address) = 0; - virtual void jmp(Operand* address) = 0; - virtual void exit(Operand* address) = 0; + virtual void jmp(ir::Value* address) = 0; + virtual void exit(ir::Value* address) = 0; - virtual Operand* binaryOp(lir::TernaryOperation op, - ir::Type type, - Operand* a, - Operand* b) = 0; - virtual Operand* unaryOp(lir::BinaryOperation op, ir::Type type, Operand* a) - = 0; + virtual ir::Value* binaryOp(lir::TernaryOperation op, + ir::Type type, + ir::Value* a, + ir::Value* b) = 0; + virtual ir::Value* unaryOp(lir::BinaryOperation op, + ir::Type type, + ir::Value* a) = 0; virtual void nullaryOp(lir::Operation op) = 0; - virtual Operand* f2f(ir::Type aType, ir::Type resType, Operand* a) = 0; - virtual Operand* f2i(ir::Type aType, ir::Type resType, Operand* a) = 0; - virtual Operand* i2f(ir::Type aType, ir::Type resType, Operand* a) = 0; + virtual ir::Value* f2f(ir::Type aType, ir::Type resType, ir::Value* a) = 0; + virtual ir::Value* f2i(ir::Type aType, ir::Type resType, ir::Value* a) = 0; + virtual ir::Value* i2f(ir::Type aType, ir::Type resType, ir::Value* a) = 0; virtual void compile(uintptr_t stackOverflowHandler, unsigned stackLimitOffset) = 0; diff --git a/include/avian/codegen/ir.h b/include/avian/codegen/ir.h index e1870f8e57..9c84e0c782 100644 --- a/include/avian/codegen/ir.h +++ b/include/avian/codegen/ir.h @@ -115,6 +115,15 @@ class Types { enum SignExtendMode { SignExtend, ZeroExtend }; +class Value { + public: + ir::Type type; + + Value(ir::Type type) : type(type) + { + } +}; + } // namespace ir } // namespace codegen } // namespace avian diff --git a/src/codegen/compiler.cpp b/src/codegen/compiler.cpp index 86a3ffea29..6b05fed086 100644 --- a/src/codegen/compiler.cpp +++ b/src/codegen/compiler.cpp @@ -2151,7 +2151,8 @@ class MyCompiler: public Compiler { return c.subroutine = new(c.zone) MySubroutine; } - virtual void returnFromSubroutine(Subroutine* subroutine, Operand* address) { + virtual void returnFromSubroutine(Subroutine* subroutine, ir::Value* address) + { appendSaveLocals(&c); appendJump(&c, lir::Jump, static_cast(address), false, true); static_cast(subroutine)->forkState = compiler::saveState(&c); @@ -2308,25 +2309,25 @@ class MyCompiler: public Compiler { return p; } - virtual Operand* constant(int64_t value, ir::Type type) + virtual ir::Value* constant(int64_t value, ir::Type type) { return promiseConstant(resolvedPromise(&c, value), type); } - virtual Operand* promiseConstant(Promise* value, ir::Type type) + virtual ir::Value* promiseConstant(Promise* value, ir::Type type) { return compiler::value(&c, type, compiler::constantSite(&c, value)); } - virtual Operand* address(ir::Type type, Promise* address) + virtual ir::Value* address(ir::Type type, Promise* address) { return value(&c, type, compiler::addressSite(&c, address)); } - virtual Operand* memory(Operand* base, - ir::Type type, - int displacement = 0, - Operand* index = 0) + virtual ir::Value* memory(ir::Value* base, + ir::Type type, + int displacement = 0, + ir::Value* index = 0) { Value* result = value(&c, type); @@ -2340,7 +2341,7 @@ class MyCompiler: public Compiler { return result; } - virtual Operand* threadRegister() + virtual ir::Value* threadRegister() { return compiler::threadRegister(&c); } @@ -2349,7 +2350,7 @@ class MyCompiler: public Compiler { return c.logicalCode[c.logicalIp]->lastEvent->makeCodePromise(&c); } - virtual void push(ir::Type type, Operand* value) + virtual void push(ir::Type type, ir::Value* value) { // TODO: once type information is flowed properly, enable this assert. // Some time later, we can remove the parameter. @@ -2357,7 +2358,7 @@ class MyCompiler: public Compiler { compiler::push(&c, typeFootprint(&c, type), static_cast(value)); } - virtual void save(ir::Type type, Operand* value) + virtual void save(ir::Type type, ir::Value* value) { // TODO: once type information is flowed properly, enable this assert. // Some time later, we can remove the parameter. @@ -2373,9 +2374,9 @@ class MyCompiler: public Compiler { } } - virtual Operand* pop(ir::Type type) + virtual ir::Value* pop(ir::Type type) { - Operand* value = compiler::pop(&c, typeFootprint(&c, type)); + ir::Value* value = compiler::pop(&c, typeFootprint(&c, type)); // TODO: once type information is flowed properly, enable this assert. // Some time later, we can remove the parameter. // assert(&c, static_cast(value)->type == type); @@ -2409,7 +2410,8 @@ class MyCompiler: public Compiler { return c.stack->index; } - virtual Operand* peek(unsigned footprint, unsigned index) { + virtual ir::Value* peek(unsigned footprint, unsigned index) + { Stack* s = c.stack; for (unsigned i = index; i > 0; --i) { s = s->next; @@ -2445,12 +2447,12 @@ class MyCompiler: public Compiler { return s->value; } - virtual Operand* call(Operand* address, - unsigned flags, - TraceHandler* traceHandler, - ir::Type resultType, - unsigned argumentCount, - ...) + virtual ir::Value* call(ir::Value* address, + unsigned flags, + TraceHandler* traceHandler, + ir::Type resultType, + unsigned argumentCount, + ...) { va_list a; va_start(a, argumentCount); @@ -2500,11 +2502,11 @@ class MyCompiler: public Compiler { return result; } - virtual Operand* stackCall(Operand* address, - unsigned flags, - TraceHandler* traceHandler, - ir::Type resultType, - unsigned argumentFootprint) + virtual ir::Value* stackCall(ir::Value* address, + unsigned flags, + TraceHandler* traceHandler, + ir::Type resultType, + unsigned argumentFootprint) { Value* result = value(&c, resultType); appendCall(&c, @@ -2519,7 +2521,7 @@ class MyCompiler: public Compiler { return result; } - virtual void return_(ir::Type type, Operand* value) + virtual void return_(ir::Type type, ir::Value* value) { // TODO: once type information is flowed properly, enable this assert. // Some time later, we can remove the parameter. @@ -2595,11 +2597,12 @@ class MyCompiler: public Compiler { linkLocals(&c, e->locals(), newLocals); } - virtual void storeLocal(unsigned footprint, Operand* src, unsigned index) { + virtual void storeLocal(unsigned footprint, ir::Value* src, unsigned index) + { compiler::storeLocal(&c, footprint, static_cast(src), index, true); } - virtual Operand* loadLocal(ir::Type type, unsigned index) + virtual ir::Value* loadLocal(ir::Type type, unsigned index) { return compiler::loadLocal(&c, type, index); } @@ -2608,17 +2611,19 @@ class MyCompiler: public Compiler { appendSaveLocals(&c); } - virtual void checkBounds(Operand* object, unsigned lengthOffset, - Operand* index, intptr_t handler) + virtual void checkBounds(ir::Value* object, + unsigned lengthOffset, + ir::Value* index, + intptr_t handler) { appendBoundsCheck(&c, static_cast(object), lengthOffset, static_cast(index), handler); } - virtual Operand* truncateThenExtend(ir::SignExtendMode signExtend, - ir::Type extendType, - ir::Type truncateType, - Operand* src) + virtual ir::Value* truncateThenExtend(ir::SignExtendMode signExtend, + ir::Type extendType, + ir::Type truncateType, + ir::Value* src) { Value* dst = value(&c, extendType); appendMove(&c, @@ -2631,9 +2636,7 @@ class MyCompiler: public Compiler { return dst; } - virtual void store(ir::Type srcType, - Operand* src, - Operand* dst) + virtual void store(ir::Type srcType, ir::Value* src, ir::Value* dst) { assert(&c, srcType.flavor() == static_cast(src)->type.flavor()); assert(&c, srcType.flavor() == static_cast(dst)->type.flavor()); @@ -2649,10 +2652,10 @@ class MyCompiler: public Compiler { static_cast(dst)); } - virtual Operand* load(ir::SignExtendMode signExtend, - ir::Type srcType, - Operand* src, - ir::Type dstType) + virtual ir::Value* load(ir::SignExtendMode signExtend, + ir::Type srcType, + ir::Value* src, + ir::Type dstType) { assert(&c, dstType.size() >= TargetBytesPerWord); assert(&c, srcType.flavor() == dstType.flavor()); @@ -2670,9 +2673,9 @@ class MyCompiler: public Compiler { virtual void condJump(lir::TernaryOperation op, ir::Type type, - Operand* a, - Operand* b, - Operand* address) + ir::Value* a, + ir::Value* b, + ir::Value* address) { assert(&c, (isGeneralBranch(op) and isGeneralValue(a) and isGeneralValue(b))or( @@ -2692,18 +2695,20 @@ class MyCompiler: public Compiler { static_cast(address)); } - virtual void jmp(Operand* address) { + virtual void jmp(ir::Value* address) + { appendJump(&c, lir::Jump, static_cast(address)); } - virtual void exit(Operand* address) { + virtual void exit(ir::Value* address) + { appendJump(&c, lir::Jump, static_cast(address), true); } - virtual Operand* binaryOp(lir::TernaryOperation op, - ir::Type type, - Operand* a, - Operand* b) + virtual ir::Value* binaryOp(lir::TernaryOperation op, + ir::Type type, + ir::Value* a, + ir::Value* b) { assert(&c, (isGeneralBinaryOp(op) and isGeneralValue(a) and isGeneralValue(b)) @@ -2722,7 +2727,9 @@ class MyCompiler: public Compiler { return result; } - virtual Operand* unaryOp(lir::BinaryOperation op, ir::Type type, Operand* a) + virtual ir::Value* unaryOp(lir::BinaryOperation op, + ir::Type type, + ir::Value* a) { assert(&c, (isGeneralUnaryOp(op) and isGeneralValue(a))or(isFloatUnaryOp(op) @@ -2733,7 +2740,7 @@ class MyCompiler: public Compiler { return result; } - virtual Operand* f2f(ir::Type aType, ir::Type resType, Operand* a) + virtual ir::Value* f2f(ir::Type aType, ir::Type resType, ir::Value* a) { assert(&c, aType == static_cast(a)->type); assert(&c, isFloatValue(a)); @@ -2749,7 +2756,7 @@ class MyCompiler: public Compiler { return result; } - virtual Operand* f2i(ir::Type aType, ir::Type resType, Operand* a) + virtual ir::Value* f2i(ir::Type aType, ir::Type resType, ir::Value* a) { // TODO: enable when possible // assert(&c, aType == static_cast(a)->type); @@ -2766,7 +2773,7 @@ class MyCompiler: public Compiler { return result; } - virtual Operand* i2f(ir::Type aType, ir::Type resType, Operand* a) + virtual ir::Value* i2f(ir::Type aType, ir::Type resType, ir::Value* a) { // TODO: enable when possible // assert(&c, aType == static_cast(a)->type); diff --git a/src/codegen/compiler/value.cpp b/src/codegen/compiler/value.cpp index c876ff9d4c..d04d2c6e0a 100644 --- a/src/codegen/compiler/value.cpp +++ b/src/codegen/compiler/value.cpp @@ -18,7 +18,7 @@ namespace codegen { namespace compiler { Value::Value(Site* site, Site* target, ir::Type type) - : Compiler::Operand(type), + : ir::Value(type), reads(0), lastRead(0), sites(site), diff --git a/src/codegen/compiler/value.h b/src/codegen/compiler/value.h index 4efe689605..3eaed04fa7 100644 --- a/src/codegen/compiler/value.h +++ b/src/codegen/compiler/value.h @@ -26,7 +26,7 @@ const int NoFrameIndex = -1; const bool DebugSites = false; -class Value: public Compiler::Operand { +class Value : public ir::Value { public: Read* reads; Read* lastRead; @@ -66,12 +66,12 @@ class Value: public Compiler::Operand { }; -inline bool isFloatValue(Compiler::Operand* a) +inline bool isFloatValue(ir::Value* a) { return static_cast(a)->type.flavor() == ir::Type::Float; } -inline bool isGeneralValue(Compiler::Operand* a) +inline bool isGeneralValue(ir::Value* a) { return !isFloatValue(a); } diff --git a/src/compile.cpp b/src/compile.cpp index 071664717d..6d156e9083 100644 --- a/src/compile.cpp +++ b/src/compile.cpp @@ -1331,18 +1331,19 @@ translateLocalIndex(Context* context, unsigned footprint, unsigned index) } } -Compiler::Operand* loadLocal(Context* context, - unsigned footprint, - ir::Type type, - unsigned index) +ir::Value* loadLocal(Context* context, + unsigned footprint, + ir::Type type, + unsigned index) { return context->compiler->loadLocal( type, translateLocalIndex(context, footprint, index)); } -void -storeLocal(Context* context, unsigned footprint, Compiler::Operand* value, - unsigned index) +void storeLocal(Context* context, + unsigned footprint, + ir::Value* value, + unsigned index) { context->compiler->storeLocal (footprint, value, translateLocalIndex(context, footprint, index)); @@ -1358,8 +1359,6 @@ class Frame { Object }; - typedef Compiler::Operand* Value; - Frame(Context* context, uint8_t* stackMap) : context(context), t(context->thread), @@ -1399,11 +1398,12 @@ class Frame { void dispose() { if (level > 1) { - context->eventLog.append(PopContextEvent); + context->eventLog.append(PopContextEvent); } } - Value append(object o) { + ir::Value* append(object o) + { BootContext* bc = context->bootContext; if (bc) { avian::codegen::Promise* p = new (bc->zone) avian::codegen::ListenPromise(t->m->system, bc->zone); @@ -1637,11 +1637,13 @@ class Frame { } } - Value addressOperand(avian::codegen::Promise* p) { + ir::Value* addressOperand(avian::codegen::Promise* p) + { return c->promiseConstant(p, types.address); } - Value absoluteAddressOperand(avian::codegen::Promise* p) { + ir::Value* absoluteAddressOperand(avian::codegen::Promise* p) + { return context->bootContext ? c->binaryOp( lir::Add, @@ -1658,7 +1660,8 @@ class Frame { : addressOperand(p); } - Value machineIp(unsigned logicalIp) { + ir::Value* machineIp(unsigned logicalIp) + { return c->promiseConstant(c->machineIp(logicalIp), types.address); } @@ -1682,35 +1685,40 @@ class Frame { this->ip = ip; } - void pushQuiet(ir::Type type, Value o) + void pushQuiet(ir::Type type, ir::Value* o) { c->push(type, o); } - void pushLongQuiet(Value o) { + void pushLongQuiet(ir::Value* o) + { pushQuiet(types.i8, o); } - Value popQuiet(ir::Type type) + ir::Value* popQuiet(ir::Type type) { return c->pop(type); } - Value popLongQuiet() { + ir::Value* popLongQuiet() + { return popQuiet(types.i8); } - void pushInt(Value o) { + void pushInt(ir::Value* o) + { pushQuiet(types.i4, o); pushedInt(); } - void pushAddress(Value o) { + void pushAddress(ir::Value* o) + { pushQuiet(types.i4, o); pushedInt(); } - void pushObject(Value o) { + void pushObject(ir::Value* o) + { assert(t, o->type == types.object || o->type.flavor() == ir::Type::Address); pushQuiet(types.object, o); pushedObject(); @@ -1722,7 +1730,8 @@ class Frame { pushedObject(); } - void pushLong(Value o) { + void pushLong(ir::Value* o) + { pushLongQuiet(o); pushedLong(); } @@ -1732,17 +1741,20 @@ class Frame { c->popped(count); } - Value popInt() { + ir::Value* popInt() + { poppedInt(); return popQuiet(types.i4); } - Value popLong() { + ir::Value* popLong() + { poppedLong(); return popLongQuiet(); } - - Value popObject() { + + ir::Value* popObject() + { poppedObject(); return popQuiet(types.object); } @@ -1798,8 +1810,8 @@ class Frame { } void dupX1() { - Value s0 = popQuiet(types.i4); - Value s1 = popQuiet(types.i4); + ir::Value* s0 = popQuiet(types.i4); + ir::Value* s1 = popQuiet(types.i4); pushQuiet(types.i4, s0); pushQuiet(types.i4, s1); @@ -1809,17 +1821,17 @@ class Frame { } void dupX2() { - Value s0 = popQuiet(types.i4); + ir::Value* s0 = popQuiet(types.i4); if (get(sp - 2) == Long) { - Value s1 = popLongQuiet(); + ir::Value* s1 = popLongQuiet(); pushQuiet(types.i4, s0); pushLongQuiet(s1); pushQuiet(types.i4, s0); } else { - Value s1 = popQuiet(types.i4); - Value s2 = popQuiet(types.i4); + ir::Value* s1 = popQuiet(types.i4); + ir::Value* s2 = popQuiet(types.i4); pushQuiet(types.i4, s0); pushQuiet(types.i4, s2); @@ -1834,8 +1846,8 @@ class Frame { if (get(sp - 1) == Long) { pushLongQuiet(c->peek(2, 0)); } else { - Value s0 = popQuiet(types.i4); - Value s1 = popQuiet(types.i4); + ir::Value* s0 = popQuiet(types.i4); + ir::Value* s1 = popQuiet(types.i4); pushQuiet(types.i4, s1); pushQuiet(types.i4, s0); @@ -1848,16 +1860,16 @@ class Frame { void dup2X1() { if (get(sp - 1) == Long) { - Value s0 = popLongQuiet(); - Value s1 = popQuiet(types.i4); + ir::Value* s0 = popLongQuiet(); + ir::Value* s1 = popQuiet(types.i4); pushLongQuiet(s0); pushQuiet(types.i4, s1); pushLongQuiet(s0); } else { - Value s0 = popQuiet(types.i4); - Value s1 = popQuiet(types.i4); - Value s2 = popQuiet(types.i4); + ir::Value* s0 = popQuiet(types.i4); + ir::Value* s1 = popQuiet(types.i4); + ir::Value* s2 = popQuiet(types.i4); pushQuiet(types.i4, s1); pushQuiet(types.i4, s0); @@ -1871,17 +1883,17 @@ class Frame { void dup2X2() { if (get(sp - 1) == Long) { - Value s0 = popLongQuiet(); + ir::Value* s0 = popLongQuiet(); if (get(sp - 3) == Long) { - Value s1 = popLongQuiet(); + ir::Value* s1 = popLongQuiet(); pushLongQuiet(s0); pushLongQuiet(s1); pushLongQuiet(s0); } else { - Value s1 = popQuiet(types.i4); - Value s2 = popQuiet(types.i4); + ir::Value* s1 = popQuiet(types.i4); + ir::Value* s2 = popQuiet(types.i4); pushLongQuiet(s0); pushQuiet(types.i4, s2); @@ -1889,10 +1901,10 @@ class Frame { pushLongQuiet(s0); } } else { - Value s0 = popQuiet(types.i4); - Value s1 = popQuiet(types.i4); - Value s2 = popQuiet(types.i4); - Value s3 = popQuiet(types.i4); + ir::Value* s0 = popQuiet(types.i4); + ir::Value* s1 = popQuiet(types.i4); + ir::Value* s2 = popQuiet(types.i4); + ir::Value* s3 = popQuiet(types.i4); pushQuiet(types.i4, s1); pushQuiet(types.i4, s0); @@ -1906,8 +1918,8 @@ class Frame { } void swap() { - Value s0 = popQuiet(types.i4); - Value s1 = popQuiet(types.i4); + ir::Value* s0 = popQuiet(types.i4); + ir::Value* s1 = popQuiet(types.i4); pushQuiet(types.i4, s0); pushQuiet(types.i4, s1); @@ -3065,9 +3077,10 @@ resultSize(MyThread* t, unsigned code) } } -void -pushReturnValue(MyThread* t, Frame* frame, unsigned code, - Compiler::Operand* result) +void pushReturnValue(MyThread* t, + Frame* frame, + unsigned code, + ir::Value* result) { switch (code) { case ByteField: @@ -3090,8 +3103,7 @@ pushReturnValue(MyThread* t, Frame* frame, unsigned code, } } -Compiler::Operand* -popField(MyThread* t, Frame* frame, int code) +ir::Value* popField(MyThread* t, Frame* frame, int code) { switch (code) { case ByteField: @@ -3169,12 +3181,12 @@ void compileSafePoint(MyThread* t, Compiler* c, Frame* frame) { c->threadRegister()); } -Compiler::Operand* compileDirectInvoke(MyThread* t, - Frame* frame, - object target, - bool tailCall, - bool useThunk, - avian::codegen::Promise* addressPromise) +ir::Value* compileDirectInvoke(MyThread* t, + Frame* frame, + object target, + bool tailCall, + bool useThunk, + avian::codegen::Promise* addressPromise) { avian::codegen::Compiler* c = frame->c; ir::Types types(TargetBytesPerWord); @@ -3205,7 +3217,7 @@ Compiler::Operand* compileDirectInvoke(MyThread* t, (frame->context->zone.allocate(sizeof(TraceElementPromise))) TraceElementPromise(t->m->system, trace); - Compiler::Operand* result = c->stackCall( + ir::Value* result = c->stackCall( c->promiseConstant(returnAddressPromise, types.address), flags, trace, @@ -3233,7 +3245,7 @@ Compiler::Operand* compileDirectInvoke(MyThread* t, methodParameterFootprint(t, target)); } } else { - Compiler::Operand* address + ir::Value* address = (addressPromise ? c->promiseConstant(addressPromise, types.address) : c->constant(methodAddress(t, target), types.address)); @@ -3253,7 +3265,7 @@ compileDirectInvoke(MyThread* t, Frame* frame, object target, bool tailCall) { unsigned rSize = resultSize(t, methodReturnCode(t, target)); - Compiler::Operand* result = 0; + ir::Value* result = 0; // don't bother calling an empty method unless calling it might // cause the class to be initialized, which may have side effects @@ -3319,9 +3331,12 @@ methodReferenceReturnCode(Thread* t, object reference) return returnCode; } -void -compileReferenceInvoke(MyThread* t, Frame* frame, Compiler::Operand* method, - object reference, bool isStatic, bool tailCall) +void compileReferenceInvoke(MyThread* t, + Frame* frame, + ir::Value* method, + object reference, + bool isStatic, + bool tailCall) { unsigned parameterFootprint = methodReferenceParameterFootprint(t, reference, isStatic); @@ -3330,12 +3345,12 @@ compileReferenceInvoke(MyThread* t, Frame* frame, Compiler::Operand* method, unsigned rSize = resultSize(t, returnCode); - Compiler::Operand* result = frame->c->stackCall - (method, - tailCall ? Compiler::TailJump : 0, - frame->trace(0, 0), - operandTypeForFieldCode(t, returnCode), - parameterFootprint); + ir::Value* result + = frame->c->stackCall(method, + tailCall ? Compiler::TailJump : 0, + frame->trace(0, 0), + operandTypeForFieldCode(t, returnCode), + parameterFootprint); frame->pop(parameterFootprint); @@ -3369,9 +3384,11 @@ compileDirectReferenceInvoke(MyThread* t, Frame* frame, Thunk thunk, tailCall); } -void -compileAbstractInvoke(MyThread* t, Frame* frame, Compiler::Operand* method, - object target, bool tailCall) +void compileAbstractInvoke(MyThread* t, + Frame* frame, + ir::Value* method, + object target, + bool tailCall) { unsigned parameterFootprint = methodParameterFootprint(t, target); ir::Types types(TargetBytesPerWord); @@ -3380,12 +3397,12 @@ compileAbstractInvoke(MyThread* t, Frame* frame, Compiler::Operand* method, unsigned rSize = resultSize(t, returnCode); - Compiler::Operand* result = frame->c->stackCall - (method, - tailCall ? Compiler::TailJump : 0, - frame->trace(0, 0), - operandTypeForFieldCode(t, returnCode), - parameterFootprint); + ir::Value* result + = frame->c->stackCall(method, + tailCall ? Compiler::TailJump : 0, + frame->trace(0, 0), + operandTypeForFieldCode(t, returnCode), + parameterFootprint); frame->pop(parameterFootprint); @@ -3422,7 +3439,7 @@ handleMonitorEvent(MyThread* t, Frame* frame, intptr_t function) object method = frame->context->method; if (methodFlags(t, method) & ACC_SYNCHRONIZED) { - Compiler::Operand* lock; + ir::Value* lock; if (methodFlags(t, method) & ACC_STATIC) { PROTECT(t, method); @@ -3601,8 +3618,8 @@ bool integerBranch(MyThread* t, object code, unsigned& ip, ir::Type type, - Compiler::Operand* a, - Compiler::Operand* b, + ir::Value* a, + ir::Value* b, unsigned* newIpp) { if (ip + 3 > codeLength(t, code)) { @@ -3614,8 +3631,8 @@ bool integerBranch(MyThread* t, uint32_t offset = codeReadInt16(t, code, ip); uint32_t newIp = (ip - 3) + offset; assert(t, newIp < codeLength(t, code)); - - Compiler::Operand* target = frame->machineIp(newIp); + + ir::Value* target = frame->machineIp(newIp); switch (instruction) { case ifeq: @@ -3680,8 +3697,8 @@ bool floatBranch(MyThread* t, unsigned& ip, ir::Type type, bool lessIfUnordered, - Compiler::Operand* a, - Compiler::Operand* b, + ir::Value* a, + ir::Value* b, unsigned* newIpp) { if (ip + 3 > codeLength(t, code)) { @@ -3693,8 +3710,8 @@ bool floatBranch(MyThread* t, uint32_t offset = codeReadInt16(t, code, ip); uint32_t newIp = (ip - 3) + offset; assert(t, newIp < codeLength(t, code)); - - Compiler::Operand* target = frame->machineIp(newIp); + + ir::Value* target = frame->machineIp(newIp); switch (instruction) { case ifeq: @@ -3719,8 +3736,7 @@ bool floatBranch(MyThread* t, return true; } -Compiler::Operand* -popLongAddress(Frame* frame) +ir::Value* popLongAddress(Frame* frame) { ir::Types types(TargetBytesPerWord); return TargetBytesPerWord == 8 ? frame->popLong() @@ -3766,7 +3782,7 @@ intrinsic(MyThread* t, Frame* frame, object target) if (MATCH(methodName(t, target), "getByte") and MATCH(methodSpec(t, target), "(J)B")) { - Compiler::Operand* address = popLongAddress(frame); + ir::Value* address = popLongAddress(frame); frame->popObject(); frame->pushInt(c->load(ir::SignExtend, types.i1, @@ -3776,8 +3792,8 @@ intrinsic(MyThread* t, Frame* frame, object target) } else if (MATCH(methodName(t, target), "putByte") and MATCH(methodSpec(t, target), "(JB)V")) { - Compiler::Operand* value = frame->popInt(); - Compiler::Operand* address = popLongAddress(frame); + ir::Value* value = frame->popInt(); + ir::Value* address = popLongAddress(frame); frame->popObject(); c->store(types.address, value, c->memory(address, types.i1)); return true; @@ -3786,7 +3802,7 @@ intrinsic(MyThread* t, Frame* frame, object target) or (MATCH(methodName(t, target), "getChar") and MATCH(methodSpec(t, target), "(J)C"))) { - Compiler::Operand* address = popLongAddress(frame); + ir::Value* address = popLongAddress(frame); frame->popObject(); frame->pushInt(c->load(ir::SignExtend, types.i2, @@ -3798,8 +3814,8 @@ intrinsic(MyThread* t, Frame* frame, object target) or (MATCH(methodName(t, target), "putChar") and MATCH(methodSpec(t, target), "(JC)V"))) { - Compiler::Operand* value = frame->popInt(); - Compiler::Operand* address = popLongAddress(frame); + ir::Value* value = frame->popInt(); + ir::Value* address = popLongAddress(frame); frame->popObject(); c->store(types.address, value, c->memory(address, types.i2)); return true; @@ -3808,7 +3824,7 @@ intrinsic(MyThread* t, Frame* frame, object target) or (MATCH(methodName(t, target), "getFloat") and MATCH(methodSpec(t, target), "(J)F"))) { - Compiler::Operand* address = popLongAddress(frame); + ir::Value* address = popLongAddress(frame); frame->popObject(); frame->pushInt( c->load(ir::SignExtend, @@ -3823,8 +3839,8 @@ intrinsic(MyThread* t, Frame* frame, object target) or (MATCH(methodName(t, target), "putFloat") and MATCH(methodSpec(t, target), "(JF)V"))) { - Compiler::Operand* value = frame->popInt(); - Compiler::Operand* address = popLongAddress(frame); + ir::Value* value = frame->popInt(); + ir::Value* address = popLongAddress(frame); frame->popObject(); ir::Type type = MATCH(methodName(t, target), "putInt") ? types.i4 : types.f4; @@ -3835,7 +3851,7 @@ intrinsic(MyThread* t, Frame* frame, object target) or (MATCH(methodName(t, target), "getDouble") and MATCH(methodSpec(t, target), "(J)D"))) { - Compiler::Operand* address = popLongAddress(frame); + ir::Value* address = popLongAddress(frame); frame->popObject(); frame->pushLong( c->load(ir::SignExtend, @@ -3850,8 +3866,8 @@ intrinsic(MyThread* t, Frame* frame, object target) or (MATCH(methodName(t, target), "putDouble") and MATCH(methodSpec(t, target), "(JD)V"))) { - Compiler::Operand* value = frame->popLong(); - Compiler::Operand* address = popLongAddress(frame); + ir::Value* value = frame->popLong(); + ir::Value* address = popLongAddress(frame); frame->popObject(); ir::Type type = MATCH(methodName(t, target), "putLong") ? types.i8 : types.f8; @@ -3860,7 +3876,7 @@ intrinsic(MyThread* t, Frame* frame, object target) } else if (MATCH(methodName(t, target), "getAddress") and MATCH(methodSpec(t, target), "(J)J")) { - Compiler::Operand* address = popLongAddress(frame); + ir::Value* address = popLongAddress(frame); frame->popObject(); frame->pushLong(c->load(ir::SignExtend, types.address, @@ -3870,8 +3886,8 @@ intrinsic(MyThread* t, Frame* frame, object target) } else if (MATCH(methodName(t, target), "putAddress") and MATCH(methodSpec(t, target), "(JJ)V")) { - Compiler::Operand* value = frame->popLong(); - Compiler::Operand* address = popLongAddress(frame); + ir::Value* value = frame->popLong(); + ir::Value* address = popLongAddress(frame); frame->popObject(); c->store(types.i8, value, c->memory(address, types.address)); return true; @@ -3949,18 +3965,18 @@ class SwitchState { SwitchState(Compiler::State* state, unsigned count, unsigned defaultIp, - Compiler::Operand* key, + ir::Value* key, avian::codegen::Promise* start, int bottom, - int top): - state(state), - count(count), - defaultIp(defaultIp), - key(key), - start(start), - bottom(bottom), - top(top), - index(0) + int top) + : state(state), + count(count), + defaultIp(defaultIp), + key(key), + start(start), + bottom(bottom), + top(top), + index(0) { } Frame* frame() { @@ -3976,7 +3992,7 @@ class SwitchState { Compiler::State* state; unsigned count; unsigned defaultIp; - Compiler::Operand* key; + ir::Value* key; avian::codegen::Promise* start; int bottom; int top; @@ -4102,8 +4118,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, case iaload: case laload: case saload: { - Compiler::Operand* index = frame->popInt(); - Compiler::Operand* array = frame->popObject(); + ir::Value* index = frame->popInt(); + ir::Value* array = frame->popObject(); if (inTryBlock(t, code, ip - 1)) { c->saveLocals(); @@ -4189,7 +4205,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, case iastore: case lastore: case sastore: { - Compiler::Operand* value; + ir::Value* value; if (instruction == dastore or instruction == lastore) { value = frame->popLong(); } else if (instruction == aastore) { @@ -4198,8 +4214,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, value = frame->popInt(); } - Compiler::Operand* index = frame->popInt(); - Compiler::Operand* array = frame->popObject(); + ir::Value* index = frame->popInt(); + ir::Value* array = frame->popObject(); if (inTryBlock(t, code, ip - 1)) { c->saveLocals(); @@ -4303,7 +4319,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, object class_ = resolveClassInPool(t, context->method, index - 1, false); - Compiler::Operand* length = frame->popInt(); + ir::Value* length = frame->popInt(); object argument; Thunk thunk; @@ -4359,7 +4375,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, break; case athrow: { - Compiler::Operand* target = frame->popObject(); + ir::Value* target = frame->popObject(); c->call(c->constant(getThunk(t, throw_Thunk), types.address), Compiler::NoReturn, frame->trace(0, 0), @@ -4396,7 +4412,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, thunk = checkCastFromReferenceThunk; } - Compiler::Operand* instance = c->peek(1, 0); + ir::Value* instance = c->peek(1, 0); c->call(c->constant(getThunk(t, thunk), types.address), 0, @@ -4425,16 +4441,16 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, case dmul: case ddiv: case vm::drem: { - Compiler::Operand* a = frame->popLong(); - Compiler::Operand* b = frame->popLong(); + ir::Value* a = frame->popLong(); + ir::Value* b = frame->popLong(); frame->pushLong( c->binaryOp(toCompilerBinaryOp(t, instruction), types.f8, a, b)); } break; case dcmpg: { - Compiler::Operand* a = frame->popLong(); - Compiler::Operand* b = frame->popLong(); + ir::Value* a = frame->popLong(); + ir::Value* b = frame->popLong(); if (floatBranch(t, frame, code, ip, types.f8, false, a, b, &newIp)) { goto branch; @@ -4445,16 +4461,16 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, 0, types.i4, 4, - static_cast(0), + static_cast(0), a, - static_cast(0), + static_cast(0), b)); } } break; case dcmpl: { - Compiler::Operand* a = frame->popLong(); - Compiler::Operand* b = frame->popLong(); + ir::Value* a = frame->popLong(); + ir::Value* b = frame->popLong(); if (floatBranch(t, frame, code, ip, types.f8, true, a, b, &newIp)) { goto branch; @@ -4465,9 +4481,9 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, 0, types.i4, 4, - static_cast(0), + static_cast(0), a, - static_cast(0), + static_cast(0), b)); } } break; @@ -4525,16 +4541,16 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, case fmul: case fdiv: case frem: { - Compiler::Operand* a = frame->popInt(); - Compiler::Operand* b = frame->popInt(); + ir::Value* a = frame->popInt(); + ir::Value* b = frame->popInt(); frame->pushInt( c->binaryOp(toCompilerBinaryOp(t, instruction), types.f4, a, b)); } break; case fcmpg: { - Compiler::Operand* a = frame->popInt(); - Compiler::Operand* b = frame->popInt(); + ir::Value* a = frame->popInt(); + ir::Value* b = frame->popInt(); if (floatBranch(t, frame, code, ip, types.f4, false, a, b, &newIp)) { goto branch; @@ -4551,8 +4567,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, } break; case fcmpl: { - Compiler::Operand* a = frame->popInt(); - Compiler::Operand* b = frame->popInt(); + ir::Value* a = frame->popInt(); + ir::Value* b = frame->popInt(); if (floatBranch(t, frame, code, ip, types.f4, true, a, b, &newIp)) { goto branch; @@ -4613,7 +4629,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, frame->append(field)); } - Compiler::Operand* table; + ir::Value* table; if (instruction == getstatic) { checkField(t, field, true); @@ -4737,7 +4753,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, ir::Type rType = operandTypeForFieldCode(t, fieldCode); - Compiler::Operand* result; + ir::Value* result; if (instruction == getstatic) { result = c->call( c->constant(getThunk(t, getStaticFieldValueFromReferenceThunk), @@ -4749,7 +4765,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, c->threadRegister(), frame->append(pair)); } else { - Compiler::Operand* instance = frame->popObject(); + ir::Value* instance = frame->popObject(); result = c->call( c->constant(getThunk(t, getFieldValueFromReferenceThunk), @@ -4830,8 +4846,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, case isub: case ixor: case imul: { - Compiler::Operand* a = frame->popInt(); - Compiler::Operand* b = frame->popInt(); + ir::Value* a = frame->popInt(); + ir::Value* b = frame->popInt(); frame->pushInt( c->binaryOp(toCompilerBinaryOp(t, instruction), types.i4, a, b)); } break; @@ -4865,8 +4881,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, break; case idiv: { - Compiler::Operand* a = frame->popInt(); - Compiler::Operand* b = frame->popInt(); + ir::Value* a = frame->popInt(); + ir::Value* b = frame->popInt(); if (inTryBlock(t, code, ip - 1)) { c->saveLocals(); @@ -4885,10 +4901,10 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, if(newIp <= ip) { compileSafePoint(t, c, frame); } - - Compiler::Operand* a = frame->popObject(); - Compiler::Operand* b = frame->popObject(); - Compiler::Operand* target = frame->machineIp(newIp); + + ir::Value* a = frame->popObject(); + ir::Value* b = frame->popObject(); + ir::Value* target = frame->machineIp(newIp); c->condJump(toCompilerJumpOp(t, instruction), types.object, a, b, target); } goto branch; @@ -4906,10 +4922,10 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, if(newIp <= ip) { compileSafePoint(t, c, frame); } - - Compiler::Operand* a = frame->popInt(); - Compiler::Operand* b = frame->popInt(); - Compiler::Operand* target = frame->machineIp(newIp); + + ir::Value* a = frame->popInt(); + ir::Value* b = frame->popInt(); + ir::Value* target = frame->machineIp(newIp); c->condJump(toCompilerJumpOp(t, instruction), types.i4, a, b, target); } goto branch; @@ -4924,14 +4940,14 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, newIp = (ip - 3) + offset; assert(t, newIp < codeLength(t, code)); - Compiler::Operand* target = frame->machineIp(newIp); + ir::Value* target = frame->machineIp(newIp); if(newIp <= ip) { compileSafePoint(t, c, frame); } - Compiler::Operand* a = c->constant(0, types.i4); - Compiler::Operand* b = frame->popInt(); + ir::Value* a = c->constant(0, types.i4); + ir::Value* b = frame->popInt(); c->condJump(toCompilerJumpOp(t, instruction), types.i4, a, b, target); } goto branch; @@ -4946,9 +4962,9 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, compileSafePoint(t, c, frame); } - Compiler::Operand* a = c->constant(0, types.object); - Compiler::Operand* b = frame->popObject(); - Compiler::Operand* target = frame->machineIp(newIp); + ir::Value* a = c->constant(0, types.object); + ir::Value* b = frame->popObject(); + ir::Value* target = frame->machineIp(newIp); c->condJump(toCompilerJumpOp(t, instruction), types.object, a, b, target); } goto branch; @@ -5005,7 +5021,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, object class_ = resolveClassInPool(t, context->method, index - 1, false); - Compiler::Operand* instance = frame->popObject(); + ir::Value* instance = frame->popObject(); object argument; Thunk thunk; @@ -5065,7 +5081,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, unsigned rSize = resultSize(t, returnCode); - Compiler::Operand* result + ir::Value* result = c->stackCall(c->call(c->constant(getThunk(t, thunk), types.address), 0, frame->trace(0, 0), @@ -5171,11 +5187,11 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, unsigned offset = TargetClassVtable + (methodOffset(t, target) * TargetBytesPerWord); - Compiler::Operand* instance = c->peek(1, parameterFootprint - 1); + ir::Value* instance = c->peek(1, parameterFootprint - 1); unsigned rSize = resultSize(t, methodReturnCode(t, target)); - Compiler::Operand* result = c->stackCall( + ir::Value* result = c->stackCall( c->memory(c->binaryOp(lir::And, types.address, c->constant(TargetPointerMask, types.i4), @@ -5227,8 +5243,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, } break; case irem: { - Compiler::Operand* a = frame->popInt(); - Compiler::Operand* b = frame->popInt(); + ir::Value* a = frame->popInt(); + ir::Value* b = frame->popInt(); if (inTryBlock(t, code, ip - 1)) { c->saveLocals(); @@ -5319,15 +5335,15 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, case lsub: case lxor: case lmul: { - Compiler::Operand* a = frame->popLong(); - Compiler::Operand* b = frame->popLong(); + ir::Value* a = frame->popLong(); + ir::Value* b = frame->popLong(); frame->pushLong( c->binaryOp(toCompilerBinaryOp(t, instruction), types.i8, a, b)); } break; case lcmp: { - Compiler::Operand* a = frame->popLong(); - Compiler::Operand* b = frame->popLong(); + ir::Value* a = frame->popLong(); + ir::Value* b = frame->popLong(); if (integerBranch(t, frame, code, ip, types.i8, a, b, &newIp)) { goto branch; @@ -5338,9 +5354,9 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, 0, types.i4, 4, - static_cast(0), + static_cast(0), a, - static_cast(0), + static_cast(0), b)); } } break; @@ -5425,8 +5441,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, } break; case ldiv_: { - Compiler::Operand* a = frame->popLong(); - Compiler::Operand* b = frame->popLong(); + ir::Value* a = frame->popLong(); + ir::Value* b = frame->popLong(); if (inTryBlock(t, code, ip - 1)) { c->saveLocals(); @@ -5470,16 +5486,16 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, ip = (ip + 3) & ~3; // pad to four byte boundary - Compiler::Operand* key = frame->popInt(); - + ir::Value* key = frame->popInt(); + uint32_t defaultIp = base + codeReadInt32(t, code, ip); assert(t, defaultIp < codeLength(t, code)); int32_t pairCount = codeReadInt32(t, code, ip); if (pairCount) { - Compiler::Operand* default_ = frame->addressOperand - (frame->addressPromise(c->machineIp(defaultIp))); + ir::Value* default_ = frame->addressOperand( + frame->addressPromise(c->machineIp(defaultIp))); avian::codegen::Promise* start = 0; uint32_t* ipTable = static_cast @@ -5501,7 +5517,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, } assert(t, start); - Compiler::Operand* address = c->call( + ir::Value* address = c->call( c->constant(getThunk(t, lookUpAddressThunk), types.address), 0, 0, @@ -5533,8 +5549,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, } break; case lrem: { - Compiler::Operand* a = frame->popLong(); - Compiler::Operand* b = frame->popLong(); + ir::Value* a = frame->popLong(); + ir::Value* b = frame->popLong(); if (inTryBlock(t, code, ip - 1)) { c->saveLocals(); @@ -5558,8 +5574,8 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, case lshl: case lshr: case lushr: { - Compiler::Operand* a = frame->popInt(); - Compiler::Operand* b = frame->popLong(); + ir::Value* a = frame->popInt(); + ir::Value* b = frame->popLong(); frame->pushLong( c->binaryOp(toCompilerBinaryOp(t, instruction), types.i8, a, b)); } break; @@ -5590,7 +5606,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, break; case monitorenter: { - Compiler::Operand* target = frame->popObject(); + ir::Value* target = frame->popObject(); c->call( c->constant(getThunk(t, acquireMonitorForObjectThunk), types.address), 0, @@ -5602,7 +5618,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, } break; case monitorexit: { - Compiler::Operand* target = frame->popObject(); + ir::Value* target = frame->popObject(); c->call( c->constant(getThunk(t, releaseMonitorForObjectThunk), types.address), 0, @@ -5639,7 +5655,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, (t, localSize(t, context->method) + c->topOfStack(), context->method) + t->arch->frameReturnAddressSize(); - Compiler::Operand* result + ir::Value* result = c->call(c->constant(getThunk(t, thunk), types.address), 0, frame->trace(0, 0), @@ -5690,7 +5706,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, case newarray: { uint8_t type = codeBody(t, code, ip++); - Compiler::Operand* length = frame->popInt(); + ir::Value* length = frame->popInt(); frame->pushObject( c->call(c->constant(getThunk(t, makeBlankArrayThunk), types.address), @@ -5773,9 +5789,9 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, } } - Compiler::Operand* value = popField(t, frame, fieldCode); + ir::Value* value = popField(t, frame, fieldCode); - Compiler::Operand* table; + ir::Value* table; if (instruction == putstatic) { PROTECT(t, field); @@ -5877,7 +5893,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, int fieldCode = vm::fieldCode (t, byteArrayBody(t, referenceSpec(t, reference), 0)); - Compiler::Operand* value = popField(t, frame, fieldCode); + ir::Value* value = popField(t, frame, fieldCode); ir::Type rType = operandTypeForFieldCode(t, fieldCode); object pair = makePair(t, context->method, reference); @@ -5901,7 +5917,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, frame->append(pair), value); } else { - Compiler::Operand* instance = frame->popObject(); + ir::Value* instance = frame->popObject(); c->call(c->constant(getThunk(t, setFieldValueFromReferenceThunk), types.address), @@ -5928,10 +5944,10 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, 4, c->threadRegister(), frame->append(pair), - static_cast(0), + static_cast(0), value); } else { - Compiler::Operand* instance = frame->popObject(); + ir::Value* instance = frame->popObject(); c->call( c->constant(getThunk(t, setLongFieldValueFromReferenceThunk), @@ -5943,7 +5959,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, c->threadRegister(), frame->append(pair), instance, - static_cast(0), + static_cast(0), value); } } break; @@ -5962,7 +5978,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, frame->append(pair), value); } else { - Compiler::Operand* instance = frame->popObject(); + ir::Value* instance = frame->popObject(); c->call( c->constant(getThunk(t, setObjectFieldValueFromReferenceThunk), @@ -6036,7 +6052,7 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, } assert(t, start); - Compiler::Operand* key = frame->popInt(); + ir::Value* key = frame->popInt(); c->condJump(lir::JumpIfLess, types.i4, @@ -6151,18 +6167,17 @@ compile(MyThread* t, Frame* initialFrame, unsigned initialIp, c->restoreState(s->state); - Compiler::Operand* normalizedKey + ir::Value* normalizedKey = (s->bottom ? c->binaryOp(lir::Subtract, types.i4, c->constant(s->bottom, types.i4), s->key) : s->key); - Compiler::Operand* entry - = c->memory(frame->absoluteAddressOperand(s->start), - types.address, - 0, - normalizedKey); + ir::Value* entry = c->memory(frame->absoluteAddressOperand(s->start), + types.address, + 0, + normalizedKey); c->jmp(c->load(ir::SignExtend, types.address,