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

[Alkis Evlogimenos]

Changes in directory llvm-java/lib/Compiler:

VMClass.h updated: 1.27 -> 1.28
VMClass.cpp updated: 1.37 -> 1.38
Resolver.cpp updated: 1.12 -> 1.13
---
Log message:

Implement instanceof for arrays. Now we pass ArrayInstanceOf.java.


---
Diffs of the changes:  (+52 -20)

 Resolver.cpp |    1 
 VMClass.cpp  |   67 ++++++++++++++++++++++++++++++++++++++++++-----------------
 VMClass.h    |    4 ++-
 3 files changed, 52 insertions(+), 20 deletions(-)


Index: llvm-java/lib/Compiler/VMClass.h
diff -u llvm-java/lib/Compiler/VMClass.h:1.27 llvm-java/lib/Compiler/VMClass.h:1.28
--- llvm-java/lib/Compiler/VMClass.h:1.27	Fri Apr  1 12:31:25 2005
+++ llvm-java/lib/Compiler/VMClass.h	Fri Apr  1 16:59:20 2005
@@ -48,7 +48,9 @@
     std::vector<const VMClass*> interfaces_;
     std::vector<const VMField*> memberFields_;
     std::vector<const VMMethod*> dynamicallyBoundMethods_;
-    llvm::Constant* classRecord_;
+    GlobalVariable* classRecord_;
+
+    void init();
 
     void computeLayout();
     void computeClassRecord();


Index: llvm-java/lib/Compiler/VMClass.cpp
diff -u llvm-java/lib/Compiler/VMClass.cpp:1.37 llvm-java/lib/Compiler/VMClass.cpp:1.38
--- llvm-java/lib/Compiler/VMClass.cpp:1.37	Fri Apr  1 16:56:20 2005
+++ llvm-java/lib/Compiler/VMClass.cpp	Fri Apr  1 16:59:20 2005
@@ -15,17 +15,32 @@
 //
 //===----------------------------------------------------------------------===//
 
+#define DEBUG_TYPE "javaclass"
+
 #include "VMClass.h"
 #include "Resolver.h"
 #include <llvm/DerivedTypes.h>
 #include <llvm/Constants.h>
 #include <llvm/Java/ClassFile.h>
-
-#define LLVM_JAVA_OBJECT_BASE "struct.llvm_java_object_base"
+#include <llvm/Support/Debug.h>
 
 using namespace llvm;
 using namespace llvm::Java;
 
+// On initialization we create a placeholder global for the class
+// record that will be patched later when the class record is
+// computed.
+void VMClass::init()
+{
+  classRecord_ = new GlobalVariable(
+    OpaqueType::get(),
+    false,
+    GlobalVariable::ExternalLinkage,
+    NULL,
+    getName() + "<classRecord>",
+    resolver_->getModule());
+}
+
 VMClass::VMClass(Resolver* resolver, const std::string& className)
   : name_(Resolver::canonicalizeClassName(className)),
     resolver_(resolver),
@@ -34,10 +49,9 @@
     layoutType_(OpaqueType::get()),
     type_(PointerType::get(layoutType_)),
     interfaceIndex_(INVALID_INTERFACE_INDEX),
-    resolvedConstantPool_(classFile_->getNumConstants()),
-    classRecord_(NULL)
+    resolvedConstantPool_(classFile_->getNumConstants())
 {
-
+  init();
 }
 
 VMClass::VMClass(Resolver* resolver, const VMClass* componentClass)
@@ -47,10 +61,9 @@
     componentClass_(componentClass),
     layoutType_(OpaqueType::get()),
     type_(PointerType::get(layoutType_)),
-    interfaceIndex_(INVALID_INTERFACE_INDEX),
-    classRecord_(NULL)
+    interfaceIndex_(INVALID_INTERFACE_INDEX)
 {
-
+  init();
 }
 
 VMClass::VMClass(Resolver* resolver, const Type* type)
@@ -67,10 +80,9 @@
     componentClass_(NULL),
     layoutType_(const_cast<Type*>(type)),
     type_(type),
-    interfaceIndex_(INVALID_INTERFACE_INDEX),
-    classRecord_(NULL)
+    interfaceIndex_(INVALID_INTERFACE_INDEX)
 {
-
+  init();
 }
 
 const VMField* VMClass::lookupField(const std::string& name) const
@@ -116,9 +128,12 @@
 
 void VMClass::computeLayout()
 {
+  DEBUG(std::cerr << "Computing layout for: " << getName() << '\n');
   // The layout of primitive classes is already computed.
-  if (isPrimitive())
+  if (isPrimitive()) {
+    DEBUG(std::cerr << "Computed layout for: " << getName() << '\n');
     return;
+  }
 
   std::vector<const Type*> layout;
   if (isArray()) {
@@ -156,6 +171,8 @@
   cast<OpaqueType>(layoutType_)->refineAbstractTypeTo(resolvedType);
   layoutType_ = holder.get();
   type_ = PointerType::get(layoutType_);
+
+  DEBUG(std::cerr << "Computed layout for: " << getName() << '\n');
 }
 
 llvm::Constant* VMClass::buildSuperClassRecords() const
@@ -266,6 +283,12 @@
   init.push_back(ConstantSInt::get(Type::IntTy, getInterfaceIndex()));
   init.push_back(buildInterfaceClassRecords());
   if (isArray())
+    init.push_back(ConstantExpr::getCast(getComponentClass()->getClassRecord(),
+                                         resolver_->getClassRecordPtrType()));
+  else
+    init.push_back(
+      llvm::Constant::getNullValue(resolver_->getClassRecordPtrType()));
+  if (isArray())
     init.push_back(
       ConstantExpr::getCast(
         ConstantExpr::getSizeOf(getComponentClass()->getType()), Type::IntTy));
@@ -281,6 +304,7 @@
 
 void VMClass::computeClassRecord()
 {
+  DEBUG(std::cerr << "Computing class record for: " << getName() << '\n');
   // Find dynamically bound methods.
   if (!isPrimitive()) {
     if (const VMClass* superClass = getSuperClass())
@@ -344,13 +368,18 @@
   llvm::Constant* classRecordInit = ConstantStruct::get(init);
   resolver_->getModule()->addTypeName("classRecord." + getName(),
                                       classRecordInit->getType());
-  classRecord_ = new GlobalVariable(
-    classRecordInit->getType(),
-    true,
-    GlobalVariable::ExternalLinkage,
-    classRecordInit,
-    getName() + "<classRecord>",
-    resolver_->getModule());
+
+  // Now resolve the opaque type of the placeholder class record.
+  const Type* classRecordType =
+    cast<PointerType>(classRecord_->getType())->getElementType();
+  OpaqueType* opaqueType = cast<OpaqueType>(const_cast<Type*>(classRecordType));
+  opaqueType->refineAbstractTypeTo(classRecordInit->getType());
+  // Set the initializer of the class record.
+  classRecord_->setInitializer(classRecordInit);
+  // Mark the class record as constant.
+  classRecord_->setConstant(true);
+
+  DEBUG(std::cerr << "Computed class record for: " << getName() << '\n');
 }
 
 void VMClass::link()


Index: llvm-java/lib/Compiler/Resolver.cpp
diff -u llvm-java/lib/Compiler/Resolver.cpp:1.12 llvm-java/lib/Compiler/Resolver.cpp:1.13
--- llvm-java/lib/Compiler/Resolver.cpp:1.12	Fri Apr  1 12:31:25 2005
+++ llvm-java/lib/Compiler/Resolver.cpp	Fri Apr  1 16:59:20 2005
@@ -55,6 +55,7 @@
   elements.push_back(PointerType::get(PointerType::get(classRecordType_)));
   elements.push_back(Type::IntTy);
   elements.push_back(PointerType::get(PointerType::get(classRecordType_)));
+  elements.push_back(PointerType::get(classRecordType_));
   elements.push_back(Type::IntTy);
   typeInfoType_ = StructType::get(elements);