[vmkit-commits] [vmkit] r71657 - in /vmkit/trunk: include/jnjvm/JnjvmModule.h lib/JnJVM/Compiler/JavaAOTCompiler.cpp

[Nicolas Geoffray]

Author: geoffray
Date: Wed May 13 08:39:04 2009
New Revision: 71657

URL: http://llvm.org/viewvc/llvm-project?rev=71657&view=rev
Log:
Remove changes in the AOT Compiler from last commit.


Modified:
    vmkit/trunk/include/jnjvm/JnjvmModule.h
    vmkit/trunk/lib/JnJVM/Compiler/JavaAOTCompiler.cpp

Modified: vmkit/trunk/include/jnjvm/JnjvmModule.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/jnjvm/JnjvmModule.h?rev=71657&r1=71656&r2=71657&view=diff

==============================================================================
--- vmkit/trunk/include/jnjvm/JnjvmModule.h (original)
+++ vmkit/trunk/include/jnjvm/JnjvmModule.h Wed May 13 08:39:04 2009
@@ -33,7 +33,6 @@
 
 namespace jnjvm {
 
-class ArrayUInt16;
 class Attribut;
 class CacheNode;
 class CommonClass;
@@ -571,6 +570,7 @@
   
   //--------------- Static compiler specific functions -----------------------//
   llvm::Constant* CreateConstantFromVT(JavaVirtualTable* VT);
+  llvm::Constant* CreateConstantFromUTF8(const UTF8* val);
   llvm::Constant* CreateConstantFromEnveloppe(Enveloppe* val);
   llvm::Constant* CreateConstantFromCacheNode(CacheNode* CN);
   llvm::Constant* CreateConstantFromCommonClass(CommonClass* cl);
@@ -585,7 +585,7 @@
   llvm::Constant* CreateConstantFromJavaClass(CommonClass* cl);
   llvm::Constant* CreateConstantForBaseObject(CommonClass* cl);
   llvm::Constant* CreateConstantFromJavaObject(JavaObject* obj);
-  llvm::Constant* getArrayUInt16(const ArrayUInt16* val);
+  llvm::Constant* getUTF8(const UTF8* val);
   
   template<typename T>
   llvm::Constant* CreateConstantFromArray(const T* val, const llvm::Type* Ty);
@@ -599,7 +599,7 @@
   std::map<const JavaString*, llvm::Constant*> strings;
   std::map<const Enveloppe*, llvm::Constant*> enveloppes;
   std::map<const JavaMethod*, llvm::Constant*> nativeFunctions;
-  std::map<const ArrayUInt16*, llvm::Constant*> utf8s;
+  std::map<const UTF8*, llvm::Constant*> utf8s;
   std::map<const Class*, llvm::Constant*> virtualMethods;
   std::map<const JavaObject*, llvm::Constant*> finalObjects;
   
@@ -636,7 +636,7 @@
   typedef std::map<const JavaMethod*, llvm::Constant*>::iterator
     native_function_iterator;
   
-  typedef std::map<const ArrayUInt16*, llvm::Constant*>::iterator
+  typedef std::map<const UTF8*, llvm::Constant*>::iterator
     utf8_iterator;
 
 #ifdef SERVICE

Modified: vmkit/trunk/lib/JnJVM/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Compiler/JavaAOTCompiler.cpp?rev=71657&r1=71656&r2=71657&view=diff

==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JavaAOTCompiler.cpp Wed May 13 08:39:04 2009
@@ -511,7 +511,8 @@
 
   Elmts.push_back(CreateConstantForBaseObject(cl));
 
-  Constant* Array = getArrayUInt16(str->value);
+  Constant* Array =
+    CreateConstantFromArray<ArrayUInt16>(str->value, Type::Int16Ty);
   Constant* ObjGEPs[2] = { JnjvmModule::constantZero,
                            JnjvmModule::constantZero };
   Array = ConstantExpr::getGetElementPtr(Array, ObjGEPs, 2);
@@ -551,8 +552,8 @@
   Elmts.push_back(new GlobalVariable(CNTy, false,
                                      GlobalValue::InternalLinkage,
                                      firstCache, "", getLLVMModule()));
-  Elmts.push_back(getArrayUInt16(val->methodName));
-  Elmts.push_back(getArrayUInt16(val->methodSign));
+  Elmts.push_back(getUTF8(val->methodName));
+  Elmts.push_back(getUTF8(val->methodSign));
 
   Elmts.push_back(Constant::getNullValue(Type::Int8Ty));
   Elmts.push_back(getNativeClass(val->classDef));
@@ -570,7 +571,7 @@
   std::vector<Constant*> Elmts;
 
   // name
-  Elmts.push_back(getArrayUInt16(attribut.name));
+  Elmts.push_back(getUTF8(attribut.name));
 
   // start
   Elmts.push_back(ConstantInt::get(Type::Int32Ty, attribut.start));
@@ -623,7 +624,7 @@
   CommonClassElts.push_back(ConstantInt::get(Type::Int16Ty, cl->nbInterfaces));
 
   // name
-  CommonClassElts.push_back(getArrayUInt16(cl->name));
+  CommonClassElts.push_back(getUTF8(cl->name));
 
   // super
   if (cl->super) {
@@ -663,10 +664,10 @@
   FieldElts.push_back(ConstantInt::get(Type::Int16Ty, field.access));
 
   // name
-  FieldElts.push_back(getArrayUInt16(field.name));
+  FieldElts.push_back(getUTF8(field.name));
 
   // type
-  FieldElts.push_back(getArrayUInt16(field.type));
+  FieldElts.push_back(getUTF8(field.type));
   
   // attributs 
   if (field.nbAttributs) {
@@ -754,10 +755,10 @@
   MethodElts.push_back(getNativeClass(method.classDef));
   
   // name
-  MethodElts.push_back(getArrayUInt16(method.name));
+  MethodElts.push_back(getUTF8(method.name));
 
   // type
-  MethodElts.push_back(getArrayUInt16(method.type));
+  MethodElts.push_back(getUTF8(method.type));
   
   // canBeInlined
   MethodElts.push_back(ConstantInt::get(Type::Int8Ty, method.canBeInlined));
@@ -1074,12 +1075,37 @@
   return ConstantStruct::get(STy, Cts);
 }
 
-Constant* JavaAOTCompiler::getArrayUInt16(const ArrayUInt16* val) {
+Constant* JavaAOTCompiler::CreateConstantFromUTF8(const UTF8* val) {
+  std::vector<const Type*> Elemts;
+  const ArrayType* ATy = ArrayType::get(Type::Int16Ty, val->size);
+  Elemts.push_back(JnjvmModule::JavaObjectType->getContainedType(0));
+  Elemts.push_back(JnjvmModule::pointerSizeType);
+
+  Elemts.push_back(ATy);
+
+  const StructType* STy = StructType::get(Elemts);
+  
+  std::vector<Constant*> Cts;
+  CommonClass* cl = JavaThread::get()->getJVM()->upcalls->ArrayOfChar;
+  Cts.push_back(CreateConstantForBaseObject(cl));
+  Cts.push_back(ConstantInt::get(JnjvmModule::pointerSizeType, val->size));
+  
+  std::vector<Constant*> Vals;
+  for (sint32 i = 0; i < val->size; ++i) {
+    Vals.push_back(ConstantInt::get(Type::Int16Ty, val->elements[i]));
+  }
+
+  Cts.push_back(ConstantArray::get(ATy, Vals));
+  
+  return ConstantStruct::get(STy, Cts);
+
+}
+
+Constant* JavaAOTCompiler::getUTF8(const UTF8* val) {
   utf8_iterator End = utf8s.end();
   utf8_iterator I = utf8s.find(val);
   if (I == End) {
-    Constant* C = CreateConstantFromArray<ArrayUInt16>(val, Type::Int16Ty);
-
+    Constant* C = CreateConstantFromUTF8(val);
     GlobalVariable* varGV = new GlobalVariable(C->getType(), true,
                                                GlobalValue::InternalLinkage,
                                                C, "", getLLVMModule());
@@ -1389,7 +1415,7 @@
        e = arrayClasses.end(); i != e; ++i) {
     Args[0] = loader;
     Args[1] = i->second;
-    Args[2] = getArrayUInt16(i->first->name);
+    Args[2] = getUTF8(i->first->name);
     CallInst::Create(GetClassArray, Args, Args + 3, "", currentBlock);
   }