fix bootimage build

This commit is contained in:
Joel Dice 2009-05-31 21:16:58 -06:00
parent 0debcf0f16
commit 11e61543a3
4 changed files with 70 additions and 76 deletions

View File

@ -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<intptr_t>(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<uint8_t*>(heap + position),
(t->m->system, reinterpret_cast<uint8_t*>(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<uint8_t*>(t->m->heap->allocate(CodeCapacity));
uintptr_t* codeMap = static_cast<uintptr_t*>
(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<unsigned*>
(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<unsigned*>
(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<uintptr_t>(code);
image->magic = BootImage::Magic;
image->codeBase = reinterpret_cast<uintptr_t>(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<uint8_t*>(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);

View File

@ -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<MyThread*>(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<unsigned*>
(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<uintptr_t>(code);
- reinterpret_cast<uintptr_t>(codeAllocator.base);
table[index++] = w->map()->find(callNodeTarget(t, p))
| (static_cast<unsigned>(callNodeFlags(t, p)) << BootShift);
}
@ -6300,9 +6295,11 @@ class MyProcessor: public Processor {
}
virtual void boot(Thread* t, BootImage* image) {
codeAllocator.base = static_cast<uint8_t*>
(s->tryAllocateExecutable(ExecutableAreaSizeInBytes));
codeAllocator.capacity = ExecutableAreaSizeInBytes;
if (codeAllocator.base == 0) {
codeAllocator.base = static_cast<uint8_t*>
(s->tryAllocateExecutable(ExecutableAreaSizeInBytes));
codeAllocator.capacity = ExecutableAreaSizeInBytes;
}
if (image) {
::boot(static_cast<MyThread*>(t), image);
@ -6313,7 +6310,7 @@ class MyProcessor: public Processor {
set(t, methodTree, TreeNodeLeft, methodTreeSentinal);
set(t, methodTree, TreeNodeRight, methodTreeSentinal);
::compileThunks(static_cast<MyThread*>(t), &codeAllocator, this, 0, 0);
::compileThunks(static_cast<MyThread*>(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<uintptr_t>(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<intptr_t>(voidPointer(compileMethod)), &call);

View File

@ -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);
}

View File

@ -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;