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

[Nicolas Geoffray]

Author: geoffray
Date: Tue Oct 27 09:43:34 2009
New Revision: 85239

URL: http://llvm.org/viewvc/llvm-project?rev=85239&view=rev
Log:
Fix AOT code generation of float and double arrays.


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=85239&r1=85238&r2=85239&view=diff

==============================================================================
--- vmkit/trunk/include/jnjvm/JnjvmModule.h (original)
+++ vmkit/trunk/include/jnjvm/JnjvmModule.h Tue Oct 27 09:43:34 2009
@@ -35,6 +35,7 @@
 
 namespace jnjvm {
 
+class ArrayObject;
 class Attribut;
 class CacheNode;
 class CommonClass;
@@ -647,7 +648,12 @@
   llvm::Constant* getUTF8(const UTF8* val);
   
   template<typename T>
-  llvm::Constant* CreateConstantFromArray(const T* val, const llvm::Type* Ty);
+  llvm::Constant* CreateConstantFromIntArray(const T* val, const llvm::Type* Ty);
+  
+  template<typename T>
+  llvm::Constant* CreateConstantFromFPArray(const T* val, const llvm::Type* Ty);
+
+  llvm::Constant* CreateConstantFromObjectArray(const ArrayObject* val);
   
   std::map<const CommonClass*, llvm::Constant*> nativeClasses;
   std::map<const ClassArray*, llvm::GlobalVariable*> arrayClasses;

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

==============================================================================
--- vmkit/trunk/lib/JnJVM/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/JnJVM/Compiler/JavaAOTCompiler.cpp Tue Oct 27 09:43:34 2009
@@ -576,35 +576,34 @@
     CommonClass* subClass = cl->asArrayClass()->baseClass();
     if (subClass->isPrimitive()) {
       if (subClass == upcalls->OfBool) {
-        return CreateConstantFromArray<ArrayUInt8>((ArrayUInt8*)obj,
+        return CreateConstantFromIntArray<ArrayUInt8>((ArrayUInt8*)obj,
                                         Type::getInt8Ty(getGlobalContext()));
       } else if (subClass == upcalls->OfByte) {
-        return CreateConstantFromArray<ArraySInt8>((ArraySInt8*)obj,
+        return CreateConstantFromIntArray<ArraySInt8>((ArraySInt8*)obj,
                                         Type::getInt8Ty(getGlobalContext()));
       } else if (subClass == upcalls->OfShort) {
-        return CreateConstantFromArray<ArraySInt16>((ArraySInt16*)obj,
+        return CreateConstantFromIntArray<ArraySInt16>((ArraySInt16*)obj,
                                         Type::getInt16Ty(getGlobalContext()));
       } else if (subClass == upcalls->OfChar) {
-        return CreateConstantFromArray<ArrayUInt16>((ArrayUInt16*)obj,
+        return CreateConstantFromIntArray<ArrayUInt16>((ArrayUInt16*)obj,
                                         Type::getInt16Ty(getGlobalContext()));
       } else if (subClass == upcalls->OfInt) {
-        return CreateConstantFromArray<ArraySInt32>((ArraySInt32*)obj,
+        return CreateConstantFromIntArray<ArraySInt32>((ArraySInt32*)obj,
                                         Type::getInt32Ty(getGlobalContext()));
       } else if (subClass == upcalls->OfFloat) {
-        return CreateConstantFromArray<ArrayFloat>((ArrayFloat*)obj,
+        return CreateConstantFromFPArray<ArrayFloat>((ArrayFloat*)obj,
                                         Type::getFloatTy(getGlobalContext()));
       } else if (subClass == upcalls->OfLong) {
-        return CreateConstantFromArray<ArrayLong>((ArrayLong*)obj,
+        return CreateConstantFromIntArray<ArrayLong>((ArrayLong*)obj,
                                         Type::getInt64Ty(getGlobalContext()));
       } else if (subClass == upcalls->OfDouble) {
-        return CreateConstantFromArray<ArrayDouble>((ArrayDouble*)obj,
+        return CreateConstantFromFPArray<ArrayDouble>((ArrayDouble*)obj,
                                         Type::getDoubleTy(getGlobalContext()));
       } else {
         abort();
       }
     } else {
-      return CreateConstantFromArray<ArrayObject>((ArrayObject*)obj,
-                                                  JnjvmModule::JavaObjectType);
+      return CreateConstantFromObjectArray((ArrayObject*)obj);
     }
   } else {
     
@@ -682,8 +681,8 @@
 
   Elmts.push_back(CreateConstantForBaseObject(cl));
 
-  Constant* Array =
-    CreateConstantFromArray<ArrayUInt16>(str->value, Type::getInt16Ty(getGlobalContext()));
+  Constant* Array = CreateConstantFromIntArray<ArrayUInt16>(str->value,
+                                        Type::getInt16Ty(getGlobalContext()));
   
 
   Module& Mod = *getLLVMModule();
@@ -1228,7 +1227,33 @@
 }
 
 template<typename T>
-Constant* JavaAOTCompiler::CreateConstantFromArray(const T* val, const Type* Ty) {
+Constant* JavaAOTCompiler::CreateConstantFromIntArray(const T* val, const Type* Ty) {
+  std::vector<const Type*> Elemts;
+  const ArrayType* ATy = ArrayType::get(Ty, val->size);
+  Elemts.push_back(JnjvmModule::JavaObjectType->getContainedType(0));
+  Elemts.push_back(JnjvmModule::pointerSizeType);
+  
+
+  Elemts.push_back(ATy);
+
+  const StructType* STy = StructType::get(getLLVMModule()->getContext(), Elemts);
+  
+  std::vector<Constant*> Cts;
+  Cts.push_back(CreateConstantForBaseObject(val->getClass()));
+  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(Ty, (uint64)val->elements[i]));
+  }
+
+  Cts.push_back(ConstantArray::get(ATy, Vals));
+  
+  return ConstantStruct::get(STy, Cts);
+}
+
+template<typename T>
+Constant* JavaAOTCompiler::CreateConstantFromFPArray(const T* val, const Type* Ty) {
   std::vector<const Type*> Elemts;
   const ArrayType* ATy = ArrayType::get(Ty, val->size);
   Elemts.push_back(JnjvmModule::JavaObjectType->getContainedType(0));
@@ -1245,16 +1270,36 @@
   
   std::vector<Constant*> Vals;
   for (sint32 i = 0; i < val->size; ++i) {
-    if (Ty->isInteger()) {
-      Vals.push_back(ConstantInt::get(Ty, (uint64)val->elements[i]));
-    } else if (Ty->isFloatingPoint()) {
-      Vals.push_back(ConstantFP::get(Ty, (double)(size_t)val->elements[i]));
+    Vals.push_back(ConstantFP::get(Ty, (double)val->elements[i]));
+  }
+
+  Cts.push_back(ConstantArray::get(ATy, Vals));
+  
+  return ConstantStruct::get(STy, Cts);
+}
+
+Constant* JavaAOTCompiler::CreateConstantFromObjectArray(const ArrayObject* val) {
+  std::vector<const Type*> Elemts;
+  const llvm::Type* Ty = JnjvmModule::JavaObjectType;
+  const ArrayType* ATy = ArrayType::get(Ty, val->size);
+  Elemts.push_back(JnjvmModule::JavaObjectType->getContainedType(0));
+  Elemts.push_back(JnjvmModule::pointerSizeType);
+  
+
+  Elemts.push_back(ATy);
+
+  const StructType* STy = StructType::get(getLLVMModule()->getContext(), Elemts);
+  
+  std::vector<Constant*> Cts;
+  Cts.push_back(CreateConstantForBaseObject(val->getClass()));
+  Cts.push_back(ConstantInt::get(JnjvmModule::pointerSizeType, val->size));
+  
+  std::vector<Constant*> Vals;
+  for (sint32 i = 0; i < val->size; ++i) {
+    if (val->elements[i]) {
+      Vals.push_back(getFinalObject(val->elements[i]));
     } else {
-      if (val->elements[i]) {
-        Vals.push_back(getFinalObject((JavaObject*)(size_t)val->elements[i]));
-      } else {
-        Vals.push_back(Constant::getNullValue(JnjvmModule::JavaObjectType));
-      }
+      Vals.push_back(Constant::getNullValue(JnjvmModule::JavaObjectType));
     }
   }