[llvm-commits] CVS: llvm-java/lib/Compiler/Resolver.cpp Class.h Class.cpp
Alkis Evlogimenos
alkis at cs.uiuc.edu
Fri Mar 25 20:32:18 PST 2005
Changes in directory llvm-java/lib/Compiler:
Resolver.cpp updated: 1.2 -> 1.3
Class.h updated: 1.4 -> 1.5
Class.cpp updated: 1.4 -> 1.5
---
Log message:
Change class interface a bit to model a jvm better in terms of
classloading. Classloading involves three phases: load, link,
initialize. Class resolution can be performed anywhere between link
and use of the to be resolved reference.
---
Diffs of the changes: (+74 -57)
Class.cpp | 96 ++++++++++++++++++++++++++++++++---------------------------
Class.h | 24 ++++++++------
Resolver.cpp | 11 ++++--
3 files changed, 74 insertions(+), 57 deletions(-)
Index: llvm-java/lib/Compiler/Resolver.cpp
diff -u llvm-java/lib/Compiler/Resolver.cpp:1.2 llvm-java/lib/Compiler/Resolver.cpp:1.3
--- llvm-java/lib/Compiler/Resolver.cpp:1.2 Fri Mar 25 20:50:56 2005
+++ llvm-java/lib/Compiler/Resolver.cpp Fri Mar 25 22:32:07 2005
@@ -93,8 +93,6 @@
ClassMap::iterator it = classMap_.lower_bound(descriptor);
if (it == classMap_.end() || it->first != descriptor) {
DEBUG(std::cerr << "Loading class: " << descriptor << '\n');
- // Insert dummy class to the map.
- it = classMap_.insert(it, std::make_pair(descriptor, Class(*this)));
switch (descriptor[0]) {
case 'B':
case 'C':
@@ -110,18 +108,23 @@
case 'L': {
unsigned pos = descriptor.find(';', 1);
const std::string& className = descriptor.substr(1, pos - 1);
- it->second.loadClass(className);
+ it = classMap_.insert(
+ it, std::make_pair(descriptor,
+ Class(*this, className)));
break;
}
case '[': {
const std::string& componentDescriptor = descriptor.substr(1);
- it->second.loadArrayClass(getClassForDesc(componentDescriptor));
+ it = classMap_.insert(
+ it, std::make_pair(descriptor,
+ Class(*this, getClassForDesc(componentDescriptor))));
break;
}
default:
assert(0 && "Cannot parse type descriptor!");
abort();
}
+ it->second.link();
module_.addTypeName(descriptor, it->second.getStructType());
DEBUG(std::cerr << "Loaded class: " << descriptor << '\n');
}
Index: llvm-java/lib/Compiler/Class.h
diff -u llvm-java/lib/Compiler/Class.h:1.4 llvm-java/lib/Compiler/Class.h:1.5
--- llvm-java/lib/Compiler/Class.h:1.4 Fri Mar 25 20:50:56 2005
+++ llvm-java/lib/Compiler/Class.h Fri Mar 25 22:32:07 2005
@@ -43,22 +43,26 @@
void addField(const std::string& name, const Type* type);
void resolveType();
- // Creates primitive class for type.
- Class(Resolver& resolver, const Type* type);
-
friend class Resolver;
// Resolver interface.
- // Creates a dummy class.
- explicit Class(Resolver& resolver);
+ // Load primitive class for type.
+ Class(Resolver& resolver, const Type* type);
+
+ // Load class by name.
+ Class(Resolver& resolver, const std::string& className);
+
+ // Load array class of component the passed class.
+ Class(Resolver& resolver, const Class& componentClass);
- // Builds the class object for the named class.
- void loadClass(const std::string& className);
- // Builds the array class object of component type componentClass.
- void loadArrayClass(const Class& componentClass);
+ // Link the class.
+ void link();
+ // Resolve the class.
+ void resolve();
+ // Initialize the class.
+ void initialize();
-
public:
const Type* getStructType() const { return structType_; }
const Type* getType() const { return type_; }
Index: llvm-java/lib/Compiler/Class.cpp
diff -u llvm-java/lib/Compiler/Class.cpp:1.4 llvm-java/lib/Compiler/Class.cpp:1.5
--- llvm-java/lib/Compiler/Class.cpp:1.4 Fri Mar 25 20:50:56 2005
+++ llvm-java/lib/Compiler/Class.cpp Fri Mar 25 22:32:07 2005
@@ -25,9 +25,9 @@
using namespace llvm;
using namespace llvm::Java;
-Class::Class(Resolver& resolver)
+Class::Class(Resolver& resolver, const std::string& className)
: resolver_(&resolver),
- classFile_(NULL),
+ classFile_(ClassFile::get(className)),
superClass_(NULL),
componentClass_(NULL),
structType_(OpaqueType::get()),
@@ -37,12 +37,24 @@
}
+Class::Class(Resolver& resolver, const Class& componentClass)
+ : resolver_(&resolver),
+ classFile_(NULL),
+ superClass_(NULL),
+ componentClass_(&componentClass),
+ structType_(OpaqueType::get()),
+ type_(PointerType::get(structType_)),
+ interfaceIndex_(INVALID_INTERFACE_INDEX)
+{
+
+}
+
Class::Class(Resolver& resolver, const Type* type)
: resolver_(&resolver),
classFile_(NULL),
superClass_(NULL),
componentClass_(NULL),
- structType_(0),
+ structType_(NULL),
type_(type),
interfaceIndex_(INVALID_INTERFACE_INDEX)
{
@@ -68,52 +80,50 @@
type_ = PointerType::get(structType_);
}
-void Class::loadClass(const std::string& className)
+void Class::link()
{
- classFile_ = ClassFile::get(className);
+ assert(!isPrimitive() && "Should not link primitive classes!");
- // This is any class but java/lang/Object.
- if (classFile_->getSuperClass()) {
- const Class& superClass =
- resolver_->getClass(classFile_->getSuperClass()->getName()->str());
-
- // We first add the struct of the super class.
- addField("super", superClass.getStructType());
-
- // Although we can safely assume that all interfaces inherits from
- // java/lang/Object, java/lang/Class.getSuperclass() returns null
- // on interface types. So we only set the superClass_ field when
- // the class is not an interface type, but we model the LLVM type
- // of the interface to be as if it inherits java/lang/Object.
- if (classFile_->isInterface())
- interfaceIndex_ = resolver_->getNextInterfaceIndex();
- else
- superClass_ = &superClass;
+ if (isArray()) {
+ superClass_ = &resolver_->getClass("java/lang/Object");
+ addField("super", superClass_->getStructType());
+ addField("<length>", Type::UIntTy);
+ addField("<data>", ArrayType::get(componentClass_->getType(), 0));
}
- // This is java/lang/Object.
- else
- addField("base", resolver_->getObjectBaseType());
-
- // Then we 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(), resolver_->getClass(field).getType());
+ else {
+ // This is any class but java/lang/Object.
+ if (classFile_->getSuperClass()) {
+ const Class& superClass =
+ resolver_->getClass(classFile_->getSuperClass()->getName()->str());
+
+ // We first add the struct of the super class.
+ addField("super", superClass.getStructType());
+
+ // Although we can safely assume that all interfaces inherits
+ // from java/lang/Object, java/lang/Class.getSuperclass()
+ // returns null on interface types. So we only set the
+ // superClass_ field when the class is not an interface type,
+ // but we model the LLVM type of the interface to be as if it
+ // inherits java/lang/Object.
+ if (classFile_->isInterface())
+ interfaceIndex_ = resolver_->getNextInterfaceIndex();
+ else
+ superClass_ = &superClass;
+ }
+ // This is java/lang/Object.
+ else
+ addField("base", resolver_->getObjectBaseType());
+
+ // Then we 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(), resolver_->getClass(field).getType());
+ }
}
resolveType();
assert(!isa<OpaqueType>(getStructType()) &&"Class not initialized properly!");
}
-
-void Class::loadArrayClass(const Class& componentClass)
-{
- superClass_ = &resolver_->getClass("java/lang/Object");
- componentClass_ = &componentClass;
- addField("super", superClass_->getStructType());
- addField("<length>", Type::UIntTy);
- addField("<data>", ArrayType::get(componentClass_->getType(), 0));
-
- resolveType();
-}
More information about the llvm-commits
mailing list