ExternalVendorCode/corda
1
0
Fork 0
mirror of https://github.com/corda/corda.git synced 2025-03-17 17:45:17 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

code cleanup and build fixes

Browse Source
This commit is contained in:
Joel Dice 2009-05-04 19:04:17 -06:00
parent 0cd4eb2655
commit eb3bd25aa1
12 changed files with 116 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/arch.h
View File

@ -14,7 +14,8 @@
#include "common.h"
extern "C" void NO_RETURN
vmJump(void* address, void* base, void* stack, void* thread);
vmJump(void* address, void* base, void* stack, void* thread,
uintptr_t returnLow, uintptr_t returnHigh);
#if (defined __i386__) || (defined __x86_64__)
# include "x86.h"

28
src/compile-x86.S
View File

@ -15,6 +15,19 @@
.text
#ifdef __x86_64__
#define THREAD_CONTINUATION 168
#define THREAD_EXCEPTION 64
#define THREAD_EXCEPTION_STACK 176
#define THREAD_EXCEPTION_OFFSET 184
#define THREAD_EXCEPTION_HANDLER 192
#define CONTINUATION_NEXT 8
#define CONTINUATION_ADDRESS 24
#define CONTINUATION_RETURN_ADDRESS_OFFSET 32
#define CONTINUATION_FRAME_POINTER_OFFSET 40
#define CONTINUATION_LENGTH 48
#define CONTINUATION_BODY 56
.globl vmInvoke
vmInvoke:
@ -65,12 +78,13 @@ LOCAL(vmInvoke_returnAddress):
// restore stack pointer
movq %rbp,%rsp
// call the next continuation frame, if any
// call the next continuation, if any
movq THREAD_CONTINUATION(%rbx),%rcx
cmpq $0,%rcx
je LOCAL(vmInvoke_exit)
movq CONTINUATION_SIZE(%rcx),%rsi
movq CONTINUATION_LENGTH(%rcx),%rsi
shrq $3,%rsi
subq %rsi,%rsp
movq CONTINUATION_BODY(%rcx),%rdi
@ -88,7 +102,8 @@ LOCAL(vmInvoke_continuationTest):
jb LOCAL(vmInvoke_continuationLoop)
movq CONTINUATION_RETURN_ADDRESS_OFFSET(%rcx),%rdi
movq LOCAL(vmInvoke_returnAddress),(%rsp,%rdi,1)
movq LOCAL(vmInvoke_returnAddress)@GOTPCREL(%rip),%r10
movq %r10,(%rsp,%rdi,1)
movq CONTINUATION_FRAME_POINTER_OFFSET(%rcx),%rdi
movq %rbp,(%rsp,%rdi,1)
@ -100,8 +115,10 @@ LOCAL(vmInvoke_continuationTest):
// call the continuation unless we're handling an exception
movq THREAD_EXCEPTION(%rbx),%rsi
cmpq $0,%rsi
je *CONTINUATION_ADDRESS(%rcx)
jne LOCAL(vmInvoke_handleException)
jmp *CONTINUATION_ADDRESS(%rcx)
LOCAL(vmInvoke_handleException):
// we're handling an exception - call the exception handler instead
movq $0,THREAD_EXCEPTION(%rbx)
movq THREAD_EXCEPTION_STACK(%rbx),%rsp
@ -137,7 +154,8 @@ vmCallWithContinuation:
movq %rdi,%rdx
movq %r8,%rbp
movq %r9,%rsp
movq LOCAL(vmInvoke_returnAddress),(%rsp)
movq LOCAL(vmInvoke_returnAddress)@GOTPCREL(%rip),%r10
movq %r10,(%rsp)
movq %rcx,8(%rsp)
movq %rdx,16(%rsp)
jmp *%rsi

99
src/compile.cpp
View File

@ -22,6 +22,10 @@ extern "C" uint64_t
vmInvoke(void* thread, void* function, void* arguments,
unsigned argumentFootprint, unsigned frameSize, unsigned returnType);
extern "C" uint64_t
vmCallWithContinuation(void* thread, void* function, void* targetObject,
object continuation, void* base, void* stack);
extern "C" void
vmCall();
@ -118,7 +122,7 @@ parameterOffset(MyThread* t, object method)
}
object
resolveThisPointer(MyThread* t, void* stack, object method)
resolveThisPointer(MyThread* t, void* stack)
{
return reinterpret_cast<object*>(stack)
[t->arch->frameFooterSize() + t->arch->frameReturnAddressSize()];
@ -127,7 +131,7 @@ resolveThisPointer(MyThread* t, void* stack, object method)
object
resolveTarget(MyThread* t, void* stack, object method)
{
object class_ = objectClass(t, resolveThisPointer(t, stack, method));
object class_ = objectClass(t, resolveThisPointer(t, stack));
if (classVmFlags(t, class_) & BootstrapFlag) {
PROTECT(t, method);
@ -211,6 +215,7 @@ class MyStackWalker: public Processor::StackWalker {
enum State {
Start,
Next,
Continuation,
Method,
NativeMethod,
Finish
@ -351,7 +356,7 @@ class MyStackWalker: public Processor::StackWalker {
virtual int ip() {
switch (state) {
case Continuation:
return continuationAddress(t, continuation)
return reinterpret_cast<intptr_t>(continuationAddress(t, continuation))
- methodCompiled(t, continuationMethod(t, continuation));
case Method:
@ -1359,7 +1364,7 @@ findExceptionHandler(Thread* t, object method, void* ip)
}
void
releaseLock(MyThread* t, object method)
releaseLock(MyThread* t, object method, void* stack)
{
if (methodFlags(t, method) & ACC_SYNCHRONIZED) {
object lock;
@ -1413,7 +1418,7 @@ findUnwindTarget(MyThread* t, void** targetIp, void** targetBase,
t->arch->nextFrame(&stack, &base);
ip = t->arch->frameIp(stack);
releaseLock(t, method);
releaseLock(t, method, stack);
}
} else {
*targetIp = ip;
@ -1430,15 +1435,19 @@ findUnwindTarget(MyThread* t, void** targetIp, void** targetBase,
t->exceptionHandler = handler;
t->exceptionStack = stackForFrame
(t, *targetStack, continuationMethod(t, t->continuation));
(t, stack, continuationMethod(t, t->continuation));
t->exceptionOffset = localOffset(t, localSize(t, method), method);
break;
} else {
releaseLock(t, continuationMethod(t, t->continuation));
releaseLock(t, continuationMethod(t, t->continuation),
reinterpret_cast<uint8_t*>(t->continuation)
+ ContinuationBody
+ continuationReturnAddressOffset(t, t->continuation)
-t->arch->returnAddressOffset());
}
t->continuation = continuationNext(t, t->continuation)
t->continuation = continuationNext(t, t->continuation);
}
}
}
@ -1470,7 +1479,7 @@ makeCurrentContinuation(MyThread* t, void** targetIp, void** targetBase,
if (method) {
PROTECT(t, method);
void** top = static_cast<void**>(stack) - t->arch->frameHeader();;
void** top = static_cast<void**>(stack) - t->arch->frameHeaderSize();
unsigned argumentFootprint
= t->arch->argumentFootprint(methodParameterFootprint(t, target));
unsigned alignment = t->arch->stackAlignmentInWords();
@ -1526,7 +1535,7 @@ unwind(MyThread* t)
void* base;
void* stack;
findUnwindTarget(t, &ip, &base, &stack);
vmJump(ip, base, stack, t);
vmJump(ip, base, stack, t, 0, 0);
}
object&
@ -4820,7 +4829,40 @@ compileVirtualMethod(MyThread* t)
}
}
inline uint64_t
void
resolveNative(MyThread* t, object method)
{
PROTECT(t, method);
assert(t, methodFlags(t, method) & ACC_NATIVE);
initClass(t, methodClass(t, method));
if (LIKELY(t->exception == 0)
and methodCompiled(t, method) == defaultThunk(t))
{
void* function = resolveNativeMethod(t, method);
if (UNLIKELY(function == 0)) {
object message = makeString
(t, "%s.%s%s",
&byteArrayBody(t, className(t, methodClass(t, method)), 0),
&byteArrayBody(t, methodName(t, method), 0),
&byteArrayBody(t, methodSpec(t, method), 0));
t->exception = makeUnsatisfiedLinkError(t, message);
return;
}
// ensure other threads see updated methodVmFlags before
// methodCompiled, since we don't want them using the slow calling
// convention on a function that expects the fast calling
// convention:
memoryBarrier();
methodCompiled(t, method) = reinterpret_cast<uintptr_t>(function);
}
}
uint64_t
invokeNativeFast(MyThread* t, object method)
{
return reinterpret_cast<FastNativeFunction>(methodCompiled(t, method))
@ -5200,7 +5242,8 @@ walkContinuationBody(MyThread* t, Heap::Walker* w, object c, int start)
int bodyStart = max(0, start - ContinuationReferenceCount);
object method = t->m->heap->follow(continuationMethod(t, c));
object method = static_cast<object>
(t->m->heap->follow(continuationMethod(t, c)));
unsigned count = frameMapSizeInBits(t, method);
if (count) {
@ -5219,7 +5262,7 @@ walkContinuationBody(MyThread* t, Heap::Walker* w, object c, int start)
((continuationFramePointerOffset(t, c) / BytesPerWord)
- t->arch->framePointerOffset()
- stackOffsetFromFrame(t, method)
+ localOffsetFromStack(c, i, method)))
+ localOffsetFromStack(t, i, method)))
{
return;
}
@ -5241,11 +5284,14 @@ callWithContinuation(MyThread* t, object method, object this_,
}
vmCallWithContinuation
(t, methodAddress(t, method), this_, continuation, base,
(t, reinterpret_cast<void*>(methodAddress(t, method)),
this_,
continuation,
base,
static_cast<void**>(stack)
- t->arch->argumentFootprint(methodParameterFootprint(t, method))
- t->arch->frameFooterSize()
- t->arch->returnAddressSize());
- t->arch->frameReturnAddressSize());
}
class ArgumentList {
@ -5516,6 +5562,7 @@ class MyProcessor: public Processor {
MyThread* t = new (m->heap->allocate(sizeof(MyThread)))
MyThread(m, javaThread, static_cast<MyThread*>(parent));
t->init();
return t;
}
@ -5905,23 +5952,23 @@ class MyProcessor: public Processor {
(t->m->system->handleSegFault(&segFaultHandler)));
}
virtual void callWithCurrentContinuation(Thread* t, object method,
virtual void callWithCurrentContinuation(Thread* vmt, object method,
object this_)
{
object coninuation;
MyThread* t = static_cast<MyThread*>(vmt);
object continuation;
void* base;
void* stack;
{ PROTECT(t, method);
PROTECT(t, this_);
compile(static_cast<MyThread*>(t),
::codeAllocator(static_cast<MyThread*>(t)), 0, method);
compile(t, ::codeAllocator(t), 0, method);
if (LIKELY(t->exception == 0)) {
void* ip;
continuation = makeCurrentContinuation
(static_cast<MyThread*>(t), &ip, &base, &stack);
continuation = makeCurrentContinuation(t, &ip, &base, &stack);
}
}
@ -5930,8 +5977,11 @@ class MyProcessor: public Processor {
}
}
virtual void callContinuation(Thread* t, object continuation, object result)
virtual void callContinuation(Thread* vmt, object continuation,
object result)
{
MyThread* t = static_cast<MyThread*>(vmt);
assert(t, t->exception == 0);
void* ip;
@ -5943,7 +5993,8 @@ class MyProcessor: public Processor {
t->trace->targetMethod = 0;
t->continuation = continuation;
vmJump(ip, base, stack, t, result, 0);
vmJump(ip, base, stack, t, reinterpret_cast<uintptr_t>(result), 0);
}
virtual void walkContinuationBody(Thread* t, Heap::Walker* w, object o,
@ -6401,7 +6452,7 @@ compileThunks(MyThread* t, Allocator* allocator, MyProcessor* p,
Assembler::Register class_(t->arch->virtualCallTarget());
Assembler::Memory virtualCallTargetSrc
(t->arch->stack(),
t->arch->frameFooterSize() + t->arch->returnAddressSize());
t->arch->frameFooterSize() + t->arch->frameReturnAddressSize());
a->apply(Move, BytesPerWord, MemoryOperand, &virtualCallTargetSrc,
BytesPerWord, RegisterOperand, &class_);

2
src/compiler.cpp
View File

@ -2420,7 +2420,7 @@ class CallEvent: public Event {
returnAddressSurrogate = stack->value;
addRead(c, this, stack->value, anyRegisterRead(c));
} else if (static_cast<int>(frameIndex) == framePointerIndex) {
framePointerSurrogate = s->value;
framePointerSurrogate = stack->value;
addRead(c, this, stack->value, anyRegisterRead(c));
} else {
addRead(c, this, stack->value, read

6
src/interpret.cpp
View File

@ -468,6 +468,12 @@ resolveNativeMethodData(Thread* t, object method)
if (LIKELY(p)) {
PROTECT(t, method);
object data = makeNativeMethodData(t, method, p);
// ensure other threads see updated methodVmFlags before
// methodCode, and that the native method data is initialized
// before it is visible to those threads:
memoryBarrier();
set(t, method, MethodCode, data);
return data;
} else {

2
src/machine.cpp
View File

@ -2757,8 +2757,6 @@ collect(Thread* t, Heap::CollectionType type)
Machine* m = t->m;
m->continuationClass = arrayBody(t, t->m->types, Machine::ContinuationType);
m->unsafe = true;
m->heap->collect(type, footprint(m->rootThread));
m->unsafe = false;

5
src/machine.h
View File

@ -92,8 +92,7 @@ const unsigned HasFinalMemberFlag = 1 << 6;
const unsigned ClassInitFlag = 1 << 0;
const unsigned CompiledFlag = 1 << 1;
const unsigned ConstructorFlag = 1 << 2;
const unsigned NativeResolved = 1 << 3;
const unsigned FastNative = 1 << 4;
const unsigned FastNative = 1 << 3;
typedef Machine JavaVM;
typedef Thread JNIEnv;
@ -1326,7 +1325,7 @@ class Thread {
#endif // VM_STRESS
};
typedef uint64_t (*FastNativeFunction)(Thread*, object, uintptr_t*) = 0;
typedef uint64_t (*FastNativeFunction)(Thread*, object, uintptr_t*);
inline object
objectClass(Thread*, object o)

2
src/posix.cpp
View File

@ -831,7 +831,7 @@ handleSignal(int signal, siginfo_t* info, void* context)
sigaddset(&set, SegFaultSignal);
sigprocmask(SIG_UNBLOCK, &set, 0);
vmJump(ip, base, stack, thread);
vmJump(ip, base, stack, thread, 0, 0);
}
} break;

5
src/process.cpp
View File

@ -199,17 +199,16 @@ resolveNativeMethod(Thread* t, object method, const char* prefix,
namespace vm {
void*
resolveNativeMethod2(Thread* t, object method)
resolveNativeMethod(Thread* t, object method)
{
void* p = ::resolveNativeMethod(t, method, "Java_", 5);
if (p) {
methodVmFlags(t, method) |= NativeResolved;
return p;
}
p = ::resolveNativeMethod(t, method, "Avian_", 6);
if (p) {
methodVmFlags(t, method) |= NativeResolved & FastNative;
methodVmFlags(t, method) |= FastNative;
return p;
}

30
src/process.h
View File

@ -126,35 +126,7 @@ isSpecialMethod(Thread* t, object method, object class_)
}
void*
resolveNativeMethod2(Thread* t, object method);
inline void
resolveNativeMethod(MyThread* t, object method)
{
PROTECT(t, method);
assert(t, methodFlags(t, method) & ACC_NATIVE);
initClass(t, methodClass(t, method));
if (UNLIKELY(t->exception)) return 0;
unsigned flags = methodVmFlags(t, method);
uintptr_t address = methodCompiled(t, method);
if ((flags & NativeResolved) == 0 or address == defaultThunk(t)) {
void* function = resolveNativeMethod2(t, method);
if (UNLIKELY(function == 0)) {
object message = makeString
(t, "%s.%s%s",
&byteArrayBody(t, className(t, methodClass(t, method)), 0),
&byteArrayBody(t, methodName(t, method), 0),
&byteArrayBody(t, methodSpec(t, method), 0));
t->exception = makeUnsatisfiedLinkError(t, message);
return;
}
methodCompiled(t, method) = reinterpret_cast<uintptr_t>(function);
}
}
resolveNativeMethod(Thread* t, object method);
inline object
findInterfaceMethod(Thread* t, object method, object class_)

2
src/processor.h
View File

@ -140,7 +140,7 @@ class Processor {
callContinuation(Thread* t, object continuation, object result) = 0;
virtual void
walkContiuationBody(Thread* t, Heap::Walker* w, object o, unsigned start)
walkContinuationBody(Thread* t, Heap::Walker* w, object o, unsigned start)
= 0;
object

2
src/x86.S
View File

@ -115,6 +115,8 @@ LOCAL(exit):
.globl vmJump
vmJump:
movq %r8,%rax
movq %r9,%rdx
movq %rsi,%rbp
movq %rdx,%rsp
movq %rcx,%rbx