From 05d80aee8ba5e8e8de315b8929fc9773986b9a7f Mon Sep 17 00:00:00 2001 From: Joshua Warner Date: Sun, 1 Jun 2014 14:41:12 -0600 Subject: [PATCH] remove static references to TargetBytesPerWord in Compiler --- include/avian/codegen/architecture.h | 4 + include/avian/codegen/ir.h | 2 +- src/codegen/compiler.cpp | 28 +-- src/codegen/compiler/context.cpp | 67 +++--- src/codegen/compiler/context.h | 1 + src/codegen/compiler/event.cpp | 342 +++++++++++++++------------ src/codegen/compiler/frame.cpp | 12 +- src/codegen/compiler/promise.cpp | 7 +- src/codegen/compiler/site.cpp | 51 ++-- src/codegen/compiler/value.cpp | 3 +- src/codegen/target/arm/assembler.cpp | 5 + src/codegen/target/x86/assembler.cpp | 5 + src/debug-util.cpp | 8 - 13 files changed, 299 insertions(+), 236 deletions(-) diff --git a/include/avian/codegen/architecture.h b/include/avian/codegen/architecture.h index e3b2c3d27e..0c82fbc207 100644 --- a/include/avian/codegen/architecture.h +++ b/include/avian/codegen/architecture.h @@ -11,6 +11,8 @@ #ifndef AVIAN_CODEGEN_ARCHITECTURE_H #define AVIAN_CODEGEN_ARCHITECTURE_H +#include "ir.h" + namespace vm { class Zone; } @@ -57,6 +59,8 @@ virtual int returnHigh() = 0; virtual int virtualCallTarget() = 0; virtual int virtualCallIndex() = 0; +virtual ir::TargetInfo targetInfo() = 0; + virtual bool bigEndian() = 0; virtual uintptr_t maximumImmediateJump() = 0; diff --git a/include/avian/codegen/ir.h b/include/avian/codegen/ir.h index ae95a2efa5..8b2b48aa9d 100644 --- a/include/avian/codegen/ir.h +++ b/include/avian/codegen/ir.h @@ -19,7 +19,7 @@ class TargetInfo { public: unsigned pointerSize; - TargetInfo(unsigned pointerSize) : pointerSize(pointerSize) + explicit TargetInfo(unsigned pointerSize) : pointerSize(pointerSize) { } }; diff --git a/src/codegen/compiler.cpp b/src/codegen/compiler.cpp index dc9bbdbe4b..16972c61c7 100644 --- a/src/codegen/compiler.cpp +++ b/src/codegen/compiler.cpp @@ -2281,7 +2281,7 @@ class MyCompiler: public Compiler { static_cast(base), displacement, static_cast(index), - index == 0 ? 1 : type.size(TargetBytesPerWord), + index == 0 ? 1 : type.size(c.targetInfo), result); return result; @@ -2585,10 +2585,10 @@ class MyCompiler: public Compiler { Value* dst = value(&c, type); appendMove(&c, lir::Move, - src->type.size(TargetBytesPerWord), - src->type.size(TargetBytesPerWord), + src->type.size(c.targetInfo), + src->type.size(c.targetInfo), static_cast(src), - type.size(TargetBytesPerWord), + type.size(c.targetInfo), dst); return dst; } @@ -2602,11 +2602,11 @@ class MyCompiler: public Compiler { appendMove(&c, signExtend == ir::SignExtend ? lir::Move : lir::MoveZ, TargetBytesPerWord, - truncateType.size(TargetBytesPerWord), + truncateType.size(c.targetInfo), static_cast(src), - extendType.size(TargetBytesPerWord) < TargetBytesPerWord + extendType.size(c.targetInfo) < TargetBytesPerWord ? TargetBytesPerWord - : extendType.size(TargetBytesPerWord), + : extendType.size(c.targetInfo), dst); return dst; } @@ -2617,10 +2617,10 @@ class MyCompiler: public Compiler { appendMove(&c, lir::Move, - src->type.size(TargetBytesPerWord), - src->type.size(TargetBytesPerWord), + src->type.size(c.targetInfo), + src->type.size(c.targetInfo), static_cast(src), - dst->type.size(TargetBytesPerWord), + dst->type.size(c.targetInfo), static_cast(dst)); } @@ -2633,12 +2633,12 @@ class MyCompiler: public Compiler { Value* dst = value(&c, dstType); appendMove(&c, signExtend == ir::SignExtend ? lir::Move : lir::MoveZ, - src->type.size(TargetBytesPerWord), - src->type.size(TargetBytesPerWord), + src->type.size(c.targetInfo), + src->type.size(c.targetInfo), static_cast(src), - dstType.size(TargetBytesPerWord) < TargetBytesPerWord + dstType.size(c.targetInfo) < TargetBytesPerWord ? TargetBytesPerWord - : dstType.size(TargetBytesPerWord), + : dstType.size(c.targetInfo), dst); return dst; } diff --git a/src/codegen/compiler/context.cpp b/src/codegen/compiler/context.cpp index 24436f1ed3..404b9aba28 100644 --- a/src/codegen/compiler/context.cpp +++ b/src/codegen/compiler/context.cpp @@ -17,38 +17,41 @@ namespace avian { namespace codegen { namespace compiler { -Context::Context(vm::System* system, Assembler* assembler, vm::Zone* zone, - Compiler::Client* client): - system(system), - assembler(assembler), - arch(assembler->arch()), - zone(zone), - client(client), - stack(0), - locals(0), - saved(0), - predecessor(0), - regFile(arch->registerFile()), - regAlloc(system, arch->registerFile()), - registerResources - (static_cast - (zone->allocate(sizeof(RegisterResource) * regFile->allRegisters.limit))), - frameResources(0), - acquiredResources(0), - firstConstant(0), - lastConstant(0), - machineCode(0), - firstEvent(0), - lastEvent(0), - forkState(0), - firstBlock(0), - logicalIp(-1), - constantCount(0), - parameterFootprint(0), - localFootprint(0), - machineCodeSize(0), - alignedFrameSize(0), - availableGeneralRegisterCount(regFile->generalRegisters.limit - regFile->generalRegisters.start) +Context::Context(vm::System* system, + Assembler* assembler, + vm::Zone* zone, + Compiler::Client* client) + : system(system), + assembler(assembler), + arch(assembler->arch()), + zone(zone), + client(client), + stack(0), + locals(0), + saved(0), + predecessor(0), + regFile(arch->registerFile()), + regAlloc(system, arch->registerFile()), + registerResources(static_cast(zone->allocate( + sizeof(RegisterResource) * regFile->allRegisters.limit))), + frameResources(0), + acquiredResources(0), + firstConstant(0), + lastConstant(0), + machineCode(0), + firstEvent(0), + lastEvent(0), + forkState(0), + firstBlock(0), + logicalIp(-1), + constantCount(0), + parameterFootprint(0), + localFootprint(0), + machineCodeSize(0), + alignedFrameSize(0), + availableGeneralRegisterCount(regFile->generalRegisters.limit + - regFile->generalRegisters.start), + targetInfo(arch->targetInfo()) { for (unsigned i = regFile->generalRegisters.start; i < regFile->generalRegisters.limit; ++i) { new (registerResources + i) RegisterResource(arch->reserved(i)); diff --git a/src/codegen/compiler/context.h b/src/codegen/compiler/context.h index 9d03a96f35..03708f39c1 100644 --- a/src/codegen/compiler/context.h +++ b/src/codegen/compiler/context.h @@ -125,6 +125,7 @@ class Context { unsigned machineCodeSize; unsigned alignedFrameSize; unsigned availableGeneralRegisterCount; + ir::TargetInfo targetInfo; }; inline Aborter* getAborter(Context* c) { diff --git a/src/codegen/compiler/event.cpp b/src/codegen/compiler/event.cpp index d4045b9aab..44685f3cc0 100644 --- a/src/codegen/compiler/event.cpp +++ b/src/codegen/compiler/event.cpp @@ -130,7 +130,7 @@ void Event::addReads(Context* c, Value* v, unsigned size, { SingleRead* r = read(c, lowMask, lowSuccessor); this->addRead(c, v, r); - if (size > vm::TargetBytesPerWord) { + if (size > c->targetInfo.pointerSize) { r->high_ = v->nextWord; this->addRead(c, v->nextWord, highMask, highSuccessor); } @@ -269,7 +269,7 @@ void slicePush(Context* c, if (footprint > 1) { assert(c, footprint == 2); - if (vm::TargetBytesPerWord == 4) { + if (c->targetInfo.pointerSize == 4) { low->maybeSplit(c); high = slicePushWord(c, low->nextWord, stackBase, slice); } else { @@ -376,9 +376,10 @@ class CallEvent: public Event { { bool thunk; OperandMask op; - c->arch->plan - ((flags & Compiler::Aligned) ? lir::AlignedCall : lir::Call, vm::TargetBytesPerWord, - op, &thunk); + c->arch->plan((flags & Compiler::Aligned) ? lir::AlignedCall : lir::Call, + c->targetInfo.pointerSize, + op, + &thunk); assert(c, not thunk); @@ -395,12 +396,12 @@ class CallEvent: public Event { for (int i = stackArgumentFootprint - 1; i >= 0; --i) { Value* v = static_cast(arguments[i]); - if ((vm::TargetBytesPerWord == 8 + if ((c->targetInfo.pointerSize == 8 && (v == 0 || (i >= 1 && arguments[i - 1] == 0))) - || (vm::TargetBytesPerWord == 4 && v->nextWord != v)) { - assert( - c, - vm::TargetBytesPerWord == 8 or v->nextWord == arguments[i - 1]); + || (c->targetInfo.pointerSize == 4 && v->nextWord != v)) { + assert(c, + c->targetInfo.pointerSize == 8 + or v->nextWord == arguments[i - 1]); arguments[i] = arguments[i - 1]; --i; @@ -553,7 +554,7 @@ class CallEvent: public Event { op = lir::Call; } - apply(c, op, vm::TargetBytesPerWord, address->source, address->source); + apply(c, op, c->targetInfo.pointerSize, address->source, address->source); if (traceHandler) { traceHandler->handleTrace(codePromise(c, c->assembler->offset(true)), @@ -576,11 +577,10 @@ class CallEvent: public Event { clean(c, this, stackBefore, localsBefore, reads, popIndex); - if (resultValue->type.size(vm::TargetBytesPerWord) - and live(c, resultValue)) { + if (resultValue->type.size(c->targetInfo) and live(c, resultValue)) { resultValue->addSite(c, registerSite(c, c->arch->returnLow())); - if (resultValue->type.size(vm::TargetBytesPerWord) - > vm::TargetBytesPerWord and live(c, resultValue->nextWord)) { + if (resultValue->type.size(c->targetInfo) > c->targetInfo.pointerSize + and live(c, resultValue->nextWord)) { resultValue->nextWord->addSite(c, registerSite(c, c->arch->returnHigh())); } @@ -628,7 +628,7 @@ class ReturnEvent: public Event { if (value) { this->addReads(c, value, - value->type.size(vm::TargetBytesPerWord), + value->type.size(c->targetInfo), SiteMask::fixedRegisterMask(c->arch->returnLow()), SiteMask::fixedRegisterMask(c->arch->returnHigh())); } @@ -680,18 +680,23 @@ class MoveEvent: public Event { assert(c, srcSelectSize <= srcSize); bool noop = srcSelectSize >= dstSize; - - if (dstSize > vm::TargetBytesPerWord) { + + if (dstSize > c->targetInfo.pointerSize) { dstValue->grow(c); } - if (srcSelectSize > vm::TargetBytesPerWord) { + if (srcSelectSize > c->targetInfo.pointerSize) { srcValue->maybeSplit(c); } - this->addReads(c, srcValue, srcSelectSize, srcLowMask, noop ? dstValue : 0, - srcHighMask, - noop and dstSize > vm::TargetBytesPerWord ? dstValue->nextWord : 0); + this->addReads( + c, + srcValue, + srcSelectSize, + srcLowMask, + noop ? dstValue : 0, + srcHighMask, + noop and dstSize > c->targetInfo.pointerSize ? dstValue->nextWord : 0); } virtual const char* name() { @@ -714,47 +719,61 @@ class MoveEvent: public Event { SiteMask dstLowMask = SiteMask::lowPart(dst); SiteMask dstHighMask = SiteMask::highPart(dst); - if (srcSelectSize >= vm::TargetBytesPerWord - and dstSize >= vm::TargetBytesPerWord - and srcSelectSize >= dstSize) - { + if (srcSelectSize >= c->targetInfo.pointerSize + and dstSize >= c->targetInfo.pointerSize and srcSelectSize >= dstSize) { if (dstValue->target) { - if (dstSize > vm::TargetBytesPerWord) { - if (srcValue->source->registerSize(c) > vm::TargetBytesPerWord) { + if (dstSize > c->targetInfo.pointerSize) { + if (srcValue->source->registerSize(c) > c->targetInfo.pointerSize) { apply(c, lir::Move, srcSelectSize, srcValue->source, srcValue->source, dstSize, dstValue->target, dstValue->target); if (live(c, dstValue) == 0) { dstValue->removeSite(c, dstValue->target); - if (dstSize > vm::TargetBytesPerWord) { + if (dstSize > c->targetInfo.pointerSize) { dstValue->nextWord->removeSite(c, dstValue->nextWord->target); } } } else { srcValue->nextWord->source->freeze(c, srcValue->nextWord); - maybeMove(c, lir::Move, vm::TargetBytesPerWord, vm::TargetBytesPerWord, srcValue, - vm::TargetBytesPerWord, dstValue, dstLowMask); + maybeMove(c, + lir::Move, + c->targetInfo.pointerSize, + c->targetInfo.pointerSize, + srcValue, + c->targetInfo.pointerSize, + dstValue, + dstLowMask); srcValue->nextWord->source->thaw(c, srcValue->nextWord); - maybeMove - (c, lir::Move, vm::TargetBytesPerWord, vm::TargetBytesPerWord, srcValue->nextWord, - vm::TargetBytesPerWord, dstValue->nextWord, dstHighMask); + maybeMove(c, + lir::Move, + c->targetInfo.pointerSize, + c->targetInfo.pointerSize, + srcValue->nextWord, + c->targetInfo.pointerSize, + dstValue->nextWord, + dstHighMask); } } else { - maybeMove(c, lir::Move, vm::TargetBytesPerWord, vm::TargetBytesPerWord, srcValue, - vm::TargetBytesPerWord, dstValue, dstLowMask); + maybeMove(c, + lir::Move, + c->targetInfo.pointerSize, + c->targetInfo.pointerSize, + srcValue, + c->targetInfo.pointerSize, + dstValue, + dstLowMask); } } else { Site* low = pickSiteOrMove(c, srcValue, dstValue, 0, 0); - if (dstSize > vm::TargetBytesPerWord) { + if (dstSize > c->targetInfo.pointerSize) { pickSiteOrMove(c, srcValue->nextWord, dstValue->nextWord, low, 1); } } - } else if (srcSelectSize <= vm::TargetBytesPerWord - and dstSize <= vm::TargetBytesPerWord) - { + } else if (srcSelectSize <= c->targetInfo.pointerSize + and dstSize <= c->targetInfo.pointerSize) { maybeMove(c, op, srcSize, @@ -764,8 +783,8 @@ class MoveEvent: public Event { dstValue, dstLowMask); } else { - assert(c, srcSize == vm::TargetBytesPerWord); - assert(c, srcSelectSize == vm::TargetBytesPerWord); + assert(c, srcSize == c->targetInfo.pointerSize); + assert(c, srcSelectSize == c->targetInfo.pointerSize); if (dstValue->nextWord->target or live(c, dstValue->nextWord)) { assert(c, dstLowMask.typeMask & (1 << lir::RegisterOperand)); @@ -785,8 +804,14 @@ class MoveEvent: public Event { srcb, dstb, srcValue); } - apply(c, lir::Move, vm::TargetBytesPerWord, srcValue->source, srcValue->source, - vm::TargetBytesPerWord, low, low); + apply(c, + lir::Move, + c->targetInfo.pointerSize, + srcValue->source, + srcValue->source, + c->targetInfo.pointerSize, + low, + low); low->thaw(c, dstValue); @@ -809,7 +834,14 @@ class MoveEvent: public Event { srcb, dstb, dstValue, dstValue->nextWord); } - apply(c, lir::Move, vm::TargetBytesPerWord, low, low, dstSize, low, high); + apply(c, + lir::Move, + c->targetInfo.pointerSize, + low, + low, + dstSize, + low, + high); high->thaw(c, dstValue->nextWord); @@ -864,7 +896,7 @@ void freezeSource(Context* c, unsigned size, Value* v) { v->source->freeze(c, v); - if (size > vm::TargetBytesPerWord) { + if (size > c->targetInfo.pointerSize) { v->nextWord->source->freeze(c, v->nextWord); } } @@ -873,7 +905,7 @@ void thawSource(Context* c, unsigned size, Value* v) { v->source->thaw(c, v); - if (size > vm::TargetBytesPerWord) { + if (size > c->targetInfo.pointerSize) { v->nextWord->source->thaw(c, v->nextWord); } } @@ -948,12 +980,11 @@ class CombineEvent: public Event { { this->addReads(c, firstValue, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), firstLowMask, firstHighMask); - if (resultValue->type.size(vm::TargetBytesPerWord) - > vm::TargetBytesPerWord) { + if (resultValue->type.size(c->targetInfo) > c->targetInfo.pointerSize) { resultValue->grow(c); } @@ -961,7 +992,7 @@ class CombineEvent: public Event { this->addReads(c, secondValue, - secondValue->type.size(vm::TargetBytesPerWord), + secondValue->type.size(c->targetInfo), secondLowMask, condensed ? resultValue : 0, secondHighMask, @@ -984,27 +1015,27 @@ class CombineEvent: public Event { assert(c, secondValue->source->type(c) == secondValue->nextWord->source->type(c)); - freezeSource(c, firstValue->type.size(vm::TargetBytesPerWord), firstValue); + freezeSource(c, firstValue->type.size(c->targetInfo), firstValue); OperandMask cMask; c->arch->planDestination( op, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), OperandMask( 1 << firstValue->source->type(c), (static_cast( firstValue->nextWord->source->registerMask(c)) << 32) | static_cast(firstValue->source->registerMask(c))), - secondValue->type.size(vm::TargetBytesPerWord), + secondValue->type.size(c->targetInfo), OperandMask( 1 << secondValue->source->type(c), (static_cast( secondValue->nextWord->source->registerMask(c)) << 32) | static_cast(secondValue->source->registerMask(c))), - resultValue->type.size(vm::TargetBytesPerWord), + resultValue->type.size(c->targetInfo), cMask); SiteMask resultLowMask = SiteMask::lowPart(cMask); @@ -1012,7 +1043,7 @@ class CombineEvent: public Event { Site* low = getTarget(c, secondValue, resultValue, resultLowMask); unsigned lowSize = low->registerSize(c); - Site* high = (resultValue->type.size(vm::TargetBytesPerWord) > lowSize + Site* high = (resultValue->type.size(c->targetInfo) > lowSize ? getTarget(c, secondValue->nextWord, resultValue->nextWord, @@ -1026,30 +1057,30 @@ class CombineEvent: public Event { apply(c, op, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), firstValue->source, firstValue->nextWord->source, - secondValue->type.size(vm::TargetBytesPerWord), + secondValue->type.size(c->targetInfo), secondValue->source, secondValue->nextWord->source, - resultValue->type.size(vm::TargetBytesPerWord), + resultValue->type.size(c->targetInfo), low, high); - thawSource(c, firstValue->type.size(vm::TargetBytesPerWord), firstValue); + thawSource(c, firstValue->type.size(c->targetInfo), firstValue); for (Read* r = reads; r; r = r->eventNext) { popRead(c, this, r->value); } low->thaw(c, secondValue); - if (resultValue->type.size(vm::TargetBytesPerWord) > lowSize) { + if (resultValue->type.size(c->targetInfo) > lowSize) { high->thaw(c, secondValue->nextWord); } if (live(c, resultValue)) { resultValue->addSite(c, low); - if (resultValue->type.size(vm::TargetBytesPerWord) > lowSize + if (resultValue->type.size(c->targetInfo) > lowSize and live(c, resultValue->nextWord)) { resultValue->nextWord->addSite(c, high); } @@ -1072,11 +1103,11 @@ void appendCombine(Context* c, OperandMask firstMask; OperandMask secondMask; c->arch->planSource(op, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), firstMask, - secondValue->type.size(vm::TargetBytesPerWord), + secondValue->type.size(c->targetInfo), secondMask, - resultValue->type.size(vm::TargetBytesPerWord), + resultValue->type.size(c->targetInfo), &thunk); if (thunk) { @@ -1087,25 +1118,24 @@ void appendCombine(Context* c, bool threadParameter; intptr_t handler = c->client->getThunk(op, - firstValue->type.size(vm::TargetBytesPerWord), - resultValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), + resultValue->type.size(c->targetInfo), &threadParameter); - unsigned stackSize - = ceilingDivide(secondValue->type.size(vm::TargetBytesPerWord), - vm::TargetBytesPerWord) - + ceilingDivide(firstValue->type.size(vm::TargetBytesPerWord), - vm::TargetBytesPerWord); + unsigned stackSize = ceilingDivide(secondValue->type.size(c->targetInfo), + c->targetInfo.pointerSize) + + ceilingDivide(firstValue->type.size(c->targetInfo), + c->targetInfo.pointerSize); slicePush(c, - ceilingDivide(secondValue->type.size(vm::TargetBytesPerWord), - vm::TargetBytesPerWord), + ceilingDivide(secondValue->type.size(c->targetInfo), + c->targetInfo.pointerSize), secondValue, stackBase, slice); slicePush(c, - ceilingDivide(firstValue->type.size(vm::TargetBytesPerWord), - vm::TargetBytesPerWord), + ceilingDivide(firstValue->type.size(c->targetInfo), + c->targetInfo.pointerSize), firstValue, stackBase, slice); @@ -1149,14 +1179,13 @@ class TranslateEvent: public Event { { bool condensed = c->arch->alwaysCondensed(op); - if (resultValue->type.size(vm::TargetBytesPerWord) - > vm::TargetBytesPerWord) { + if (resultValue->type.size(c->targetInfo) > c->targetInfo.pointerSize) { resultValue->grow(c); } this->addReads(c, firstValue, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), valueLowMask, condensed ? resultValue : 0, valueHighMask, @@ -1174,14 +1203,14 @@ class TranslateEvent: public Event { c->arch->planDestination( op, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), OperandMask( 1 << firstValue->source->type(c), (static_cast( firstValue->nextWord->source->registerMask(c)) << 32) | static_cast(firstValue->source->registerMask(c))), - resultValue->type.size(vm::TargetBytesPerWord), + resultValue->type.size(c->targetInfo), bMask); SiteMask resultLowMask = SiteMask::lowPart(bMask); @@ -1189,7 +1218,7 @@ class TranslateEvent: public Event { Site* low = getTarget(c, firstValue, resultValue, resultLowMask); unsigned lowSize = low->registerSize(c); - Site* high = (resultValue->type.size(vm::TargetBytesPerWord) > lowSize + Site* high = (resultValue->type.size(c->targetInfo) > lowSize ? getTarget(c, firstValue->nextWord, resultValue->nextWord, @@ -1198,10 +1227,10 @@ class TranslateEvent: public Event { apply(c, op, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), firstValue->source, firstValue->nextWord->source, - resultValue->type.size(vm::TargetBytesPerWord), + resultValue->type.size(c->targetInfo), low, high); @@ -1210,13 +1239,13 @@ class TranslateEvent: public Event { } low->thaw(c, firstValue); - if (resultValue->type.size(vm::TargetBytesPerWord) > lowSize) { + if (resultValue->type.size(c->targetInfo) > lowSize) { high->thaw(c, firstValue->nextWord); } if (live(c, resultValue)) { resultValue->addSite(c, low); - if (resultValue->type.size(vm::TargetBytesPerWord) > lowSize + if (resultValue->type.size(c->targetInfo) > lowSize and live(c, resultValue->nextWord)) { resultValue->nextWord->addSite(c, high); } @@ -1237,19 +1266,19 @@ void appendTranslate(Context* c, Value* resultValue) { assert(c, - firstValue->type.size(vm::TargetBytesPerWord) - == firstValue->type.size(vm::TargetBytesPerWord)); + firstValue->type.size(c->targetInfo) + == firstValue->type.size(c->targetInfo)); assert(c, - resultValue->type.size(vm::TargetBytesPerWord) - == resultValue->type.size(vm::TargetBytesPerWord)); + resultValue->type.size(c->targetInfo) + == resultValue->type.size(c->targetInfo)); bool thunk; OperandMask first; c->arch->planSource(op, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), first, - resultValue->type.size(vm::TargetBytesPerWord), + resultValue->type.size(c->targetInfo), &thunk); if (thunk) { @@ -1257,8 +1286,8 @@ void appendTranslate(Context* c, FixedSliceStack slice; slicePush(c, - ceilingDivide(firstValue->type.size(vm::TargetBytesPerWord), - vm::TargetBytesPerWord), + ceilingDivide(firstValue->type.size(c->targetInfo), + c->targetInfo.pointerSize), firstValue, stackBase, slice); @@ -1266,12 +1295,11 @@ void appendTranslate(Context* c, appendCall(c, value(c, ir::Type::addr(), - constantSite( - c, - c->client->getThunk( - op, - firstValue->type.size(vm::TargetBytesPerWord), - resultValue->type.size(vm::TargetBytesPerWord)))), + constantSite(c, + c->client->getThunk( + op, + firstValue->type.size(c->targetInfo), + resultValue->type.size(c->targetInfo)))), ir::NativeCallingConvention, 0, 0, @@ -1374,7 +1402,7 @@ class MemoryEvent: public Event { popRead(c, this, base); if (index) { - if (vm::TargetBytesPerWord == 8 and indexRegister != lir::NoRegister) { + if (c->targetInfo.pointerSize == 8 and indexRegister != lir::NoRegister) { apply(c, lir::Move, 4, index->source, index->source, 8, index->source, index->source); } @@ -1544,22 +1572,22 @@ class BranchEvent: public Event { { this->addReads(c, firstValue, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), firstLowMask, firstHighMask); this->addReads(c, secondValue, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), secondLowMask, secondHighMask); OperandMask dstMask; c->arch->planDestination(op, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), OperandMask(0, 0), - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), OperandMask(0, 0), - vm::TargetBytesPerWord, + c->targetInfo.pointerSize, dstMask); this->addRead(c, addressValue, SiteMask::lowPart(dstMask)); @@ -1582,8 +1610,7 @@ class BranchEvent: public Event { int64_t firstConstVal = firstConstant->value->value(); int64_t secondConstVal = secondConstant->value->value(); - if (firstValue->type.size(vm::TargetBytesPerWord) - > vm::TargetBytesPerWord) { + if (firstValue->type.size(c->targetInfo) > c->targetInfo.pointerSize) { firstConstVal |= findConstantSite (c, firstValue->nextWord)->value->value() << 32; secondConstVal |= findConstantSite @@ -1592,35 +1619,35 @@ class BranchEvent: public Event { if (shouldJump(c, op, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), firstConstVal, secondConstVal)) { - apply(c, lir::Jump, vm::TargetBytesPerWord, addressValue->source, addressValue->source); + apply(c, + lir::Jump, + c->targetInfo.pointerSize, + addressValue->source, + addressValue->source); } } else { - freezeSource( - c, firstValue->type.size(vm::TargetBytesPerWord), firstValue); - freezeSource( - c, firstValue->type.size(vm::TargetBytesPerWord), secondValue); - freezeSource(c, vm::TargetBytesPerWord, addressValue); + freezeSource(c, firstValue->type.size(c->targetInfo), firstValue); + freezeSource(c, firstValue->type.size(c->targetInfo), secondValue); + freezeSource(c, c->targetInfo.pointerSize, addressValue); apply(c, op, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), firstValue->source, firstValue->nextWord->source, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), secondValue->source, secondValue->nextWord->source, - vm::TargetBytesPerWord, + c->targetInfo.pointerSize, addressValue->source, addressValue->source); - thawSource(c, vm::TargetBytesPerWord, addressValue); - thawSource( - c, firstValue->type.size(vm::TargetBytesPerWord), secondValue); - thawSource( - c, firstValue->type.size(vm::TargetBytesPerWord), firstValue); + thawSource(c, c->targetInfo.pointerSize, addressValue); + thawSource(c, firstValue->type.size(c->targetInfo), secondValue); + thawSource(c, firstValue->type.size(c->targetInfo), firstValue); } } @@ -1648,11 +1675,11 @@ void appendBranch(Context* c, OperandMask secondMask; c->arch->planSource(op, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), firstMask, - firstValue->type.size(vm::TargetBytesPerWord), + firstValue->type.size(c->targetInfo), secondMask, - vm::TargetBytesPerWord, + c->targetInfo.pointerSize, &thunk); if (thunk) { @@ -1661,23 +1688,22 @@ void appendBranch(Context* c, size_t stackBase = c->stack ? c->stack->index + 1 : 0; bool threadParameter; - intptr_t handler - = c->client->getThunk(op, - firstValue->type.size(vm::TargetBytesPerWord), - firstValue->type.size(vm::TargetBytesPerWord), - &threadParameter); + intptr_t handler = c->client->getThunk(op, + firstValue->type.size(c->targetInfo), + firstValue->type.size(c->targetInfo), + &threadParameter); assert(c, not threadParameter); slicePush(c, - ceilingDivide(firstValue->type.size(vm::TargetBytesPerWord), - vm::TargetBytesPerWord), + ceilingDivide(firstValue->type.size(c->targetInfo), + c->targetInfo.pointerSize), secondValue, stackBase, slice); slicePush(c, - ceilingDivide(firstValue->type.size(vm::TargetBytesPerWord), - vm::TargetBytesPerWord), + ceilingDivide(firstValue->type.size(c->targetInfo), + c->targetInfo.pointerSize), firstValue, stackBase, slice); @@ -1758,7 +1784,7 @@ class JumpEvent: public Event { { bool thunk; OperandMask mask; - c->arch->plan(op, vm::TargetBytesPerWord, mask, &thunk); + c->arch->plan(op, c->targetInfo.pointerSize, mask, &thunk); assert(c, not thunk); @@ -1771,7 +1797,7 @@ class JumpEvent: public Event { virtual void compile(Context* c) { if (not this->isUnreachable()) { - apply(c, op, vm::TargetBytesPerWord, address->source, address->source); + apply(c, op, c->targetInfo.pointerSize, address->source, address->source); } for (Read* r = reads; r; r = r->eventNext) { @@ -1832,17 +1858,26 @@ class BoundsCheckEvent: public Event { if (constant->value->value() < 0) { lir::Constant handlerConstant(resolvedPromise(c, handler)); a->apply(lir::Call, - OperandInfo(vm::TargetBytesPerWord, lir::ConstantOperand, &handlerConstant)); + OperandInfo(c->targetInfo.pointerSize, + lir::ConstantOperand, + &handlerConstant)); } } else { outOfBoundsPromise = compiler::codePromise(c, static_cast(0)); ConstantSite zero(resolvedPromise(c, 0)); ConstantSite oob(outOfBoundsPromise); - apply(c, lir::JumpIfLess, - 4, &zero, &zero, - 4, index->source, index->source, - vm::TargetBytesPerWord, &oob, &oob); + apply(c, + lir::JumpIfLess, + 4, + &zero, + &zero, + 4, + index->source, + index->source, + c->targetInfo.pointerSize, + &oob, + &oob); } if (constant == 0 or constant->value->value() >= 0) { @@ -1853,15 +1888,22 @@ class BoundsCheckEvent: public Event { CodePromise* nextPromise = compiler::codePromise(c, static_cast(0)); - freezeSource(c, vm::TargetBytesPerWord, index); + freezeSource(c, c->targetInfo.pointerSize, index); ConstantSite next(nextPromise); - apply(c, lir::JumpIfGreater, - 4, index->source, - index->source, 4, &length, - &length, vm::TargetBytesPerWord, &next, &next); + apply(c, + lir::JumpIfGreater, + 4, + index->source, + index->source, + 4, + &length, + &length, + c->targetInfo.pointerSize, + &next, + &next); - thawSource(c, vm::TargetBytesPerWord, index); + thawSource(c, c->targetInfo.pointerSize, index); if (constant == 0) { outOfBoundsPromise->offset = a->offset(); @@ -1869,7 +1911,9 @@ class BoundsCheckEvent: public Event { lir::Constant handlerConstant(resolvedPromise(c, handler)); a->apply(lir::Call, - OperandInfo(vm::TargetBytesPerWord, lir::ConstantOperand, &handlerConstant)); + OperandInfo(c->targetInfo.pointerSize, + lir::ConstantOperand, + &handlerConstant)); nextPromise->offset = a->offset(); } diff --git a/src/codegen/compiler/frame.cpp b/src/codegen/compiler/frame.cpp index f6a94f3b7a..223d036e9d 100644 --- a/src/codegen/compiler/frame.cpp +++ b/src/codegen/compiler/frame.cpp @@ -45,16 +45,18 @@ int frameIndex(Context* c, int localIndex) { unsigned frameIndexToOffset(Context* c, unsigned frameIndex) { assert(c, frameIndex < totalFrameSize(c)); - return (frameIndex + c->arch->frameFooterSize()) * vm::TargetBytesPerWord; + return (frameIndex + c->arch->frameFooterSize()) * c->targetInfo.pointerSize; } unsigned offsetToFrameIndex(Context* c, unsigned offset) { - assert(c, static_cast - ((offset / vm::TargetBytesPerWord) - c->arch->frameFooterSize()) >= 0); - assert(c, ((offset / vm::TargetBytesPerWord) - c->arch->frameFooterSize()) + assert(c, + static_cast((offset / c->targetInfo.pointerSize) + - c->arch->frameFooterSize()) >= 0); + assert(c, + ((offset / c->targetInfo.pointerSize) - c->arch->frameFooterSize()) < totalFrameSize(c)); - return (offset / vm::TargetBytesPerWord) - c->arch->frameFooterSize(); + return (offset / c->targetInfo.pointerSize) - c->arch->frameFooterSize(); } unsigned frameBase(Context* c) { diff --git a/src/codegen/compiler/promise.cpp b/src/codegen/compiler/promise.cpp index e3b5aa7247..1567140cca 100644 --- a/src/codegen/compiler/promise.cpp +++ b/src/codegen/compiler/promise.cpp @@ -90,9 +90,10 @@ class PoolPromise: public Promise { virtual int64_t value() { if (resolved()) { - return reinterpret_cast - (c->machineCode + vm::pad(c->machineCodeSize, vm::TargetBytesPerWord) - + (key * vm::TargetBytesPerWord)); + return reinterpret_cast( + c->machineCode + + vm::pad(c->machineCodeSize, c->targetInfo.pointerSize) + + (key * c->targetInfo.pointerSize)); } abort(c); diff --git a/src/codegen/compiler/site.cpp b/src/codegen/compiler/site.cpp index e5a1c02cb2..b1ddcee1d7 100644 --- a/src/codegen/compiler/site.cpp +++ b/src/codegen/compiler/site.cpp @@ -52,7 +52,7 @@ SiteIterator::SiteIterator(Context* c, Value* v, bool includeBuddies, Site** SiteIterator::findNext(Site** p) { while (true) { if (*p) { - if (pass == 0 or (*p)->registerSize(c) > vm::TargetBytesPerWord) { + if (pass == 0 or (*p)->registerSize(c) > c->targetInfo.pointerSize) { return p; } else { p = &((*p)->next); @@ -103,14 +103,11 @@ void SiteIterator::remove(Context* c) { previous = 0; } - - -unsigned Site::registerSize(Context*) { - return vm::TargetBytesPerWord; +unsigned Site::registerSize(Context* c) +{ + return c->targetInfo.pointerSize; } - - Site* constantSite(Context* c, Promise* value) { return new(c->zone) ConstantSite(value); } @@ -250,7 +247,7 @@ bool RegisterSite::matchNextWord(Context* c, Site* s, unsigned) { RegisterSite* rs = static_cast(s); unsigned size = rs->registerSize(c); - if (size > vm::TargetBytesPerWord) { + if (size > c->targetInfo.pointerSize) { assert(c, number != lir::NoRegister); return number == rs->number; } else { @@ -352,7 +349,7 @@ SiteMask RegisterSite::mask(Context* c UNUSED) { SiteMask RegisterSite::nextWordMask(Context* c, unsigned) { assert(c, number != lir::NoRegister); - if (registerSize(c) > vm::TargetBytesPerWord) { + if (registerSize(c) > c->targetInfo.pointerSize) { return SiteMask (1 << lir::RegisterOperand, number, NoFrameIndex); } else { @@ -367,7 +364,7 @@ unsigned RegisterSite::registerSize(Context* c) { if ((1 << number) & c->regFile->floatRegisters.mask) { return c->arch->floatRegisterSize(); } else { - return vm::TargetBytesPerWord; + return c->targetInfo.pointerSize; } } @@ -469,12 +466,15 @@ bool MemorySite::matchNextWord(Context* c, Site* s, unsigned index) { if (s->type(c) == lir::MemoryOperand) { MemorySite* ms = static_cast(s); return ms->base == this->base - and ((index == 1 and ms->offset == static_cast - (this->offset + vm::TargetBytesPerWord)) - or (index == 0 and this->offset == static_cast - (ms->offset + vm::TargetBytesPerWord))) - and ms->index == this->index - and ms->scale == this->scale; + and ((index == 1 + and ms->offset + == static_cast(this->offset + + c->targetInfo.pointerSize)) + or (index == 0 + and this->offset + == static_cast(ms->offset + + c->targetInfo.pointerSize))) + and ms->index == this->index and ms->scale == this->scale; } else { return false; } @@ -551,10 +551,11 @@ void MemorySite::asAssemblerOperand(Context* c UNUSED, Site* high UNUSED, lir::Operand* result) { // todo: endianness? - assert(c, high == this + assert(c, + high == this or (static_cast(high)->base == base and static_cast(high)->offset - == static_cast(offset + vm::TargetBytesPerWord) + == static_cast(offset + c->targetInfo.pointerSize) and static_cast(high)->index == index and static_cast(high)->scale == scale)); @@ -569,7 +570,8 @@ Site* MemorySite::copy(Context* c) { Site* MemorySite::copyHalf(Context* c, bool add) { if (add) { - return memorySite(c, base, offset + vm::TargetBytesPerWord, index, scale); + return memorySite( + c, base, offset + c->targetInfo.pointerSize, index, scale); } else { return copy(c); } @@ -584,10 +586,13 @@ Site* MemorySite::copyHigh(Context* c) { } Site* MemorySite::makeNextWord(Context* c, unsigned index) { - return memorySite - (c, base, offset + ((index == 1) xor c->arch->bigEndian() - ? vm::TargetBytesPerWord : -vm::TargetBytesPerWord), - this->index, scale); + return memorySite(c, + base, + offset + ((index == 1) xor c->arch->bigEndian() + ? c->targetInfo.pointerSize + : -c->targetInfo.pointerSize), + this->index, + scale); } SiteMask MemorySite::mask(Context* c) { diff --git a/src/codegen/compiler/value.cpp b/src/codegen/compiler/value.cpp index d04d2c6e0a..411cbe37ee 100644 --- a/src/codegen/compiler/value.cpp +++ b/src/codegen/compiler/value.cpp @@ -115,7 +115,8 @@ bool Value::uniqueSite(Context* c, Site* s) { if (it.hasMore()) { // the site is not this word's only site, but if the site is // shared with the next word, it may be that word's only site - if (this->nextWord != this and s->registerSize(c) > vm::TargetBytesPerWord) { + if (this->nextWord != this + and s->registerSize(c) > c->targetInfo.pointerSize) { SiteIterator nit(c, this->nextWord); Site* p = nit.next(); if (nit.hasMore()) { diff --git a/src/codegen/target/arm/assembler.cpp b/src/codegen/target/arm/assembler.cpp index db62aeef71..b817ef1ae2 100644 --- a/src/codegen/target/arm/assembler.cpp +++ b/src/codegen/target/arm/assembler.cpp @@ -180,6 +180,11 @@ class MyArchitecture: public Architecture { return 3; } + virtual ir::TargetInfo targetInfo() + { + return ir::TargetInfo(TargetBytesPerWord); + } + virtual bool bigEndian() { return false; } diff --git a/src/codegen/target/x86/assembler.cpp b/src/codegen/target/x86/assembler.cpp index 0614f21954..4791f65681 100644 --- a/src/codegen/target/x86/assembler.cpp +++ b/src/codegen/target/x86/assembler.cpp @@ -204,6 +204,11 @@ class MyArchitecture: public Architecture { return rdx; } + virtual ir::TargetInfo targetInfo() + { + return ir::TargetInfo(TargetBytesPerWord); + } + virtual bool bigEndian() { return false; } diff --git a/src/debug-util.cpp b/src/debug-util.cpp index 03a3c9540e..c0275aae97 100644 --- a/src/debug-util.cpp +++ b/src/debug-util.cpp @@ -446,12 +446,6 @@ int printInstruction(uint8_t* code, unsigned& ip, const char* prefix) fprintf( stderr, "lookupswitch default: %d pairCount: %d", default_, pairCount); - bool good = true; - if (pairCount >= 1000) { - pairCount = 1; - good = false; - } - for (int i = 0; i < pairCount; i++) { int32_t k = read32(code, ip); int32_t d = read32(code, ip) + startIp; @@ -459,8 +453,6 @@ int printInstruction(uint8_t* code, unsigned& ip, const char* prefix) } fprintf(stderr, "\n"); fflush(stderr); - if (!good) - asm("int3"); return 0; }