[llvm-commits] CVS: llvm-java/lib/Compiler/VMClass.h VMClass.cpp

[Alkis Evlogimenos]

Changes in directory llvm-java/lib/Compiler:

VMClass.h updated: 1.17 -> 1.18
VMClass.cpp updated: 1.20 -> 1.21
---
Log message:

Resolve fields when computing the layout type of the object.


---
Diffs of the changes:  (+37 -32)

 VMClass.cpp |   62 ++++++++++++++++++++++++++++++++----------------------------
 VMClass.h   |    7 ++----
 2 files changed, 37 insertions(+), 32 deletions(-)


Index: llvm-java/lib/Compiler/VMClass.h
diff -u llvm-java/lib/Compiler/VMClass.h:1.17 llvm-java/lib/Compiler/VMClass.h:1.18
--- llvm-java/lib/Compiler/VMClass.h:1.17	Mon Mar 28 20:47:41 2005
+++ llvm-java/lib/Compiler/VMClass.h	Mon Mar 28 20:49:46 2005
@@ -15,6 +15,7 @@
 #ifndef LLVM_JAVA_VMCLASS_H
 #define LLVM_JAVA_VMCLASS_H
 
+#include "VMField.h"
 #include <llvm/Constant.h>
 #include <llvm/Module.h>
 #include <llvm/Type.h>
@@ -39,14 +40,12 @@
     unsigned interfaceIndex_;
     typedef std::map<std::string, int> Field2IndexMap;
     Field2IndexMap f2iMap_;
-    typedef std::vector<const Type*> ElementTypes;
-    ElementTypes elementTypes_;
     mutable std::vector<void*> resolvedConstantPool_;
     std::vector<const VMClass*> superClasses_;
     std::vector<const VMClass*> interfaces_;
+    std::vector<const VMField*> memberFields_;
 
-    void addField(const std::string& name, const Type* type);
-    void resolveType();
+    void computeLayout();
 
     friend class Resolver;
 


Index: llvm-java/lib/Compiler/VMClass.cpp
diff -u llvm-java/lib/Compiler/VMClass.cpp:1.20 llvm-java/lib/Compiler/VMClass.cpp:1.21
--- llvm-java/lib/Compiler/VMClass.cpp:1.20	Mon Mar 28 19:01:16 2005
+++ llvm-java/lib/Compiler/VMClass.cpp	Mon Mar 28 20:49:46 2005
@@ -70,20 +70,44 @@
 
 }
 
-void VMClass::addField(const std::string& name, const Type* type)
-{
-  f2iMap_.insert(std::make_pair(name, elementTypes_.size()));
-  elementTypes_.push_back(type);
-}
-
 int VMClass::getFieldIndex(const std::string& name) const {
   Field2IndexMap::const_iterator it = f2iMap_.find(name);
   return it == f2iMap_.end() ? -1 : it->second;
 }
 
-void VMClass::resolveType() {
+void VMClass::computeLayout() {
+  std::vector<const Type*> layout;
+  if (isArray()) {
+    layout.reserve(3);
+    layout.push_back(resolver_->getClass("java/lang/Object")->getLayoutType());
+    layout.push_back(Type::UIntTy);
+    layout.push_back(ArrayType::get(componentClass_->getType(), 0));
+  }
+  else if (isInterface()) {
+    layout.reserve(1);
+    layout.push_back(resolver_->getClass("java/lang/Object")->getLayoutType());
+  }
+  else {
+    if (const VMClass* superClass = getSuperClass())
+      layout.push_back(superClass->getLayoutType());
+    else // This is java/lang/Object
+      layout.push_back(resolver_->getObjectBaseLayoutType());
+    // Now add the fields.
+    const Fields& fields = classFile_->getFields();
+    for (unsigned i = 0, e = fields.size(); i != e; ++i) {
+      Field* field = fields[i];
+      if (!field->isStatic()) {
+        memberFields_.push_back(NULL);
+        f2iMap_.insert(std::make_pair(field->getName()->str(),
+                                      memberFields_.size()));
+        layout.push_back(
+          getClassForDescriptor(field->getDescriptorIndex())->getType());
+      }
+    }
+  }
+
   PATypeHolder holder = layoutType_;
-  Type* resolvedType = StructType::get(elementTypes_);
+  Type* resolvedType = StructType::get(layout);
   cast<OpaqueType>(layoutType_)->refineAbstractTypeTo(resolvedType);
   layoutType_ = holder.get();
   type_ = PointerType::get(layoutType_);
@@ -98,20 +122,14 @@
   if (isArray()) {
     superClasses_.reserve(1);
     superClasses_.push_back(resolver_->getClass("java/lang/Object"));
-    addField("super", superClasses_[0]->getLayoutType());
-    addField("<length>", Type::UIntTy);
-    addField("<data>", ArrayType::get(componentClass_->getType(), 0));
 
     interfaces_.reserve(2);
     interfaces_.push_back(resolver_->getClass("java/lang/Cloneable"));
     interfaces_.push_back(resolver_->getClass("java/io/Serializable"));
   }
   else {
-    // This is java/lang/Object.
-    if (!classFile_->getSuperClass())
-      addField("base", resolver_->getObjectBaseLayoutType());
     // This is any class but java/lang/Object.
-    else {
+    if (classFile_->getSuperClass()) {
       // Our direct super class.
       const VMClass* superClass =
         getClassForClass(classFile_->getSuperClassIndex());
@@ -120,9 +138,6 @@
       for (unsigned i = 0, e = superClass->getNumInterfaces(); i != e; ++i)
         interfaces_.push_back(superClass->getInterface(i));
 
-      // We first add the struct of the super class.
-      addField("super", superClass->getLayoutType());
-
       // Although we can safely assume that all interfaces inherit
       // from java/lang/Object, java/lang/Class.getSuperclass()
       // returns null on interface types. So we only set the
@@ -155,18 +170,9 @@
     std::sort(interfaces_.begin(), interfaces_.end());
     interfaces_.erase(std::unique(interfaces_.begin(), interfaces_.end()),
                       interfaces_.end());
-
-    // Now add the rest of the fields.
-    const Fields& fields = classFile_->getFields();
-    for (unsigned i = 0, e = fields.size(); i != e; ++i) {
-      Field* field = fields[i];
-      if (!field->isStatic())
-        addField(field->getName()->str(),
-                 getClassForDescriptor(field->getDescriptorIndex())->getType());
-    }
   }
 
-  resolveType();
+  computeLayout();
 
   assert(!isa<OpaqueType>(getLayoutType()) &&"Class not initialized properly!");
 }