[llvm-commits] CVS: llvm-java/lib/Compiler/VMClass.h VMClass.cpp Resolver.h Resolver.cpp Compiler.cpp Class.h Class.cpp
Alkis Evlogimenos
alkis at cs.uiuc.edu
Mon Mar 28 11:53:35 PST 2005
Changes in directory llvm-java/lib/Compiler:
VMClass.h updated: 1.12 -> 1.13
VMClass.cpp updated: 1.13 -> 1.14
Resolver.h updated: 1.7 -> 1.8
Resolver.cpp updated: 1.5 -> 1.6
Compiler.cpp updated: 1.260 -> 1.261
Class.h (r1.12) removed
Class.cpp (r1.13) removed
---
Log message:
Rename Class to VMClass.
---
Diffs of the changes: (+101 -97)
Compiler.cpp | 88 ++++++++++++++++++++++++++++++-----------------------------
Resolver.cpp | 26 ++++++++---------
Resolver.h | 18 ++++++------
VMClass.cpp | 38 ++++++++++++-------------
VMClass.h | 28 +++++++++---------
5 files changed, 101 insertions(+), 97 deletions(-)
Index: llvm-java/lib/Compiler/VMClass.h
diff -u llvm-java/lib/Compiler/VMClass.h:1.12 llvm-java/lib/Compiler/VMClass.h:1.13
--- llvm-java/lib/Compiler/VMClass.h:1.12 Sun Mar 27 20:46:19 2005
+++ llvm-java/lib/Compiler/VMClass.h Mon Mar 28 13:53:24 2005
@@ -1,4 +1,4 @@
-//===-- Class.h - Compiler representation of a Java class -------*- C++ -*-===//
+//===-- VMClass.h - Compiler representation of a Java class -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@@ -27,13 +27,13 @@
class ClassFile;
class Resolver;
- class Class {
+ class VMClass {
static const unsigned INVALID_INTERFACE_INDEX = 0xFFFFFFFF;
const std::string name_;
Resolver* resolver_;
const ClassFile* classFile_;
- const Class* componentClass_;
+ const VMClass* componentClass_;
Type* structType_;
const Type* type_;
unsigned interfaceIndex_;
@@ -42,8 +42,8 @@
typedef std::vector<const Type*> ElementTypes;
ElementTypes elementTypes_;
mutable std::vector<void*> resolvedConstantPool_;
- std::vector<const Class*> superClasses_;
- std::vector<const Class*> interfaces_;
+ std::vector<const VMClass*> superClasses_;
+ std::vector<const VMClass*> interfaces_;
void addField(const std::string& name, const Type* type);
void resolveType();
@@ -53,13 +53,13 @@
// Resolver interface.
// Load primitive class for type.
- Class(Resolver* resolver, const Type* type);
+ VMClass(Resolver* resolver, const Type* type);
// Load class by name.
- Class(Resolver* resolver, const std::string& className);
+ VMClass(Resolver* resolver, const std::string& className);
// Load array class of component the passed class.
- Class(Resolver* resolver, const Class* componentClass);
+ VMClass(Resolver* resolver, const VMClass* componentClass);
// Link the class.
void link();
@@ -74,13 +74,13 @@
const Type* getType() const { return type_; }
const ClassFile* getClassFile() const { return classFile_; }
unsigned getNumSuperClasses() const { return superClasses_.size(); }
- const Class* getSuperClass(unsigned i) const { return superClasses_[i]; }
- const Class* getSuperClass() const {
+ const VMClass* getSuperClass(unsigned i) const { return superClasses_[i]; }
+ const VMClass* getSuperClass() const {
return getNumSuperClasses() ? getSuperClass(0) : NULL;
}
unsigned getNumInterfaces() const { return interfaces_.size(); }
- const Class* getInterface(unsigned i) const { return interfaces_[i]; }
- const Class* getComponentClass() const { return componentClass_; }
+ const VMClass* getInterface(unsigned i) const { return interfaces_[i]; }
+ const VMClass* getComponentClass() const { return componentClass_; }
bool isArray() const { return componentClass_; }
bool isPrimitive() const { return !structType_; }
bool isInterface() const { return classFile_ && !getSuperClass(); }
@@ -88,8 +88,8 @@
int getFieldIndex(const std::string& name) const;
llvm::Constant* getConstant(unsigned index) const;
- const Class* getClassForClass(unsigned index) const;
- const Class* getClassForDescriptor(unsigned index) const;
+ const VMClass* getClassForClass(unsigned index) const;
+ const VMClass* getClassForDescriptor(unsigned index) const;
};
} } // namespace llvm::Java
Index: llvm-java/lib/Compiler/VMClass.cpp
diff -u llvm-java/lib/Compiler/VMClass.cpp:1.13 llvm-java/lib/Compiler/VMClass.cpp:1.14
--- llvm-java/lib/Compiler/VMClass.cpp:1.13 Sun Mar 27 20:48:25 2005
+++ llvm-java/lib/Compiler/VMClass.cpp Mon Mar 28 13:53:24 2005
@@ -1,4 +1,4 @@
-//===-- Class.cpp - Compiler representation of a Java class -----*- C++ -*-===//
+//===-- VMClass.cpp - Compiler representation of a Java class ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@@ -15,7 +15,7 @@
//
//===----------------------------------------------------------------------===//
-#include "Class.h"
+#include "VMClass.h"
#include "Resolver.h"
#include <llvm/DerivedTypes.h>
#include <llvm/Constants.h>
@@ -26,7 +26,7 @@
using namespace llvm;
using namespace llvm::Java;
-Class::Class(Resolver* resolver, const std::string& className)
+VMClass::VMClass(Resolver* resolver, const std::string& className)
: name_(Resolver::canonicalizeClassName(className)),
resolver_(resolver),
classFile_(ClassFile::get(className)),
@@ -39,7 +39,7 @@
}
-Class::Class(Resolver* resolver, const Class* componentClass)
+VMClass::VMClass(Resolver* resolver, const VMClass* componentClass)
: name_('[' + componentClass->getName()),
resolver_(resolver),
classFile_(NULL),
@@ -51,7 +51,7 @@
}
-Class::Class(Resolver* resolver, const Type* type)
+VMClass::VMClass(Resolver* resolver, const Type* type)
: name_(type == Type::SByteTy ? "B" :
type == Type::UShortTy ? "C" :
type == Type::DoubleTy ? "D" :
@@ -70,18 +70,18 @@
}
-void Class::addField(const std::string& name, const Type* type)
+void VMClass::addField(const std::string& name, const Type* type)
{
f2iMap_.insert(std::make_pair(name, elementTypes_.size()));
elementTypes_.push_back(type);
}
-int Class::getFieldIndex(const std::string& name) const {
+int VMClass::getFieldIndex(const std::string& name) const {
Field2IndexMap::const_iterator it = f2iMap_.find(name);
return it == f2iMap_.end() ? -1 : it->second;
}
-void Class::resolveType() {
+void VMClass::resolveType() {
PATypeHolder holder = structType_;
Type* resolvedType = StructType::get(elementTypes_);
cast<OpaqueType>(structType_)->refineAbstractTypeTo(resolvedType);
@@ -89,7 +89,7 @@
type_ = PointerType::get(structType_);
}
-void Class::link()
+void VMClass::link()
{
assert(!isPrimitive() && "Should not link primitive classes!");
@@ -111,7 +111,7 @@
// This is any class but java/lang/Object.
else {
// Our direct super class.
- const Class* superClass =
+ const VMClass* superClass =
resolver_->getClass(classFile_->getSuperClass()->getName()->str());
// Add the interfaces of our direct superclass.
@@ -121,7 +121,7 @@
// For each of the interfaces we implement, load it and add that
// interface and all the interfaces it inherits from.
for (unsigned i = 0, e = classFile_->getNumInterfaces(); i != e; ++i) {
- const Class* interface =
+ const VMClass* interface =
getClassForClass(classFile_->getInterfaceIndex(i));
interfaces_.push_back(interface);
for (unsigned j = 0, f = interface->getNumInterfaces(); j != f; ++j)
@@ -169,7 +169,7 @@
assert(!isa<OpaqueType>(getStructType()) &&"Class not initialized properly!");
}
-llvm::Constant* Class::getConstant(unsigned index) const
+llvm::Constant* VMClass::getConstant(unsigned index) const
{
assert(classFile_ && "No constant pool!");
assert((dynamic_cast<ConstantString*>(classFile_->getConstant(index)) ||
@@ -183,7 +183,7 @@
if (!resolvedConstantPool_[index]) {
Constant* jc = classFile_->getConstant(index);
if (ConstantString* s = dynamic_cast<ConstantString*>(jc)) {
- const Class* stringClass = resolver_->getClass("java/lang/String");
+ const VMClass* stringClass = resolver_->getClass("java/lang/String");
const Type* stringType = stringClass->getStructType();
resolvedConstantPool_[index] =
new GlobalVariable(stringType,
@@ -212,7 +212,7 @@
return static_cast<llvm::Constant*>(resolvedConstantPool_[index]);
}
-const Class* Class::getClassForClass(unsigned index) const
+const VMClass* VMClass::getClassForClass(unsigned index) const
{
assert(classFile_ && "No constant pool!");
assert(dynamic_cast<ConstantClass*>(classFile_->getConstant(index)) &&
@@ -222,13 +222,13 @@
if (!resolvedConstantPool_[index]) {
ConstantClass* jc = classFile_->getConstantClass(index);
resolvedConstantPool_[index] =
- const_cast<Class*>(resolver_->getClass(jc->getName()->str()));
+ const_cast<VMClass*>(resolver_->getClass(jc->getName()->str()));
}
- return static_cast<const Class*>(resolvedConstantPool_[index]);
+ return static_cast<const VMClass*>(resolvedConstantPool_[index]);
}
-const Class* Class::getClassForDescriptor(unsigned index) const
+const VMClass* VMClass::getClassForDescriptor(unsigned index) const
{
assert(classFile_ && "No constant pool!");
assert(dynamic_cast<ConstantUtf8*>(classFile_->getConstant(index)) &&
@@ -238,8 +238,8 @@
if (!resolvedConstantPool_[index]) {
ConstantUtf8* jc = classFile_->getConstantUtf8(index);
resolvedConstantPool_[index] =
- const_cast<Class*>(resolver_->getClassForDesc(jc->str()));
+ const_cast<VMClass*>(resolver_->getClassForDesc(jc->str()));
}
- return static_cast<const Class*>(resolvedConstantPool_[index]);
+ return static_cast<const VMClass*>(resolvedConstantPool_[index]);
}
Index: llvm-java/lib/Compiler/Resolver.h
diff -u llvm-java/lib/Compiler/Resolver.h:1.7 llvm-java/lib/Compiler/Resolver.h:1.8
--- llvm-java/lib/Compiler/Resolver.h:1.7 Sun Mar 27 20:48:25 2005
+++ llvm-java/lib/Compiler/Resolver.h Mon Mar 28 13:53:24 2005
@@ -15,7 +15,7 @@
#ifndef LLVM_JAVA_RESOLVER_H
#define LLVM_JAVA_RESOLVER_H
-#include "Class.h"
+#include "VMClass.h"
#include <llvm/Java/Bytecode.h>
#include <llvm/Java/ClassFile.h>
#include <llvm/Module.h>
@@ -27,26 +27,26 @@
class Resolver {
Module* module_;
- typedef std::map<std::string, Class> ClassMap;
+ typedef std::map<std::string, VMClass> ClassMap;
ClassMap classMap_;
unsigned nextInterfaceIndex_;
const Type* objectBaseType_;
const Type* objectBaseRefType_;
- const Class* getClassForDesc(const std::string& descriptor);
+ const VMClass* getClassForDesc(const std::string& descriptor);
const Type* getTypeHelper(const std::string&,
unsigned& i,
bool memberMethod = false) const;
- std::pair<ClassMap::iterator, bool> insertClass(const Class& clazz) {
+ std::pair<ClassMap::iterator, bool> insertClass(const VMClass& clazz) {
return classMap_.insert(std::make_pair(clazz.getName(), clazz));
}
- ClassMap::iterator insertClass(ClassMap::iterator i, const Class& clazz) {
+ ClassMap::iterator insertClass(ClassMap::iterator i, const VMClass& clazz) {
return classMap_.insert(i, std::make_pair(clazz.getName(), clazz));
}
- friend class Class;
+ friend class VMClass;
public:
static std::string canonicalizeClassName(const std::string& className) {
@@ -73,13 +73,13 @@
return !isTwoSlotType(type);
}
- const Class* getClass(const std::string& className) {
+ const VMClass* getClass(const std::string& className) {
return getClassForDesc(canonicalizeClassName(className));
}
- const Class* getClass(JType type);
+ const VMClass* getClass(JType type);
- const Class* getArrayClass(const Class* clazz) {
+ const VMClass* getArrayClass(const VMClass* clazz) {
return getClassForDesc('[' + clazz->getName());
}
Index: llvm-java/lib/Compiler/Resolver.cpp
diff -u llvm-java/lib/Compiler/Resolver.cpp:1.5 llvm-java/lib/Compiler/Resolver.cpp:1.6
--- llvm-java/lib/Compiler/Resolver.cpp:1.5 Sat Mar 26 18:04:10 2005
+++ llvm-java/lib/Compiler/Resolver.cpp Mon Mar 28 13:53:24 2005
@@ -27,15 +27,15 @@
objectBaseType_(OpaqueType::get()),
objectBaseRefType_(PointerType::get(objectBaseType_))
{
- insertClass(Class(this, Type::SByteTy));
- insertClass(Class(this, Type::UShortTy));
- insertClass(Class(this, Type::DoubleTy));
- insertClass(Class(this, Type::FloatTy));
- insertClass(Class(this, Type::IntTy));
- insertClass(Class(this, Type::LongTy));
- insertClass(Class(this, Type::ShortTy));
- insertClass(Class(this, Type::BoolTy));
- insertClass(Class(this, Type::VoidTy));
+ insertClass(VMClass(this, Type::SByteTy));
+ insertClass(VMClass(this, Type::UShortTy));
+ insertClass(VMClass(this, Type::DoubleTy));
+ insertClass(VMClass(this, Type::FloatTy));
+ insertClass(VMClass(this, Type::IntTy));
+ insertClass(VMClass(this, Type::LongTy));
+ insertClass(VMClass(this, Type::ShortTy));
+ insertClass(VMClass(this, Type::BoolTy));
+ insertClass(VMClass(this, Type::VoidTy));
module_->addTypeName("struct.llvm_java_object_base", objectBaseType_);
}
@@ -88,7 +88,7 @@
return 0; // not reached
}
-const Class* Resolver::getClassForDesc(const std::string& descriptor)
+const VMClass* Resolver::getClassForDesc(const std::string& descriptor)
{
ClassMap::iterator it = classMap_.lower_bound(descriptor);
if (it == classMap_.end() || it->first != descriptor) {
@@ -108,12 +108,12 @@
case 'L': {
unsigned pos = descriptor.find(';', 1);
const std::string& className = descriptor.substr(1, pos - 1);
- it = insertClass(it, Class(this, className));
+ it = insertClass(it, VMClass(this, className));
break;
}
case '[': {
const std::string& componentDescriptor = descriptor.substr(1);
- it = insertClass(it, Class(this, getClassForDesc(componentDescriptor)));
+ it = insertClass(it, VMClass(this, getClassForDesc(componentDescriptor)));
break;
}
default:
@@ -128,7 +128,7 @@
return &it->second;
}
-const Class* Resolver::getClass(JType type)
+const VMClass* Resolver::getClass(JType type)
{
switch (type) {
case BOOLEAN: return getClassForDesc("Z");
Index: llvm-java/lib/Compiler/Compiler.cpp
diff -u llvm-java/lib/Compiler/Compiler.cpp:1.260 llvm-java/lib/Compiler/Compiler.cpp:1.261
--- llvm-java/lib/Compiler/Compiler.cpp:1.260 Sun Mar 27 20:46:19 2005
+++ llvm-java/lib/Compiler/Compiler.cpp Mon Mar 28 13:53:24 2005
@@ -61,7 +61,7 @@
Module* module_;
std::auto_ptr<Resolver> resolver_;
GlobalVariable* JNIEnvPtr_;
- const Class* class_;
+ const VMClass* class_;
std::auto_ptr<BasicBlockBuilder> bbBuilder_;
std::list<BasicBlock*> bbWorkList_;
typedef std::map<BasicBlock*, unsigned> OpStackDepthMap;
@@ -93,7 +93,7 @@
static StructType* VTableTy;
static StructType* TypeInfoTy;
};
- typedef std::map<const Class*, VTableInfo> Class2VTableInfoMap;
+ typedef std::map<const VMClass*, VTableInfo> Class2VTableInfoMap;
Class2VTableInfoMap c2viMap_;
public:
@@ -191,7 +191,7 @@
new CallInst(memcpy_, params, "", ip);
// Get class information for java/lang/String.
- const Class* clazz = resolver_->getClass("java/lang/String");
+ const VMClass* clazz = resolver_->getClass("java/lang/String");
const VTableInfo* vi = getVTableInfoGeneric(clazz);
// Install the vtable pointer.
@@ -263,7 +263,7 @@
/// VTableInfo for java.lang.Object.
bool initializeVTableInfoMap() {
DEBUG(std::cerr << "Building VTableInfo for: java/lang/Object\n");
- const Class* clazz = resolver_->getClass("java/lang/Object");
+ const VMClass* clazz = resolver_->getClass("java/lang/Object");
VTableInfo& vi = c2viMap_[clazz];
assert(!vi.vtable && vi.m2iMap.empty() &&
@@ -361,7 +361,7 @@
/// its corresponding VTable. The direct superclass goes first in
/// the array.
llvm::Constant*
- buildSuperClassesVTables(const Class* clazz, const VTableInfo& vi) const {
+ buildSuperClassesVTables(const VMClass* clazz, const VTableInfo& vi) const {
std::vector<llvm::Constant*> superVtables(vi.superVtables.size());
for (unsigned i = 0, e = vi.superVtables.size(); i != e; ++i)
superVtables[i] = ConstantExpr::getCast(
@@ -387,8 +387,8 @@
/// Builds an interface VTable for the specified <class,interface>
/// pair.
- llvm::Constant* buildInterfaceVTable(const Class* clazz,
- const Class* interface) {
+ llvm::Constant* buildInterfaceVTable(const VMClass* clazz,
+ const VMClass* interface) {
DEBUG(std::cerr << "Building interface vtable: "
<< interface->getName() << " for: " << clazz->getName() << '\n');
@@ -438,8 +438,8 @@
}
void insertVtablesForInterface(std::vector<llvm::Constant*>& vtables,
- const Class* clazz,
- const Class* interface) {
+ const VMClass* clazz,
+ const VMClass* interface) {
static llvm::Constant* nullVTable =
llvm::Constant::getNullValue(PointerType::get(VTableInfo::VTableTy));
@@ -455,7 +455,7 @@
/// corresponding VTableInfo. If this classfile is an interface we
/// return a pointer to 0xFFFFFFFF.
std::pair<int, llvm::Constant*>
- buildInterfacesVTables(const Class* clazz, const VTableInfo& vi) {
+ buildInterfacesVTables(const VMClass* clazz, const VTableInfo& vi) {
// If this is an interface then we are not implementing any
// interfaces so the lastInterface field is our index and the
// pointer to the array of interface vtables is an all-ones
@@ -501,7 +501,7 @@
/// Given the classfile and its corresponding VTableInfo,
/// construct the typeinfo constant for it.
- llvm::Constant* buildClassTypeInfo(const Class* clazz,
+ llvm::Constant* buildClassTypeInfo(const VMClass* clazz,
const VTableInfo& vi) {
std::vector<llvm::Constant*> typeInfoInit;
@@ -529,7 +529,7 @@
}
/// Returns the VTableInfo associated with this classfile.
- const VTableInfo& getVTableInfo(const Class* clazz) {
+ const VTableInfo& getVTableInfo(const VMClass* clazz) {
static bool initialized = initializeVTableInfoMap();
Class2VTableInfoMap::iterator it = c2viMap_.lower_bound(clazz);
@@ -552,7 +552,7 @@
// this inherits from.
if (clazz->isInterface()) {
for (unsigned i = 0, e = clazz->getNumInterfaces(); i != e; ++i) {
- const Class* interface = clazz->getInterface(i);
+ const VMClass* interface = clazz->getInterface(i);
const VTableInfo& ifaceVI = getVTableInfo(interface);
const ClassFile* ifaceCF = interface->getClassFile();
ConstantStruct* ifaceInit =
@@ -574,7 +574,7 @@
// Otherwise this is a class, so add all methods from its super
// class.
else {
- const Class* superClass = clazz->getSuperClass();
+ const VMClass* superClass = clazz->getSuperClass();
assert(superClass && "Class does not have superclass!");
const VTableInfo& superVI = getVTableInfo(superClass);
@@ -808,9 +808,9 @@
/// Finds a static field in the specified class, any of its
/// super clases, or any of the interfaces it implements.
- GlobalVariable* getStaticField(const Class* clazz,
+ GlobalVariable* getStaticField(const VMClass* clazz,
const std::string& name,
- const Class* fieldClass) {
+ const VMClass* fieldClass) {
emitStaticInitializers(clazz->getClassFile());
std::string globalName =
@@ -821,7 +821,7 @@
return g;
for (unsigned i = 0, e = clazz->getNumInterfaces(); i != e; ++i) {
- const Class* interface = clazz->getInterface(i);
+ const VMClass* interface = clazz->getInterface(i);
emitStaticInitializers(interface->getClassFile());
globalName =
interface->getClassFile()->getThisClass()->getName()->str() +
@@ -832,7 +832,7 @@
}
for (unsigned i = 0, e = clazz->getNumSuperClasses(); i != e; ++i) {
- const Class* superClass = clazz->getSuperClass(i);
+ const VMClass* superClass = clazz->getSuperClass(i);
emitStaticInitializers(superClass->getClassFile());
globalName =
superClass->getClassFile()->getThisClass()->getName()->str() +
@@ -859,7 +859,7 @@
/// Emits the necessary code to get a field from the passed
/// pointer to an object.
- Value* getField(const Class* clazz,
+ Value* getField(const VMClass* clazz,
const std::string& fieldName,
Value* ptr) {
// Cast ptr to correct type.
@@ -1094,14 +1094,14 @@
const std::string& className =
classfile->getThisClass()->getName()->str();
- const Class* clazz = resolver_->getClass(className);
+ const VMClass* clazz = resolver_->getClass(className);
// Create the global variables of this class.
const Fields& fields = classfile->getFields();
for (unsigned i = 0, e = fields.size(); i != e; ++i) {
Field* field = fields[i];
if (field->isStatic()) {
- const Class* fieldClass =
+ const VMClass* fieldClass =
clazz->getClassForDescriptor(field->getDescriptorIndex());
const Type* globalTy = fieldClass->getType();
// A java field can be final/constant even if it has a
@@ -1281,7 +1281,7 @@
void do_saload() { do_aload_common("[S"); }
void do_aload_common(const std::string& className) {
- const Class* arrayClass = resolver_->getClass(className);
+ const VMClass* arrayClass = resolver_->getClass(className);
assert(arrayClass->isArray() && "Not an array class!");
Value* index = pop(Type::IntTy);
Value* arrayRef = pop(arrayClass->getType());
@@ -1318,9 +1318,9 @@
void do_sastore() { do_astore_common("[S"); }
void do_astore_common(const std::string& className) {
- const Class* arrayClass = resolver_->getClass(className);
+ const VMClass* arrayClass = resolver_->getClass(className);
assert(arrayClass->isArray() && "Not an array class!");
- const Class* componentClass = arrayClass->getComponentClass();
+ const VMClass* componentClass = arrayClass->getComponentClass();
Value* value = pop(componentClass->getType());
Value* index = pop(Type::IntTy);
Value* arrayRef = pop(arrayClass->getType());
@@ -1636,7 +1636,7 @@
void do_putfield(unsigned index) {
ConstantFieldRef* fieldRef =
class_->getClassFile()->getConstantFieldRef(index);
- const Class* fieldClass = class_->getClassForDescriptor(
+ const VMClass* fieldClass = class_->getClassForDescriptor(
fieldRef->getNameAndType()->getDescriptorIndex());
const Type* type = fieldClass->getType();
Value* v = pop(type);
@@ -1669,11 +1669,11 @@
return params;
}
- const VTableInfo* getVTableInfoGeneric(const Class* clazz) {
+ const VTableInfo* getVTableInfoGeneric(const VMClass* clazz) {
assert(!clazz->isPrimitive() &&
"Cannot get VTableInfo for primitive class!");
if (clazz->isArray()) {
- const Class* componentClass = clazz->getComponentClass();
+ const VMClass* componentClass = clazz->getComponentClass();
if (componentClass->isPrimitive())
return &getPrimitiveArrayVTableInfo(componentClass->getType());
else
@@ -1690,7 +1690,8 @@
const std::string& className = methodRef->getClass()->getName()->str();
- const Class* clazz = class_->getClassForClass(methodRef->getClassIndex());
+ const VMClass* clazz =
+ class_->getClassForClass(methodRef->getClassIndex());
const VTableInfo* vi = getVTableInfoGeneric(clazz);
const std::string& methodDescr =
@@ -1732,7 +1733,8 @@
const std::string& methodDescr =
methodName + nameAndType->getDescriptor()->str();
std::string funcName = className + '/' + methodDescr;
- const Class* clazz = class_->getClassForClass(methodRef->getClassIndex());
+ const VMClass* clazz =
+ class_->getClassForClass(methodRef->getClassIndex());
const FunctionType* funcTy = cast<FunctionType>(
resolver_->getType(nameAndType->getDescriptor()->str(), true));
@@ -1744,7 +1746,8 @@
void do_invokestatic(unsigned index) {
ConstantMethodRef* methodRef =
class_->getClassFile()->getConstantMethodRef(index);
- const Class* clazz = class_->getClassForClass(methodRef->getClassIndex());
+ const VMClass* clazz =
+ class_->getClassForClass(methodRef->getClassIndex());
emitStaticInitializers(clazz->getClassFile());
Method* method = getMethod(methodRef);
Function* function = getFunction(method);
@@ -1771,7 +1774,8 @@
const std::string& className = methodRef->getClass()->getName()->str();
- const Class* clazz = class_->getClassForClass(methodRef->getClassIndex());
+ const VMClass* clazz =
+ class_->getClassForClass(methodRef->getClassIndex());
const VTableInfo* vi = getVTableInfoGeneric(clazz);
const std::string& methodDescr =
@@ -1822,7 +1826,7 @@
}
template<typename InsertionPointTy>
- Value* allocateObject(const Class& clazz,
+ Value* allocateObject(const VMClass& clazz,
const VTableInfo& vi,
InsertionPointTy* ip) {
static std::vector<Value*> params(4);
@@ -1844,7 +1848,7 @@
}
void do_new(unsigned index) {
- const Class* clazz = class_->getClassForClass(index);
+ const VMClass* clazz = class_->getClassForClass(index);
emitStaticInitializers(clazz->getClassFile());
const VTableInfo& vi = getVTableInfo(clazz);
@@ -1872,14 +1876,14 @@
}
template<typename InsertionPointTy>
- Value* allocateArray(const Class* clazz,
+ Value* allocateArray(const VMClass* clazz,
const VTableInfo* vi,
Value* count,
InsertionPointTy* ip) {
static std::vector<Value*> params(4);
assert(clazz->isArray() && "Not an array class!");
- const Class* componentClass = clazz->getComponentClass();
+ const VMClass* componentClass = clazz->getComponentClass();
const Type* elementTy = componentClass->getType();
// The size of the element.
@@ -1923,8 +1927,8 @@
void do_newarray(JType type) {
Value* count = pop(Type::UIntTy);
- const Class* clazz = resolver_->getClass(type);
- const Class* arrayClass = resolver_->getArrayClass(clazz);
+ const VMClass* clazz = resolver_->getClass(type);
+ const VMClass* arrayClass = resolver_->getArrayClass(clazz);
const VTableInfo* vi = getVTableInfoGeneric(arrayClass);
push(allocateArray(arrayClass, vi, count, currentBB_));
@@ -1933,15 +1937,15 @@
void do_anewarray(unsigned index) {
Value* count = pop(Type::UIntTy);
- const Class* clazz = class_->getClassForClass(index);
- const Class* arrayClass = resolver_->getArrayClass(clazz);
+ const VMClass* clazz = class_->getClassForClass(index);
+ const VMClass* arrayClass = resolver_->getArrayClass(clazz);
const VTableInfo* vi = getVTableInfoGeneric(arrayClass);
push(allocateArray(arrayClass, vi, count, currentBB_));
}
void do_arraylength() {
- const Class* clazz = resolver_->getClass("[Ljava/lang/Object;");
+ const VMClass* clazz = resolver_->getClass("[Ljava/lang/Object;");
Value* arrayRef = pop(clazz->getType());
Value* lengthPtr = getArrayLengthPtr(arrayRef, currentBB_);
Value* length = new LoadInst(lengthPtr, TMP, currentBB_);
@@ -1955,7 +1959,7 @@
}
void do_checkcast(unsigned index) {
- const Class* clazz = class_->getClassForClass(index);
+ const VMClass* clazz = class_->getClassForClass(index);
const VTableInfo* vi = getVTableInfoGeneric(clazz);
Value* objRef = pop(resolver_->getObjectBaseRefType());
@@ -1972,7 +1976,7 @@
}
void do_instanceof(unsigned index) {
- const Class* clazz = class_->getClassForClass(index);
+ const VMClass* clazz = class_->getClassForClass(index);
const VTableInfo* vi = getVTableInfoGeneric(clazz);
Value* objRef = pop(resolver_->getObjectBaseRefType());
More information about the llvm-commits
mailing list