[vmkit-commits] [vmkit] r145038 - in /vmkit/trunk: include/ include/j3/ include/vmkit/ lib/J3/ClassLib/ lib/J3/ClassLib/GNUClasspath/ lib/J3/ClassLib/OpenJDK/ lib/J3/Compiler/ lib/J3/VMCore/ lib/vmkit/CommonThread/ lib/vmkit/Compiler/ lib/vmkit/MMTk/ lib/vmkit/Runtime/ mmtk/magic/ mmtk/mmtk-alloc/ mmtk/mmtk-j3/ tools/j3/ tools/precompiler/ tools/vmjc/
Gael Thomas
gael.thomas at lip6.fr
Mon Nov 21 03:03:33 PST 2011
Author: gthomas
Date: Mon Nov 21 05:03:32 2011
New Revision: 145038
URL: http://llvm.org/viewvc/llvm-project?rev=145038&view=rev
Log:
rename the namespace mvm into vmkit, no more mvm in the code\!
Modified:
vmkit/trunk/include/debug.h
vmkit/trunk/include/j3/J3Intrinsics.h
vmkit/trunk/include/j3/JavaAOTCompiler.h
vmkit/trunk/include/j3/JavaCompiler.h
vmkit/trunk/include/j3/LLVMInfo.h
vmkit/trunk/include/vmkit/Allocator.h
vmkit/trunk/include/vmkit/CollectionRV.h
vmkit/trunk/include/vmkit/Cond.h
vmkit/trunk/include/vmkit/GC.h
vmkit/trunk/include/vmkit/JIT.h
vmkit/trunk/include/vmkit/Locks.h
vmkit/trunk/include/vmkit/MethodInfo.h
vmkit/trunk/include/vmkit/ObjectLocks.h
vmkit/trunk/include/vmkit/System.h
vmkit/trunk/include/vmkit/Thread.h
vmkit/trunk/include/vmkit/UTF8.h
vmkit/trunk/include/vmkit/VirtualMachine.h
vmkit/trunk/include/vmkit/VmkitDenseMap.h
vmkit/trunk/include/vmkit/VmkitDenseSet.h
vmkit/trunk/lib/J3/ClassLib/ClassContext.inc
vmkit/trunk/lib/J3/ClassLib/ClasspathConstructor.inc
vmkit/trunk/lib/J3/ClassLib/ClasspathMethod.inc
vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc
vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc
vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc
vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h
vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h
vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
vmkit/trunk/lib/J3/ClassLib/Unsafe.inc
vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp
vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp
vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp
vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp
vmkit/trunk/lib/J3/VMCore/JavaArray.cpp
vmkit/trunk/lib/J3/VMCore/JavaClass.cpp
vmkit/trunk/lib/J3/VMCore/JavaClass.h
vmkit/trunk/lib/J3/VMCore/JavaConstantPool.cpp
vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h
vmkit/trunk/lib/J3/VMCore/JavaMetaJIT.cpp
vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
vmkit/trunk/lib/J3/VMCore/JavaObject.h
vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp
vmkit/trunk/lib/J3/VMCore/JavaString.cpp
vmkit/trunk/lib/J3/VMCore/JavaString.h
vmkit/trunk/lib/J3/VMCore/JavaThread.cpp
vmkit/trunk/lib/J3/VMCore/JavaThread.h
vmkit/trunk/lib/J3/VMCore/JavaTypes.cpp
vmkit/trunk/lib/J3/VMCore/JavaTypes.h
vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
vmkit/trunk/lib/J3/VMCore/Jnjvm.h
vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h
vmkit/trunk/lib/J3/VMCore/LinkJavaRuntime.h
vmkit/trunk/lib/J3/VMCore/LockedMap.h
vmkit/trunk/lib/J3/VMCore/Precompiled.cpp
vmkit/trunk/lib/J3/VMCore/Reader.h
vmkit/trunk/lib/J3/VMCore/ReferenceQueue.cpp
vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h
vmkit/trunk/lib/J3/VMCore/UTF8.h
vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp
vmkit/trunk/lib/J3/VMCore/Zip.cpp
vmkit/trunk/lib/J3/VMCore/Zip.h
vmkit/trunk/lib/vmkit/CommonThread/CollectionRV.cpp
vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp
vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x64.inc
vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x86.inc
vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-macos-x64.inc
vmkit/trunk/lib/vmkit/CommonThread/Sigsegv.cpp
vmkit/trunk/lib/vmkit/CommonThread/ctlock.cpp
vmkit/trunk/lib/vmkit/CommonThread/ctthread.cpp
vmkit/trunk/lib/vmkit/Compiler/Disassembler.cpp
vmkit/trunk/lib/vmkit/Compiler/EscapeAnalysis.cpp
vmkit/trunk/lib/vmkit/Compiler/InlineMalloc.cpp
vmkit/trunk/lib/vmkit/Compiler/JIT.cpp
vmkit/trunk/lib/vmkit/Compiler/VmkitGC.cpp
vmkit/trunk/lib/vmkit/MMTk/MutatorThread.h
vmkit/trunk/lib/vmkit/MMTk/VmkitGC.cpp
vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h
vmkit/trunk/lib/vmkit/Runtime/MethodInfo.cpp
vmkit/trunk/lib/vmkit/Runtime/Object.cpp
vmkit/trunk/lib/vmkit/Runtime/UTF8.cpp
vmkit/trunk/mmtk/magic/LowerMagic.cpp
vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp
vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp
vmkit/trunk/mmtk/mmtk-j3/Collection.cpp
vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp
vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h
vmkit/trunk/mmtk/mmtk-j3/MMTk_Events.cpp
vmkit/trunk/mmtk/mmtk-j3/Memory.cpp
vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp
vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp
vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp
vmkit/trunk/mmtk/mmtk-j3/Selected.cpp
vmkit/trunk/mmtk/mmtk-j3/Strings.cpp
vmkit/trunk/mmtk/mmtk-j3/VM.cpp
vmkit/trunk/tools/j3/Main.cpp
vmkit/trunk/tools/precompiler/Precompiler.cpp
vmkit/trunk/tools/vmjc/vmjc.cpp
Modified: vmkit/trunk/include/debug.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/debug.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/debug.h (original)
+++ vmkit/trunk/include/debug.h Mon Nov 21 05:03:32 2011
@@ -65,7 +65,7 @@
#endif
#define UNIMPLEMENTED() { \
- mvm::Thread::get()->printBacktrace(); \
+ vmkit::Thread::get()->printBacktrace(); \
fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \
abort(); } \
Modified: vmkit/trunk/include/j3/J3Intrinsics.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/J3Intrinsics.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/j3/J3Intrinsics.h (original)
+++ vmkit/trunk/include/j3/J3Intrinsics.h Mon Nov 21 05:03:32 2011
@@ -14,7 +14,7 @@
namespace j3 {
-class J3Intrinsics : public mvm::BaseIntrinsics {
+class J3Intrinsics : public vmkit::BaseIntrinsics {
public:
void init(llvm::Module* M);
Modified: vmkit/trunk/include/j3/JavaAOTCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/JavaAOTCompiler.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/j3/JavaAOTCompiler.h (original)
+++ vmkit/trunk/include/j3/JavaAOTCompiler.h Mon Nov 21 05:03:32 2011
@@ -21,7 +21,7 @@
class ClassBytes;
class JnjvmBootstrapLoader;
-using mvm::UTF8;
+using vmkit::UTF8;
class JavaAOTCompiler : public JavaLLVMCompiler {
@@ -98,8 +98,8 @@
llvm::Constant* CreateConstantFromJavaObject(JavaObject* obj);
llvm::Constant* CreateConstantFromClassBytes(ClassBytes* bytes);
llvm::Constant* CreateConstantFromJavaConstantPool(JavaConstantPool* ctp);
- llvm::Constant* CreateConstantFromClassMap(const mvm::VmkitDenseMap<const UTF8*, CommonClass*>& map);
- llvm::Constant* CreateConstantFromUTF8Map(const mvm::VmkitDenseSet<mvm::UTF8MapKey, const UTF8*>& set);
+ llvm::Constant* CreateConstantFromClassMap(const vmkit::VmkitDenseMap<const UTF8*, CommonClass*>& map);
+ llvm::Constant* CreateConstantFromUTF8Map(const vmkit::VmkitDenseSet<vmkit::UTF8MapKey, const UTF8*>& set);
void AddInitializerToClass(llvm::GlobalVariable* varGV, CommonClass* classDef);
llvm::Constant* getUTF8(const UTF8* val);
Modified: vmkit/trunk/include/j3/JavaCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/JavaCompiler.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/j3/JavaCompiler.h (original)
+++ vmkit/trunk/include/j3/JavaCompiler.h Mon Nov 21 05:03:32 2011
@@ -18,7 +18,7 @@
#include "vmkit/GC.h"
#include "vmkit/Allocator.h"
-namespace mvm {
+namespace vmkit {
class UTF8;
}
@@ -34,7 +34,7 @@
class JavaCompiler {
public:
- mvm::BumpPtrAllocator allocator;
+ vmkit::BumpPtrAllocator allocator;
virtual JavaCompiler* Create(const std::string&) {
return this;
@@ -106,8 +106,8 @@
return dlsym(handle, symbol);
}
- static const mvm::UTF8* InlinePragma;
- static const mvm::UTF8* NoInlinePragma;
+ static const vmkit::UTF8* InlinePragma;
+ static const vmkit::UTF8* NoInlinePragma;
virtual CommonClass* getUniqueBaseClass(CommonClass* cl) {
return 0;
Modified: vmkit/trunk/include/j3/LLVMInfo.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/LLVMInfo.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/j3/LLVMInfo.h (original)
+++ vmkit/trunk/include/j3/LLVMInfo.h Mon Nov 21 05:03:32 2011
@@ -36,7 +36,7 @@
uint8_t logSizeInBytesConstant;
};
-class LLVMClassInfo : public mvm::PermanentObject {
+class LLVMClassInfo : public vmkit::PermanentObject {
friend class JavaAOTCompiler;
friend class JavaJITCompiler;
friend class JavaLLVMCompiler;
@@ -75,7 +75,7 @@
}
};
-class LLVMMethodInfo : public mvm::PermanentObject {
+class LLVMMethodInfo : public vmkit::PermanentObject {
private:
/// Compiler - The compiler for this method info.
JavaLLVMCompiler* Compiler;
@@ -111,7 +111,7 @@
};
-class LLVMFieldInfo : public mvm::PermanentObject {
+class LLVMFieldInfo : public vmkit::PermanentObject {
private:
/// Compiler - The compiler for this field info.
JavaLLVMCompiler* Compiler;
@@ -133,7 +133,7 @@
}
};
-class LLVMSignatureInfo : public mvm::PermanentObject {
+class LLVMSignatureInfo : public vmkit::PermanentObject {
private:
/// Compiler - The compiler for this signature info.
JavaLLVMCompiler* Compiler;
Modified: vmkit/trunk/include/vmkit/Allocator.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Allocator.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Allocator.h (original)
+++ vmkit/trunk/include/vmkit/Allocator.h Mon Nov 21 05:03:32 2011
@@ -17,7 +17,7 @@
class VirtualTable;
-namespace mvm {
+namespace vmkit {
class BumpPtrAllocator {
private:
@@ -75,6 +75,6 @@
}
};
-} // end namespace mvm
+} // end namespace vmkit
#endif // VMKIT_ALLOCATOR_H
Modified: vmkit/trunk/include/vmkit/CollectionRV.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/CollectionRV.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/CollectionRV.h (original)
+++ vmkit/trunk/include/vmkit/CollectionRV.h Mon Nov 21 05:03:32 2011
@@ -14,7 +14,7 @@
#include "vmkit/Locks.h"
#include "vmkit/Thread.h"
-namespace mvm {
+namespace vmkit {
class CollectionRV {
protected:
@@ -46,13 +46,13 @@
void waitRV();
void startRV() {
- mvm::Thread::get()->inRV = true;
+ vmkit::Thread::get()->inRV = true;
lockRV();
}
void cancelRV() {
unlockRV();
- mvm::Thread::get()->inRV = false;
+ vmkit::Thread::get()->inRV = false;
}
void another_mark();
Modified: vmkit/trunk/include/vmkit/Cond.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Cond.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Cond.h (original)
+++ vmkit/trunk/include/vmkit/Cond.h Mon Nov 21 05:03:32 2011
@@ -13,7 +13,7 @@
#include <cstdlib>
#include <pthread.h>
-namespace mvm {
+namespace vmkit {
class Lock;
@@ -29,6 +29,6 @@
void signal(void) __attribute__ ((noinline));
};
-} // end namespace mvm
+} // end namespace vmkit
#endif // VMKIT_COND_H
Modified: vmkit/trunk/include/vmkit/GC.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/GC.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/GC.h (original)
+++ vmkit/trunk/include/vmkit/GC.h Mon Nov 21 05:03:32 2011
@@ -35,7 +35,7 @@
}
};
-namespace mvm {
+namespace vmkit {
// TODO(ngeoffray): Make these two constants easily configurable. For now they
// work for all our supported GCs.
static const uint32_t GCBits = 8;
Modified: vmkit/trunk/include/vmkit/JIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/JIT.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/JIT.h (original)
+++ vmkit/trunk/include/vmkit/JIT.h Mon Nov 21 05:03:32 2011
@@ -38,7 +38,7 @@
class Type;
}
-namespace mvm {
+namespace vmkit {
class LockRecursive;
@@ -171,7 +171,7 @@
class VmkitModule {
public:
- static mvm::LockRecursive protectEngine;
+ static vmkit::LockRecursive protectEngine;
static void runPasses(llvm::Function* func, llvm::FunctionPassManager*);
static void initialise(int argc, char** argv);
@@ -179,7 +179,7 @@
static Frames* addToVM(VirtualMachine* VM,
llvm::GCFunctionInfo* GFI,
llvm::JIT* jit,
- mvm::BumpPtrAllocator& allocator,
+ vmkit::BumpPtrAllocator& allocator,
void* meta);
static int disassemble(unsigned int* addr);
@@ -192,6 +192,6 @@
static const char* getHostTriple();
};
-} // end namespace mvm
+} // end namespace vmkit
#endif // VMKIT_JIT_H
Modified: vmkit/trunk/include/vmkit/Locks.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Locks.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Locks.h (original)
+++ vmkit/trunk/include/vmkit/Locks.h Mon Nov 21 05:03:32 2011
@@ -21,7 +21,7 @@
class gc;
-namespace mvm {
+namespace vmkit {
class Cond;
class FatLock;
@@ -42,7 +42,7 @@
protected:
/// owner - Which thread is currently holding the lock?
///
- mvm::Thread* owner;
+ vmkit::Thread* owner;
/// internalLock - The lock implementation of the platform.
///
@@ -72,7 +72,7 @@
/// getOwner - Get the thread that is holding the lock.
///
- mvm::Thread* getOwner();
+ vmkit::Thread* getOwner();
};
@@ -81,7 +81,7 @@
friend class Cond;
private:
virtual void unsafeLock(int n) {
- owner = mvm::Thread::get();
+ owner = vmkit::Thread::get();
}
virtual int unsafeUnlock() {
@@ -107,7 +107,7 @@
virtual void unsafeLock(int a) {
n = a;
- owner = mvm::Thread::get();
+ owner = vmkit::Thread::get();
}
virtual int unsafeUnlock() {
@@ -162,7 +162,7 @@
}
while (__sync_val_compare_and_swap(&locked, 0, 1))
- mvm::Thread::yield();
+ vmkit::Thread::yield();
}
void lock() { acquire(); }
@@ -176,6 +176,6 @@
};
-} // end namespace mvm
+} // end namespace vmkit
#endif // VMKIT_LOCKS_H
Modified: vmkit/trunk/include/vmkit/MethodInfo.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/MethodInfo.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/MethodInfo.h (original)
+++ vmkit/trunk/include/vmkit/MethodInfo.h Mon Nov 21 05:03:32 2011
@@ -14,7 +14,7 @@
#include "vmkit/System.h"
#include "vmkit/GC.h"
-namespace mvm {
+namespace vmkit {
class FrameInfo {
public:
@@ -48,7 +48,7 @@
reinterpret_cast<word_t>(this) + kWordSize);
}
- void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator, uint32_t NumDescriptors, uint32_t NumOffsets) {
+ void* operator new(size_t sz, vmkit::BumpPtrAllocator& allocator, uint32_t NumDescriptors, uint32_t NumOffsets) {
Frames* res = reinterpret_cast<Frames*>(
allocator.Allocate(kWordSize + NumDescriptors * MethodInfoHelper::FrameInfoSize(NumOffsets), "Frames"));
assert(System::IsWordAligned(reinterpret_cast<word_t>(res)));
@@ -95,5 +95,5 @@
}
};
-} // end namespace mvm
+} // end namespace vmkit
#endif // VMKIT_METHODINFO_H
Modified: vmkit/trunk/include/vmkit/ObjectLocks.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/ObjectLocks.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/ObjectLocks.h (original)
+++ vmkit/trunk/include/vmkit/ObjectLocks.h Mon Nov 21 05:03:32 2011
@@ -16,7 +16,7 @@
#include "vmkit/Locks.h"
#include "vmkit/Thread.h"
-namespace mvm {
+namespace vmkit {
class FatLock;
class LockSystem;
@@ -26,7 +26,7 @@
/// varcond - Condition variable when the thread needs to be awaken from
/// a wait.
///
- mvm::Cond varcond;
+ vmkit::Cond varcond;
/// interruptFlag - Has this thread been interrupted?
///
@@ -65,10 +65,10 @@
};
-class FatLock : public mvm::PermanentObject {
+class FatLock : public vmkit::PermanentObject {
private:
- mvm::LockRecursive internalLock;
- mvm::SpinLock spinLock;
+ vmkit::LockRecursive internalLock;
+ vmkit::SpinLock spinLock;
uint32_t waitingThreads;
uint32_t lockingThreads;
LockingThread* firstThread;
@@ -82,7 +82,7 @@
bool acquire(gc* object);
void acquireAll(gc* object, word_t count);
void release(gc* object, LockSystem& table);
- mvm::Thread* getOwner();
+ vmkit::Thread* getOwner();
bool owner();
gc* getAssociatedObject() { return associatedObject; }
gc** getAssociatedObjectPtr() { return &associatedObject; }
@@ -108,7 +108,7 @@
static const uint32_t BitMask = IndexSize - 1;
static const uint32_t MaxLocks = GlobalSize * IndexSize;
- mvm::BumpPtrAllocator& allocator;
+ vmkit::BumpPtrAllocator& allocator;
/// LockTable - The global table that will hold the locks. The table is
/// a two-dimensional array, and only one entry is created, so that
@@ -127,7 +127,7 @@
/// threadLock - Spin lock to protect the currentIndex field.
///
- mvm::SpinLock threadLock;
+ vmkit::SpinLock threadLock;
/// allocate - Allocate a FatLock.
///
@@ -139,7 +139,7 @@
/// LockSystem - Default constructor. Initialize the table.
///
- LockSystem(mvm::BumpPtrAllocator& allocator);
+ LockSystem(vmkit::BumpPtrAllocator& allocator);
/// getLock - Get a lock from an index in the table.
///
@@ -196,6 +196,6 @@
static FatLock* getFatLock(gc* object, LockSystem& table);
};
-} // end namespace mvm
+} // end namespace vmkit
#endif // VMKIT_OBJECT_LOCKS_H
Modified: vmkit/trunk/include/vmkit/System.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/System.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/System.h (original)
+++ vmkit/trunk/include/vmkit/System.h Mon Nov 21 05:03:32 2011
@@ -56,7 +56,7 @@
typedef uint32_t word_t;
#endif
-namespace mvm {
+namespace vmkit {
const int kWordSize = sizeof(word_t);
const int kWordSizeLog2 = kWordSize == 4 ? 2 : 3;
@@ -95,9 +95,9 @@
const word_t kGCMemorySize = 0x30000000;
-#define TRY { mvm::ExceptionBuffer __buffer__; if (!SETJMP(__buffer__.buffer))
+#define TRY { vmkit::ExceptionBuffer __buffer__; if (!SETJMP(__buffer__.buffer))
#define CATCH else
-#define IGNORE else { mvm::Thread::get()->clearException(); }}
+#define IGNORE else { vmkit::Thread::get()->clearException(); }}
#define END_CATCH }
class System {
@@ -223,9 +223,9 @@
static uint8_t* GetLastBytePtr(word_t ptr) {
#if ARCH_PPC
- return ((uint8_t*)ptr) + 2 * mvm::kWordSize - 1;
+ return ((uint8_t*)ptr) + 2 * vmkit::kWordSize - 1;
#else
- return ((uint8_t*)ptr) + mvm::kWordSize;
+ return ((uint8_t*)ptr) + vmkit::kWordSize;
#endif
}
Modified: vmkit/trunk/include/vmkit/Thread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/Thread.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/Thread.h (original)
+++ vmkit/trunk/include/vmkit/Thread.h Mon Nov 21 05:03:32 2011
@@ -20,7 +20,7 @@
#include "vmkit/System.h"
-namespace mvm {
+namespace vmkit {
class FrameInfo;
class VirtualMachine;
@@ -137,7 +137,7 @@
/// start - Start the execution of a thread.
///
- virtual int start(void (*fct)(mvm::Thread*));
+ virtual int start(void (*fct)(vmkit::Thread*));
uint64_t getThreadID() {
return (uint64_t)this;
@@ -188,7 +188,7 @@
/// internalThreadStart - The implementation sepcific thread starter
/// function.
///
- static void internalThreadStart(mvm::Thread* th);
+ static void internalThreadStart(vmkit::Thread* th);
/// internalClearException - Clear any pending exception.
///
@@ -247,11 +247,11 @@
/// releaseThread - Free the stack so that another thread can use it.
///
- static void releaseThread(mvm::Thread* th);
+ static void releaseThread(vmkit::Thread* th);
/// routine - The function to invoke when the thread starts.
///
- void (*routine)(mvm::Thread*);
+ void (*routine)(vmkit::Thread*);
/// printBacktrace - Print the backtrace.
///
@@ -329,9 +329,9 @@
word_t addr;
word_t ip;
KnownFrame* frame;
- mvm::Thread* thread;
+ vmkit::Thread* thread;
- StackWalker(mvm::Thread* th) __attribute__ ((noinline));
+ StackWalker(vmkit::Thread* th) __attribute__ ((noinline));
void operator++();
word_t operator*();
FrameInfo* get();
@@ -339,5 +339,5 @@
};
-} // end namespace mvm
+} // end namespace vmkit
#endif // VMKIT_THREAD_H
Modified: vmkit/trunk/include/vmkit/UTF8.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/UTF8.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/UTF8.h (original)
+++ vmkit/trunk/include/vmkit/UTF8.h Mon Nov 21 05:03:32 2011
@@ -6,7 +6,7 @@
#include "vmkit/VmkitDenseMap.h"
#include "vmkit/VmkitDenseSet.h"
-namespace mvm {
+namespace vmkit {
class UTF8Map;
@@ -16,7 +16,7 @@
/// operator new - Redefines the new operator of this class to allocate
/// its objects in permanent memory, not with the garbage collector.
- void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator, sint32 n) {
+ void* operator new(size_t sz, vmkit::BumpPtrAllocator& allocator, sint32 n) {
return allocator.Allocate(sizeof(UTF8) + (n - 1) * sizeof(uint16), "UTF8");
}
@@ -119,7 +119,7 @@
}
};
-class UTF8Map : public mvm::PermanentObject {
+class UTF8Map : public vmkit::PermanentObject {
public:
typedef VmkitDenseSet<UTF8MapKey, const UTF8*>::iterator iterator;
@@ -185,6 +185,6 @@
}
};
-} // end namespace mvm
+} // end namespace vmkit
#endif
Modified: vmkit/trunk/include/vmkit/VirtualMachine.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/VirtualMachine.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/VirtualMachine.h (original)
+++ vmkit/trunk/include/vmkit/VirtualMachine.h Mon Nov 21 05:03:32 2011
@@ -20,7 +20,7 @@
#include <cassert>
#include <map>
-namespace mvm {
+namespace vmkit {
class CompiledFrames;
class FrameInfo;
@@ -36,7 +36,7 @@
/// FunctionMapLock - Spin lock to protect the Functions map.
///
- mvm::SpinLock FunctionMapLock;
+ vmkit::SpinLock FunctionMapLock;
/// IPToFrameInfo - Map a code start instruction instruction to the FrameInfo.
///
@@ -57,7 +57,7 @@
/// VirtualMachine - This class is the root of virtual machine classes. It
/// defines what a VM should be.
///
-class VirtualMachine : public mvm::PermanentObject {
+class VirtualMachine : public vmkit::PermanentObject {
protected:
VirtualMachine(BumpPtrAllocator &Alloc, CompiledFrames** frames) :
allocator(Alloc), FunctionsCache(Alloc, frames) {
@@ -75,7 +75,7 @@
/// allocator - Bump pointer allocator to allocate permanent memory
/// related to this VM.
///
- mvm::BumpPtrAllocator& allocator;
+ vmkit::BumpPtrAllocator& allocator;
//===----------------------------------------------------------------------===//
// (1) Thread-related methods.
@@ -83,7 +83,7 @@
/// mainThread - The main thread of this VM.
///
- mvm::Thread* mainThread;
+ vmkit::Thread* mainThread;
/// NumberOfThreads - The number of threads that currently run under this VM.
///
@@ -91,29 +91,29 @@
/// ThreadLock - Lock to create or destroy a new thread.
///
- mvm::LockNormal threadLock;
+ vmkit::LockNormal threadLock;
/// ThreadVar - Condition variable to wake up the thread manager.
- mvm::Cond threadVar;
+ vmkit::Cond threadVar;
/// exitingThread - Thread that is currently exiting. Used by the thread
/// manager to free the resources (stack) used by a thread.
- mvm::Thread* exitingThread;
+ vmkit::Thread* exitingThread;
/// doExit - Should the VM exit now?
bool doExit;
/// setMainThread - Set the main thread of this VM.
///
- void setMainThread(mvm::Thread* th) { mainThread = th; }
+ void setMainThread(vmkit::Thread* th) { mainThread = th; }
/// getMainThread - Get the main thread of this VM.
///
- mvm::Thread* getMainThread() const { return mainThread; }
+ vmkit::Thread* getMainThread() const { return mainThread; }
/// addThread - Add a new thread to the list of threads.
///
- void addThread(mvm::Thread* th) {
+ void addThread(vmkit::Thread* th) {
threadLock.lock();
numberOfThreads++;
if (th != mainThread) {
@@ -125,7 +125,7 @@
/// removeThread - Remove the thread from the list of threads.
///
- void removeThread(mvm::Thread* th) {
+ void removeThread(vmkit::Thread* th) {
threadLock.lock();
while (exitingThread != NULL) {
// Make sure the thread manager had a chance to consume the previous
@@ -233,5 +233,5 @@
virtual void stackOverflowError() = 0;
};
-} // end namespace mvm
+} // end namespace vmkit
#endif // VMKIT_VIRTUALMACHINE_H
Modified: vmkit/trunk/include/vmkit/VmkitDenseMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/VmkitDenseMap.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/VmkitDenseMap.h (original)
+++ vmkit/trunk/include/vmkit/VmkitDenseMap.h Mon Nov 21 05:03:32 2011
@@ -26,7 +26,7 @@
#include <cstddef>
#include <cstring>
-namespace mvm {
+namespace vmkit {
template<typename T>
struct VmkitDenseMapInfo {
Modified: vmkit/trunk/include/vmkit/VmkitDenseSet.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/vmkit/VmkitDenseSet.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/include/vmkit/VmkitDenseSet.h (original)
+++ vmkit/trunk/include/vmkit/VmkitDenseSet.h Mon Nov 21 05:03:32 2011
@@ -27,7 +27,7 @@
#include <cstddef>
#include <cstring>
-namespace mvm {
+namespace vmkit {
template<typename ValueT,
typename ValueInfoT = VmkitDenseMapInfo<ValueT>,
@@ -486,6 +486,6 @@
}
};
-} // end namespace mvm
+} // end namespace vmkit
#endif
Modified: vmkit/trunk/lib/J3/ClassLib/ClassContext.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/ClassContext.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/ClassContext.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/ClassContext.inc Mon Nov 21 05:03:32 2011
@@ -17,7 +17,7 @@
Jnjvm* vm = th->getJVM();
uint32 length = th->getFrameContextLength();
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length * sizeof(uintptr_t));
uint32 finalSize = th->getJavaFrameContext((void**)buffer);
Modified: vmkit/trunk/lib/J3/ClassLib/ClasspathConstructor.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/ClasspathConstructor.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/ClasspathConstructor.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/ClasspathConstructor.inc Mon Nov 21 05:03:32 2011
@@ -95,7 +95,7 @@
if (isAbstract(cl->access)) vm->instantiationException(cl);
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
// Allocate a buffer to store the arguments.
jvalue* buf = size ?
(jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;
Modified: vmkit/trunk/lib/J3/ClassLib/ClasspathMethod.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/ClasspathMethod.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/ClasspathMethod.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/ClasspathMethod.inc Mon Nov 21 05:03:32 2011
@@ -115,7 +115,7 @@
Signdef* sign = meth->getSignature();
sint32 size = sign->nbArguments;
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
jvalue* buf = size ?
(jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;
Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h Mon Nov 21 05:03:32 2011
@@ -42,7 +42,7 @@
static void setProtectionDomain(JavaObjectClass* cl, JavaObject* pd) {
llvm_gcroot(cl, 0);
llvm_gcroot(pd, 0);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)cl, (gc**)&(cl->pd), (gc*)pd);
}
@@ -52,12 +52,12 @@
}
static void staticTracer(JavaObjectClass* obj, word_t closure) {
- mvm::Collector::markAndTrace(obj, &obj->pd, closure);
- mvm::Collector::markAndTrace(obj, &obj->signers, closure);
- mvm::Collector::markAndTrace(obj, &obj->constructor, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->pd, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->signers, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->constructor, closure);
if (obj->vmdata) {
JavaObject** Obj = obj->vmdata->classLoader->getJavaClassLoaderPtr();
- if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
+ if (*Obj) vmkit::Collector::markAndTraceRoot(Obj, closure);
}
}
@@ -81,8 +81,8 @@
public:
static void staticTracer(JavaObjectField* obj, word_t closure) {
- mvm::Collector::markAndTrace(obj, &obj->name, closure);
- mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->name, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaringClass, closure);
}
static JavaField* getInternalField(JavaObjectField* self) {
@@ -110,8 +110,8 @@
public:
static void staticTracer(JavaObjectMethod* obj, word_t closure) {
- mvm::Collector::markAndTrace(obj, &obj->name, closure);
- mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->name, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaringClass, closure);
}
static JavaMethod* getInternalMethod(JavaObjectMethod* self);
@@ -133,7 +133,7 @@
public:
static void staticTracer(JavaObjectConstructor* obj, word_t closure) {
- mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaringClass, closure);
}
static JavaMethod* getInternalMethod(JavaObjectConstructor* self);
@@ -155,7 +155,7 @@
public:
static void staticTracer(JavaObjectVMThread* obj, word_t closure) {
- mvm::Collector::markAndTrace(obj, &obj->thread, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->thread, closure);
}
static void setVmdata(JavaObjectVMThread* vmthread,
@@ -179,7 +179,7 @@
static void setDetailedMessage(JavaObjectThrowable* self, JavaObject* obj) {
llvm_gcroot(self, 0);
llvm_gcroot(obj, 0);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)self, (gc**)&(self->detailedMessage), (gc*)obj);
}
@@ -189,10 +189,10 @@
llvm_gcroot(stackTrace, 0);
stackTrace = internalFillInStackTrace(self);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)self, (gc**)&(self->vmState), (gc*)stackTrace);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)self, (gc**)&(self->cause), (gc*)self);
self->stackTrace = NULL;
@@ -210,9 +210,9 @@
llvm_gcroot(self, 0);
llvm_gcroot(r, 0);
llvm_gcroot(q, 0);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)self, (gc**)&(self->referent), (gc*)r);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)self, (gc**)&(self->queue), (gc*)q);
}
Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc Mon Nov 21 05:03:32 2011
@@ -75,7 +75,7 @@
typedef int (*onLoad_t)(const void**, void*);
extern "C" void j3EndJNI(uint32** old);
-extern "C" void j3StartJNI(uint32* num, uint32** old, mvm::KnownFrame* Frame);
+extern "C" void j3StartJNI(uint32* num, uint32** old, vmkit::KnownFrame* Frame);
extern "C" void callOnLoad(void* res, JnjvmClassLoader* loader, Jnjvm* vm)
__attribute__ ((noinline));
@@ -96,7 +96,7 @@
if (onLoad) {
uint32 num = 0;
uint32* old = 0;
- mvm::KnownFrame Frame;
+ vmkit::KnownFrame Frame;
j3StartJNI(&num, &old, &Frame);
doCall(onLoad, res, vm);
@@ -125,7 +125,7 @@
JnjvmClassLoader* loader =
JnjvmClassLoader::getJnjvmLoaderFromJavaObject(javaLoader, vm);
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char* buf = JavaString::strToAsciiz(str, &allocator);
res = loader->loadLib(buf);
@@ -146,7 +146,7 @@
) {
BEGIN_NATIVE_EXCEPTION(0)
- mvm::Collector::collect();
+ vmkit::Collector::collect();
END_NATIVE_EXCEPTION
}
@@ -157,7 +157,7 @@
jclass clazz,
#endif
) {
- mvm::Collector::collect();
+ vmkit::Collector::collect();
// Sleep a bit.
sleep(1);
return;
@@ -188,7 +188,7 @@
jclass clazz,
#endif
jint par1) {
- mvm::System::Exit(par1);
+ vmkit::System::Exit(par1);
}
JNIEXPORT jlong Java_java_lang_VMRuntime_freeMemory(
@@ -197,7 +197,7 @@
jclass clazz,
#endif
) {
- return (jlong)mvm::Collector::getFreeMemory();
+ return (jlong)vmkit::Collector::getFreeMemory();
}
JNIEXPORT jlong Java_java_lang_VMRuntime_totalMemory(
@@ -206,7 +206,7 @@
jclass clazz,
#endif
) {
- return (jlong)mvm::Collector::getTotalMemory();
+ return (jlong)vmkit::Collector::getTotalMemory();
}
JNIEXPORT jlong Java_java_lang_VMRuntime_maxMemory(
@@ -215,7 +215,7 @@
jclass clazz,
#endif
) {
- return (jlong)mvm::Collector::getMaxMemory();
+ return (jlong)vmkit::Collector::getMaxMemory();
}
JNIEXPORT jint Java_java_lang_VMRuntime_availableProcessors(){
@@ -223,7 +223,7 @@
JNIEnv *env,
jclass clazz,
#endif
- return mvm::System::GetNumberOfProcessors();
+ return vmkit::System::GetNumberOfProcessors();
}
}
Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc Mon Nov 21 05:03:32 2011
@@ -42,7 +42,7 @@
Jnjvm* vm = thread->getJVM();
// Wait some time to let the creator initialise these fields.
while ((thread->javaThread == NULL) || (thread->vmThread == NULL)) {
- mvm::Thread::yield();
+ vmkit::Thread::yield();
}
// Ok, now that the thread is created we can set the the value of vmdata,
@@ -95,7 +95,7 @@
JavaThread* th = new JavaThread(vm);
if (!th) vm->outOfMemoryError();
- th->start((void (*)(mvm::Thread*))start);
+ th->start((void (*)(vmkit::Thread*))start);
// Now that the thread has been created, initialise its object fields.
th->initialise(javaThread, vmThread);
@@ -118,16 +118,16 @@
// It's possible that the thread to be interrupted has not finished
// its initialization. Wait until the initialization is done.
while (field->getInstanceObjectField(vmthread) == 0)
- mvm::Thread::yield();
+ vmkit::Thread::yield();
JavaThread* th = (JavaThread*)field->getInstanceObjectField(vmthread);
th->lockingThread.interruptFlag = 1;
- mvm::FatLock* lock = th->lockingThread.waitsOn;
+ vmkit::FatLock* lock = th->lockingThread.waitsOn;
// If the thread is blocked on a wait. We also verify nextWaiting in case
// the thread has been notified.
if (lock && th->lockingThread.nextWaiting) {
- th->lockingThread.state = mvm::LockingThread::StateInterrupted;
+ th->lockingThread.state = vmkit::LockingThread::StateInterrupted;
// Make sure the thread is waiting.
uint32 locked = 0;
@@ -135,7 +135,7 @@
locked = (lock->tryAcquire() == 0);
if (locked || (lock->getOwner() != th && lock->getOwner() != 0))
break;
- else mvm::Thread::yield();
+ else vmkit::Thread::yield();
}
// Interrupt the thread.
@@ -211,7 +211,7 @@
jclass clazz,
#endif
) {
- mvm::Thread::yield();
+ vmkit::Thread::yield();
}
}
Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc Mon Nov 21 05:03:32 2011
@@ -47,7 +47,7 @@
}
// Don't call th->getFrameContext because it is not GC-safe.
- mvm::StackWalker Walker(th);
+ vmkit::StackWalker Walker(th);
uint32_t i = 0;
while (intptr_t ip = *Walker) {
@@ -83,7 +83,7 @@
}
-JavaObject* consStackElement(mvm::FrameInfo* FI, intptr_t ip) {
+JavaObject* consStackElement(vmkit::FrameInfo* FI, intptr_t ip) {
JavaString* methodName = 0;
JavaString* className = 0;
@@ -144,7 +144,7 @@
// on the stack.
sint32 index = 2;;
while (index != JavaArray::getSize(stack)) {
- mvm::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
+ vmkit::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
if (FI->Metadata == NULL) ++index;
else {
JavaMethod* meth = (JavaMethod*)FI->Metadata;
@@ -158,7 +158,7 @@
sint32 size = 0;
sint32 cur = index;
while (cur < JavaArray::getSize(stack)) {
- mvm::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
+ vmkit::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
++cur;
if (FI->Metadata != NULL) ++size;
}
@@ -168,7 +168,7 @@
cur = 0;
for (sint32 i = index; i < JavaArray::getSize(stack); ++i) {
- mvm::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, i));
+ vmkit::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, i));
if (FI->Metadata != NULL) {
ArrayObject::setElement(result, consStackElement(FI, ArrayPtr::getElement((ArrayPtr*)stack, i)), cur);
cur++;
Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp Mon Nov 21 05:03:32 2011
@@ -523,7 +523,7 @@
BEGIN_NATIVE_EXCEPTION(0)
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char* buf = JavaString::strToAsciiz(str, &allocator);
char* res = getenv(buf);
if (res) {
Modified: vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h Mon Nov 21 05:03:32 2011
@@ -62,7 +62,7 @@
class ClassArray;
class JnjvmClassLoader;
-class Classpath : public mvm::PermanentObject {
+class Classpath : public vmkit::PermanentObject {
public:
ISOLATE_STATIC UserClass* newClassLoader;
ISOLATE_STATIC JavaMethod* getSystemClassLoader;
Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp Mon Nov 21 05:03:32 2011
@@ -44,7 +44,7 @@
stack = self->backtrace;
sint32 index = 2;;
while (index != JavaArray::getSize(stack)) {
- mvm::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
+ vmkit::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
if (FI->Metadata == NULL) ++index;
else {
JavaMethod* meth = (JavaMethod*)FI->Metadata;
@@ -74,7 +74,7 @@
sint32 size = 0;
sint32 cur = index;
while (cur < JavaArray::getSize(stack)) {
- mvm::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
+ vmkit::FrameInfo* FI = vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
++cur;
if (FI->Metadata != NULL) ++size;
}
Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h Mon Nov 21 05:03:32 2011
@@ -59,7 +59,7 @@
static void setProtectionDomain(JavaObjectClass* cl, JavaObject* pd) {
llvm_gcroot(cl, 0);
llvm_gcroot(pd, 0);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)cl, (gc**)&(cl->pd), (gc*)pd);
}
@@ -69,27 +69,27 @@
}
static void staticTracer(JavaObjectClass* obj, word_t closure) {
- mvm::Collector::markAndTrace(obj, &obj->cachedConstructor, closure);
- mvm::Collector::markAndTrace(obj, &obj->newInstanceCallerCache, closure);
- mvm::Collector::markAndTrace(obj, &obj->name, closure);
- mvm::Collector::markAndTrace(obj, &obj->declaredFields, closure);
- mvm::Collector::markAndTrace(obj, &obj->publicFields, closure);
- mvm::Collector::markAndTrace(obj, &obj->declaredMethods, closure);
- mvm::Collector::markAndTrace(obj, &obj->publicMethods, closure);
- mvm::Collector::markAndTrace(obj, &obj->declaredConstructors, closure);
- mvm::Collector::markAndTrace(obj, &obj->publicConstructors, closure);
- mvm::Collector::markAndTrace(obj, &obj->declaredPublicFields, closure);
- mvm::Collector::markAndTrace(obj, &obj->genericInfo, closure);
- mvm::Collector::markAndTrace(obj, &obj->enumConstants, closure);
- mvm::Collector::markAndTrace(obj, &obj->enumConstantDictionary, closure);
- mvm::Collector::markAndTrace(obj, &obj->annotations, closure);
- mvm::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
- mvm::Collector::markAndTrace(obj, &obj->annotationType, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->cachedConstructor, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->newInstanceCallerCache, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->name, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaredFields, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->publicFields, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaredMethods, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->publicMethods, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaredConstructors, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->publicConstructors, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaredPublicFields, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->genericInfo, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->enumConstants, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->enumConstantDictionary, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->annotations, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->annotationType, closure);
UserCommonClass * cl = getClass(obj);
if (cl) {
JavaObject** Obj = cl->classLoader->getJavaClassLoaderPtr();
- if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
+ if (*Obj) vmkit::Collector::markAndTraceRoot(Obj, closure);
}
}
@@ -126,18 +126,18 @@
public:
static void staticTracer(JavaObjectField* obj, word_t closure) {
- mvm::Collector::markAndTrace(obj, &obj->clazz, closure);
- mvm::Collector::markAndTrace(obj, &obj->name, closure);
- mvm::Collector::markAndTrace(obj, &obj->type, closure);
- mvm::Collector::markAndTrace(obj, &obj->signature, closure);
- mvm::Collector::markAndTrace(obj, &obj->genericInfo, closure);
- mvm::Collector::markAndTrace(obj, &obj->annotations, closure);
- mvm::Collector::markAndTrace(obj, &obj->fieldAccessor, closure);
- mvm::Collector::markAndTrace(obj, &obj->overrideFieldAccessor, closure);
- mvm::Collector::markAndTrace(obj, &obj->root, closure);
- mvm::Collector::markAndTrace(obj, &obj->securityCheckCache, closure);
- mvm::Collector::markAndTrace(obj, &obj->securityCheckTargetClassCache, closure);
- mvm::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->clazz, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->name, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->type, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->signature, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->genericInfo, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->annotations, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->fieldAccessor, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->overrideFieldAccessor, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->root, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->securityCheckCache, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->securityCheckTargetClassCache, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
}
static JavaField* getInternalField(JavaObjectField* self) {
@@ -181,21 +181,21 @@
public:
static void staticTracer(JavaObjectMethod* obj, word_t closure) {
- mvm::Collector::markAndTrace(obj, &obj->clazz, closure);
- mvm::Collector::markAndTrace(obj, &obj->name, closure);
- mvm::Collector::markAndTrace(obj, &obj->returnType, closure);
- mvm::Collector::markAndTrace(obj, &obj->parameterTypes, closure);
- mvm::Collector::markAndTrace(obj, &obj->exceptionTypes, closure);
- mvm::Collector::markAndTrace(obj, &obj->Signature, closure);
- mvm::Collector::markAndTrace(obj, &obj->genericInfo, closure);
- mvm::Collector::markAndTrace(obj, &obj->annotations, closure);
- mvm::Collector::markAndTrace(obj, &obj->parameterAnnotations, closure);
- mvm::Collector::markAndTrace(obj, &obj->annotationDefault, closure);
- mvm::Collector::markAndTrace(obj, &obj->methodAccessor, closure);
- mvm::Collector::markAndTrace(obj, &obj->root, closure);
- mvm::Collector::markAndTrace(obj, &obj->securityCheckCache, closure);
- mvm::Collector::markAndTrace(obj, &obj->securityCheckTargetClassCache, closure);
- mvm::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->clazz, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->name, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->returnType, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->parameterTypes, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->exceptionTypes, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->Signature, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->genericInfo, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->annotations, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->parameterAnnotations, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->annotationDefault, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->methodAccessor, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->root, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->securityCheckCache, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->securityCheckTargetClassCache, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
}
static JavaMethod* getInternalMethod(JavaObjectMethod* self);
@@ -230,17 +230,17 @@
public:
static void staticTracer(JavaObjectConstructor* obj, word_t closure) {
- mvm::Collector::markAndTrace(obj, &obj->clazz, closure);
- mvm::Collector::markAndTrace(obj, &obj->parameterTypes, closure);
- mvm::Collector::markAndTrace(obj, &obj->exceptionTypes, closure);
- mvm::Collector::markAndTrace(obj, &obj->signature, closure);
- mvm::Collector::markAndTrace(obj, &obj->genericInfo, closure);
- mvm::Collector::markAndTrace(obj, &obj->annotations, closure);
- mvm::Collector::markAndTrace(obj, &obj->parameterAnnotations, closure);
- mvm::Collector::markAndTrace(obj, &obj->securityCheckCache, closure);
- mvm::Collector::markAndTrace(obj, &obj->constructorAccessor, closure);
- mvm::Collector::markAndTrace(obj, &obj->root, closure);
- mvm::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->clazz, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->parameterTypes, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->exceptionTypes, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->signature, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->genericInfo, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->annotations, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->parameterAnnotations, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->securityCheckCache, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->constructorAccessor, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->root, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaredAnnotations, closure);
}
static JavaMethod* getInternalMethod(JavaObjectConstructor* self);
@@ -266,7 +266,7 @@
static void setDetailedMessage(JavaObjectThrowable* self, JavaObject* obj) {
llvm_gcroot(self, 0);
llvm_gcroot(obj, 0);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)self, (gc**)&(self->detailedMessage), (gc*)obj);
}
@@ -276,10 +276,10 @@
llvm_gcroot(stackTrace, 0);
stackTrace = internalFillInStackTrace(self);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)self, (gc**)&(self->backtrace), (gc*)stackTrace);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)self, (gc**)&(self->cause), (gc*)self);
self->stackTrace = NULL;
@@ -301,9 +301,9 @@
llvm_gcroot(self, 0);
llvm_gcroot(r, 0);
llvm_gcroot(q, 0);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)self, (gc**)&(self->referent), (gc*)r);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)self, (gc**)&(self->queue), (gc*)q);
}
Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h Mon Nov 21 05:03:32 2011
@@ -62,7 +62,7 @@
class ClassArray;
class JnjvmClassLoader;
-class Classpath : public mvm::PermanentObject {
+class Classpath : public vmkit::PermanentObject {
public:
ISOLATE_STATIC UserClass* newClassLoader;
ISOLATE_STATIC JavaMethod* getSystemClassLoader;
Modified: vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/OpenJDK/OpenJDK.inc Mon Nov 21 05:03:32 2011
@@ -49,7 +49,7 @@
#endif
// Don't call th->getFrameContext because it is not GC-safe.
- mvm::StackWalker Walker(th);
+ vmkit::StackWalker Walker(th);
uint32_t i = 0;
while (intptr_t ip = *Walker) {
@@ -61,7 +61,7 @@
return result;
}
-JavaObject* consStackElement(mvm::FrameInfo* FI, intptr_t ip) {
+JavaObject* consStackElement(vmkit::FrameInfo* FI, intptr_t ip) {
JavaString* methodName = 0;
JavaString* className = 0;
@@ -262,18 +262,18 @@
*/
JNIEXPORT void JNICALL
JVM_Exit(jint code) {
- mvm::System::Exit(code);
+ vmkit::System::Exit(code);
}
JNIEXPORT void JNICALL
JVM_Halt(jint code) {
- mvm::System::Exit(code);
+ vmkit::System::Exit(code);
}
JNIEXPORT void JNICALL
JVM_GC(void) {
BEGIN_JNI_EXCEPTION
- mvm::Collector::collect();
+ vmkit::Collector::collect();
RETURN_VOID_FROM_JNI;
END_JNI_EXCEPTION
}
@@ -309,22 +309,22 @@
JNIEXPORT jlong JNICALL
JVM_TotalMemory(void) {
- return (jlong)mvm::Collector::getTotalMemory();
+ return (jlong)vmkit::Collector::getTotalMemory();
}
JNIEXPORT jlong JNICALL
JVM_FreeMemory(void) {
- return (jlong)mvm::Collector::getFreeMemory();
+ return (jlong)vmkit::Collector::getFreeMemory();
}
JNIEXPORT jlong JNICALL
JVM_MaxMemory(void) {
- return (jlong)mvm::Collector::getMaxMemory();
+ return (jlong)vmkit::Collector::getMaxMemory();
}
JNIEXPORT jint JNICALL
JVM_ActiveProcessorCount(void) {
- return mvm::System::GetNumberOfProcessors();
+ return vmkit::System::GetNumberOfProcessors();
}
JNIEXPORT void * JNICALL
@@ -432,7 +432,7 @@
sint32 cur = 0;
for (sint32 i = base; i < JavaArray::getSize(stack); ++i) {
intptr_t ip = ArrayPtr::getElement((ArrayPtr*)stack, i);
- mvm::FrameInfo* FI = vm->IPToFrameInfo(ip);
+ vmkit::FrameInfo* FI = vm->IPToFrameInfo(ip);
if (FI->Metadata != NULL) {
if (cur == index) {
result = consStackElement(FI, ip);
@@ -497,7 +497,7 @@
// Wait some time to let the creator initialise this field
while (thread->javaThread == NULL) {
- mvm::Thread::yield();
+ vmkit::Thread::yield();
}
javaThread = thread->javaThread;
@@ -542,7 +542,7 @@
JavaThread * newTh = new JavaThread(vm);
if (!newTh) vm->outOfMemoryError();
- newTh->start((void (*)(mvm::Thread*))start);
+ newTh->start((void (*)(vmkit::Thread*))start);
newTh->initialise(thread, 0);
@@ -602,7 +602,7 @@
JNIEXPORT void JNICALL
JVM_Yield(JNIEnv *env, jclass threadClass) {
- mvm::Thread::yield();
+ vmkit::Thread::yield();
}
JNIEXPORT void JNICALL
@@ -638,16 +638,16 @@
// It's possible that the thread to be interrupted has not finished
// its initialization. Wait until the initialization is done.
while (field->getInstanceLongField(thread) == 0)
- mvm::Thread::yield();
+ vmkit::Thread::yield();
JavaThread* th = (JavaThread*)field->getInstanceLongField(thread);
th->lockingThread.interruptFlag = 1;
- mvm::FatLock* lock = th->lockingThread.waitsOn;
+ vmkit::FatLock* lock = th->lockingThread.waitsOn;
// If the thread is blocked on a wait. We also verify nextWaiting in case
// the thread has been notified.
if (lock && th->lockingThread.nextWaiting) {
- th->lockingThread.state = mvm::LockingThread::StateInterrupted;
+ th->lockingThread.state = vmkit::LockingThread::StateInterrupted;
// Make sure the thread is waiting.
uint32 locked = 0;
@@ -655,7 +655,7 @@
locked = (lock->tryAcquire() == 0);
if (locked || (lock->getOwner() != th && lock->getOwner() != 0))
break;
- else mvm::Thread::yield();
+ else vmkit::Thread::yield();
}
// Interrupt the thread.
Modified: vmkit/trunk/lib/J3/ClassLib/Unsafe.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/ClassLib/Unsafe.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/ClassLib/Unsafe.inc (original)
+++ vmkit/trunk/lib/J3/ClassLib/Unsafe.inc Mon Nov 21 05:03:32 2011
@@ -232,7 +232,7 @@
llvm_gcroot(value, 0);
JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
- mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
+ vmkit::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
}
@@ -260,7 +260,7 @@
llvm_gcroot(value, 0);
JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
- mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
+ vmkit::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
// Ensure this value is seen.
__sync_synchronize();
}
@@ -287,7 +287,7 @@
llvm_gcroot(value, 0);
JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
- mvm::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
+ vmkit::Collector::objectReferenceWriteBarrier((gc*)base, (gc**)ptr, (gc*)value);
// No barrier (difference between volatile and ordered)
}
@@ -338,7 +338,7 @@
llvm_gcroot(update, 0);
JavaObject** ptr = (JavaObject**)fieldPtr(base, offset);
- return mvm::Collector::objectReferenceTryCASBarrier((gc*)base, (gc**)ptr, (gc*)expect, (gc*)update);
+ return vmkit::Collector::objectReferenceTryCASBarrier((gc*)base, (gc**)ptr, (gc*)expect, (gc*)update);
}
@@ -526,12 +526,12 @@
JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_pageSize(
JavaObject* unsafe) {
- return mvm::System::GetPageSize();
+ return vmkit::System::GetPageSize();
}
JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_addressSize(
JavaObject* unsafe) {
- return mvm::kWordSize;
+ return vmkit::kWordSize;
}
JNIEXPORT jint JNICALL Java_sun_misc_Unsafe_getLoadAverage(
Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Mon Nov 21 05:03:32 2011
@@ -379,7 +379,7 @@
final_object_iterator I = finalObjects.find(obj);
if (I == End) {
- if (mvm::Collector::begOf(obj)) {
+ if (vmkit::Collector::begOf(obj)) {
Type* Ty = 0;
CommonClass* cl = JavaObject::getClass(obj);
@@ -1041,7 +1041,7 @@
return ConstantStruct::get(STy, ClassElts);
}
-Constant* JavaAOTCompiler::CreateConstantFromClassMap(const mvm::VmkitDenseMap<const UTF8*, CommonClass*>& map) {
+Constant* JavaAOTCompiler::CreateConstantFromClassMap(const vmkit::VmkitDenseMap<const UTF8*, CommonClass*>& map) {
StructType* STy =
dyn_cast<StructType>(JavaIntrinsics.J3DenseMapType->getContainedType(0));
Module& Mod = *getLLVMModule();
@@ -1055,11 +1055,11 @@
ArrayType* ATy = ArrayType::get(JavaIntrinsics.ptrType, map.NumBuckets * 2);
for (uint32 i = 0; i < map.NumBuckets; ++i) {
- mvm::VmkitPair<const UTF8*, CommonClass*> pair = map.Buckets[i];
- if (pair.first == &mvm::TombstoneKey) {
+ vmkit::VmkitPair<const UTF8*, CommonClass*> pair = map.Buckets[i];
+ if (pair.first == &vmkit::TombstoneKey) {
TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, UTF8TombstoneGV, JavaIntrinsics.ptrType));
TempElts.push_back(Constant::getNullValue(JavaIntrinsics.ptrType));
- } else if (pair.first == &mvm::EmptyKey) {
+ } else if (pair.first == &vmkit::EmptyKey) {
TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, UTF8EmptyGV, JavaIntrinsics.ptrType));
TempElts.push_back(Constant::getNullValue(JavaIntrinsics.ptrType));
} else {
@@ -1086,7 +1086,7 @@
ConstantStruct::get(STy, elements), "ClassMap");
}
-Constant* JavaAOTCompiler::CreateConstantFromUTF8Map(const mvm::VmkitDenseSet<mvm::UTF8MapKey, const UTF8*>& set) {
+Constant* JavaAOTCompiler::CreateConstantFromUTF8Map(const vmkit::VmkitDenseSet<vmkit::UTF8MapKey, const UTF8*>& set) {
StructType* STy =
dyn_cast<StructType>(JavaIntrinsics.J3DenseMapType->getContainedType(0));
Module& Mod = *getLLVMModule();
@@ -1101,9 +1101,9 @@
for (uint32 i = 0; i < set.NumBuckets; ++i) {
const UTF8* utf8 = set.Buckets[i];
- if (utf8 == &mvm::EmptyKey) {
+ if (utf8 == &vmkit::EmptyKey) {
TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, UTF8EmptyGV, JavaIntrinsics.ptrType));
- } else if (utf8 == &mvm::TombstoneKey) {
+ } else if (utf8 == &vmkit::TombstoneKey) {
TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, UTF8TombstoneGV, JavaIntrinsics.ptrType));
} else {
TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, getUTF8(utf8), JavaIntrinsics.ptrType));
@@ -1795,8 +1795,8 @@
JavaLLVMCompiler(ModuleID) {
std::string Error;
- const Target* TheTarget(TargetRegistry::lookupTarget(mvm::VmkitModule::getHostTriple(), Error));
- TargetMachine* TM = TheTarget->createTargetMachine(mvm::VmkitModule::getHostTriple(), "", "");
+ const Target* TheTarget(TargetRegistry::lookupTarget(vmkit::VmkitModule::getHostTriple(), Error));
+ TargetMachine* TM = TheTarget->createTargetMachine(vmkit::VmkitModule::getHostTriple(), "", "");
TheTargetData = TM->getTargetData();
TheModule->setDataLayout(TheTargetData->getStringRepresentation());
TheModule->setTargetTriple(TM->getTargetTriple());
@@ -2047,7 +2047,7 @@
std::vector<Class*>& classes) {
ZipArchive archive(bytes, bootstrapLoader->allocator);
- mvm::BumpPtrAllocator allocator;
+ vmkit::BumpPtrAllocator allocator;
char* realName = (char*)allocator.Allocate(4096, "temp");
for (ZipArchive::table_iterator i = archive.filetable.begin(),
e = archive.filetable.end(); i != e; ++i) {
@@ -2225,7 +2225,7 @@
}
} else {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char* realName = (char*)allocator.Allocate(size + 1);
if (size > 6 && !strcmp(&name[size - 6], ".class")) {
memcpy(realName, name, size - 6);
@@ -2276,7 +2276,7 @@
name = n;
JavaThread* th = new JavaThread(vm);
vm->setMainThread(th);
- th->start((void (*)(mvm::Thread*))mainCompilerStart);
+ th->start((void (*)(vmkit::Thread*))mainCompilerStart);
vm->waitForExit();
}
Modified: vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJIT.cpp Mon Nov 21 05:03:32 2011
@@ -389,7 +389,7 @@
sint32 mnlen = jniConsName->size;
sint32 mtlen = jniConsType->size;
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char* functionName = (char*)allocator.Allocate(
3 + JNI_NAME_PRE_LEN + ((mnlen + clen + mtlen) << 3));
@@ -455,7 +455,7 @@
Value* oldCLIN = new AllocaInst(PointerType::getUnqual(Type::getInt32Ty(*llvmContext)), "",
currentBlock);
- Constant* sizeF = ConstantInt::get(Type::getInt32Ty(*llvmContext), sizeof(mvm::KnownFrame));
+ Constant* sizeF = ConstantInt::get(Type::getInt32Ty(*llvmContext), sizeof(vmkit::KnownFrame));
Value* Frame = new AllocaInst(Type::getInt8Ty(*llvmContext), sizeF, "", currentBlock);
uint32 nargs = func->arg_size() + 1 + (stat ? 1 : 0);
@@ -653,7 +653,7 @@
Value* lock = new LoadInst(lockPtr, "", currentBlock);
lock = new PtrToIntInst(lock, intrinsics->pointerSizeType, "", currentBlock);
Value* NonLockBitsMask = ConstantInt::get(intrinsics->pointerSizeType,
- mvm::ThinLock::NonLockBitsMask);
+ vmkit::ThinLock::NonLockBitsMask);
lock = BinaryOperator::CreateAnd(lock, NonLockBitsMask, "", currentBlock);
@@ -697,7 +697,7 @@
"", currentBlock);
Value* lock = new LoadInst(lockPtr, "", currentBlock);
Value* NonLockBitsMask = ConstantInt::get(
- intrinsics->pointerSizeType, mvm::ThinLock::NonLockBitsMask);
+ intrinsics->pointerSizeType, vmkit::ThinLock::NonLockBitsMask);
Value* lockedMask = BinaryOperator::CreateAnd(
lock, NonLockBitsMask, "", currentBlock);
@@ -1104,7 +1104,7 @@
nbHandlers = readExceptionTable(reader, codeLen);
if (nbHandlers != 0) {
- jmpBuffer = new AllocaInst(ArrayType::get(Type::getInt8Ty(*llvmContext), sizeof(mvm::ExceptionBuffer)), "", currentBlock);
+ jmpBuffer = new AllocaInst(ArrayType::get(Type::getInt8Ty(*llvmContext), sizeof(vmkit::ExceptionBuffer)), "", currentBlock);
jmpBuffer = new BitCastInst(jmpBuffer, intrinsics->ptrType, "", currentBlock);
}
@@ -1124,7 +1124,7 @@
}
if (TheCompiler->hasExceptionsEnabled() &&
- !mvm::System::SupportsHardwareStackOverflow()) {
+ !vmkit::System::SupportsHardwareStackOverflow()) {
// Variables have been allocated and the lock has been taken. Do the stack
// check now: if there is an exception, we will go to the lock release code.
currentExceptionBlock = opcodeInfos[0].exceptionBlock;
@@ -1337,7 +1337,7 @@
void JavaJIT::JITVerifyNull(Value* obj) {
if (TheCompiler->hasExceptionsEnabled()) {
- if (nbHandlers == 0 && mvm::System::SupportsHardwareNullCheck()) {
+ if (nbHandlers == 0 && vmkit::System::SupportsHardwareNullCheck()) {
Value* indexes[2] = { intrinsics->constantZero, intrinsics->constantZero };
Value* VTPtr = GetElementPtrInst::Create(obj, indexes, "", currentBlock);
Instruction* VT = new LoadInst(VTPtr, "", true, currentBlock);
@@ -1397,7 +1397,7 @@
void JavaJIT::makeArgs(FunctionType::param_iterator it,
uint32 index, std::vector<Value*>& Args, uint32 nb) {
Args.reserve(nb + 2);
- mvm::ThreadAllocator threadAllocator;
+ vmkit::ThreadAllocator threadAllocator;
Value** args = (Value**)threadAllocator.Allocate(nb*sizeof(Value*));
sint32 start = nb - 1;
@@ -1968,7 +1968,7 @@
convertValue(val, type, currentBlock, false);
}
- if (mvm::Collector::needsNonHeapWriteBarrier() && type == intrinsics->JavaObjectType) {
+ if (vmkit::Collector::needsNonHeapWriteBarrier() && type == intrinsics->JavaObjectType) {
ptr = new BitCastInst(ptr, intrinsics->ptrPtrType, "", currentBlock);
val = new BitCastInst(val, intrinsics->ptrType, "", currentBlock);
Value* args[2] = { ptr, val };
@@ -2025,7 +2025,7 @@
JavaObject* val = field->getStaticObjectField();
JnjvmClassLoader* JCL = field->classDef->classLoader;
Value* V = TheCompiler->getFinalObject(val, sign->assocClass(JCL));
- CommonClass* cl = mvm::Collector::begOf(val) ?
+ CommonClass* cl = vmkit::Collector::begOf(val) ?
JavaObject::getClass(val) : NULL;
push(V, false, cl);
} else {
@@ -2074,7 +2074,7 @@
convertValue(val, type, currentBlock, false);
}
- if (mvm::Collector::needsWriteBarrier() && type == intrinsics->JavaObjectType) {
+ if (vmkit::Collector::needsWriteBarrier() && type == intrinsics->JavaObjectType) {
ptr = new BitCastInst(ptr, intrinsics->ptrPtrType, "", currentBlock);
val = new BitCastInst(val, intrinsics->ptrType, "", currentBlock);
object = new LoadInst(object, "", false, currentBlock);
@@ -2445,7 +2445,7 @@
sint16 sync = isSynchro(compilingMethod->access) ? 1 : 0;
nbe += sync;
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
// Loop over all handlers in the bytecode to initialize their values.
Handler* handlers =
(Handler*)allocator.Allocate(sizeof(Handler) * (nbe - sync));
Modified: vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJITCompiler.cpp Mon Nov 21 05:03:32 2011
@@ -163,7 +163,7 @@
executionEngine->RegisterJITEventListener(&listener);
TheTargetData = executionEngine->getTargetData();
TheModule->setDataLayout(TheTargetData->getStringRepresentation());
- TheModule->setTargetTriple(mvm::VmkitModule::getHostTriple());
+ TheModule->setTargetTriple(vmkit::VmkitModule::getHostTriple());
JavaIntrinsics.init(TheModule);
initialiseAssessorInfo();
@@ -217,8 +217,8 @@
BEGIN_NATIVE_EXCEPTION(1);
// Lookup the caller of this class.
- mvm::StackWalker Walker(th);
- mvm::FrameInfo* FI = Walker.get();
+ vmkit::StackWalker Walker(th);
+ vmkit::FrameInfo* FI = Walker.get();
assert(FI->Metadata != NULL && "Wrong stack trace");
JavaMethod* meth = (JavaMethod*)FI->Metadata;
@@ -320,7 +320,7 @@
}
void* JavaJITCompiler::materializeFunction(JavaMethod* meth, Class* customizeFor) {
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
Function* func = parseFunction(meth, customizeFor);
void* res = executionEngine->getPointerToGlobal(func);
@@ -328,12 +328,12 @@
llvm::GCFunctionInfo& GFI = GCInfo->getFunctionInfo(*func);
Jnjvm* vm = JavaThread::get()->getJVM();
- mvm::VmkitModule::addToVM(vm, &GFI, (JIT*)executionEngine, allocator, meth);
+ vmkit::VmkitModule::addToVM(vm, &GFI, (JIT*)executionEngine, allocator, meth);
// Now that it's compiled, we don't need the IR anymore
func->deleteBody();
}
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
if (customizeFor == NULL || !getMethodInfo(meth)->isCustomizable) {
meth->code = res;
}
@@ -341,7 +341,7 @@
}
void* JavaJITCompiler::GenerateStub(llvm::Function* F) {
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
void* res = executionEngine->getPointerToGlobal(F);
// If the stub was already generated through an equivalent signature,
@@ -350,12 +350,12 @@
llvm::GCFunctionInfo& GFI = GCInfo->getFunctionInfo(*F);
Jnjvm* vm = JavaThread::get()->getJVM();
- mvm::VmkitModule::addToVM(vm, &GFI, (JIT*)executionEngine, allocator, NULL);
+ vmkit::VmkitModule::addToVM(vm, &GFI, (JIT*)executionEngine, allocator, NULL);
// Now that it's compiled, we don't need the IR anymore
F->deleteBody();
}
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
return res;
}
@@ -363,16 +363,16 @@
extern "C" int StartJnjvmWithJIT(int argc, char** argv, char* mainClass) {
llvm::llvm_shutdown_obj X;
- mvm::VmkitModule::initialise(argc, argv);
- mvm::Collector::initialise(argc, argv);
+ vmkit::VmkitModule::initialise(argc, argv);
+ vmkit::Collector::initialise(argc, argv);
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char** newArgv = (char**)allocator.Allocate((argc + 1) * sizeof(char*));
memcpy(newArgv + 1, argv, argc * sizeof(void*));
newArgv[0] = newArgv[1];
newArgv[1] = mainClass;
- mvm::BumpPtrAllocator Allocator;
+ vmkit::BumpPtrAllocator Allocator;
JavaJITCompiler* Comp = JavaJITCompiler::CreateCompiler("JITModule");
JnjvmBootstrapLoader* loader = new(Allocator, "Bootstrap loader")
JnjvmBootstrapLoader(Allocator, Comp, true);
Modified: vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaJITOpcodes.cpp Mon Nov 21 05:03:32 2011
@@ -102,7 +102,7 @@
bool wide = false;
uint32 jsrIndex = 0;
uint32 start = reader.cursor;
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
for(uint32 i = 0; i < codeLength; ++i) {
reader.cursor = start + i;
uint8 bytecode = reader.readU1();
@@ -725,7 +725,7 @@
Value* obj = pop();
Value* ptr = verifyAndComputePtr(obj, index,
intrinsics->JavaArrayObjectType, false);
- if (mvm::Collector::needsWriteBarrier()) {
+ if (vmkit::Collector::needsWriteBarrier()) {
ptr = new BitCastInst(ptr, intrinsics->ptrPtrType, "", currentBlock);
val = new BitCastInst(val, intrinsics->ptrType, "", currentBlock);
obj = new BitCastInst(obj, intrinsics->ptrType, "", currentBlock);
Modified: vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaLLVMCompiler.cpp Mon Nov 21 05:03:32 2011
@@ -35,18 +35,18 @@
void JavaLLVMCompiler::resolveVirtualClass(Class* cl) {
// Lock here because we may be called by a class resolver
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl);
LCI->getVirtualType();
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
}
void JavaLLVMCompiler::resolveStaticClass(Class* cl) {
// Lock here because we may be called by a class initializer
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl);
LCI->getStaticType();
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
}
Function* JavaLLVMCompiler::getMethod(JavaMethod* meth, Class* customizeFor) {
@@ -59,17 +59,17 @@
Function* func = LMI->getMethod(customizeFor);
// We are jitting. Take the lock.
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
if (func->getLinkage() == GlobalValue::ExternalWeakLinkage) {
JavaJIT jit(this, meth, func, customizeFor);
if (isNative(meth->access)) {
jit.nativeCompile();
- mvm::VmkitModule::runPasses(func, JavaNativeFunctionPasses);
- mvm::VmkitModule::runPasses(func, J3FunctionPasses);
+ vmkit::VmkitModule::runPasses(func, JavaNativeFunctionPasses);
+ vmkit::VmkitModule::runPasses(func, J3FunctionPasses);
} else {
jit.javaCompile();
- mvm::VmkitModule::runPasses(func, JavaFunctionPasses);
- mvm::VmkitModule::runPasses(func, J3FunctionPasses);
+ vmkit::VmkitModule::runPasses(func, JavaFunctionPasses);
+ vmkit::VmkitModule::runPasses(func, J3FunctionPasses);
}
func->setLinkage(GlobalValue::ExternalLinkage);
if (!LMI->isCustomizable && jit.isCustomizable) {
@@ -82,7 +82,7 @@
}
}
}
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
return func;
}
@@ -115,7 +115,7 @@
JavaFunctionPasses = new FunctionPassManager(TheModule);
JavaFunctionPasses->add(new TargetData(TheModule));
- mvm::VmkitModule::addCommandLinePasses(JavaFunctionPasses);
+ vmkit::VmkitModule::addCommandLinePasses(JavaFunctionPasses);
}
} // end namespace j3
Modified: vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/LLVMInfo.cpp Mon Nov 21 05:03:32 2011
@@ -140,7 +140,7 @@
extern bool JITEmitDebugInfo;
}
-static char* GetMethodName(mvm::ThreadAllocator& allocator,
+static char* GetMethodName(vmkit::ThreadAllocator& allocator,
JavaMethod* methodDef,
Class* customizeFor) {
const UTF8* jniConsClName = methodDef->classDef->name;
@@ -181,7 +181,7 @@
if (result == NULL) {
if (Compiler->emitFunctionName() || JITEmitDebugInfo) {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char* buf = GetMethodName(
allocator, methodDef, customizing ? customizeFor : NULL);
result = Function::Create(getFunctionType(),
@@ -215,7 +215,7 @@
void LLVMMethodInfo::setCustomizedVersion(Class* cl, llvm::Function* F) {
assert(customizedVersions.size() == 0);
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
if (Compiler->emitFunctionName() || JITEmitDebugInfo) {
char* buf = GetMethodName(allocator, methodDef, cl);
F->setName(buf);
@@ -267,7 +267,7 @@
llvm::FunctionType* LLVMSignatureInfo::getVirtualType() {
if (!virtualType) {
// Lock here because we are called by arbitrary code
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
std::vector<llvm::Type*> llvmArgs;
uint32 size = signature->nbArguments;
Typedef* const* arguments = signature->getArgumentsType();
@@ -283,7 +283,7 @@
LLVMAssessorInfo& LAI =
Compiler->getTypedefInfo(signature->getReturnType());
virtualType = FunctionType::get(LAI.llvmType, llvmArgs, false);
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
}
return virtualType;
}
@@ -291,7 +291,7 @@
llvm::FunctionType* LLVMSignatureInfo::getStaticType() {
if (!staticType) {
// Lock here because we are called by arbitrary code
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
std::vector<llvm::Type*> llvmArgs;
uint32 size = signature->nbArguments;
Typedef* const* arguments = signature->getArgumentsType();
@@ -305,7 +305,7 @@
LLVMAssessorInfo& LAI =
Compiler->getTypedefInfo(signature->getReturnType());
staticType = FunctionType::get(LAI.llvmType, llvmArgs, false);
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
}
return staticType;
}
@@ -313,7 +313,7 @@
llvm::FunctionType* LLVMSignatureInfo::getNativeType() {
if (!nativeType) {
// Lock here because we are called by arbitrary code
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
std::vector<llvm::Type*> llvmArgs;
uint32 size = signature->nbArguments;
Typedef* const* arguments = signature->getArgumentsType();
@@ -341,14 +341,14 @@
LAI.llvmType == Compiler->getIntrinsics()->JavaObjectType ?
LAI.llvmTypePtr : LAI.llvmType;
nativeType = FunctionType::get(RetType, llvmArgs, false);
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
}
return nativeType;
}
llvm::FunctionType* LLVMSignatureInfo::getNativeStubType() {
// Lock here because we are called by arbitrary code
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
std::vector<llvm::Type*> llvmArgs;
uint32 size = signature->nbArguments;
Typedef* const* arguments = signature->getArgumentsType();
@@ -377,7 +377,7 @@
LAI.llvmType == Compiler->getIntrinsics()->JavaObjectType ?
LAI.llvmTypePtr : LAI.llvmType;
FunctionType* FTy = FunctionType::get(RetType, llvmArgs, false);
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
return FTy;
}
@@ -399,7 +399,7 @@
return res;
}
if (Compiler->isStaticCompiling()) {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
const char* type = virt ? "virtual_buf" : "static_buf";
char* buf = (char*)allocator.Allocate(
(signature->keyName->size << 1) + 1 + 11);
@@ -500,7 +500,7 @@
return res;
}
if (Compiler->isStaticCompiling()) {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
const char* type = virt ? "virtual_ap" : "static_ap";
char* buf = (char*)allocator.Allocate(
(signature->keyName->size << 1) + 1 + 11);
@@ -593,7 +593,7 @@
return stub;
}
if (Compiler->isStaticCompiling()) {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
const char* type = virt ? "virtual_stub" : special ? "special_stub" : "static_stub";
char* buf = (char*)allocator.Allocate(
(signature->keyName->size << 1) + 1 + 11);
@@ -718,7 +718,7 @@
FunctionType* LLVMSignatureInfo::getVirtualBufType() {
if (!virtualBufType) {
// Lock here because we are called by arbitrary code
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
std::vector<llvm::Type*> Args;
Args.push_back(Compiler->getIntrinsics()->ResolvedConstantPoolType); // ctp
Args.push_back(getVirtualPtrType());
@@ -727,7 +727,7 @@
LLVMAssessorInfo& LAI =
Compiler->getTypedefInfo(signature->getReturnType());
virtualBufType = FunctionType::get(LAI.llvmType, Args, false);
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
}
return virtualBufType;
}
@@ -735,7 +735,7 @@
FunctionType* LLVMSignatureInfo::getStaticBufType() {
if (!staticBufType) {
// Lock here because we are called by arbitrary code
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
std::vector<llvm::Type*> Args;
Args.push_back(Compiler->getIntrinsics()->ResolvedConstantPoolType); // ctp
Args.push_back(getStaticPtrType());
@@ -743,7 +743,7 @@
LLVMAssessorInfo& LAI =
Compiler->getTypedefInfo(signature->getReturnType());
staticBufType = FunctionType::get(LAI.llvmType, Args, false);
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
}
return staticBufType;
}
@@ -751,84 +751,84 @@
Function* LLVMSignatureInfo::getVirtualBuf() {
// Lock here because we are called by arbitrary code. Also put that here
// because we are waiting on virtualBufFunction to have an address.
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
if (!virtualBufFunction) {
virtualBufFunction = createFunctionCallBuf(true);
signature->setVirtualCallBuf(Compiler->GenerateStub(virtualBufFunction));
}
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
return virtualBufFunction;
}
Function* LLVMSignatureInfo::getVirtualAP() {
// Lock here because we are called by arbitrary code. Also put that here
// because we are waiting on virtualAPFunction to have an address.
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
if (!virtualAPFunction) {
virtualAPFunction = createFunctionCallAP(true);
signature->setVirtualCallAP(Compiler->GenerateStub(virtualAPFunction));
}
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
return virtualAPFunction;
}
Function* LLVMSignatureInfo::getStaticBuf() {
// Lock here because we are called by arbitrary code. Also put that here
// because we are waiting on staticBufFunction to have an address.
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
if (!staticBufFunction) {
staticBufFunction = createFunctionCallBuf(false);
signature->setStaticCallBuf(Compiler->GenerateStub(staticBufFunction));
}
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
return staticBufFunction;
}
Function* LLVMSignatureInfo::getStaticAP() {
// Lock here because we are called by arbitrary code. Also put that here
// because we are waiting on staticAPFunction to have an address.
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
if (!staticAPFunction) {
staticAPFunction = createFunctionCallAP(false);
signature->setStaticCallAP(Compiler->GenerateStub(staticAPFunction));
}
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
return staticAPFunction;
}
Function* LLVMSignatureInfo::getStaticStub() {
// Lock here because we are called by arbitrary code. Also put that here
// because we are waiting on staticStubFunction to have an address.
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
if (!staticStubFunction) {
staticStubFunction = createFunctionStub(false, false);
signature->setStaticCallStub(Compiler->GenerateStub(staticStubFunction));
}
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
return staticStubFunction;
}
Function* LLVMSignatureInfo::getSpecialStub() {
// Lock here because we are called by arbitrary code. Also put that here
// because we are waiting on specialStubFunction to have an address.
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
if (!specialStubFunction) {
specialStubFunction = createFunctionStub(true, false);
signature->setSpecialCallStub(Compiler->GenerateStub(specialStubFunction));
}
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
return specialStubFunction;
}
Function* LLVMSignatureInfo::getVirtualStub() {
// Lock here because we are called by arbitrary code. Also put that here
// because we are waiting on virtualStubFunction to have an address.
- mvm::VmkitModule::protectIR();
+ vmkit::VmkitModule::protectIR();
if (!virtualStubFunction) {
virtualStubFunction = createFunctionStub(false, true);
signature->setVirtualCallStub(Compiler->GenerateStub(virtualStubFunction));
}
- mvm::VmkitModule::unprotectIR();
+ vmkit::VmkitModule::unprotectIR();
return virtualStubFunction;
}
Modified: vmkit/trunk/lib/J3/VMCore/JavaArray.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaArray.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaArray.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaArray.cpp Mon Nov 21 05:03:32 2011
@@ -40,6 +40,6 @@
llvm_gcroot(value, 0);
assert((ssize_t)i < self->size);
if (value != NULL) assert(value->getVirtualTable());
- mvm::Collector::objectReferenceArrayWriteBarrier(
+ vmkit::Collector::objectReferenceArrayWriteBarrier(
(gc*)self, (gc**)&(self->elements[i]), (gc*)value);
}
Modified: vmkit/trunk/lib/J3/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaClass.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaClass.cpp Mon Nov 21 05:03:32 2011
@@ -572,7 +572,7 @@
void* obj = classDef->getStaticInstance();
assert(isReference());
JavaObject** ptr = (JavaObject**)((uint64)obj + ptrOffset);
- mvm::Collector::objectReferenceNonHeapWriteBarrier((gc**)ptr, (gc*)val);
+ vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)ptr, (gc*)val);
}
void JavaField::InitStaticField(double val) {
@@ -794,7 +794,7 @@
}
}
- mvm::BumpPtrAllocator& allocator = classLoader->allocator;
+ vmkit::BumpPtrAllocator& allocator = classLoader->allocator;
virtualVT = new(allocator, virtualTableSize) JavaVirtualTable(this);
}
@@ -818,7 +818,7 @@
void Class::readMethods(Reader& reader) {
uint16 nbMethods = reader.readU2();
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
if (isAbstract(access)) {
virtualMethods = (JavaMethod*)
allocator.Allocate(nbMethods * sizeof(JavaMethod));
@@ -874,7 +874,7 @@
PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "; ", 0);
PRINT_DEBUG(JNJVM_LOAD, 0, LIGHT_GREEN, "reading ", 0);
- PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", mvm::PrintBuffer(this).cString());
+ PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", vmkit::PrintBuffer(this).cString());
Reader reader(bytes);
uint32 magic;
@@ -1025,7 +1025,7 @@
JavaObject** obj = &(delegatee[0]);
classLoader->lock.lock();
if (*obj == NULL) {
- mvm::Collector::objectReferenceNonHeapWriteBarrier((gc**)obj, (gc*)val);
+ vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)obj, (gc*)val);
}
classLoader->lock.unlock();
return getDelegatee();
@@ -1401,7 +1401,7 @@
outOfDepth = 1;
}
- mvm::BumpPtrAllocator& allocator = C->classLoader->allocator;
+ vmkit::BumpPtrAllocator& allocator = C->classLoader->allocator;
secondaryTypes = (JavaVirtualTable**)
allocator.Allocate(sizeof(JavaVirtualTable*) * nbSecondaryTypes,
"Secondary types");
@@ -1525,7 +1525,7 @@
if (intf || depth != getDisplayLength()) addSuper = 1;
}
- mvm::BumpPtrAllocator& allocator = JCL->allocator;
+ vmkit::BumpPtrAllocator& allocator = JCL->allocator;
if (!newSecondaryTypes) {
if (base->nbInterfaces || addSuper) {
@@ -1619,7 +1619,7 @@
offset = getCacheIndex() + 2;
nbSecondaryTypes = 2;
- mvm::BumpPtrAllocator& allocator = JCL->allocator;
+ vmkit::BumpPtrAllocator& allocator = JCL->allocator;
secondaryTypes = (JavaVirtualTable**)
allocator.Allocate(sizeof(JavaVirtualTable*) * nbSecondaryTypes,
"Secondary types");
@@ -1693,7 +1693,7 @@
}
}
-uint16 JavaMethod::lookupLineNumber(mvm::FrameInfo* info) {
+uint16 JavaMethod::lookupLineNumber(vmkit::FrameInfo* info) {
Attribut* codeAtt = lookupAttribut(Attribut::codeAttribut);
if (codeAtt == NULL) return 0;
Reader reader(codeAtt, classDef->bytes);
@@ -1723,7 +1723,7 @@
return 0;
}
-uint16 JavaMethod::lookupCtpIndex(mvm::FrameInfo* FI) {
+uint16 JavaMethod::lookupCtpIndex(vmkit::FrameInfo* FI) {
Attribut* codeAtt = lookupAttribut(Attribut::codeAttribut);
Reader reader(codeAtt, classDef->bytes);
reader.cursor = reader.cursor + 2 + 2 + 4 + FI->SourceIndex + 1;
@@ -1765,7 +1765,7 @@
if (val != NULL) assert(val->getVirtualTable());
assert(classDef->isResolved());
JavaObject** ptr = (JavaObject**)((uint64)obj + ptrOffset);
- mvm::Collector::objectReferenceWriteBarrier((gc*)obj, (gc**)ptr, (gc*)val);
+ vmkit::Collector::objectReferenceWriteBarrier((gc*)obj, (gc**)ptr, (gc*)val);
}
void JavaField::setStaticObjectField(JavaObject* val) {
@@ -1773,5 +1773,5 @@
if (val != NULL) assert(val->getVirtualTable());
assert(classDef->isResolved());
JavaObject** ptr = (JavaObject**)((uint64)classDef->getStaticInstance() + ptrOffset);
- mvm::Collector::objectReferenceNonHeapWriteBarrier((gc**)ptr, (gc*)val);
+ vmkit::Collector::objectReferenceNonHeapWriteBarrier((gc**)ptr, (gc*)val);
}
Modified: vmkit/trunk/lib/J3/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaClass.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaClass.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaClass.h Mon Nov 21 05:03:32 2011
@@ -73,7 +73,7 @@
/// Attribut - This class represents JVM attributes to Java class, methods and
/// fields located in the .class file.
///
-class Attribut : public mvm::PermanentObject {
+class Attribut : public vmkit::PermanentObject {
public:
/// name - The name of the attribut. These are specified in the JVM book.
@@ -156,7 +156,7 @@
/// object that stays in memory has a reference to the class. Same for
/// super or interfaces.
///
-class CommonClass : public mvm::PermanentObject {
+class CommonClass : public vmkit::PermanentObject {
public:
@@ -436,7 +436,7 @@
/// ownerClass - Who is initializing this class.
///
- mvm::Thread* ownerClass;
+ vmkit::Thread* ownerClass;
/// bytes - The .class file of this class.
///
@@ -496,13 +496,13 @@
/// getOwnerClass - Get the thread that is currently initializing the class.
///
- mvm::Thread* getOwnerClass() const {
+ vmkit::Thread* getOwnerClass() const {
return ownerClass;
}
/// setOwnerClass - Set the thread that is currently initializing the class.
///
- void setOwnerClass(mvm::Thread* th) {
+ void setOwnerClass(vmkit::Thread* th) {
ownerClass = th;
}
@@ -822,7 +822,7 @@
/// JavaMethod - This class represents Java methods.
///
-class JavaMethod : public mvm::PermanentObject {
+class JavaMethod : public vmkit::PermanentObject {
private:
/// _signature - The signature of this method. Null if not resolved.
@@ -899,12 +899,12 @@
/// lookupLineNumber - Find the line number based on the given frame info.
///
- uint16 lookupLineNumber(mvm::FrameInfo* FI);
+ uint16 lookupLineNumber(vmkit::FrameInfo* FI);
/// lookupCtpIndex - Lookup the constant pool index pointed by the opcode
/// related to the given frame info.
///
- uint16 lookupCtpIndex(mvm::FrameInfo* FI);
+ uint16 lookupCtpIndex(vmkit::FrameInfo* FI);
/// getSignature - Get the signature of thes method, resolving it if
/// necessary.
@@ -1079,7 +1079,7 @@
/// JavaField - This class represents a Java field.
///
-class JavaField : public mvm::PermanentObject {
+class JavaField : public vmkit::PermanentObject {
private:
/// _signature - The signature of the field. Null if not resolved.
///
Modified: vmkit/trunk/lib/J3/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaConstantPool.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaConstantPool.cpp Mon Nov 21 05:03:32 2011
@@ -155,7 +155,7 @@
void*
-JavaConstantPool::operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+JavaConstantPool::operator new(size_t sz, vmkit::BumpPtrAllocator& allocator,
uint32 ctpSize) {
uint32 size = sz + ctpSize * (sizeof(void*) + sizeof(sint32) + sizeof(uint8));
return allocator.Allocate(size, "Constant pool");
@@ -188,7 +188,7 @@
}
if (!ctpRes[entry]) {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
Reader reader(classDef->bytes, ctpDef[entry]);
uint32 len = reader.readU2();
uint16* buf = (uint16*)allocator.Allocate(len * sizeof(uint16));
Modified: vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaConstantPool.h Mon Nov 21 05:03:32 2011
@@ -29,7 +29,7 @@
/// JavaConstantPool - This class represents a Java constant pool, a place where
/// a Java class makes external references such as classes and methods and
/// stores constants such as integers or UTF8s.
-class JavaConstantPool : public mvm::PermanentObject {
+class JavaConstantPool : public vmkit::PermanentObject {
public:
/// classDef - The owning class of this constant pool.
@@ -56,7 +56,7 @@
/// operator new - Redefine the operator to allocate the arrays of a
/// constant pool inline.
- void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+ void* operator new(size_t sz, vmkit::BumpPtrAllocator& allocator,
uint32 ctpSize);
/// CtpReaderClass - Reads a class entry.
Modified: vmkit/trunk/lib/J3/VMCore/JavaMetaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaMetaJIT.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaMetaJIT.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaMetaJIT.cpp Mon Nov 21 05:03:32 2011
@@ -72,7 +72,7 @@
llvm_gcroot(obj, 0); \
verifyNull(obj); \
Signdef* sign = getSignature(); \
- mvm::ThreadAllocator allocator; \
+ vmkit::ThreadAllocator allocator; \
jvalue* buf = (jvalue*)allocator.Allocate(sign->nbArguments * sizeof(jvalue)); \
readArgs(buf, sign, ap, jni); \
return invoke##TYPE_NAME##VirtualBuf(vm, cl, obj, buf); \
@@ -82,7 +82,7 @@
llvm_gcroot(obj, 0); \
verifyNull(obj); \
Signdef* sign = getSignature(); \
- mvm::ThreadAllocator allocator; \
+ vmkit::ThreadAllocator allocator; \
jvalue* buf = (jvalue*)allocator.Allocate(sign->nbArguments * sizeof(jvalue)); \
readArgs(buf, sign, ap, jni); \
return invoke##TYPE_NAME##SpecialBuf(vm, cl, obj, buf); \
@@ -90,7 +90,7 @@
\
TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, UserClass* cl, va_list ap) {\
Signdef* sign = getSignature(); \
- mvm::ThreadAllocator allocator; \
+ vmkit::ThreadAllocator allocator; \
jvalue* buf = (jvalue*)allocator.Allocate(sign->nbArguments * sizeof(jvalue)); \
readArgs(buf, sign, ap, jni); \
return invoke##TYPE_NAME##StaticBuf(vm, cl, buf); \
Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaObject.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaObject.cpp Mon Nov 21 05:03:32 2011
@@ -22,21 +22,21 @@
using namespace j3;
-static const int hashCodeIncrement = mvm::GCBitMask + 1;
+static const int hashCodeIncrement = vmkit::GCBitMask + 1;
uint16_t JavaObject::hashCodeGenerator = hashCodeIncrement;
-static const uint64_t HashMask = ((1 << mvm::HashBits) - 1) << mvm::GCBits;
+static const uint64_t HashMask = ((1 << vmkit::HashBits) - 1) << vmkit::GCBits;
/// hashCode - Return the hash code of this object.
uint32_t JavaObject::hashCode(JavaObject* self) {
llvm_gcroot(self, 0);
- if (!mvm::MovesObject) return (uint32_t)(long)self;
+ if (!vmkit::MovesObject) return (uint32_t)(long)self;
assert(HashMask != 0);
- assert(mvm::HashBits != 0);
+ assert(vmkit::HashBits != 0);
word_t header = self->header;
word_t GCBits;
- GCBits = header & mvm::GCBitMask;
+ GCBits = header & vmkit::GCBitMask;
word_t val = header & HashMask;
if (val != 0) {
return val ^ (word_t)getClass(self);
@@ -50,7 +50,7 @@
val = hashCodeIncrement;
hashCodeGenerator += hashCodeIncrement;
}
- assert(val > mvm::GCBitMask);
+ assert(val > vmkit::GCBitMask);
assert(val <= HashMask);
do {
@@ -62,7 +62,7 @@
} while (true);
assert((self->header & HashMask) != 0);
- assert(GCBits == (self->header & mvm::GCBitMask));
+ assert(GCBits == (self->header & vmkit::GCBitMask));
return (self->header & HashMask) ^ (word_t)getClass(self);
}
@@ -71,7 +71,7 @@
JavaObject* self, struct timeval* info, bool timed) {
llvm_gcroot(self, 0);
JavaThread* thread = JavaThread::get();
- mvm::LockSystem& table = thread->getJVM()->lockSystem;
+ vmkit::LockSystem& table = thread->getJVM()->lockSystem;
if (!owner(self)) {
thread->getJVM()->illegalMonitorStateException(self);
@@ -121,7 +121,7 @@
void JavaObject::notify(JavaObject* self) {
llvm_gcroot(self, 0);
JavaThread* thread = JavaThread::get();
- mvm::LockSystem& table = thread->getJVM()->lockSystem;
+ vmkit::LockSystem& table = thread->getJVM()->lockSystem;
if (!owner(self)) {
thread->getJVM()->illegalMonitorStateException(self);
@@ -133,7 +133,7 @@
void JavaObject::notifyAll(JavaObject* self) {
llvm_gcroot(self, 0);
JavaThread* thread = JavaThread::get();
- mvm::LockSystem& table = thread->getJVM()->lockSystem;
+ vmkit::LockSystem& table = thread->getJVM()->lockSystem;
if (!owner(self)) {
thread->getJVM()->illegalMonitorStateException(self);
@@ -183,7 +183,7 @@
if (field.isReference()) {
tmp = field.getInstanceObjectField(src);
JavaObject** ptr = field.getInstanceObjectFieldPtr(res);
- mvm::Collector::objectReferenceWriteBarrier((gc*)res, (gc**)ptr, (gc*)tmp);
+ vmkit::Collector::objectReferenceWriteBarrier((gc*)res, (gc**)ptr, (gc*)tmp);
} else if (field.isLong()) {
field.setInstanceLongField(res, field.getInstanceLongField(src));
} else if (field.isDouble()) {
@@ -209,22 +209,22 @@
void JavaObject::overflowThinLock(JavaObject* self) {
llvm_gcroot(self, 0);
- mvm::ThinLock::overflowThinLock(self, JavaThread::get()->getJVM()->lockSystem);
+ vmkit::ThinLock::overflowThinLock(self, JavaThread::get()->getJVM()->lockSystem);
}
void JavaObject::acquire(JavaObject* self) {
llvm_gcroot(self, 0);
- mvm::ThinLock::acquire(self, JavaThread::get()->getJVM()->lockSystem);
+ vmkit::ThinLock::acquire(self, JavaThread::get()->getJVM()->lockSystem);
}
void JavaObject::release(JavaObject* self) {
llvm_gcroot(self, 0);
- mvm::ThinLock::release(self, JavaThread::get()->getJVM()->lockSystem);
+ vmkit::ThinLock::release(self, JavaThread::get()->getJVM()->lockSystem);
}
bool JavaObject::owner(JavaObject* self) {
llvm_gcroot(self, 0);
- return mvm::ThinLock::owner(self, JavaThread::get()->getJVM()->lockSystem);
+ return vmkit::ThinLock::owner(self, JavaThread::get()->getJVM()->lockSystem);
}
void JavaObject::decapsulePrimitive(JavaObject* obj, Jnjvm *vm, jvalue* buf,
Modified: vmkit/trunk/lib/J3/VMCore/JavaObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaObject.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaObject.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaObject.h Mon Nov 21 05:03:32 2011
@@ -30,12 +30,12 @@
class Typedef;
class UserCommonClass;
-class InterfaceMethodTable : public mvm::PermanentObject {
+class InterfaceMethodTable : public vmkit::PermanentObject {
public:
static const uint32_t NumIndexes = 29;
word_t contents[NumIndexes];
- static uint32_t getIndex(const mvm::UTF8* name, const mvm::UTF8* type) {
+ static uint32_t getIndex(const vmkit::UTF8* name, const vmkit::UTF8* type) {
return (name->hash() + type->hash()) % NumIndexes;
}
};
@@ -107,7 +107,7 @@
/// size must contain the additional information for type checking, as well
/// as the function pointers.
///
- void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+ void* operator new(size_t sz, vmkit::BumpPtrAllocator& allocator,
uint32 nbMethods) {
return allocator.Allocate(sizeof(word_t) * (nbMethods), "Virtual table");
}
Modified: vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaRuntimeJIT.cpp Mon Nov 21 05:03:32 2011
@@ -224,7 +224,7 @@
va_list ap;
va_start(ap, len);
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
sint32* dims = (sint32*)allocator.Allocate(sizeof(sint32) * len);
for (uint32 i = 0; i < len; ++i){
dims[i] = va_arg(ap, int);
@@ -268,13 +268,13 @@
extern "C" word_t j3StartJNI(uint32* localReferencesNumber,
uint32** oldLocalReferencesNumber,
- mvm::KnownFrame* Frame)
+ vmkit::KnownFrame* Frame)
__attribute__((noinline));
// Never throws. Does not call Java code. Can not yield a GC. May join a GC.
extern "C" word_t j3StartJNI(uint32* localReferencesNumber,
uint32** oldLocalReferencesNumber,
- mvm::KnownFrame* Frame) {
+ vmkit::KnownFrame* Frame) {
JavaThread* th = JavaThread::get();
@@ -370,9 +370,9 @@
void* result = NULL;
// Lookup the caller of this class.
- mvm::StackWalker Walker(th);
+ vmkit::StackWalker Walker(th);
++Walker; // Remove the stub.
- mvm::FrameInfo* FI = Walker.get();
+ vmkit::FrameInfo* FI = Walker.get();
assert(FI->Metadata != NULL && "Wrong stack trace");
JavaMethod* meth = (JavaMethod*)FI->Metadata;
@@ -430,9 +430,9 @@
void* result = NULL;
// Lookup the caller of this class.
- mvm::StackWalker Walker(th);
+ vmkit::StackWalker Walker(th);
++Walker; // Remove the stub.
- mvm::FrameInfo* FI = Walker.get();
+ vmkit::FrameInfo* FI = Walker.get();
assert(FI->Metadata != NULL && "Wrong stack trace");
JavaMethod* caller = (JavaMethod*)FI->Metadata;
@@ -463,9 +463,9 @@
void* result = NULL;
// Lookup the caller of this class.
- mvm::StackWalker Walker(th);
+ vmkit::StackWalker Walker(th);
++Walker; // Remove the stub.
- mvm::FrameInfo* FI = Walker.get();
+ vmkit::FrameInfo* FI = Walker.get();
assert(FI->Metadata != NULL && "Wrong stack trace");
JavaMethod* caller = (JavaMethod*)FI->Metadata;
@@ -525,20 +525,20 @@
}
extern "C" void j3PrintMethodStart(JavaMethod* meth) {
- fprintf(stderr, "[%p] executing %s.%s\n", (void*)mvm::Thread::get(),
+ fprintf(stderr, "[%p] executing %s.%s\n", (void*)vmkit::Thread::get(),
UTF8Buffer(meth->classDef->name).cString(),
UTF8Buffer(meth->name).cString());
}
extern "C" void j3PrintMethodEnd(JavaMethod* meth) {
- fprintf(stderr, "[%p] return from %s.%s\n", (void*)mvm::Thread::get(),
+ fprintf(stderr, "[%p] return from %s.%s\n", (void*)vmkit::Thread::get(),
UTF8Buffer(meth->classDef->name).cString(),
UTF8Buffer(meth->name).cString());
}
extern "C" void j3PrintExecution(uint32 opcode, uint32 index,
JavaMethod* meth) {
- fprintf(stderr, "[%p] executing %s.%s %s at %d\n", (void*)mvm::Thread::get(),
+ fprintf(stderr, "[%p] executing %s.%s %s at %d\n", (void*)vmkit::Thread::get(),
UTF8Buffer(meth->classDef->name).cString(),
UTF8Buffer(meth->name).cString(),
OpcodeNames[opcode], index);
Modified: vmkit/trunk/lib/J3/VMCore/JavaString.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaString.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaString.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaString.cpp Mon Nov 21 05:03:32 2011
@@ -57,7 +57,7 @@
}
char* JavaString::strToAsciiz(JavaString* self,
- mvm::ThreadAllocator* allocator) {
+ vmkit::ThreadAllocator* allocator) {
const ArrayUInt16* value = NULL;
llvm_gcroot(self, 0);
llvm_gcroot(value, 0);
@@ -127,7 +127,7 @@
llvm_gcroot(value, 0);
value = JavaString::getValue(self);
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
uint16* java = (uint16*)allocator.Allocate(self->count * sizeof(uint16));
for (sint32 i = 0; i < self->count; ++i) {
Modified: vmkit/trunk/lib/J3/VMCore/JavaString.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaString.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaString.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaString.h Mon Nov 21 05:03:32 2011
@@ -39,7 +39,7 @@
static void setValue(JavaString* self, const ArrayUInt16* array) {
llvm_gcroot(self, 0);
llvm_gcroot(array, 0);
- mvm::Collector::objectReferenceWriteBarrier(
+ vmkit::Collector::objectReferenceWriteBarrier(
(gc*)self, (gc**)&(self->value), (gc*)array);
}
static const ArrayUInt16* getValue(const JavaString* self) {
@@ -58,7 +58,7 @@
static void stringDestructor(JavaString*);
static char* strToAsciiz(JavaString* self);
- static char* strToAsciiz(JavaString* self, mvm::ThreadAllocator* allocator);
+ static char* strToAsciiz(JavaString* self, vmkit::ThreadAllocator* allocator);
static const ArrayUInt16* strToArray(JavaString* self, Jnjvm* vm);
/// javaToInternal - Replaces all '/' into '.'.
Modified: vmkit/trunk/lib/J3/VMCore/JavaThread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaThread.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaThread.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaThread.cpp Mon Nov 21 05:03:32 2011
@@ -67,10 +67,10 @@
}
uint32 JavaThread::getJavaFrameContext(void** buffer) {
- mvm::StackWalker Walker(this);
+ vmkit::StackWalker Walker(this);
uint32 i = 0;
- while (mvm::FrameInfo* FI = Walker.get()) {
+ while (vmkit::FrameInfo* FI = Walker.get()) {
if (FI->Metadata != NULL) {
JavaMethod* M = (JavaMethod*)FI->Metadata;
buffer[i++] = M;
@@ -81,10 +81,10 @@
}
JavaMethod* JavaThread::getCallingMethodLevel(uint32 level) {
- mvm::StackWalker Walker(this);
+ vmkit::StackWalker Walker(this);
uint32 index = 0;
- while (mvm::FrameInfo* FI = Walker.get()) {
+ while (vmkit::FrameInfo* FI = Walker.get()) {
if (FI->Metadata != NULL) {
if (index == level) {
return (JavaMethod*)FI->Metadata;
@@ -107,9 +107,9 @@
JavaObject* obj = 0;
llvm_gcroot(obj, 0);
- mvm::StackWalker Walker(this);
+ vmkit::StackWalker Walker(this);
- while (mvm::FrameInfo* FI = Walker.get()) {
+ while (vmkit::FrameInfo* FI = Walker.get()) {
if (FI->Metadata != NULL) {
JavaMethod* meth = (JavaMethod*)FI->Metadata;
JnjvmClassLoader* loader = meth->classDef->classLoader;
@@ -123,9 +123,9 @@
void JavaThread::printJavaBacktrace() {
- mvm::StackWalker Walker(this);
+ vmkit::StackWalker Walker(this);
- while (mvm::FrameInfo* FI = Walker.get()) {
+ while (vmkit::FrameInfo* FI = Walker.get()) {
if (FI->Metadata != NULL) {
MyVM->printMethod(FI, Walker.ip, Walker.addr);
}
Modified: vmkit/trunk/lib/J3/VMCore/JavaThread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaThread.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaThread.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaThread.h Mon Nov 21 05:03:32 2011
@@ -35,7 +35,7 @@
JavaThread* th = JavaThread::get(); \
word_t SP = th->getLastSP(); \
th->leaveUncooperativeCode(); \
- mvm::KnownFrame Frame; \
+ vmkit::KnownFrame Frame; \
th->startKnownFrame(Frame); \
TRY {
@@ -59,7 +59,7 @@
/// It maintains thread-specific information such as its state, the current
/// exception if there is one, the layout of the stack, etc.
///
-class JavaThread : public mvm::MutatorThread {
+class JavaThread : public vmkit::MutatorThread {
public:
/// jniEnv - The JNI environment of the thread.
@@ -78,7 +78,7 @@
///
JavaObject* vmThread;
- mvm::LockingThread lockingThread;
+ vmkit::LockingThread lockingThread;
/// currentAddedReferences - Current number of added local references.
///
@@ -120,7 +120,7 @@
/// get - Get the current thread as a J3 object.
///
static JavaThread* get() {
- return (JavaThread*)mvm::Thread::get();
+ return (JavaThread*)vmkit::Thread::get();
}
/// getJVM - Get the Java VM in which this thread executes.
Modified: vmkit/trunk/lib/J3/VMCore/JavaTypes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaTypes.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaTypes.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaTypes.cpp Mon Nov 21 05:03:32 2011
@@ -59,7 +59,7 @@
word_t Signdef::staticCallBuf() {
if (!_staticCallBuf) {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
nativeName(buf, "static_buf");
bool unused = false;
@@ -75,7 +75,7 @@
word_t Signdef::virtualCallBuf() {
if (!_virtualCallBuf) {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
nativeName(buf, "virtual_buf");
bool unused = false;
@@ -91,7 +91,7 @@
word_t Signdef::staticCallAP() {
if (!_staticCallAP) {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
nativeName(buf, "static_ap");
bool unused = false;
@@ -107,7 +107,7 @@
word_t Signdef::virtualCallAP() {
if (!_virtualCallAP) {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
nativeName(buf, "virtual_ap");
bool unused = false;
@@ -123,7 +123,7 @@
word_t Signdef::virtualCallStub() {
if (!_virtualCallAP) {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
nativeName(buf, "virtual_stub");
bool unused = false;
@@ -139,7 +139,7 @@
word_t Signdef::specialCallStub() {
if (!_specialCallStub) {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
nativeName(buf, "special_stub");
bool unused = false;
@@ -155,7 +155,7 @@
word_t Signdef::staticCallStub() {
if (!_staticCallStub) {
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char* buf = (char*)allocator.Allocate((keyName->size << 1) + 1 + 11);
nativeName(buf, "static_stub");
bool unused = false;
Modified: vmkit/trunk/lib/J3/VMCore/JavaTypes.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JavaTypes.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JavaTypes.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JavaTypes.h Mon Nov 21 05:03:32 2011
@@ -55,7 +55,7 @@
/// which has not been loaded yet. Typedefs are hashed on the name of the class.
/// Hashing is for memory purposes, not for comparison.
///
-class Typedef : public mvm::PermanentObject {
+class Typedef : public vmkit::PermanentObject {
public:
/// keyName - The name of the Typedef. It is the representation of a class
@@ -274,7 +274,7 @@
/// Java signature. Signdefs are hashed for memory purposes, not equality
/// purposes.
///
-class Signdef : public mvm::PermanentObject {
+class Signdef : public vmkit::PermanentObject {
private:
/// _staticCallBuf - A dynamically generated method which calls a static Java
@@ -336,7 +336,7 @@
/// operator new - Redefines the new operator of this class to allocate
/// the arguments in the object itself.
///
- void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator,
+ void* operator new(size_t sz, vmkit::BumpPtrAllocator& allocator,
sint32 size) {
return allocator.Allocate(sizeof(Signdef) + size * sizeof(Typedef),
"Signdef");
Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.cpp Mon Nov 21 05:03:32 2011
@@ -160,7 +160,7 @@
PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "; ", 0);
PRINT_DEBUG(JNJVM_LOAD, 0, LIGHT_GREEN, "clinit ", 0);
- PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", mvm::PrintString(this).cString());
+ PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", vmkit::PrintString(this).cString());
JavaField* fields = cl->getStaticFields();
for (uint32 i = 0; i < cl->nbStaticFields; ++i) {
@@ -844,7 +844,7 @@
return;
}
- mvm::BumpPtrAllocator allocator;
+ vmkit::BumpPtrAllocator allocator;
ZipArchive* archive = new(allocator, "TempZipArchive")
ZipArchive(bytes, allocator);
if (archive->getOfscd() != -1) {
@@ -1005,7 +1005,7 @@
} else if (!(strcmp(cur, "-verbosegc"))) {
nyi();
} else if (!(strcmp(cur, "-verbose:gc"))) {
- mvm::Collector::verbose = 1;
+ vmkit::Collector::verbose = 1;
} else if (!(strcmp(cur, "-verbose:jni"))) {
nyi();
} else if (!(strcmp(cur, "-version"))) {
@@ -1064,11 +1064,11 @@
// First create system threads.
finalizerThread = new FinalizerThread(this);
finalizerThread->start(
- (void (*)(mvm::Thread*))FinalizerThread::finalizerStart);
+ (void (*)(vmkit::Thread*))FinalizerThread::finalizerStart);
referenceThread = new ReferenceThread(this);
referenceThread->start(
- (void (*)(mvm::Thread*))ReferenceThread::enqueueStart);
+ (void (*)(vmkit::Thread*))ReferenceThread::enqueueStart);
// Initialise the bootstrap class loader if it's not
// done already.
@@ -1200,7 +1200,7 @@
method->invokeIntStatic(this, method->classDef, &args);
} else {
fprintf(stderr, "Main method not public.\n");
- mvm::System::Exit(1);
+ vmkit::System::Exit(1);
}
} CATCH {
} END_CATCH;
@@ -1219,7 +1219,7 @@
"Can not print stack trace.\n");
} END_CATCH;
// Program failed. Exit with return code not 0.
- mvm::System::Exit(1);
+ vmkit::System::Exit(1);
}
}
@@ -1303,7 +1303,7 @@
void ThreadSystem::leave() {
nonDaemonLock.lock();
--nonDaemonThreads;
- if (nonDaemonThreads == 0) mvm::Thread::get()->MyVM->exit();
+ if (nonDaemonThreads == 0) vmkit::Thread::get()->MyVM->exit();
nonDaemonLock.unlock();
}
@@ -1317,11 +1317,11 @@
argumentsInfo.argc = argc;
argumentsInfo.argv = argv;
mainThread = new JavaThread(this);
- mainThread->start((void (*)(mvm::Thread*))mainJavaStart);
+ mainThread->start((void (*)(vmkit::Thread*))mainJavaStart);
}
-Jnjvm::Jnjvm(mvm::BumpPtrAllocator& Alloc,
- mvm::CompiledFrames** frames,
+Jnjvm::Jnjvm(vmkit::BumpPtrAllocator& Alloc,
+ vmkit::CompiledFrames** frames,
JnjvmBootstrapLoader* loader) :
VirtualMachine(Alloc, frames), lockSystem(Alloc) {
@@ -1436,15 +1436,15 @@
// Helper function to run J3 without JIT.
extern "C" int StartJnjvmWithoutJIT(int argc, char** argv, char* mainClass) {
- mvm::Collector::initialise(argc, argv);
+ vmkit::Collector::initialise(argc, argv);
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
char** newArgv = (char**)allocator.Allocate((argc + 1) * sizeof(char*));
memcpy(newArgv + 1, argv, argc * sizeof(char*));
newArgv[0] = newArgv[1];
newArgv[1] = mainClass;
- mvm::BumpPtrAllocator Allocator;
+ vmkit::BumpPtrAllocator Allocator;
JavaCompiler* Comp = new JavaCompiler();
JnjvmBootstrapLoader* loader = new(Allocator, "Bootstrap loader")
JnjvmBootstrapLoader(Allocator, Comp, true);
@@ -1456,9 +1456,9 @@
return 0;
}
-void Jnjvm::printMethod(mvm::FrameInfo* FI, word_t ip, word_t addr) {
+void Jnjvm::printMethod(vmkit::FrameInfo* FI, word_t ip, word_t addr) {
if (FI->Metadata == NULL) {
- mvm::MethodInfoHelper::print(ip, addr);
+ vmkit::MethodInfoHelper::print(ip, addr);
return;
}
JavaMethod* meth = (JavaMethod*)FI->Metadata;
Modified: vmkit/trunk/lib/J3/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Jnjvm.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Jnjvm.h (original)
+++ vmkit/trunk/lib/J3/VMCore/Jnjvm.h Mon Nov 21 05:03:32 2011
@@ -59,7 +59,7 @@
/// nonDaemonLock - Protection lock for the nonDaemonThreads variable.
///
- mvm::SpinLock nonDaemonLock;
+ vmkit::SpinLock nonDaemonLock;
/// ThreadSystem - Allocates a thread system management, initializing the
/// lock, the condition variable and setting the initial number of non
@@ -104,7 +104,7 @@
/// Jnjvm - A JVM. Each execution of a program allocates a Jnjvm.
///
-class Jnjvm : public mvm::VirtualMachine {
+class Jnjvm : public vmkit::VirtualMachine {
friend class JnjvmClassLoader;
public:
/// throwable - The java/lang/Throwable class. In an isolate
@@ -130,7 +130,7 @@
virtual void addFinalizationCandidate(gc* obj);
virtual size_t getObjectSize(gc* obj);
virtual const char* getObjectTypeName(gc* obj);
- virtual void printMethod(mvm::FrameInfo* FI, word_t ip, word_t addr);
+ virtual void printMethod(vmkit::FrameInfo* FI, word_t ip, word_t addr);
/// CreateError - Creates a Java object of the specified exception class
@@ -209,7 +209,7 @@
/// lockSystem - The lock system to allocate and manage Java locks.
///
- mvm::LockSystem lockSystem;
+ vmkit::LockSystem lockSystem;
/// argumentsInfo - The command line arguments given to the vm
///
@@ -237,7 +237,7 @@
/// globalRefsLock - Lock for adding a new global reference.
///
- mvm::LockNormal globalRefsLock;
+ vmkit::LockNormal globalRefsLock;
/// appClassLoader - The bootstrap class loader.
///
@@ -338,8 +338,8 @@
/// Jnjvm - Allocates a new JVM.
///
- Jnjvm(mvm::BumpPtrAllocator& Alloc,
- mvm::CompiledFrames** frames,
+ Jnjvm(vmkit::BumpPtrAllocator& Alloc,
+ vmkit::CompiledFrames** frames,
JnjvmBootstrapLoader* loader);
/// runApplication - Runs the application with the given command line.
Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.cpp Mon Nov 21 05:03:32 2011
@@ -50,7 +50,7 @@
const UTF8* JavaCompiler::NoInlinePragma = 0;
-JnjvmBootstrapLoader::JnjvmBootstrapLoader(mvm::BumpPtrAllocator& Alloc,
+JnjvmBootstrapLoader::JnjvmBootstrapLoader(vmkit::BumpPtrAllocator& Alloc,
JavaCompiler* Comp,
bool dlLoad) :
JnjvmClassLoader(Alloc) {
@@ -162,7 +162,7 @@
clinitType = asciizConstructUTF8("()V");
runName = asciizConstructUTF8("run");
prelib = asciizConstructUTF8("lib");
- postlib = asciizConstructUTF8(mvm::System::GetDyLibExtension());
+ postlib = asciizConstructUTF8(vmkit::System::GetDyLibExtension());
mathName = asciizConstructUTF8("java/lang/Math");
VMFloatName = asciizConstructUTF8("java/lang/VMFloat");
VMDoubleName = asciizConstructUTF8("java/lang/VMDouble");
@@ -204,7 +204,7 @@
#undef DEF_UTF8
}
-JnjvmClassLoader::JnjvmClassLoader(mvm::BumpPtrAllocator& Alloc,
+JnjvmClassLoader::JnjvmClassLoader(vmkit::BumpPtrAllocator& Alloc,
JnjvmClassLoader& JCL, JavaObject* loader,
VMClassLoader* vmdata,
Jnjvm* I) : allocator(Alloc) {
@@ -220,7 +220,7 @@
strings = new(allocator, "StringList") StringList();
vmdata->JCL = this;
- mvm::Collector::objectReferenceNonHeapWriteBarrier(
+ vmkit::Collector::objectReferenceNonHeapWriteBarrier(
(gc**)&javaLoader, (gc*)loader);
isolate = I;
@@ -237,11 +237,11 @@
}
ClassBytes* JnjvmBootstrapLoader::openName(const UTF8* utf8) {
- ClassBytes* res = reinterpret_cast<ClassBytes*>(dlsym(mvm::System::GetSelfHandle(),
+ ClassBytes* res = reinterpret_cast<ClassBytes*>(dlsym(vmkit::System::GetSelfHandle(),
UTF8Buffer(utf8).toCompileName("_bytes")->cString()));
if (res != NULL) return res;
- mvm::ThreadAllocator threadAllocator;
+ vmkit::ThreadAllocator threadAllocator;
char* asciiz = (char*)threadAllocator.Allocate(utf8->size + 1);
for (sint32 i = 0; i < utf8->size; ++i)
@@ -440,7 +440,7 @@
if (name->size == 0) {
return 0;
} else if (name->elements[0] == I_TAB) {
- mvm::ThreadAllocator threadAllocator;
+ vmkit::ThreadAllocator threadAllocator;
bool prim = false;
UTF8* holder = (UTF8*)threadAllocator.Allocate(
sizeof(UTF8) + name->size * sizeof(uint16));
@@ -463,7 +463,7 @@
bool doResolve,
bool doThrow) {
const UTF8* name = hashUTF8->lookupAsciiz(asciiz);
- mvm::ThreadAllocator threadAllocator;
+ vmkit::ThreadAllocator threadAllocator;
UserCommonClass* result = NULL;
if (!name) name = bootstrapLoader->hashUTF8->lookupAsciiz(asciiz);
if (!name) {
@@ -498,7 +498,7 @@
bool doThrow) {
llvm_gcroot(str, 0);
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
UTF8* name = (UTF8*)allocator.Allocate(sizeof(UTF8) + str->count * sizeof(uint16));
name->size = str->count;
@@ -534,7 +534,7 @@
llvm_gcroot(str, 0);
llvm_gcroot(value, 0);
value = JavaString::getValue(str);
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
UTF8* name = (UTF8*)allocator.Allocate(sizeof(UTF8) + str->count * sizeof(uint16));
name->size = str->count;
@@ -817,7 +817,7 @@
(VMClassLoader*)(upcalls->vmdataClassLoader->getInstanceObjectField(loader));
if (!vmdata || !VMClassLoader::isVMClassLoader(vmdata)) {
vmdata = VMClassLoader::allocate();
- mvm::BumpPtrAllocator* A = new mvm::BumpPtrAllocator();
+ vmkit::BumpPtrAllocator* A = new vmkit::BumpPtrAllocator();
JCL = new(*A, "Class loader") JnjvmClassLoader(*A, *vm->bootstrapLoader,
loader, vmdata, vm);
upcalls->vmdataClassLoader->setInstanceObjectField(loader, (JavaObject*)vmdata);
@@ -898,7 +898,7 @@
void JnjvmBootstrapLoader::analyseClasspathEnv(const char* str) {
ClassBytes* bytes = NULL;
- mvm::ThreadAllocator threadAllocator;
+ vmkit::ThreadAllocator threadAllocator;
if (str != 0) {
unsigned int len = strlen(str);
char* buf = (char*)threadAllocator.Allocate((len + 1) * sizeof(char));
@@ -952,7 +952,7 @@
uint32 pos = steps;
bool isTab = (className->elements[0] == I_TAB ? true : false);
uint32 n = steps + len + (isTab ? 0 : 2);
- mvm::ThreadAllocator allocator;
+ vmkit::ThreadAllocator allocator;
uint16* buf = (uint16*)allocator.Allocate(n * sizeof(uint16));
for (uint32 i = 0; i < steps; i++) {
@@ -981,7 +981,7 @@
// code dlopen'd something itself (with RTLD_GLOBAL; OpenJDK does this).
// To handle this, we search both ourselves and the libraries we loaded.
word_t sym =
- (word_t)TheCompiler->loadMethod(mvm::System::GetSelfHandle(), buf);
+ (word_t)TheCompiler->loadMethod(vmkit::System::GetSelfHandle(), buf);
// Search loaded libraries as well, both as fallback and to determine
// whether or not the symbol in question is defined by vmkit.
@@ -1052,7 +1052,7 @@
return next->addString(JCL, obj);
} else {
JCL->lock.lock();
- mvm::Collector::objectReferenceNonHeapWriteBarrier(
+ vmkit::Collector::objectReferenceNonHeapWriteBarrier(
(gc**)&(strings[length]), (gc*)obj);
JavaString** res = &strings[length++];
JCL->lock.unlock();
Modified: vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/trunk/lib/J3/VMCore/JnjvmClassLoader.h Mon Nov 21 05:03:32 2011
@@ -50,7 +50,7 @@
/// its own tables (signatures, UTF8, types) which are mapped to a single
/// table for non-isolate environments.
///
-class JnjvmClassLoader : public mvm::PermanentObject {
+class JnjvmClassLoader : public vmkit::PermanentObject {
private:
/// isolate - Which isolate defined me? Null for the bootstrap class loader.
@@ -75,7 +75,7 @@
/// JnjvmClassLoader - Allocate a user-defined class loader. Called on
/// first use of a Java class loader.
///
- JnjvmClassLoader(mvm::BumpPtrAllocator& Alloc, JnjvmClassLoader& JCL,
+ JnjvmClassLoader(vmkit::BumpPtrAllocator& Alloc, JnjvmClassLoader& JCL,
JavaObject* loader, VMClassLoader* vmdata, Jnjvm* isolate);
/// lookupComponentName - Try to find the component name of the given array
@@ -86,7 +86,7 @@
protected:
- JnjvmClassLoader(mvm::BumpPtrAllocator& Alloc) : allocator(Alloc) {}
+ JnjvmClassLoader(vmkit::BumpPtrAllocator& Alloc) : allocator(Alloc) {}
/// TheCompiler - The Java compiler for this class loader.
///
@@ -106,7 +106,7 @@
/// lock - Lock when loading classes.
///
- mvm::LockRecursive lock;
+ vmkit::LockRecursive lock;
/// registeredNatives - Stores the native function pointers corresponding
/// to methods that were defined through JNI's RegisterNatives mechanism.
@@ -115,14 +115,14 @@
/// nativesLock - Locks the registeredNatives map above
///
- mvm::LockRecursive nativesLock;
+ vmkit::LockRecursive nativesLock;
public:
/// allocator - Reference to the memory allocator, which will allocate UTF8s,
/// signatures and types.
///
- mvm::BumpPtrAllocator& allocator;
+ vmkit::BumpPtrAllocator& allocator;
/// getIsolate - Returns the isolate that created this class loader.
///
@@ -370,7 +370,7 @@
/// to do before any execution of a JVM. Also try to load libvmjc.so
/// if dlLoad is not false.
///
- JnjvmBootstrapLoader(mvm::BumpPtrAllocator& Alloc, JavaCompiler* Comp,
+ JnjvmBootstrapLoader(vmkit::BumpPtrAllocator& Alloc, JavaCompiler* Comp,
bool dlLoad);
virtual JavaString** UTF8ToStr(const UTF8* utf8);
@@ -512,7 +512,7 @@
#define MAXIMUM_STRINGS 100
-class StringList : public mvm::PermanentObject {
+class StringList : public vmkit::PermanentObject {
friend class JnjvmClassLoader;
friend class Jnjvm;
Modified: vmkit/trunk/lib/J3/VMCore/LinkJavaRuntime.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LinkJavaRuntime.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LinkJavaRuntime.h (original)
+++ vmkit/trunk/lib/J3/VMCore/LinkJavaRuntime.h Mon Nov 21 05:03:32 2011
@@ -23,7 +23,7 @@
class Jnjvm;
}
-namespace mvm {
+namespace vmkit {
class KnownFrame;
}
@@ -41,7 +41,7 @@
extern "C" UserClassArray* j3GetArrayClass(UserCommonClass*,
UserClassArray**);
extern "C" void j3EndJNI(uint32**);
-extern "C" void* j3StartJNI(uint32*, uint32**, mvm::KnownFrame*);
+extern "C" void* j3StartJNI(uint32*, uint32**, vmkit::KnownFrame*);
extern "C" void j3JavaObjectAquire(JavaObject* obj);
extern "C" void j3JavaObjectRelease(JavaObject* obj);
extern "C" void j3ThrowException(JavaObject* obj);
Modified: vmkit/trunk/lib/J3/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LockedMap.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/J3/VMCore/LockedMap.h Mon Nov 21 05:03:32 2011
@@ -42,12 +42,12 @@
bool operator()(const ArrayUInt16 *const s1, const ArrayUInt16 *const s2) const;
};
-class StringMap : public mvm::PermanentObject {
+class StringMap : public vmkit::PermanentObject {
public:
typedef std::map<const ArrayUInt16 *const, JavaString*, ltarray16>::iterator iterator;
typedef JavaString* (*funcCreate)(const ArrayUInt16 *const& V, Jnjvm* vm);
- mvm::LockNormal lock;
+ vmkit::LockNormal lock;
std::map<const ArrayUInt16 *const, JavaString*, ltarray16,
std::allocator<std::pair<const ArrayUInt16 *const, JavaString*> > > map;
@@ -108,28 +108,28 @@
};
-class ClassMap : public mvm::PermanentObject {
+class ClassMap : public vmkit::PermanentObject {
public:
ClassMap() {}
- ClassMap(mvm::VmkitDenseMap<const mvm::UTF8*, UserCommonClass*>* precompiled) : map(*precompiled) {}
+ ClassMap(vmkit::VmkitDenseMap<const vmkit::UTF8*, UserCommonClass*>* precompiled) : map(*precompiled) {}
- mvm::LockRecursive lock;
- mvm::VmkitDenseMap<const mvm::UTF8*, UserCommonClass*> map;
- typedef mvm::VmkitDenseMap<const mvm::UTF8*, UserCommonClass*>::iterator iterator;
+ vmkit::LockRecursive lock;
+ vmkit::VmkitDenseMap<const vmkit::UTF8*, UserCommonClass*> map;
+ typedef vmkit::VmkitDenseMap<const vmkit::UTF8*, UserCommonClass*>::iterator iterator;
};
-class TypeMap : public mvm::PermanentObject {
+class TypeMap : public vmkit::PermanentObject {
public:
- mvm::LockNormal lock;
- mvm::VmkitDenseMap<const mvm::UTF8*, Typedef*> map;
- typedef mvm::VmkitDenseMap<const mvm::UTF8*, Typedef*>::iterator iterator;
+ vmkit::LockNormal lock;
+ vmkit::VmkitDenseMap<const vmkit::UTF8*, Typedef*> map;
+ typedef vmkit::VmkitDenseMap<const vmkit::UTF8*, Typedef*>::iterator iterator;
};
-class SignMap : public mvm::PermanentObject {
+class SignMap : public vmkit::PermanentObject {
public:
- mvm::LockNormal lock;
- mvm::VmkitDenseMap<const mvm::UTF8*, Signdef*> map;
- typedef mvm::VmkitDenseMap<const mvm::UTF8*, Signdef*>::iterator iterator;
+ vmkit::LockNormal lock;
+ vmkit::VmkitDenseMap<const vmkit::UTF8*, Signdef*> map;
+ typedef vmkit::VmkitDenseMap<const vmkit::UTF8*, Signdef*>::iterator iterator;
};
} // end namespace j3
Modified: vmkit/trunk/lib/J3/VMCore/Precompiled.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Precompiled.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Precompiled.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Precompiled.cpp Mon Nov 21 05:03:32 2011
@@ -29,7 +29,7 @@
void JnjvmClassLoader::loadLibFromJar(Jnjvm* vm, const char* name,
const char* file) {
- mvm::ThreadAllocator threadAllocator;
+ vmkit::ThreadAllocator threadAllocator;
char* soName = (char*)threadAllocator.Allocate(
strlen(name) + strlen(DYLD_EXTENSION));
const char* ptr = strrchr(name, '/');
@@ -48,7 +48,7 @@
void JnjvmClassLoader::loadLibFromFile(Jnjvm* vm, const char* name) {
- mvm::ThreadAllocator threadAllocator;
+ vmkit::ThreadAllocator threadAllocator;
assert(classes->map.size() == 0);
char* soName = (char*)threadAllocator.Allocate(
strlen(name) + strlen(DYLD_EXTENSION));
@@ -98,7 +98,7 @@
sint32 mnlen = jniConsName->size;
sint32 mtlen = jniConsType->size;
- mvm::ThreadAllocator threadAllocator;
+ vmkit::ThreadAllocator threadAllocator;
char* buf = (char*)threadAllocator.Allocate(
3 + JNI_NAME_PRE_LEN + 1 + ((mnlen + clen + mtlen) << 3));
word_t res = meth->classDef->classLoader->nativeLookup(meth, j3, buf);
@@ -114,7 +114,7 @@
bool Precompiled::Init(JnjvmBootstrapLoader* loader) {
Class* javaLangObject = (Class*)dlsym(SELF_HANDLE, "java_lang_Object");
- void* nativeHandle = mvm::System::GetSelfHandle();
+ void* nativeHandle = vmkit::System::GetSelfHandle();
if (javaLangObject == NULL) {
void* handle = dlopen("libvmjc"DYLD_EXTENSION, RTLD_LAZY | RTLD_GLOBAL);
if (handle != NULL) {
@@ -150,12 +150,12 @@
upcalls->OfLong->classLoader = loader;
upcalls->OfDouble->classLoader = loader;
- mvm::VmkitDenseSet<mvm::UTF8MapKey, const UTF8*>* precompiledUTF8Map =
- reinterpret_cast<mvm::VmkitDenseSet<mvm::UTF8MapKey, const UTF8*>*>(dlsym(nativeHandle, "UTF8Map"));
+ vmkit::VmkitDenseSet<vmkit::UTF8MapKey, const UTF8*>* precompiledUTF8Map =
+ reinterpret_cast<vmkit::VmkitDenseSet<vmkit::UTF8MapKey, const UTF8*>*>(dlsym(nativeHandle, "UTF8Map"));
loader->hashUTF8 = new (loader->allocator, "UTF8Map") UTF8Map(loader->allocator, precompiledUTF8Map);
- mvm::VmkitDenseMap<const UTF8*, CommonClass*>* precompiledClassMap =
- reinterpret_cast<mvm::VmkitDenseMap<const UTF8*, CommonClass*>*>(dlsym(nativeHandle, "ClassMap"));
+ vmkit::VmkitDenseMap<const UTF8*, CommonClass*>* precompiledClassMap =
+ reinterpret_cast<vmkit::VmkitDenseMap<const UTF8*, CommonClass*>*>(dlsym(nativeHandle, "ClassMap"));
loader->classes = new (loader->allocator, "ClassMap") ClassMap(precompiledClassMap);
for (ClassMap::iterator i = loader->getClasses()->map.begin(),
Modified: vmkit/trunk/lib/J3/VMCore/Reader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Reader.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Reader.h (original)
+++ vmkit/trunk/lib/J3/VMCore/Reader.h Mon Nov 21 05:03:32 2011
@@ -28,7 +28,7 @@
size = l;
}
- void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator, int n) {
+ void* operator new(size_t sz, vmkit::BumpPtrAllocator& allocator, int n) {
return allocator.Allocate(sizeof(uint32_t) + n * sizeof(uint8_t),
"Class bytes");
}
@@ -59,12 +59,12 @@
}
static double readDouble(int first, int second) {
- return mvm::System::ReadDouble(first, second);
+ return vmkit::System::ReadDouble(first, second);
}
static sint64 readLong(int first, int second) {
- return mvm::System::ReadLong(first, second);
+ return vmkit::System::ReadLong(first, second);
}
static const int SeekSet;
Modified: vmkit/trunk/lib/J3/VMCore/ReferenceQueue.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/ReferenceQueue.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/ReferenceQueue.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/ReferenceQueue.cpp Mon Nov 21 05:03:32 2011
@@ -40,7 +40,7 @@
TRY {
enqueueReference(res);
} IGNORE;
- mvm::Thread::get()->clearException();
+ vmkit::Thread::get()->clearException();
}
void ReferenceThread::enqueueStart(ReferenceThread* th) {
@@ -109,7 +109,7 @@
}
gc* ReferenceQueue::processReference(gc* reference, ReferenceThread* th, word_t closure) {
- if (!mvm::Collector::isLive(reference, closure)) {
+ if (!vmkit::Collector::isLive(reference, closure)) {
clearReferent(reference);
return NULL;
}
@@ -123,16 +123,16 @@
if (semantics == SOFT) {
// TODO: are we are out of memory? Consider that we always are for now.
if (false) {
- mvm::Collector::retainReferent(referent, closure);
+ vmkit::Collector::retainReferent(referent, closure);
}
} else if (semantics == PHANTOM) {
// Nothing to do.
}
gc* newReference =
- mvm::Collector::getForwardedReference(reference, closure);
- if (mvm::Collector::isLive(referent, closure)) {
- gc* newReferent = mvm::Collector::getForwardedReferent(referent, closure);
+ vmkit::Collector::getForwardedReference(reference, closure);
+ if (vmkit::Collector::isLive(referent, closure)) {
+ gc* newReferent = vmkit::Collector::getForwardedReferent(referent, closure);
setReferent(newReference, newReferent);
return newReference;
} else {
@@ -215,8 +215,8 @@
for (uint32 i = 0; i < CurrentIndex; ++i) {
gc* obj = FinalizationQueue[i];
- if (!mvm::Collector::isLive(obj, closure)) {
- obj = mvm::Collector::retainForFinalize(FinalizationQueue[i], closure);
+ if (!vmkit::Collector::isLive(obj, closure)) {
+ obj = vmkit::Collector::retainForFinalize(FinalizationQueue[i], closure);
if (CurrentFinalizedIndex >= ToBeFinalizedLength)
growToBeFinalizedQueue();
@@ -225,7 +225,7 @@
ToBeFinalized[CurrentFinalizedIndex++] = obj;
} else {
FinalizationQueue[NewIndex++] =
- mvm::Collector::getForwardedFinalizable(obj, closure);
+ vmkit::Collector::getForwardedFinalizable(obj, closure);
}
}
CurrentIndex = NewIndex;
@@ -247,7 +247,7 @@
TRY {
invokeFinalizer(res);
} IGNORE;
- mvm::Thread::get()->clearException();
+ vmkit::Thread::get()->clearException();
}
void FinalizerThread::finalizerStart(FinalizerThread* th) {
Modified: vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h (original)
+++ vmkit/trunk/lib/J3/VMCore/ReferenceQueue.h Mon Nov 21 05:03:32 2011
@@ -28,7 +28,7 @@
gc** References;
uint32 QueueLength;
uint32 CurrentIndex;
- mvm::SpinLock QueueLock;
+ vmkit::SpinLock QueueLock;
uint8_t semantics;
gc* processReference(gc*, ReferenceThread*, word_t closure);
@@ -102,9 +102,9 @@
/// ToEnqueueLock - A lock to protect access to the queue.
///
- mvm::LockNormal EnqueueLock;
- mvm::Cond EnqueueCond;
- mvm::SpinLock ToEnqueueLock;
+ vmkit::LockNormal EnqueueLock;
+ vmkit::Cond EnqueueCond;
+ vmkit::SpinLock ToEnqueueLock;
void addToEnqueue(gc* obj);
@@ -142,7 +142,7 @@
public:
/// FinalizationQueueLock - A lock to protect access to the queue.
///
- mvm::SpinLock FinalizationQueueLock;
+ vmkit::SpinLock FinalizationQueueLock;
/// finalizationQueue - A list of allocated objets that contain a finalize
/// method.
@@ -181,11 +181,11 @@
/// finalizationCond - Condition variable to wake up finalization threads.
///
- mvm::Cond FinalizationCond;
+ vmkit::Cond FinalizationCond;
/// finalizationLock - Lock for the condition variable.
///
- mvm::LockNormal FinalizationLock;
+ vmkit::LockNormal FinalizationLock;
static void finalizerStart(FinalizerThread*);
Modified: vmkit/trunk/lib/J3/VMCore/UTF8.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/UTF8.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/UTF8.h (original)
+++ vmkit/trunk/lib/J3/VMCore/UTF8.h Mon Nov 21 05:03:32 2011
@@ -15,8 +15,8 @@
#include "vmkit/UTF8.h"
namespace j3 {
- using mvm::UTF8;
- using mvm::UTF8Map;
+ using vmkit::UTF8;
+ using vmkit::UTF8Map;
/// UTF8Buffer - Helper class to create char* buffers suitable for
/// printf.
Modified: vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/VirtualTables.cpp Mon Nov 21 05:03:32 2011
@@ -86,7 +86,7 @@
extern "C" void RegularObjectTracer(JavaObject* obj, word_t closure) {
Class* cl = JavaObject::getClass(obj)->asClass();
assert(cl && "Not a class in regular tracer");
- mvm::Collector::markAndTraceRoot(
+ vmkit::Collector::markAndTraceRoot(
cl->classLoader->getJavaClassLoaderPtr(), closure);
while (cl->super != 0) {
@@ -94,7 +94,7 @@
JavaField& field = cl->virtualFields[i];
if (field.isReference()) {
JavaObject** ptr = field.getInstanceObjectFieldPtr(obj);
- mvm::Collector::markAndTrace(obj, ptr, closure);
+ vmkit::Collector::markAndTrace(obj, ptr, closure);
}
}
cl = cl->super;
@@ -106,13 +106,13 @@
extern "C" void ArrayObjectTracer(ArrayObject* obj, word_t closure) {
CommonClass* cl = JavaObject::getClass(obj);
assert(cl && "No class");
- mvm::Collector::markAndTraceRoot(
+ vmkit::Collector::markAndTraceRoot(
cl->classLoader->getJavaClassLoaderPtr(), closure);
for (sint32 i = 0; i < ArrayObject::getSize(obj); i++) {
if (ArrayObject::getElement(obj, i) != NULL) {
- mvm::Collector::markAndTrace(
+ vmkit::Collector::markAndTrace(
obj, ArrayObject::getElements(obj) + i, closure);
}
}
@@ -123,7 +123,7 @@
JavaObjectReference* obj, word_t closure) {
Class* cl = JavaObject::getClass(obj)->asClass();
assert(cl && "Not a class in reference tracer");
- mvm::Collector::markAndTraceRoot(
+ vmkit::Collector::markAndTraceRoot(
cl->classLoader->getJavaClassLoaderPtr(), closure);
bool found = false;
@@ -133,7 +133,7 @@
if (field.isReference()) {
JavaObject** ptr = field.getInstanceObjectFieldPtr(obj);
if (ptr != JavaObjectReference::getReferentPtr(obj)) {
- mvm::Collector::markAndTrace(obj, ptr, closure);
+ vmkit::Collector::markAndTrace(obj, ptr, closure);
} else {
found = true;
}
@@ -159,24 +159,24 @@
if (super != NULL && super->classLoader != NULL) {
JavaObject** Obj = super->classLoader->getJavaClassLoaderPtr();
- if (*Obj != NULL) mvm::Collector::markAndTraceRoot(Obj, closure);
+ if (*Obj != NULL) vmkit::Collector::markAndTraceRoot(Obj, closure);
for (uint32 i = 0; i < nbInterfaces; ++i) {
if (interfaces[i]->classLoader) {
JavaObject** Obj = interfaces[i]->classLoader->getJavaClassLoaderPtr();
- if (*Obj != NULL) mvm::Collector::markAndTraceRoot(Obj, closure);
+ if (*Obj != NULL) vmkit::Collector::markAndTraceRoot(Obj, closure);
}
}
}
if (classLoader != NULL) {
- mvm::Collector::markAndTraceRoot(
+ vmkit::Collector::markAndTraceRoot(
classLoader->getJavaClassLoaderPtr(), closure);
}
for (uint32 i = 0; i < NR_ISOLATES; ++i) {
if (delegatee[i] != NULL) {
- mvm::Collector::markAndTraceRoot(delegatee + i, closure);
+ vmkit::Collector::markAndTraceRoot(delegatee + i, closure);
}
}
}
@@ -191,7 +191,7 @@
JavaField& field = staticFields[i];
if (field.isReference()) {
JavaObject** ptr = field.getStaticObjectFieldPtr();
- mvm::Collector::markAndTraceRoot(ptr, closure);
+ vmkit::Collector::markAndTraceRoot(ptr, closure);
}
}
}
@@ -228,12 +228,12 @@
while (end != NULL) {
for (uint32 i = 0; i < end->length; ++i) {
JavaString** obj = end->strings + i;
- mvm::Collector::markAndTraceRoot(obj, closure);
+ vmkit::Collector::markAndTraceRoot(obj, closure);
}
end = end->prev;
}
- mvm::Collector::markAndTraceRoot(&javaLoader, closure);
+ vmkit::Collector::markAndTraceRoot(&javaLoader, closure);
}
void JnjvmBootstrapLoader::tracer(word_t closure) {
@@ -270,7 +270,7 @@
// (2) Trace the application class loader.
if (appClassLoader != NULL) {
- mvm::Collector::markAndTraceRoot(
+ vmkit::Collector::markAndTraceRoot(
appClassLoader->getJavaClassLoaderPtr(), closure);
}
@@ -279,7 +279,7 @@
while (start != NULL) {
for (uint32 i = 0; i < start->length; ++i) {
JavaObject** obj = start->globalReferences + i;
- mvm::Collector::markAndTraceRoot(obj, closure);
+ vmkit::Collector::markAndTraceRoot(obj, closure);
}
start = start->next;
}
@@ -288,51 +288,51 @@
for (StringMap::iterator i = hashStr.map.begin(), e = hashStr.map.end();
i!= e; ++i) {
JavaString** str = &(i->second);
- mvm::Collector::markAndTraceRoot(str, closure);
+ vmkit::Collector::markAndTraceRoot(str, closure);
ArrayUInt16** key = const_cast<ArrayUInt16**>(&(i->first));
- mvm::Collector::markAndTraceRoot(key, closure);
+ vmkit::Collector::markAndTraceRoot(key, closure);
}
// (5) Trace the finalization queue.
for (uint32 i = 0; i < finalizerThread->CurrentFinalizedIndex; ++i) {
- mvm::Collector::markAndTraceRoot(finalizerThread->ToBeFinalized + i, closure);
+ vmkit::Collector::markAndTraceRoot(finalizerThread->ToBeFinalized + i, closure);
}
// (6) Trace the reference queue
for (uint32 i = 0; i < referenceThread->ToEnqueueIndex; ++i) {
- mvm::Collector::markAndTraceRoot(referenceThread->ToEnqueue + i, closure);
+ vmkit::Collector::markAndTraceRoot(referenceThread->ToEnqueue + i, closure);
}
// (7) Trace the locks and their associated object.
uint32 i = 0;
- for (; i < mvm::LockSystem::GlobalSize; i++) {
- mvm::FatLock** array = lockSystem.LockTable[i];
+ for (; i < vmkit::LockSystem::GlobalSize; i++) {
+ vmkit::FatLock** array = lockSystem.LockTable[i];
if (array == NULL) break;
uint32 j = 0;
- for (; j < mvm::LockSystem::IndexSize; j++) {
+ for (; j < vmkit::LockSystem::IndexSize; j++) {
if (array[j] == NULL) break;
- mvm::FatLock* lock = array[j];
- mvm::Collector::markAndTraceRoot(lock->getAssociatedObjectPtr(), closure);
+ vmkit::FatLock* lock = array[j];
+ vmkit::Collector::markAndTraceRoot(lock->getAssociatedObjectPtr(), closure);
}
- for (j = j + 1; j < mvm::LockSystem::IndexSize; j++) {
+ for (j = j + 1; j < vmkit::LockSystem::IndexSize; j++) {
assert(array[j] == NULL);
}
}
- for (i = i + 1; i < mvm::LockSystem::GlobalSize; i++) {
+ for (i = i + 1; i < vmkit::LockSystem::GlobalSize; i++) {
assert(lockSystem.LockTable[i] == NULL);
}
}
void JavaThread::tracer(word_t closure) {
- mvm::Collector::markAndTraceRoot(&pendingException, closure);
- mvm::Collector::markAndTraceRoot(&javaThread, closure);
- mvm::Collector::markAndTraceRoot(&vmThread, closure);
+ vmkit::Collector::markAndTraceRoot(&pendingException, closure);
+ vmkit::Collector::markAndTraceRoot(&javaThread, closure);
+ vmkit::Collector::markAndTraceRoot(&vmThread, closure);
JNILocalReferences* end = localJNIRefs;
while (end != NULL) {
for (uint32 i = 0; i < end->length; ++i) {
JavaObject** obj = end->localReferences + i;
- mvm::Collector::markAndTraceRoot(obj, closure);
+ vmkit::Collector::markAndTraceRoot(obj, closure);
}
end = end->prev;
}
Modified: vmkit/trunk/lib/J3/VMCore/Zip.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Zip.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Zip.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Zip.cpp Mon Nov 21 05:03:32 2011
@@ -17,7 +17,7 @@
using namespace j3;
-ZipArchive::ZipArchive(ClassBytes* bytes, mvm::BumpPtrAllocator& A) : allocator(A) {
+ZipArchive::ZipArchive(ClassBytes* bytes, vmkit::BumpPtrAllocator& A) : allocator(A) {
this->bytes = bytes;
findOfscd();
if (ofscd > -1) addFiles();
Modified: vmkit/trunk/lib/J3/VMCore/Zip.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Zip.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Zip.h (original)
+++ vmkit/trunk/lib/J3/VMCore/Zip.h Mon Nov 21 05:03:32 2011
@@ -19,7 +19,7 @@
class classBytes;
class JnjvmBootstrapLoader;
-struct ZipFile : public mvm::PermanentObject {
+struct ZipFile : public vmkit::PermanentObject {
char* filename;
int ucsize;
int csize;
@@ -32,9 +32,9 @@
-class ZipArchive : public mvm::PermanentObject {
+class ZipArchive : public vmkit::PermanentObject {
- mvm::BumpPtrAllocator& allocator;
+ vmkit::BumpPtrAllocator& allocator;
struct ltstr
{
@@ -70,7 +70,7 @@
}
int getOfscd() { return ofscd; }
- ZipArchive(ClassBytes* bytes, mvm::BumpPtrAllocator& allocator);
+ ZipArchive(ClassBytes* bytes, vmkit::BumpPtrAllocator& allocator);
ZipFile* getFile(const char* filename);
int readFile(ClassBytes* array, const ZipFile* file);
Modified: vmkit/trunk/lib/vmkit/CommonThread/CollectionRV.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/CollectionRV.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/CollectionRV.cpp (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/CollectionRV.cpp Mon Nov 21 05:03:32 2011
@@ -15,10 +15,10 @@
#include "debug.h"
-namespace mvm {
+namespace vmkit {
void CollectionRV::another_mark() {
- mvm::Thread* th = mvm::Thread::get();
+ vmkit::Thread* th = vmkit::Thread::get();
assert(th->getLastSP() != 0);
assert(nbJoined < th->MyVM->numberOfThreads);
nbJoined++;
@@ -28,7 +28,7 @@
}
void CollectionRV::waitEndOfRV() {
- mvm::Thread* th = mvm::Thread::get();
+ vmkit::Thread* th = vmkit::Thread::get();
assert(th->getLastSP() != 0);
while (th->doYield) {
@@ -37,7 +37,7 @@
}
void CollectionRV::waitRV() {
- mvm::Thread* self = mvm::Thread::get();
+ vmkit::Thread* self = vmkit::Thread::get();
// Add myself.
nbJoined++;
@@ -48,26 +48,26 @@
void CooperativeCollectionRV::synchronize() {
assert(nbJoined == 0);
- mvm::Thread* self = mvm::Thread::get();
+ vmkit::Thread* self = vmkit::Thread::get();
// Lock thread lock, so that we can traverse the thread list safely. This will
// be released on finishRV.
self->MyVM->threadLock.lock();
- mvm::Thread* cur = self;
+ vmkit::Thread* cur = self;
assert(initiator == NULL);
initiator = self;
do {
cur->doYield = true;
assert(!cur->joinedRV);
- cur = (mvm::Thread*)cur->next();
+ cur = (vmkit::Thread*)cur->next();
} while (cur != self);
// The CAS is not necessary but it does a memory barrier.
__sync_bool_compare_and_swap(&(self->joinedRV), false, true);
// Lookup currently blocked threads.
- for (cur = (mvm::Thread*)self->next(); cur != self;
- cur = (mvm::Thread*)cur->next()) {
+ for (cur = (vmkit::Thread*)self->next(); cur != self;
+ cur = (vmkit::Thread*)cur->next()) {
if (cur->getLastSP()) {
nbJoined++;
cur->joinedRV = true;
@@ -83,7 +83,7 @@
}
void CooperativeCollectionRV::join() {
- mvm::Thread* th = mvm::Thread::get();
+ vmkit::Thread* th = vmkit::Thread::get();
assert(th->doYield && "No yield");
assert((th->getLastSP() == 0) && "SP present in cooperative code");
@@ -101,7 +101,7 @@
}
void CooperativeCollectionRV::joinBeforeUncooperative() {
- mvm::Thread* th = mvm::Thread::get();
+ vmkit::Thread* th = vmkit::Thread::get();
assert((th->getLastSP() != 0) &&
"SP not set before entering uncooperative code");
@@ -121,7 +121,7 @@
}
void CooperativeCollectionRV::joinAfterUncooperative(word_t SP) {
- mvm::Thread* th = mvm::Thread::get();
+ vmkit::Thread* th = vmkit::Thread::get();
assert((th->getLastSP() == 0) &&
"SP set after entering uncooperative code");
@@ -143,21 +143,21 @@
}
extern "C" void conditionalSafePoint() {
- mvm::Thread* th = mvm::Thread::get();
+ vmkit::Thread* th = vmkit::Thread::get();
th->MyVM->rendezvous.join();
}
void CooperativeCollectionRV::finishRV() {
lockRV();
- assert(mvm::Thread::get() == initiator);
- mvm::Thread* cur = initiator;
+ assert(vmkit::Thread::get() == initiator);
+ vmkit::Thread* cur = initiator;
do {
assert(cur->doYield && "Inconsistent state");
assert(cur->joinedRV && "Inconsistent state");
cur->doYield = false;
cur->joinedRV = false;
- cur = (mvm::Thread*)cur->next();
+ cur = (vmkit::Thread*)cur->next();
} while (cur != initiator);
assert(nbJoined == initiator->MyVM->numberOfThreads && "Inconsistent state");
@@ -166,7 +166,7 @@
condEndRV.broadcast();
initiator = NULL;
unlockRV();
- mvm::Thread::get()->inRV = false;
+ vmkit::Thread::get()->inRV = false;
}
void CooperativeCollectionRV::addThread(Thread* th) {
Modified: vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/ObjectLocks.cpp Mon Nov 21 05:03:32 2011
@@ -20,7 +20,7 @@
#include <pthread.h>
-namespace mvm {
+namespace vmkit {
void ThinLock::overflowThinLock(gc* object, LockSystem& table) {
llvm_gcroot(object, 0);
@@ -89,7 +89,7 @@
llvm_gcroot(object, 0);
fprintf(stderr,
"WARNING: [%p] has been waiting really long for %p (header = %p)\n",
- (void*)mvm::Thread::get(),
+ (void*)vmkit::Thread::get(),
(void*)object,
(void*)object->header);
FatLock* obj = table.getFatLockFromID(object->header);
@@ -97,7 +97,7 @@
fprintf(stderr,
"WARNING: [%p] is waiting on fatlock %p. "
"Its associated object is %p. The owner is %p\n",
- (void*)mvm::Thread::get(),
+ (void*)vmkit::Thread::get(),
(void*)obj,
(void*)obj->getAssociatedObject(),
(void*)obj->owner());
@@ -106,7 +106,7 @@
void ThinLock::acquire(gc* object, LockSystem& table) {
llvm_gcroot(object, 0);
- uint64_t id = mvm::Thread::get()->getThreadID();
+ uint64_t id = vmkit::Thread::get()->getThreadID();
word_t oldValue = 0;
word_t newValue = 0;
word_t yieldedValue = 0;
@@ -160,7 +160,7 @@
if (object->header & FatMask) {
break;
} else {
- mvm::Thread::yield();
+ vmkit::Thread::yield();
}
}
@@ -193,7 +193,7 @@
void ThinLock::release(gc* object, LockSystem& table) {
llvm_gcroot(object, 0);
assert(owner(object, table) && "Not owner when entering release!");
- uint64 id = mvm::Thread::get()->getThreadID();
+ uint64 id = vmkit::Thread::get()->getThreadID();
word_t oldValue = 0;
word_t newValue = 0;
word_t yieldedValue = 0;
@@ -226,7 +226,7 @@
FatLock* obj = table.getFatLockFromID(object->header);
if (obj != NULL) return obj->owner();
} else {
- uint64 id = mvm::Thread::get()->getThreadID();
+ uint64 id = vmkit::Thread::get()->getThreadID();
if ((object->header & System::GetThreadIDMask()) == id) return true;
}
return false;
@@ -252,7 +252,7 @@
return internalLock.selfOwner();
}
-mvm::Thread* FatLock::getOwner() {
+vmkit::Thread* FatLock::getOwner() {
return internalLock.getOwner();
}
@@ -277,7 +277,7 @@
assert(associatedObject == obj && "Mismatch object in lock");
if (!waitingThreads && !lockingThreads &&
internalLock.recursionCount() == 1) {
- mvm::ThinLock::removeFatLock(this, table);
+ vmkit::ThinLock::removeFatLock(this, table);
table.deallocate(this);
}
internalLock.unlock();
@@ -316,7 +316,7 @@
threadLock.unlock();
}
-LockSystem::LockSystem(mvm::BumpPtrAllocator& all) : allocator(all) {
+LockSystem::LockSystem(vmkit::BumpPtrAllocator& all) : allocator(all) {
assert(ThinLock::ThinCountMask > 0);
LockTable = (FatLock* **)
allocator.Allocate(GlobalSize * sizeof(FatLock**), "Global LockTable");
@@ -349,7 +349,7 @@
FatLock** tab = LockTable[index >> BitIndex];
- VirtualMachine* vm = mvm::Thread::get()->MyVM;
+ VirtualMachine* vm = vmkit::Thread::get()->MyVM;
if (tab == NULL) {
tab = (FatLock**)vm->allocator.Allocate(
IndexSize * sizeof(FatLock*), "Index LockTable");
@@ -385,11 +385,11 @@
bool LockingThread::wait(
gc* self, LockSystem& table, struct timeval* info, bool timed) {
llvm_gcroot(self, 0);
- assert(mvm::ThinLock::owner(self, table));
+ assert(vmkit::ThinLock::owner(self, table));
- FatLock* l = mvm::ThinLock::changeToFatlock(self, table);
+ FatLock* l = vmkit::ThinLock::changeToFatlock(self, table);
this->waitsOn = l;
- mvm::Cond& varcondThread = this->varcond;
+ vmkit::Cond& varcondThread = this->varcond;
if (this->interruptFlag != 0) {
this->interruptFlag = 0;
@@ -431,7 +431,7 @@
varcondThread.wait(&l->internalLock);
}
}
- assert(mvm::ThinLock::owner(self, table) && "Not owner after wait");
+ assert(vmkit::ThinLock::owner(self, table) && "Not owner after wait");
l->waitingThreads--;
@@ -477,14 +477,14 @@
return true;
}
- assert(mvm::ThinLock::owner(self, table) && "Not owner after wait");
+ assert(vmkit::ThinLock::owner(self, table) && "Not owner after wait");
return false;
}
void LockingThread::notify(gc* self, LockSystem& table) {
llvm_gcroot(self, 0);
- assert(mvm::ThinLock::owner(self, table));
- FatLock* l = mvm::ThinLock::getFatLock(self, table);
+ assert(vmkit::ThinLock::owner(self, table));
+ FatLock* l = vmkit::ThinLock::getFatLock(self, table);
if (l == NULL) return;
LockingThread* cur = l->firstThread;
@@ -517,13 +517,13 @@
}
} while (cur != l->firstThread);
- assert(mvm::ThinLock::owner(self, table) && "Not owner after notify");
+ assert(vmkit::ThinLock::owner(self, table) && "Not owner after notify");
}
void LockingThread::notifyAll(gc* self, LockSystem& table) {
llvm_gcroot(self, 0);
- assert(mvm::ThinLock::owner(self, table));
- FatLock* l = mvm::ThinLock::getFatLock(self, table);
+ assert(vmkit::ThinLock::owner(self, table));
+ FatLock* l = vmkit::ThinLock::getFatLock(self, table);
if (l == NULL) return;
LockingThread* cur = l->firstThread;
if (cur == NULL) return;
@@ -535,7 +535,7 @@
cur = temp;
} while (cur != l->firstThread);
l->firstThread = NULL;
- assert(mvm::ThinLock::owner(self, table) && "Not owner after notifyAll");
+ assert(vmkit::ThinLock::owner(self, table) && "Not owner after notifyAll");
}
}
Modified: vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x64.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x64.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x64.inc (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x64.inc Mon Nov 21 05:03:32 2011
@@ -37,7 +37,7 @@
}
void Handler::UpdateRegistersForStackOverflow() {
- word_t alt_stack = mvm::Thread::get()->GetAlternativeStackStart();
+ word_t alt_stack = vmkit::Thread::get()->GetAlternativeStackStart();
((ucontext_t*)context)->uc_mcontext.gregs[REG_RDI] = System::GetIPFromCallerAddress(((ucontext_t*)context)->uc_mcontext.gregs[REG_RBP]);
((ucontext_t*)context)->uc_mcontext.gregs[REG_RSI] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_RBP];
((ucontext_t*)context)->uc_mcontext.gregs[REG_RSP] = alt_stack;
Modified: vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x86.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x86.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x86.inc (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-linux-x86.inc Mon Nov 21 05:03:32 2011
@@ -39,7 +39,7 @@
}
void Handler::UpdateRegistersForStackOverflow() {
- word_t alt_stack = mvm::Thread::get()->GetAlternativeStackStart();
+ word_t alt_stack = vmkit::Thread::get()->GetAlternativeStackStart();
((ucontext_t*)context)->uc_mcontext.gregs[REG_EBX] = System::GetIPFromCallerAddress(((ucontext_t*)context)->uc_mcontext.gregs[REG_EBP]);
((ucontext_t*)context)->uc_mcontext.gregs[REG_EAX] = ((ucontext_t*)context)->uc_mcontext.gregs[REG_EBP];
((ucontext_t*)context)->uc_mcontext.gregs[REG_ESP] = alt_stack;
Modified: vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-macos-x64.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-macos-x64.inc?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-macos-x64.inc (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/Sigsegv-macos-x64.inc Mon Nov 21 05:03:32 2011
@@ -37,7 +37,7 @@
}
void Handler::UpdateRegistersForStackOverflow() {
- word_t alt_stack = mvm::Thread::get()->GetAlternativeStackStart();
+ word_t alt_stack = vmkit::Thread::get()->GetAlternativeStackStart();
((ucontext_t*)context)->uc_mcontext->__ss.__rdi = System::GetIPFromCallerAddress(((ucontext_t*)context)->uc_mcontext->__ss.__rbp);
((ucontext_t*)context)->uc_mcontext->__ss.__rsi = ((ucontext_t*)context)->uc_mcontext->__ss.__rbp;
((ucontext_t*)context)->uc_mcontext->__ss.__rsp = alt_stack;
Modified: vmkit/trunk/lib/vmkit/CommonThread/Sigsegv.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/Sigsegv.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/Sigsegv.cpp (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/Sigsegv.cpp Mon Nov 21 05:03:32 2011
@@ -16,7 +16,7 @@
#include <csignal>
#include <cstdio>
-using namespace mvm;
+using namespace vmkit;
namespace {
class Handler {
@@ -53,37 +53,37 @@
#endif
extern "C" void ThrowStackOverflowError(word_t ip) {
- mvm::Thread* th = mvm::Thread::get();
- mvm::FrameInfo* FI = th->MyVM->IPToFrameInfo(ip);
+ vmkit::Thread* th = vmkit::Thread::get();
+ vmkit::FrameInfo* FI = th->MyVM->IPToFrameInfo(ip);
if (FI->Metadata == NULL) {
fprintf(stderr, "Thread %p received a SIGSEGV: either the VM code or an external\n"
"native method is bogus. Aborting...\n", (void*)th);
abort();
} else {
- mvm::Thread::get()->MyVM->stackOverflowError();
+ vmkit::Thread::get()->MyVM->stackOverflowError();
}
UNREACHABLE();
}
extern "C" void ThrowNullPointerException(word_t ip) {
- mvm::Thread* th = mvm::Thread::get();
- mvm::FrameInfo* FI = th->MyVM->IPToFrameInfo(ip);
+ vmkit::Thread* th = vmkit::Thread::get();
+ vmkit::FrameInfo* FI = th->MyVM->IPToFrameInfo(ip);
if (FI->Metadata == NULL) {
fprintf(stderr, "Thread %p received a SIGSEGV: either the VM code or an external\n"
"native method is bogus. Aborting...\n", (void*)th);
abort();
} else {
- mvm::Thread::get()->MyVM->nullPointerException();
+ vmkit::Thread::get()->MyVM->nullPointerException();
}
UNREACHABLE();
}
void sigsegvHandler(int n, siginfo_t *info, void *context) {
Handler handler(context);
- mvm::Thread* th = mvm::Thread::get();
+ vmkit::Thread* th = vmkit::Thread::get();
word_t addr = (word_t)info->si_addr;
if (th->IsStackOverflowAddr(addr)) {
- if (mvm::System::SupportsHardwareStackOverflow()) {
+ if (vmkit::System::SupportsHardwareStackOverflow()) {
handler.UpdateRegistersForStackOverflow();
} else {
fprintf(stderr, "Stack overflow in VM code or in JNI code. If it is from\n"
@@ -94,7 +94,7 @@
abort();
}
} else {
- if (mvm::System::SupportsHardwareNullCheck()) {
+ if (vmkit::System::SupportsHardwareNullCheck()) {
handler.UpdateRegistersForNPE();
} else {
fprintf(stderr, "Thread %p received a SIGSEGV: either the VM code or an external\n"
Modified: vmkit/trunk/lib/vmkit/CommonThread/ctlock.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/ctlock.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/ctlock.cpp (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/ctlock.cpp Mon Nov 21 05:03:32 2011
@@ -19,7 +19,7 @@
#include <pthread.h>
-namespace mvm {
+namespace vmkit {
Lock::Lock() {
pthread_mutexattr_t attr;
@@ -56,10 +56,10 @@
}
bool Lock::selfOwner() {
- return owner == mvm::Thread::get();
+ return owner == vmkit::Thread::get();
}
-mvm::Thread* Lock::getOwner() {
+vmkit::Thread* Lock::getOwner() {
return owner;
}
@@ -92,7 +92,7 @@
int res = 0;
if (!selfOwner()) {
res = pthread_mutex_trylock((pthread_mutex_t*)&internalLock);
- owner = mvm::Thread::get();
+ owner = vmkit::Thread::get();
}
++n;
return res;
Modified: vmkit/trunk/lib/vmkit/CommonThread/ctthread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/CommonThread/ctthread.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/CommonThread/ctthread.cpp (original)
+++ vmkit/trunk/lib/vmkit/CommonThread/ctthread.cpp Mon Nov 21 05:03:32 2011
@@ -25,7 +25,7 @@
#include <signal.h>
#include <unistd.h>
-using namespace mvm;
+using namespace vmkit;
int Thread::kill(void* tid, int signo) {
return pthread_kill((pthread_t)tid, signo);
@@ -40,7 +40,7 @@
}
void Thread::yield(void) {
- Thread* th = mvm::Thread::get();
+ Thread* th = vmkit::Thread::get();
if (th->isVmkitThread()) {
if (th->doYield && !th->inRV) {
th->MyVM->rendezvous.join();
@@ -102,7 +102,7 @@
}
void Thread::getFrameContext(word_t* buffer) {
- mvm::StackWalker Walker(this);
+ vmkit::StackWalker Walker(this);
uint32_t i = 0;
while (word_t ip = *Walker) {
@@ -112,7 +112,7 @@
}
uint32_t Thread::getFrameContextLength() {
- mvm::StackWalker Walker(this);
+ vmkit::StackWalker Walker(this);
uint32_t i = 0;
while (*Walker) {
@@ -151,10 +151,10 @@
}
}
-StackWalker::StackWalker(mvm::Thread* th) {
+StackWalker::StackWalker(vmkit::Thread* th) {
thread = th;
frame = th->lastKnownFrame;
- if (mvm::Thread::get() == th) {
+ if (vmkit::Thread::get() == th) {
addr = System::GetCallerAddress();
addr = System::GetCallerOfAddress(addr);
} else {
@@ -234,7 +234,7 @@
}
// Finally, yield until lastSP is not set.
- while ((sp = lastSP) == 0) mvm::Thread::yield();
+ while ((sp = lastSP) == 0) vmkit::Thread::yield();
assert(sp != 0 && "Still no sp");
return sp;
@@ -282,13 +282,13 @@
uint32 pagesize = System::GetPageSize();
for (uint32 i = 0; i < NR_THREADS; ++i) {
word_t addr = baseAddr + (i * STACK_SIZE) + pagesize
- + mvm::System::GetAlternativeStackSize();
+ + vmkit::System::GetAlternativeStackSize();
mprotect((void*)addr, pagesize, PROT_NONE);
}
memset((void*)used, 0, NR_THREADS * sizeof(uint32));
allocPtr = 0;
- mvm::Thread::baseAddr = baseAddr;
+ vmkit::Thread::baseAddr = baseAddr;
}
word_t allocate() {
@@ -323,7 +323,7 @@
/// thread specific data, registers the thread to the GC and calls the
/// given routine of th.
///
-void Thread::internalThreadStart(mvm::Thread* th) {
+void Thread::internalThreadStart(vmkit::Thread* th) {
th->baseSP = System::GetCallerAddress();
// Set the alternate stack as the second page of the thread's
@@ -353,7 +353,7 @@
/// start - Called by the creator of the thread to run the new thread.
-int Thread::start(void (*fct)(mvm::Thread*)) {
+int Thread::start(void (*fct)(vmkit::Thread*)) {
pthread_attr_t attributs;
pthread_attr_init(&attributs);
pthread_attr_setstack(&attributs, this, STACK_SIZE);
@@ -381,7 +381,7 @@
/// releaseThread - Remove the stack of the thread from the list of stacks
/// in use.
-void Thread::releaseThread(mvm::Thread* th) {
+void Thread::releaseThread(vmkit::Thread* th) {
// It seems like the pthread implementation in Linux is clearing with NULL
// the stack of the thread. So we have to get the thread id before
// calling pthread_join.
Modified: vmkit/trunk/lib/vmkit/Compiler/Disassembler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Compiler/Disassembler.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Compiler/Disassembler.cpp (original)
+++ vmkit/trunk/lib/vmkit/Compiler/Disassembler.cpp Mon Nov 21 05:03:32 2011
@@ -25,7 +25,7 @@
// this is the only function exported from this file
-int mvm::VmkitModule::disassemble(unsigned int *addr)
+int vmkit::VmkitModule::disassemble(unsigned int *addr)
{
if (!initialised)
@@ -56,7 +56,7 @@
static int initialised= 0;
-int mvm::VmkitModule::disassemble(unsigned int *addr)
+int vmkit::VmkitModule::disassemble(unsigned int *addr)
{
if (!initialised)
{
@@ -74,7 +74,7 @@
#else
-int mvm::VmkitModule::disassemble(unsigned int* addr) {
+int vmkit::VmkitModule::disassemble(unsigned int* addr) {
return 0;
}
@@ -82,7 +82,7 @@
#else
-int mvm::VmkitModule::disassemble(unsigned int* addr) {
+int vmkit::VmkitModule::disassemble(unsigned int* addr) {
return 0;
}
Modified: vmkit/trunk/lib/vmkit/Compiler/EscapeAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Compiler/EscapeAnalysis.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Compiler/EscapeAnalysis.cpp (original)
+++ vmkit/trunk/lib/vmkit/Compiler/EscapeAnalysis.cpp Mon Nov 21 05:03:32 2011
@@ -243,7 +243,7 @@
}
}
-namespace mvm {
+namespace vmkit {
FunctionPass* createEscapeAnalysisPass() {
return new EscapeAnalysis();
}
Modified: vmkit/trunk/lib/vmkit/Compiler/InlineMalloc.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Compiler/InlineMalloc.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Compiler/InlineMalloc.cpp (original)
+++ vmkit/trunk/lib/vmkit/Compiler/InlineMalloc.cpp Mon Nov 21 05:03:32 2011
@@ -23,7 +23,7 @@
using namespace llvm;
-namespace mvm {
+namespace vmkit {
class InlineMalloc : public FunctionPass {
public:
Modified: vmkit/trunk/lib/vmkit/Compiler/JIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Compiler/JIT.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Compiler/JIT.cpp (original)
+++ vmkit/trunk/lib/vmkit/Compiler/JIT.cpp Mon Nov 21 05:03:32 2011
@@ -49,10 +49,10 @@
#include <dlfcn.h>
#include <sys/mman.h>
-using namespace mvm;
+using namespace vmkit;
using namespace llvm;
-namespace mvm {
+namespace vmkit {
namespace llvm_runtime {
#include "LLVMRuntime.inc"
}
@@ -190,7 +190,7 @@
addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs
}
-namespace mvm {
+namespace vmkit {
llvm::FunctionPass* createInlineMallocPass();
}
@@ -308,7 +308,7 @@
constantDoubleMinusInfinity = ConstantFP::get(Type::getDoubleTy(Context), MinDouble);
constantDoubleMinusZero = ConstantFP::get(Type::getDoubleTy(Context), -0.0);
constantFloatMinusZero = ConstantFP::get(Type::getFloatTy(Context), -0.0f);
- constantThreadIDMask = ConstantInt::get(pointerSizeType, mvm::System::GetThreadIDMask());
+ constantThreadIDMask = ConstantInt::get(pointerSizeType, vmkit::System::GetThreadIDMask());
constantStackOverflowMask =
ConstantInt::get(pointerSizeType, Thread::StackOverflowMask);
constantFatMask = ConstantInt::get(pointerSizeType, ThinLock::FatMask);
Modified: vmkit/trunk/lib/vmkit/Compiler/VmkitGC.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Compiler/VmkitGC.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Compiler/VmkitGC.cpp (original)
+++ vmkit/trunk/lib/vmkit/Compiler/VmkitGC.cpp Mon Nov 21 05:03:32 2011
@@ -28,7 +28,7 @@
};
}
-namespace mvm {
+namespace vmkit {
void linkVmkitGC() { }
}
Modified: vmkit/trunk/lib/vmkit/MMTk/MutatorThread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/MMTk/MutatorThread.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/MMTk/MutatorThread.h (original)
+++ vmkit/trunk/lib/vmkit/MMTk/MutatorThread.h Mon Nov 21 05:03:32 2011
@@ -14,30 +14,30 @@
#include "vmkit/Allocator.h"
#include "vmkit/Thread.h"
-namespace mvm {
+namespace vmkit {
-class MutatorThread : public mvm::Thread {
+class MutatorThread : public vmkit::Thread {
public:
- MutatorThread() : mvm::Thread() {
+ MutatorThread() : vmkit::Thread() {
MutatorContext = 0;
CollectionAttempts = 0;
}
- mvm::ThreadAllocator Allocator;
+ vmkit::ThreadAllocator Allocator;
word_t MutatorContext;
/// realRoutine - The function to invoke when the thread starts.
///
- void (*realRoutine)(mvm::Thread*);
+ void (*realRoutine)(vmkit::Thread*);
uint32_t CollectionAttempts;
static void init(Thread* _th);
static MutatorThread* get() {
- return (MutatorThread*)mvm::Thread::get();
+ return (MutatorThread*)vmkit::Thread::get();
}
- virtual int start(void (*fct)(mvm::Thread*)) {
+ virtual int start(void (*fct)(vmkit::Thread*)) {
realRoutine = fct;
routine = init;
return Thread::start(init);
Modified: vmkit/trunk/lib/vmkit/MMTk/VmkitGC.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/MMTk/VmkitGC.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/MMTk/VmkitGC.cpp (original)
+++ vmkit/trunk/lib/vmkit/MMTk/VmkitGC.cpp Mon Nov 21 05:03:32 2011
@@ -13,9 +13,9 @@
#include <set>
-using namespace mvm;
+using namespace vmkit;
-static mvm::SpinLock lock;
+static vmkit::SpinLock lock;
std::set<gc*> __InternalSet__;
int Collector::verbose = 0;
@@ -37,12 +37,12 @@
extern "C" void* gcmallocUnresolved(uint32_t sz, VirtualTable* VT) {
gc* res = (gc*)gcmalloc(sz, VT);
if (VT->hasDestructor())
- mvm::Thread::get()->MyVM->addFinalizationCandidate(res);
+ vmkit::Thread::get()->MyVM->addFinalizationCandidate(res);
return res;
}
extern "C" void addFinalizationCandidate(gc* obj) {
- mvm::Thread::get()->MyVM->addFinalizationCandidate(obj);
+ vmkit::Thread::get()->MyVM->addFinalizationCandidate(obj);
}
extern "C" void* AllocateMagicArray(int32_t sz, void* length) {
Modified: vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h (original)
+++ vmkit/trunk/lib/vmkit/MMTk/VmkitGC.h Mon Nov 21 05:03:32 2011
@@ -72,7 +72,7 @@
extern "C" void fieldWriteBarrier(void* ref, void** ptr, void* value);
extern "C" void nonHeapWriteBarrier(void** ptr, void* value);
-namespace mvm {
+namespace vmkit {
class Collector {
public:
Modified: vmkit/trunk/lib/vmkit/Runtime/MethodInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Runtime/MethodInfo.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Runtime/MethodInfo.cpp (original)
+++ vmkit/trunk/lib/vmkit/Runtime/MethodInfo.cpp Mon Nov 21 05:03:32 2011
@@ -17,7 +17,7 @@
#include <dlfcn.h>
-namespace mvm {
+namespace vmkit {
void MethodInfoHelper::scan(word_t closure, FrameInfo* FI, word_t ip, word_t addr) {
//word_t spaddr = (word_t)addr + FI->FrameSize + sizeof(void*);
Modified: vmkit/trunk/lib/vmkit/Runtime/Object.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Runtime/Object.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Runtime/Object.cpp (original)
+++ vmkit/trunk/lib/vmkit/Runtime/Object.cpp Mon Nov 21 05:03:32 2011
@@ -13,7 +13,7 @@
#include "VmkitGC.h"
#include "vmkit/VirtualMachine.h"
-using namespace mvm;
+using namespace vmkit;
extern "C" void printFloat(float f) {
fprintf(stderr, "%f\n", f);
@@ -54,7 +54,7 @@
if (exitingThread != NULL) {
Thread* th = exitingThread;
exitingThread = NULL;
- mvm::Thread::releaseThread(th);
+ vmkit::Thread::releaseThread(th);
}
}
Modified: vmkit/trunk/lib/vmkit/Runtime/UTF8.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/vmkit/Runtime/UTF8.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/lib/vmkit/Runtime/UTF8.cpp (original)
+++ vmkit/trunk/lib/vmkit/Runtime/UTF8.cpp Mon Nov 21 05:03:32 2011
@@ -10,7 +10,7 @@
#include "vmkit/Allocator.h"
#include "vmkit/UTF8.h"
-namespace mvm {
+namespace vmkit {
extern "C" const UTF8 TombstoneKey(-1);
extern "C" const UTF8 EmptyKey(-1);
@@ -92,4 +92,4 @@
return res;
}
-} // namespace mvm
+} // namespace vmkit
Modified: vmkit/trunk/mmtk/magic/LowerMagic.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/magic/LowerMagic.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/magic/LowerMagic.cpp (original)
+++ vmkit/trunk/mmtk/magic/LowerMagic.cpp Mon Nov 21 05:03:32 2011
@@ -357,7 +357,7 @@
static bool removePotentialNullCheck(BasicBlock* Cur, Value* Obj) {
if (!Obj->getType()->isPointerTy()) return false;
- if (mvm::System::SupportsHardwareNullCheck()) {
+ if (vmkit::System::SupportsHardwareNullCheck()) {
for (Value::use_iterator I = Obj->use_begin(), E = Obj->use_end(); I != E; I++) {
if (GetElementPtrInst* GE = dyn_cast<GetElementPtrInst>(*I)) {
for (Value::use_iterator II = GE->use_begin(), EE = GE->use_end(); II != EE; II++) {
Modified: vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-alloc/Selected.cpp Mon Nov 21 05:03:32 2011
@@ -18,7 +18,7 @@
#include "debug.h"
-using namespace mvm;
+using namespace vmkit;
int Collector::verbose = 0;
extern "C" void Java_org_j3_mmtk_Collection_triggerCollection__I(word_t, int32_t) ALWAYS_INLINE;
@@ -67,7 +67,7 @@
extern "C" void addFinalizationCandidate(gc* obj) {
llvm_gcroot(obj, 0);
- mvm::Thread::get()->MyVM->addFinalizationCandidate(obj);
+ vmkit::Thread::get()->MyVM->addFinalizationCandidate(obj);
}
extern "C" void* gcmallocUnresolved(uint32_t sz, VirtualTable* VT) {
@@ -81,18 +81,18 @@
extern "C" void arrayWriteBarrier(void* ref, void** ptr, void* value) {
JnJVM_org_j3_bindings_Bindings_arrayWriteBarrier__Lorg_vmmagic_unboxed_ObjectReference_2Lorg_vmmagic_unboxed_Address_2Lorg_vmmagic_unboxed_ObjectReference_2(
(gc*)ref, (gc**)ptr, (gc*)value);
- if (mvm::Thread::get()->doYield) mvm::Collector::collect();
+ if (vmkit::Thread::get()->doYield) vmkit::Collector::collect();
}
extern "C" void fieldWriteBarrier(void* ref, void** ptr, void* value) {
JnJVM_org_j3_bindings_Bindings_fieldWriteBarrier__Lorg_vmmagic_unboxed_ObjectReference_2Lorg_vmmagic_unboxed_Address_2Lorg_vmmagic_unboxed_ObjectReference_2(
(gc*)ref, (gc**)ptr, (gc*)value);
- if (mvm::Thread::get()->doYield) mvm::Collector::collect();
+ if (vmkit::Thread::get()->doYield) vmkit::Collector::collect();
}
extern "C" void nonHeapWriteBarrier(void** ptr, void* value) {
JnJVM_org_j3_bindings_Bindings_nonHeapWriteBarrier__Lorg_vmmagic_unboxed_Address_2Lorg_vmmagic_unboxed_ObjectReference_2((gc**)ptr, (gc*)value);
- if (mvm::Thread::get()->doYield) mvm::Collector::collect();
+ if (vmkit::Thread::get()->doYield) vmkit::Collector::collect();
}
void MutatorThread::init(Thread* _th) {
@@ -222,7 +222,7 @@
bool Collector::objectReferenceTryCASBarrier(gc* ref, gc** slot, gc* old, gc* value) {
bool res = JnJVM_org_j3_bindings_Bindings_writeBarrierCAS__Lorg_vmmagic_unboxed_ObjectReference_2Lorg_vmmagic_unboxed_Address_2Lorg_vmmagic_unboxed_ObjectReference_2Lorg_vmmagic_unboxed_ObjectReference_2(ref, slot, old, value);
- if (mvm::Thread::get()->doYield) mvm::Collector::collect();
+ if (vmkit::Thread::get()->doYield) vmkit::Collector::collect();
return res;
}
Modified: vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/ActivePlan.cpp Mon Nov 21 05:03:32 2011
@@ -18,12 +18,12 @@
assert(A && "No active plan");
if (A->current == NULL) {
- A->current = (mvm::MutatorThread*)mvm::Thread::get()->MyVM->mainThread;
- } else if (A->current->next() == mvm::Thread::get()->MyVM->mainThread) {
+ A->current = (vmkit::MutatorThread*)vmkit::Thread::get()->MyVM->mainThread;
+ } else if (A->current->next() == vmkit::Thread::get()->MyVM->mainThread) {
A->current = NULL;
return NULL;
} else {
- A->current = (mvm::MutatorThread*)A->current->next();
+ A->current = (vmkit::MutatorThread*)A->current->next();
}
if (A->current->MutatorContext == 0) {
Modified: vmkit/trunk/mmtk/mmtk-j3/Collection.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Collection.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Collection.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Collection.cpp Mon Nov 21 05:03:32 2011
@@ -20,13 +20,13 @@
}
extern "C" void Java_org_j3_mmtk_Collection_reportAllocationSuccess__ (MMTkObject* C) {
- mvm::MutatorThread::get()->CollectionAttempts = 0;
+ vmkit::MutatorThread::get()->CollectionAttempts = 0;
}
extern "C" void JnJVM_org_j3_bindings_Bindings_collect__I(int why);
extern "C" void Java_org_j3_mmtk_Collection_triggerCollection__I (MMTkObject* C, int why) {
- mvm::MutatorThread* th = mvm::MutatorThread::get();
+ vmkit::MutatorThread* th = vmkit::MutatorThread::get();
if (why > 2) th->CollectionAttempts++;
// Verify that another collection is not happening.
@@ -48,7 +48,7 @@
}
extern "C" void Java_org_j3_mmtk_Collection_joinCollection__ (MMTkObject* C) {
- mvm::Thread* th = mvm::Thread::get();
+ vmkit::Thread* th = vmkit::Thread::get();
assert(th->inRV && "Joining collection without a rendezvous");
th->MyVM->rendezvous.join();
}
@@ -58,15 +58,15 @@
}
extern "C" int Java_org_j3_mmtk_Collection_maximumCollectionAttempt__ (MMTkObject* C) {
- mvm::MutatorThread* th = mvm::MutatorThread::get();
- mvm::MutatorThread* tcur = th;
+ vmkit::MutatorThread* th = vmkit::MutatorThread::get();
+ vmkit::MutatorThread* tcur = th;
uint32_t max = 0;
do {
if (tcur->CollectionAttempts > max) {
max = tcur->CollectionAttempts;
}
- tcur = (mvm::MutatorThread*)tcur->next();
+ tcur = (vmkit::MutatorThread*)tcur->next();
} while (tcur != th);
return max;
@@ -85,11 +85,11 @@
extern "C" void Java_org_j3_mmtk_Collection_reportPhysicalAllocationFailed__ (MMTkObject* C) { UNIMPLEMENTED(); }
extern "C" void Java_org_j3_mmtk_Collection_triggerAsyncCollection__I (MMTkObject* C, sint32 val) {
- mvm::Thread::get()->doYield = true;
+ vmkit::Thread::get()->doYield = true;
}
extern "C" uint8_t Java_org_j3_mmtk_Collection_noThreadsInGC__ (MMTkObject* C) {
- mvm::Thread* th = mvm::Thread::get();
+ vmkit::Thread* th = vmkit::Thread::get();
bool threadInGC = th->doYield;
return !threadInGC;
}
Modified: vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/FinalizableProcessor.cpp Mon Nov 21 05:03:32 2011
@@ -25,7 +25,7 @@
extern "C" void
Java_org_j3_mmtk_FinalizableProcessor_scan__Lorg_mmtk_plan_TraceLocal_2Z (MMTkObject* FP, MMTkObject* TL, uint8_t nursery) {
- mvm::Thread* th = mvm::Thread::get();
+ vmkit::Thread* th = vmkit::Thread::get();
th->MyVM->scanFinalizationQueue(reinterpret_cast<word_t>(TL));
}
Modified: vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h (original)
+++ vmkit/trunk/mmtk/mmtk-j3/MMTkObject.h Mon Nov 21 05:03:32 2011
@@ -54,7 +54,7 @@
};
struct MMTkActivePlan : public MMTkObject {
- mvm::MutatorThread* current;
+ vmkit::MutatorThread* current;
};
struct MMTkReferenceProcessor : public MMTkObject {
Modified: vmkit/trunk/mmtk/mmtk-j3/MMTk_Events.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/MMTk_Events.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/MMTk_Events.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/MMTk_Events.cpp Mon Nov 21 05:03:32 2011
@@ -14,14 +14,14 @@
extern "C" void Java_org_j3_mmtk_MMTk_1Events_tracePageAcquired__Lorg_mmtk_policy_Space_2Lorg_vmmagic_unboxed_Address_2I(
MMTkObject* event, MMTkObject* space, word_t address, int numPages) {
#if 0
- fprintf(stderr, "Pages acquired by thread %p from space %p at %x (%d)\n", (void*)mvm::Thread::get(), (void*)space, address, numPages);
+ fprintf(stderr, "Pages acquired by thread %p from space %p at %x (%d)\n", (void*)vmkit::Thread::get(), (void*)space, address, numPages);
#endif
}
extern "C" void Java_org_j3_mmtk_MMTk_1Events_tracePageReleased__Lorg_mmtk_policy_Space_2Lorg_vmmagic_unboxed_Address_2I(
MMTkObject* event, MMTkObject* space, word_t address, int numPages) {
#if 0
- fprintf(stderr, "Pages released by thread %p from space %p at %x (%d)\n", (void*)mvm::Thread::get(), (void*)space, address, numPages);
+ fprintf(stderr, "Pages released by thread %p from space %p at %x (%d)\n", (void*)vmkit::Thread::get(), (void*)space, address, numPages);
#endif
}
Modified: vmkit/trunk/mmtk/mmtk-j3/Memory.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Memory.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Memory.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Memory.cpp Mon Nov 21 05:03:32 2011
@@ -19,7 +19,7 @@
public:
InitCollector() {
uint32 flags = MAP_PRIVATE | MAP_ANON | MAP_FIXED;
- void* baseAddr = mmap((void*)mvm::kGCMemoryStart, mvm::kGCMemorySize, PROT_READ | PROT_WRITE,
+ void* baseAddr = mmap((void*)vmkit::kGCMemoryStart, vmkit::kGCMemorySize, PROT_READ | PROT_WRITE,
flags, -1, 0);
if (baseAddr == MAP_FAILED) {
perror("mmap for GC memory");
@@ -32,11 +32,11 @@
InitCollector initCollector;
extern "C" word_t Java_org_j3_mmtk_Memory_getHeapStartConstant__ (MMTkObject* M) {
- return mvm::kGCMemoryStart;
+ return vmkit::kGCMemoryStart;
}
extern "C" word_t Java_org_j3_mmtk_Memory_getHeapEndConstant__ (MMTkObject* M) {
- return mvm::kGCMemoryStart + mvm::kGCMemorySize;
+ return vmkit::kGCMemoryStart + vmkit::kGCMemorySize;
}
extern "C" word_t Java_org_j3_mmtk_Memory_getAvailableStartConstant__ (MMTkObject* M) {
Modified: vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/ObjectModel.cpp Mon Nov 21 05:03:32 2011
@@ -40,11 +40,11 @@
}
extern "C" uint8_t Java_org_j3_mmtk_ObjectModel_readAvailableByte__Lorg_vmmagic_unboxed_ObjectReference_2 (MMTkObject* OM, gc* obj) {
- return *mvm::System::GetLastBytePtr(reinterpret_cast<word_t>(obj));
+ return *vmkit::System::GetLastBytePtr(reinterpret_cast<word_t>(obj));
}
extern "C" void Java_org_j3_mmtk_ObjectModel_writeAvailableByte__Lorg_vmmagic_unboxed_ObjectReference_2B (MMTkObject* OM, gc* obj, uint8_t val) {
- *mvm::System::GetLastBytePtr(reinterpret_cast<word_t>(obj)) = val;
+ *vmkit::System::GetLastBytePtr(reinterpret_cast<word_t>(obj)) = val;
}
extern "C" gc* Java_org_j3_mmtk_ObjectModel_getObjectFromStartAddress__Lorg_vmmagic_unboxed_Address_2 (MMTkObject* OM, gc* obj) {
@@ -78,11 +78,11 @@
extern "C" word_t Java_org_j3_mmtk_ObjectModel_copy__Lorg_vmmagic_unboxed_ObjectReference_2I (
MMTkObject* OM, gc* src, int allocator) {
- size_t size = mvm::Thread::get()->MyVM->getObjectSize(src);
+ size_t size = vmkit::Thread::get()->MyVM->getObjectSize(src);
size = llvm::RoundUpToAlignment(size, sizeof(void*));
word_t res = JnJVM_org_j3_bindings_Bindings_copy__Lorg_vmmagic_unboxed_ObjectReference_2Lorg_vmmagic_unboxed_ObjectReference_2II(
src, src->getVirtualTable(), size, allocator);
- assert((((word_t*)res)[1] & ~mvm::GCBitMask) == (((word_t*)src)[1] & ~mvm::GCBitMask));
+ assert((((word_t*)res)[1] & ~vmkit::GCBitMask) == (((word_t*)src)[1] & ~vmkit::GCBitMask));
return res;
}
@@ -94,7 +94,7 @@
extern "C" word_t Java_org_j3_mmtk_ObjectModel_getObjectEndAddress__Lorg_vmmagic_unboxed_ObjectReference_2 (
MMTkObject* OM, gc* object) {
- size_t size = mvm::Thread::get()->MyVM->getObjectSize(object);
+ size_t size = vmkit::Thread::get()->MyVM->getObjectSize(object);
size = llvm::RoundUpToAlignment(size, sizeof(void*));
return reinterpret_cast<word_t>(object) + size;
}
@@ -134,7 +134,7 @@
extern "C" FakeByteArray* Java_org_j3_mmtk_ObjectModel_getTypeDescriptor__Lorg_vmmagic_unboxed_ObjectReference_2 (
MMTkObject* OM, gc* src) {
- const char* name = mvm::Thread::get()->MyVM->getObjectTypeName(src);
+ const char* name = vmkit::Thread::get()->MyVM->getObjectTypeName(src);
// This code is only used for debugging on a fatal error. It is fine to
// allocate in the C++ heap.
return new (strlen(name)) FakeByteArray(name);
Modified: vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/ReferenceProcessor.cpp Mon Nov 21 05:03:32 2011
@@ -15,7 +15,7 @@
namespace mmtk {
extern "C" void Java_org_j3_mmtk_ReferenceProcessor_scan__Lorg_mmtk_plan_TraceLocal_2Z (MMTkReferenceProcessor* RP, word_t TL, uint8_t nursery) {
- mvm::Thread* th = mvm::Thread::get();
+ vmkit::Thread* th = vmkit::Thread::get();
uint32_t val = RP->ordinal;
if (val == 0) {
Modified: vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Scanning.cpp Mon Nov 21 05:03:32 2011
@@ -17,24 +17,24 @@
extern "C" void Java_org_j3_mmtk_Scanning_computeThreadRoots__Lorg_mmtk_plan_TraceLocal_2 (MMTkObject* Scanning, MMTkObject* TL) {
// When entering this function, all threads are waiting on the rendezvous to
// finish.
- mvm::Thread* th = mvm::Thread::get();
- mvm::Thread* tcur = th;
+ vmkit::Thread* th = vmkit::Thread::get();
+ vmkit::Thread* tcur = th;
do {
tcur->scanStack(reinterpret_cast<word_t>(TL));
- tcur = (mvm::Thread*)tcur->next();
+ tcur = (vmkit::Thread*)tcur->next();
} while (tcur != th);
}
extern "C" void Java_org_j3_mmtk_Scanning_computeGlobalRoots__Lorg_mmtk_plan_TraceLocal_2 (MMTkObject* Scanning, MMTkObject* TL) {
- mvm::Thread::get()->MyVM->tracer(reinterpret_cast<word_t>(TL));
+ vmkit::Thread::get()->MyVM->tracer(reinterpret_cast<word_t>(TL));
- mvm::Thread* th = mvm::Thread::get();
- mvm::Thread* tcur = th;
+ vmkit::Thread* th = vmkit::Thread::get();
+ vmkit::Thread* tcur = th;
do {
tcur->tracer(reinterpret_cast<word_t>(TL));
- tcur = (mvm::Thread*)tcur->next();
+ tcur = (vmkit::Thread*)tcur->next();
} while (tcur != th);
}
Modified: vmkit/trunk/mmtk/mmtk-j3/Selected.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Selected.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Selected.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Selected.cpp Mon Nov 21 05:03:32 2011
@@ -13,7 +13,7 @@
namespace mmtk {
extern "C" MMTkObject* Java_org_j3_config_Selected_00024Mutator_get__() {
- return (MMTkObject*)mvm::MutatorThread::get()->MutatorContext;
+ return (MMTkObject*)vmkit::MutatorThread::get()->MutatorContext;
}
}
Modified: vmkit/trunk/mmtk/mmtk-j3/Strings.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/Strings.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/Strings.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/Strings.cpp Mon Nov 21 05:03:32 2011
@@ -24,7 +24,7 @@
extern "C" void Java_org_j3_mmtk_Strings_writeThreadId___3CI(MMTkObject* str,
MMTkArray* msg,
sint32 len) {
- fprintf(stderr, "[%p] ", (void*)mvm::Thread::get());
+ fprintf(stderr, "[%p] ", (void*)vmkit::Thread::get());
for (sint32 i = 0; i < len; ++i) {
fprintf(stderr, "%c", msg->elements[i]);
Modified: vmkit/trunk/mmtk/mmtk-j3/VM.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/mmtk/mmtk-j3/VM.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/mmtk/mmtk-j3/VM.cpp (original)
+++ vmkit/trunk/mmtk/mmtk-j3/VM.cpp Mon Nov 21 05:03:32 2011
@@ -64,7 +64,7 @@
}
extern "C" bool Java_org_j3_runtime_VM_buildFor64Addr__ () {
- return mvm::kWordSize == 8;
+ return vmkit::kWordSize == 8;
}
extern "C" bool Java_org_j3_runtime_VM_buildForIA32__ () {
Modified: vmkit/trunk/tools/j3/Main.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/j3/Main.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/tools/j3/Main.cpp (original)
+++ vmkit/trunk/tools/j3/Main.cpp Mon Nov 21 05:03:32 2011
@@ -21,7 +21,7 @@
#include "llvm/Support/ManagedStatic.h"
using namespace j3;
-using namespace mvm;
+using namespace vmkit;
#include "FrametablesExterns.inc"
@@ -38,7 +38,7 @@
Collector::initialise(argc, argv);
// Create the allocator that will allocate the bootstrap loader and the JVM.
- mvm::BumpPtrAllocator Allocator;
+ vmkit::BumpPtrAllocator Allocator;
JavaJITCompiler* Comp = JavaJITCompiler::CreateCompiler("JITModule");
JnjvmBootstrapLoader* loader = new(Allocator, "Bootstrap loader")
JnjvmBootstrapLoader(Allocator, Comp, true);
Modified: vmkit/trunk/tools/precompiler/Precompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/precompiler/Precompiler.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/tools/precompiler/Precompiler.cpp (original)
+++ vmkit/trunk/tools/precompiler/Precompiler.cpp Mon Nov 21 05:03:32 2011
@@ -30,7 +30,7 @@
#include <string>
using namespace j3;
-using namespace mvm;
+using namespace vmkit;
#include "FrametablesExterns.inc"
@@ -67,7 +67,7 @@
Collector::initialise(argc, argv);
// Create the allocator that will allocate the bootstrap loader and the JVM.
- mvm::BumpPtrAllocator Allocator;
+ vmkit::BumpPtrAllocator Allocator;
JavaAOTCompiler* AOT;
if (EmitClassBytes) {
AOT = new JavaAOTCompiler("AOT");
@@ -90,7 +90,7 @@
vm->doExit = false;
JavaThread* th = new JavaThread(vm);
vm->setMainThread(th);
- th->start((void (*)(mvm::Thread*))mainCompilerLoaderStart);
+ th->start((void (*)(vmkit::Thread*))mainCompilerLoaderStart);
vm->waitForExit();
AOT = (JavaAOTCompiler*)loader->getCompiler();
Modified: vmkit/trunk/tools/vmjc/vmjc.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/vmjc.cpp?rev=145038&r1=145037&r2=145038&view=diff
==============================================================================
--- vmkit/trunk/tools/vmjc/vmjc.cpp (original)
+++ vmkit/trunk/tools/vmjc/vmjc.cpp Mon Nov 21 05:03:32 2011
@@ -121,12 +121,12 @@
return 0;
}
- mvm::VmkitModule::initialise(argc, argv);
- mvm::Collector::initialise(argc, argv);
+ vmkit::VmkitModule::initialise(argc, argv);
+ vmkit::Collector::initialise(argc, argv);
JavaAOTCompiler* Comp = new JavaAOTCompiler("AOT");
- mvm::BumpPtrAllocator allocator;
+ vmkit::BumpPtrAllocator allocator;
JnjvmBootstrapLoader* loader = new(allocator, "Bootstrap loader")
JnjvmBootstrapLoader(allocator, Comp, false);
More information about the vmkit-commits
mailing list