diff --git a/src/bootimage.cpp b/src/bootimage.cpp index 3618e98333..eab820af1d 100644 --- a/src/bootimage.cpp +++ b/src/bootimage.cpp @@ -33,12 +33,9 @@ endsWith(const char* suffix, const char* s, unsigned length) object makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code, - unsigned capacity, uintptr_t* codeMap, const char* className, + uintptr_t* codeMap, const char* className, const char* methodName, const char* methodSpec) { - unsigned size = 0; - t->m->processor->initialize(t, image, code, &size, capacity); - object constants = 0; PROTECT(t, constants); @@ -118,8 +115,6 @@ makeCodeImage(Thread* t, Zone* zone, BootImage* image, uint8_t* code, - reinterpret_cast(code)); } - image->codeSize = size; - return constants; } @@ -143,7 +138,7 @@ visitRoots(Thread* t, BootImage* image, HeapWalker* w, object constants) image->loader = w->visitRoot(m->loader); image->types = w->visitRoot(m->types); - m->processor->visitRoots(image, w); + m->processor->visitRoots(w); for (; constants; constants = tripleThird(t, constants)) { w->visitRoot(tripleFirst(t, constants)); @@ -186,7 +181,7 @@ makeHeapImage(Thread* t, BootImage* image, uintptr_t* heap, uintptr_t* map, and (currentOffset * BytesPerWord) == ClassStaticTable) { FixedAllocator allocator - (t, reinterpret_cast(heap + position), + (t->m->system, reinterpret_cast(heap + position), (capacity - position) * BytesPerWord); unsigned totalInBytes; @@ -284,21 +279,18 @@ offset(object a, uintptr_t* b) } void -writeBootImage(Thread* t, FILE* out, const char* className, +writeBootImage(Thread* t, FILE* out, BootImage* image, uint8_t* code, + unsigned codeCapacity, const char* className, const char* methodName, const char* methodSpec) { Zone zone(t->m->system, t->m->heap, 64 * 1024); - BootImage image; - const unsigned CodeCapacity = 32 * 1024 * 1024; - uint8_t* code = static_cast(t->m->heap->allocate(CodeCapacity)); uintptr_t* codeMap = static_cast - (t->m->heap->allocate(codeMapSize(CodeCapacity))); - memset(codeMap, 0, codeMapSize(CodeCapacity)); + (t->m->heap->allocate(codeMapSize(codeCapacity))); + memset(codeMap, 0, codeMapSize(codeCapacity)); object constants = makeCodeImage - (t, &zone, &image, code, CodeCapacity, codeMap, className, methodName, - methodSpec); + (t, &zone, image, code, codeMap, className, methodName, methodSpec); if (t->exception) return; @@ -314,13 +306,13 @@ writeBootImage(Thread* t, FILE* out, const char* className, collect(t, Heap::MajorCollection); HeapWalker* heapWalker = makeHeapImage - (t, &image, heap, heapMap, HeapCapacity, constants); + (t, image, heap, heapMap, HeapCapacity, constants); updateConstants(t, constants, code, codeMap, heapWalker->map()); - image.classCount = hashMapSize(t, t->m->classMap); + image->classCount = hashMapSize(t, t->m->classMap); unsigned* classTable = static_cast - (t->m->heap->allocate(image.classCount * sizeof(unsigned))); + (t->m->heap->allocate(image->classCount * sizeof(unsigned))); { unsigned i = 0; for (HashMapIterator it(t, t->m->classMap); it.hasMore();) { @@ -328,9 +320,9 @@ writeBootImage(Thread* t, FILE* out, const char* className, } } - image.stringCount = hashMapSize(t, t->m->stringMap); + image->stringCount = hashMapSize(t, t->m->stringMap); unsigned* stringTable = static_cast - (t->m->heap->allocate(image.stringCount * sizeof(unsigned))); + (t->m->heap->allocate(image->stringCount * sizeof(unsigned))); { unsigned i = 0; for (HashMapIterator it(t, t->m->stringMap); it.hasMore();) { @@ -339,29 +331,28 @@ writeBootImage(Thread* t, FILE* out, const char* className, } } - unsigned* callTable = t->m->processor->makeCallTable - (t, &image, heapWalker, code); + unsigned* callTable = t->m->processor->makeCallTable(t, heapWalker); heapWalker->dispose(); - image.magic = BootImage::Magic; - image.codeBase = reinterpret_cast(code); + image->magic = BootImage::Magic; + image->codeBase = reinterpret_cast(code); fprintf(stderr, "class count %d string count %d call count %d\n" "heap size %d code size %d\n", - image.classCount, image.stringCount, image.callCount, image.heapSize, - image.codeSize); + image->classCount, image->stringCount, image->callCount, + image->heapSize, image->codeSize); if (true) { - fwrite(&image, sizeof(BootImage), 1, out); + fwrite(image, sizeof(BootImage), 1, out); - fwrite(classTable, image.classCount * sizeof(unsigned), 1, out); - fwrite(stringTable, image.stringCount * sizeof(unsigned), 1, out); - fwrite(callTable, image.callCount * sizeof(unsigned) * 2, 1, out); + fwrite(classTable, image->classCount * sizeof(unsigned), 1, out); + fwrite(stringTable, image->stringCount * sizeof(unsigned), 1, out); + fwrite(callTable, image->callCount * sizeof(unsigned) * 2, 1, out); - unsigned offset = (image.classCount * sizeof(unsigned)) - + (image.stringCount * sizeof(unsigned)) - + (image.callCount * sizeof(unsigned) * 2); + unsigned offset = (image->classCount * sizeof(unsigned)) + + (image->stringCount * sizeof(unsigned)) + + (image->callCount * sizeof(unsigned) * 2); while (offset % BytesPerWord) { uint8_t c = 0; @@ -369,11 +360,11 @@ writeBootImage(Thread* t, FILE* out, const char* className, ++ offset; } - fwrite(heapMap, pad(heapMapSize(image.heapSize)), 1, out); - fwrite(heap, pad(image.heapSize), 1, out); + fwrite(heapMap, pad(heapMapSize(image->heapSize)), 1, out); + fwrite(heap, pad(image->heapSize), 1, out); - fwrite(codeMap, pad(codeMapSize(image.codeSize)), 1, out); - fwrite(code, pad(image.codeSize), 1, out); + fwrite(codeMap, pad(codeMapSize(image->codeSize)), 1, out); + fwrite(code, pad(image->codeSize), 1, out); } } @@ -392,6 +383,12 @@ main(int ac, const char** av) Heap* h = makeHeap(s, 128 * 1024 * 1024); Finder* f = makeFinder(s, av[1], 0); Processor* p = makeProcessor(s, h); + + BootImage image; + const unsigned CodeCapacity = 32 * 1024 * 1024; + uint8_t* code = static_cast(h->allocate(CodeCapacity)); + p->initialize(&image, code, CodeCapacity); + Machine* m = new (h->allocate(sizeof(Machine))) Machine(s, h, f, p, 0, 0); Thread* t = p->makeThread(m, 0, 0); @@ -399,8 +396,8 @@ main(int ac, const char** av) enter(t, Thread::IdleState); writeBootImage - (t, stdout, (ac > 2 ? av[2] : 0), (ac > 3 ? av[3] : 0), - (ac > 4 ? av[4] : 0)); + (t, stdout, &image, code, CodeCapacity, + (ac > 2 ? av[2] : 0), (ac > 3 ? av[3] : 0), (ac > 4 ? av[4] : 0)); if (t->exception) { printTrace(t, t->exception); diff --git a/src/compile.cpp b/src/compile.cpp index 95cbaa7a99..8b542d1874 100644 --- a/src/compile.cpp +++ b/src/compile.cpp @@ -5884,8 +5884,7 @@ boot(MyThread* t, BootImage* image); class MyProcessor; void -compileThunks(MyThread* t, Allocator* allocator, MyProcessor* p, - BootImage* image, uint8_t* imageBase); +compileThunks(MyThread* t, Allocator* allocator, MyProcessor* p); MyProcessor* processor(MyThread* t); @@ -5909,7 +5908,8 @@ class MyProcessor: public Processor { receiveMethod(0), windMethod(0), rewindMethod(0), - codeAllocator(s, 0, 0) + codeAllocator(s, 0, 0), + bootImage(0) { } virtual Thread* @@ -6248,14 +6248,10 @@ class MyProcessor: public Processor { return visitor.trace; } - virtual void initialize(Thread* vmt, BootImage* image, uint8_t* code, - unsigned capacity) - { + virtual void initialize(BootImage* image, uint8_t* code, unsigned capacity) { + bootImage = image; codeAllocator.base = code; codeAllocator.capacity = capacity; - - ::compileThunks - (static_cast(vmt), &codeAllocator, this, image, code); } virtual void compileMethod(Thread* vmt, Zone* zone, object* constants, @@ -6272,16 +6268,15 @@ class MyProcessor: public Processor { *addresses = bootContext.addresses; } - virtual void visitRoots(BootImage* image, HeapWalker* w) { - image->methodTree = w->visitRoot(methodTree); - image->methodTreeSentinal = w->visitRoot(methodTreeSentinal); - image->virtualThunks = w->visitRoot(virtualThunks); + virtual void visitRoots(HeapWalker* w) { + bootImage->methodTree = w->visitRoot(methodTree); + bootImage->methodTreeSentinal = w->visitRoot(methodTreeSentinal); + bootImage->virtualThunks = w->visitRoot(virtualThunks); } - virtual unsigned* makeCallTable(Thread* t, BootImage* image, HeapWalker* w, - uint8_t* code) - { - image->callCount = callTableSize; + virtual unsigned* makeCallTable(Thread* t, HeapWalker* w) { + bootImage->codeSize = codeAllocator.offset; + bootImage->callCount = callTableSize; unsigned* table = static_cast (t->m->heap->allocate(callTableSize * sizeof(unsigned) * 2)); @@ -6290,7 +6285,7 @@ class MyProcessor: public Processor { for (unsigned i = 0; i < arrayLength(t, callTable); ++i) { for (object p = arrayBody(t, callTable, i); p; p = callNodeNext(t, p)) { table[index++] = callNodeAddress(t, p) - - reinterpret_cast(code); + - reinterpret_cast(codeAllocator.base); table[index++] = w->map()->find(callNodeTarget(t, p)) | (static_cast(callNodeFlags(t, p)) << BootShift); } @@ -6300,9 +6295,11 @@ class MyProcessor: public Processor { } virtual void boot(Thread* t, BootImage* image) { - codeAllocator.base = static_cast - (s->tryAllocateExecutable(ExecutableAreaSizeInBytes)); - codeAllocator.capacity = ExecutableAreaSizeInBytes; + if (codeAllocator.base == 0) { + codeAllocator.base = static_cast + (s->tryAllocateExecutable(ExecutableAreaSizeInBytes)); + codeAllocator.capacity = ExecutableAreaSizeInBytes; + } if (image) { ::boot(static_cast(t), image); @@ -6313,7 +6310,7 @@ class MyProcessor: public Processor { set(t, methodTree, TreeNodeLeft, methodTreeSentinal); set(t, methodTree, TreeNodeRight, methodTreeSentinal); - ::compileThunks(static_cast(t), &codeAllocator, this, 0, 0); + ::compileThunks(static_cast(t), &codeAllocator, this); } segFaultHandler.m = t->m; @@ -6389,6 +6386,7 @@ class MyProcessor: public Processor { object rewindMethod; SegFaultHandler segFaultHandler; FixedAllocator codeAllocator; + BootImage* bootImage; }; object @@ -6697,9 +6695,9 @@ fixupVirtualThunks(MyThread* t, BootImage* image, uint8_t* code) MyProcessor* p = processor(t); for (unsigned i = 0; i < wordArrayLength(t, p->virtualThunks); ++i) { - if (wordArrayBody(t, p->virtualThunks, 0)) { - wordArrayBody(t, p->virtualThunks, 0) - = (wordArrayBody(t, p->virtualThunks, 0) - image->codeBase) + if (wordArrayBody(t, p->virtualThunks, i)) { + wordArrayBody(t, p->virtualThunks, i) + = (wordArrayBody(t, p->virtualThunks, i) - image->codeBase) + reinterpret_cast(code); } } @@ -6779,8 +6777,7 @@ getThunk(MyThread* t, Thunk thunk) } void -compileThunks(MyThread* t, Allocator* allocator, MyProcessor* p, - BootImage* image, uint8_t* imageBase) +compileThunks(MyThread* t, Allocator* allocator, MyProcessor* p) { class ThunkContext { public: @@ -6905,6 +6902,9 @@ compileThunks(MyThread* t, Allocator* allocator, MyProcessor* p, p->defaultThunk = finish (t, allocator, defaultContext.context.assembler, "default"); + BootImage* image = p->bootImage; + uint8_t* imageBase = p->codeAllocator.base; + { void* call; defaultContext.promise.listener->resolve (reinterpret_cast(voidPointer(compileMethod)), &call); diff --git a/src/interpret.cpp b/src/interpret.cpp index a85ecdc056..1f14762a5f 100644 --- a/src/interpret.cpp +++ b/src/interpret.cpp @@ -3217,7 +3217,7 @@ class MyProcessor: public Processor { return 0; } - virtual void initialize(vm::Thread*, BootImage*, uint8_t*, unsigned) { + virtual void initialize(BootImage*, uint8_t*, unsigned) { abort(s); } @@ -3227,13 +3227,11 @@ class MyProcessor: public Processor { abort(s); } - virtual void visitRoots(BootImage*, HeapWalker*) { + virtual void visitRoots(HeapWalker*) { abort(s); } - virtual unsigned* makeCallTable(vm::Thread*, BootImage*, HeapWalker*, - uint8_t*) - { + virtual unsigned* makeCallTable(vm::Thread*, HeapWalker*) { abort(s); } diff --git a/src/processor.h b/src/processor.h index 13d4328d5f..234c7b8afe 100644 --- a/src/processor.h +++ b/src/processor.h @@ -117,18 +117,17 @@ class Processor { getStackTrace(Thread* t, Thread* target) = 0; virtual void - initialize(Thread* t, BootImage* image, uint8_t* code, - unsigned capacity) = 0; + initialize(BootImage* image, uint8_t* code, unsigned capacity) = 0; virtual void compileMethod(Thread* t, Zone* zone, object* constants, object* calls, DelayedPromise** addresses, object method) = 0; virtual void - visitRoots(BootImage* image, HeapWalker* w) = 0; + visitRoots(HeapWalker* w) = 0; virtual unsigned* - makeCallTable(Thread* t, BootImage* image, HeapWalker* w, uint8_t* code) = 0; + makeCallTable(Thread* t, HeapWalker* w) = 0; virtual void boot(Thread* t, BootImage* image) = 0;