6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-28 19:31:58 +00:00
Code Issues Projects Releases Wiki Activity

Minor efficiency improvements all over. Finegrainify Namespacification

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10082 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-11-19 17:17:36 +00:00
parent deab9a7ae5
commit ebfb9f487d
1 changed files with 14 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
lib/Bytecode/Reader/ConstantReader.cpp
View File

@ -19,8 +19,7 @@
#include "llvm/Module.h"
#include "llvm/Constants.h"
#include <algorithm>
namespace llvm {
using namespace llvm;
const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
const unsigned char *EndBuf) {
@ -104,7 +103,7 @@ const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
// something and when we reread the type later, we can replace the opaque type
// with a new resolved concrete type.
//
void debug_type_tables();
namespace llvm { void debug_type_tables(); }
void BytecodeParser::parseTypeConstants(const unsigned char *&Buf,
const unsigned char *EndBuf,
TypeValuesListTy &Tab,
@ -112,6 +111,8 @@ void BytecodeParser::parseTypeConstants(const unsigned char *&Buf,
assert(Tab.size() == 0 && "should not have read type constants in before!");
// Insert a bunch of opaque types to be resolved later...
// FIXME: this is dumb
Tab.reserve(NumEntries);
for (unsigned i = 0; i < NumEntries; ++i)
Tab.push_back(OpaqueType::get());
@ -149,7 +150,7 @@ void BytecodeParser::parseTypeConstants(const unsigned char *&Buf,
Constant *BytecodeParser::parseConstantValue(const unsigned char *&Buf,
const unsigned char *EndBuf,
const Type *Ty) {
unsigned TypeID) {
// We must check for a ConstantExpr before switching by type because
// a ConstantExpr can be of any type, and has no explicit value.
@ -178,7 +179,7 @@ Constant *BytecodeParser::parseConstantValue(const unsigned char *&Buf,
// Construct a ConstantExpr of the appropriate kind
if (isExprNumArgs == 1) { // All one-operand expressions
assert(Opcode == Instruction::Cast);
return ConstantExpr::getCast(ArgVec[0], Ty);
return ConstantExpr::getCast(ArgVec[0], getType(TypeID));
} else if (Opcode == Instruction::GetElementPtr) { // GetElementPtr
std::vector<Constant*> IdxList(ArgVec.begin()+1, ArgVec.end());
return ConstantExpr::getGetElementPtr(ArgVec[0], IdxList);
@ -190,6 +191,7 @@ Constant *BytecodeParser::parseConstantValue(const unsigned char *&Buf,
}
// Ok, not an ConstantExpr. We now know how to read the given type...
const Type *Ty = getType(TypeID);
switch (Ty->getPrimitiveID()) {
case Type::BoolTyID: {
unsigned Val;
@ -274,37 +276,14 @@ Constant *BytecodeParser::parseConstantValue(const unsigned char *&Buf,
BCR_TRACE(4, "CPR: Type: '" << Ty << "' slot: " << Slot << "\n");
// Check to see if we have already read this global variable...
Value *Val = getValue(PT, Slot, false);
Value *Val = getValue(TypeID, Slot, false);
GlobalValue *GV;
if (Val) {
if (!(GV = dyn_cast<GlobalValue>(Val)))
throw std::string("Value of ConstantPointerRef not in ValueTable!");
BCR_TRACE(5, "Value Found in ValueTable!\n");
} else if (RevisionNum > 0) {
// Revision #0 could have forward references to globals that were weird.
// We got rid of this in subsequent revs.
throw std::string("Forward references to globals not allowed.");
} else { // Nope... find or create a forward ref. for it
GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PT, Slot));
if (I != GlobalRefs.end()) {
BCR_TRACE(5, "Previous forward ref found!\n");
GV = cast<GlobalValue>(I->second);
} else {
BCR_TRACE(5, "Creating new forward ref to a global variable!\n");
// Create a placeholder for the global variable reference...
GlobalVariable *GVar =
new GlobalVariable(PT->getElementType(), false,
GlobalValue::InternalLinkage);
// Keep track of the fact that we have a forward ref to recycle it
GlobalRefs.insert(std::make_pair(std::make_pair(PT, Slot), GVar));
// Must temporarily push this value into the module table...
TheModule->getGlobalList().push_back(GVar);
GV = GVar;
}
} else {
throw std::string("Forward references are not allowed here.");
}
return ConstantPointerRef::get(GV);
@ -335,11 +314,11 @@ void BytecodeParser::ParseConstantPool(const unsigned char *&Buf,
BCR_TRACE(3, "Type: 'type' NumEntries: " << NumEntries << "\n");
parseTypeConstants(Buf, EndBuf, TypeTab, NumEntries);
} else {
const Type *Ty = getType(Typ);
BCR_TRACE(3, "Type: '" << *Ty << "' NumEntries: " << NumEntries << "\n");
BCR_TRACE(3, "Type: '" << *getType(Typ) << "' NumEntries: "
<< NumEntries << "\n");
for (unsigned i = 0; i < NumEntries; ++i) {
Constant *C = parseConstantValue(Buf, EndBuf, Ty);
Constant *C = parseConstantValue(Buf, EndBuf, Typ);
assert(C && "parseConstantValue returned NULL!");
BCR_TRACE(4, "Read Constant: '" << *C << "'\n");
unsigned Slot = insertValue(C, Typ, Tab);
@ -349,12 +328,10 @@ void BytecodeParser::ParseConstantPool(const unsigned char *&Buf,
//
if (&Tab != &ModuleValues && Typ < ModuleValues.size())
Slot += ModuleValues[Typ]->size();
ResolveReferencesToValue(C, Slot);
ResolveReferencesToConstant(C, Slot);
}
}
}
if (Buf > EndBuf) throw std::string("Read past end of buffer.");
}
} // End llvm namespace