6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-14 11:32:34 +00:00
Code Issues Projects Releases Wiki Activity

Major refactoring of the bytecode reader. This includes the following

Browse Source 
changes:
  * BytecodeReader::getType(...) used to return a null pointer
    on error.  This was only checked about half the time.  Now we convert
    it to throw an exception, and delete the half that checked for error.
    This was checked in before, but psmith crashed and lost the change :(
  * insertValue no longer returns -1 on error, so callers don't need to
    check for it.
  * Substantial rewrite of InstructionReader.cpp, to use more efficient,
    simpler, data structures.  This provides another 5% speedup.  This also
    makes the code much easier to read and understand.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@8984 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-10-09 20:22:47 +00:00
parent 3483f54367
commit 927b185c17
4 changed files with 168 additions and 312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -27,7 +27,6 @@ const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
unsigned Typ;
if (read_vbr(Buf, EndBuf, Typ)) return Val;
const Type *RetType = getType(Typ);
if (RetType == 0) return Val;
unsigned NumParams;
if (read_vbr(Buf, EndBuf, NumParams)) return Val;
@ -35,9 +34,7 @@ const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
std::vector<const Type*> Params;
while (NumParams--) {
if (read_vbr(Buf, EndBuf, Typ)) return Val;
const Type *Ty = getType(Typ);
if (Ty == 0) return Val;
Params.push_back(Ty);
Params.push_back(getType(Typ));
}
bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
@ -49,7 +46,6 @@ const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
unsigned ElTyp;
if (read_vbr(Buf, EndBuf, ElTyp)) return Val;
const Type *ElementType = getType(ElTyp);
if (ElementType == 0) return Val;
unsigned NumElements;
if (read_vbr(Buf, EndBuf, NumElements)) return Val;
@ -64,10 +60,7 @@ const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
if (read_vbr(Buf, EndBuf, Typ)) return Val;
while (Typ) { // List is terminated by void/0 typeid
const Type *Ty = getType(Typ);
if (Ty == 0) return Val;
Elements.push_back(Ty);
Elements.push_back(getType(Typ));
if (read_vbr(Buf, EndBuf, Typ)) return Val;
}
@ -77,9 +70,7 @@ const Type *BytecodeParser::parseTypeConstant(const unsigned char *&Buf,
unsigned ElTyp;
if (read_vbr(Buf, EndBuf, ElTyp)) return Val;
BCR_TRACE(5, "Pointer Type Constant #" << ElTyp << "\n");
const Type *ElementType = getType(ElTyp);
if (ElementType == 0) return Val;
return PointerType::get(ElementType);
return PointerType::get(getType(ElTyp));
}
case Type::OpaqueTyID: {
@ -169,9 +160,8 @@ Constant *BytecodeParser::parseConstantValue(const unsigned char *&Buf,
if (read_vbr(Buf, EndBuf, ArgValSlot)) throw Error_readvbr;
if (read_vbr(Buf, EndBuf, ArgTypeSlot)) throw Error_readvbr;
const Type *ArgTy = getType(ArgTypeSlot);
if (ArgTy == 0) throw std::string("Argument type slot not found.");
BCR_TRACE(4, "CE Arg " << i << ": Type: '" << ArgTy << "' slot: "
BCR_TRACE(4, "CE Arg " << i << ": Type: '" << *ArgTy << "' slot: "
<< ArgValSlot << "\n");
// Get the arg value from its slot if it exists, otherwise a placeholder
@ -355,27 +345,25 @@ void BytecodeParser::ParseConstantPool(const unsigned char *&Buf,
if (read_vbr(Buf, EndBuf, NumEntries) ||
read_vbr(Buf, EndBuf, Typ)) throw Error_readvbr;
const Type *Ty = getType(Typ);
if (Ty == 0) throw std::string("Invalid type read.");
BCR_TRACE(3, "Type: '" << Ty << "' NumEntries: " << NumEntries << "\n");
if (Typ == Type::TypeTyID) {
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");
for (unsigned i = 0; i < NumEntries; ++i) {
Constant *C = parseConstantValue(Buf, EndBuf, Ty);
assert(C && "parseConstantValue returned NULL!");
BCR_TRACE(4, "Read Constant: '" << *C << "'\n");
int Slot;
if ((Slot = insertValue(C, Tab)) == -1)
throw std::string("Could not insert value into ValueTable.");
unsigned Slot = insertValue(C, Tab);
// If we are reading a function constant table, make sure that we adjust
// the slot number to be the real global constant number.
//
if (&Tab != &ModuleValues && Typ < ModuleValues.size())
Slot += ModuleValues[Typ]->size();
ResolveReferencesToValue(C, (unsigned)Slot);
ResolveReferencesToValue(C, Slot);
}
}
}

376
lib/Bytecode/Reader/InstructionReader.cpp
View File

@ -6,9 +6,6 @@
// Note that this library should be as fast as possible, reentrant, and
// threadsafe!!
//
// TODO: Change from getValue(Raw.Arg1) etc, to getArg(Raw, 1)
// Make it check type, so that casts are checked.
//
//===----------------------------------------------------------------------===//
#include "ReaderInternals.h"
@ -17,11 +14,21 @@
#include "llvm/iPHINode.h"
#include "llvm/iOther.h"
std::auto_ptr<RawInst>
BytecodeParser::ParseRawInst(const unsigned char *&Buf,
const unsigned char *EndBuf) {
struct RawInst { // The raw fields out of the bytecode stream...
unsigned NumOperands;
unsigned Opcode;
unsigned Type;
RawInst(const unsigned char *&Buf, const unsigned char *EndBuf,
std::vector<unsigned> &Args);
};
RawInst::RawInst(const unsigned char *&Buf, const unsigned char *EndBuf,
std::vector<unsigned> &Args) {
unsigned Op, Typ;
std::auto_ptr<RawInst> Result = std::auto_ptr<RawInst>(new RawInst());
if (read(Buf, EndBuf, Op))
throw std::string("Error reading from buffer.");
@ -29,20 +36,20 @@ BytecodeParser::ParseRawInst(const unsigned char *&Buf,
// --------------------------
// 01-00: Opcode type, fixed to 1.
// 07-02: Opcode
Result->NumOperands = (Op >> 0) & 03;
Result->Opcode = (Op >> 2) & 63;
Opcode = (Op >> 2) & 63;
Args.resize((Op >> 0) & 03);
switch (Result->NumOperands) {
switch (Args.size()) {
case 1:
// bits Instruction format:
// --------------------------
// 19-08: Resulting type plane
// 31-20: Operand #1 (if set to (2^12-1), then zero operands)
//
Result->Ty = getType((Op >> 8) & 4095);
Result->Arg1 = (Op >> 20) & 4095;
if (Result->Arg1 == 4095) // Handle special encoding for 0 operands...
Result->NumOperands = 0;
Type = (Op >> 8) & 4095;
Args[0] = (Op >> 20) & 4095;
if (Args[0] == 4095) // Handle special encoding for 0 operands...
Args.resize(0);
break;
case 2:
// bits Instruction format:
@ -51,9 +58,9 @@ BytecodeParser::ParseRawInst(const unsigned char *&Buf,
// 23-16: Operand #1
// 31-24: Operand #2
//
Result->Ty = getType((Op >> 8) & 255);
Result->Arg1 = (Op >> 16) & 255;
Result->Arg2 = (Op >> 24) & 255;
Type = (Op >> 8) & 255;
Args[0] = (Op >> 16) & 255;
Args[1] = (Op >> 24) & 255;
break;
case 3:
// bits Instruction format:
@ -63,159 +70,101 @@ BytecodeParser::ParseRawInst(const unsigned char *&Buf,
// 25-20: Operand #2
// 31-26: Operand #3
//
Result->Ty = getType((Op >> 8) & 63);
Result->Arg1 = (Op >> 14) & 63;
Result->Arg2 = (Op >> 20) & 63;
Result->Arg3 = (Op >> 26) & 63;
Type = (Op >> 8) & 63;
Args[0] = (Op >> 14) & 63;
Args[1] = (Op >> 20) & 63;
Args[2] = (Op >> 26) & 63;
break;
case 0:
Buf -= 4; // Hrm, try this again...
if (read_vbr(Buf, EndBuf, Result->Opcode))
if (read_vbr(Buf, EndBuf, Opcode))
throw std::string("Error reading from buffer.");
Result->Opcode >>= 2;
if (read_vbr(Buf, EndBuf, Typ))
throw std::string("Error reading from buffer.");
Result->Ty = getType(Typ);
if (Result->Ty == 0)
throw std::string("Invalid type read in instruction.");
if (read_vbr(Buf, EndBuf, Result->NumOperands))
Opcode >>= 2;
if (read_vbr(Buf, EndBuf, Type))
throw std::string("Error reading from buffer.");
switch (Result->NumOperands) {
case 0:
unsigned NumOperands;
if (read_vbr(Buf, EndBuf, NumOperands))
throw std::string("Error reading from buffer.");
Args.resize(NumOperands);
if (NumOperands == 0)
throw std::string("Zero-argument instruction found; this is invalid.");
case 1:
if (read_vbr(Buf, EndBuf, Result->Arg1))
throw std::string("Error reading from buffer");
break;
case 2:
if (read_vbr(Buf, EndBuf, Result->Arg1) ||
read_vbr(Buf, EndBuf, Result->Arg2))
throw std::string("Error reading from buffer");
break;
case 3:
if (read_vbr(Buf, EndBuf, Result->Arg1) ||
read_vbr(Buf, EndBuf, Result->Arg2) ||
read_vbr(Buf, EndBuf, Result->Arg3))
throw std::string("Error reading from buffer");
break;
default:
if (read_vbr(Buf, EndBuf, Result->Arg1) ||
read_vbr(Buf, EndBuf, Result->Arg2))
throw std::string("Error reading from buffer");
// Allocate a vector to hold arguments 3, 4, 5, 6 ...
Result->VarArgs = new std::vector<unsigned>(Result->NumOperands-2);
for (unsigned a = 0; a < Result->NumOperands-2; a++)
if (read_vbr(Buf, EndBuf, (*Result->VarArgs)[a]))
throw std::string("Error reading from buffer");
break;
}
if (align32(Buf, EndBuf))
for (unsigned i = 0; i != NumOperands; ++i)
if (read_vbr(Buf, EndBuf, Args[i]))
throw std::string("Error reading from buffer");
if (align32(Buf, EndBuf))
throw std::string("Unaligned bytecode buffer.");
break;
}
#if 0
std::cerr << "NO: " << Result->NumOperands << " opcode: " << Result->Opcode
<< " Ty: "<< Result->Ty->getDescription()<< " arg1: "<< Result->Arg1
<< " arg2: " << Result->Arg2 << " arg3: " << Result->Arg3 << "\n";
#endif
return Result;
}
Instruction *BytecodeParser::ParseInstruction(const unsigned char *&Buf,
const unsigned char *EndBuf) {
std::auto_ptr<RawInst> Raw = ParseRawInst(Buf, EndBuf);
std::vector<unsigned> Args;
RawInst RI(Buf, EndBuf, Args);
const Type *InstTy = getType(RI.Type);
if (Raw->Opcode >= Instruction::BinaryOpsBegin &&
Raw->Opcode < Instruction::BinaryOpsEnd && Raw->NumOperands == 2)
return BinaryOperator::create((Instruction::BinaryOps)Raw->Opcode,
getValue(Raw->Ty, Raw->Arg1),
getValue(Raw->Ty, Raw->Arg2));
if (RI.Opcode >= Instruction::BinaryOpsBegin &&
RI.Opcode < Instruction::BinaryOpsEnd && Args.size() == 2)
return BinaryOperator::create((Instruction::BinaryOps)RI.Opcode,
getValue(InstTy, Args[0]),
getValue(InstTy, Args[1]));
switch (Raw->Opcode) {
switch (RI.Opcode) {
case Instruction::VarArg:
case Instruction::Cast: {
Value *V = getValue(Raw->Ty, Raw->Arg1);
const Type *Ty = getType(Raw->Arg2);
if (Ty == 0) throw std::string("Invalid cast!\n");
if (Raw->Opcode == Instruction::Cast)
return new CastInst(V, Ty);
else
return new VarArgInst(V, Ty);
}
return new VarArgInst(getValue(InstTy, Args[0]), getType(Args[1]));
case Instruction::Cast:
return new CastInst(getValue(InstTy, Args[0]), getType(Args[1]));
case Instruction::PHINode: {
PHINode *PN = new PHINode(Raw->Ty);
switch (Raw->NumOperands) {
case 0:
case 1:
case 3:
delete PN;
if (Args.size() == 0 || (Args.size() & 1))
throw std::string("Invalid phi node encountered!\n");
case 2:
PN->addIncoming(getValue(Raw->Ty, Raw->Arg1), getBasicBlock(Raw->Arg2));
break;
default:
PN->addIncoming(getValue(Raw->Ty, Raw->Arg1), getBasicBlock(Raw->Arg2));
if (Raw->VarArgs->size() & 1) {
delete PN;
throw std::string("PHI Node with ODD number of arguments!\n");
} else {
std::vector<unsigned> &args = *Raw->VarArgs;
for (unsigned i = 0; i < args.size(); i+=2)
PN->addIncoming(getValue(Raw->Ty, args[i]), getBasicBlock(args[i+1]));
}
delete Raw->VarArgs;
break;
}
PHINode *PN = new PHINode(InstTy);
for (unsigned i = 0, e = Args.size(); i != e; i += 2)
PN->addIncoming(getValue(InstTy, Args[i]), getBasicBlock(Args[i+1]));
return PN;
}
case Instruction::Shl:
case Instruction::Shr:
return new ShiftInst((Instruction::OtherOps)Raw->Opcode,
getValue(Raw->Ty, Raw->Arg1),
getValue(Type::UByteTyID, Raw->Arg2));
return new ShiftInst((Instruction::OtherOps)RI.Opcode,
getValue(InstTy, Args[0]),
getValue(Type::UByteTyID, Args[1]));
case Instruction::Ret:
if (Raw->NumOperands == 0)
if (Args.size() == 0)
return new ReturnInst();
else if (Raw->NumOperands == 1)
return new ReturnInst(getValue(Raw->Ty, Raw->Arg1));
else if (Args.size() == 1)
return new ReturnInst(getValue(InstTy, Args[0]));
break;
case Instruction::Br:
if (Raw->NumOperands == 1)
return new BranchInst(getBasicBlock(Raw->Arg1));
else if (Raw->NumOperands == 3)
return new BranchInst(getBasicBlock(Raw->Arg1), getBasicBlock(Raw->Arg2),
getValue(Type::BoolTyID , Raw->Arg3));
if (Args.size() == 1)
return new BranchInst(getBasicBlock(Args[0]));
else if (Args.size() == 3)
return new BranchInst(getBasicBlock(Args[0]), getBasicBlock(Args[1]),
getValue(Type::BoolTyID , Args[2]));
throw std::string("Invalid number of operands for a 'br' instruction!");
case Instruction::Switch: {
SwitchInst *I = new SwitchInst(getValue(Raw->Ty, Raw->Arg1),
getBasicBlock(Raw->Arg2));
if (Raw->NumOperands < 3)
return I;
if (Raw->NumOperands == 3 || Raw->VarArgs->size() & 1) {
delete I;
if (Args.size() & 1)
throw std::string("Switch statement with odd number of arguments!");
}
std::vector<unsigned> &args = *Raw->VarArgs;
for (unsigned i = 0; i < args.size(); i += 2)
I->addCase(cast<Constant>(getValue(Raw->Ty, args[i])),
getBasicBlock(args[i+1]));
delete Raw->VarArgs;
SwitchInst *I = new SwitchInst(getValue(InstTy, Args[0]),
getBasicBlock(Args[1]));
for (unsigned i = 2, e = Args.size(); i != e; i += 2)
I->addCase(cast<Constant>(getValue(InstTy, Args[i])),
getBasicBlock(Args[i+1]));
return I;
}
case Instruction::Call: {
Value *F = getValue(Raw->Ty, Raw->Arg1);
if (Args.size() == 0)
throw std::string("Invalid call instruction encountered!");
Value *F = getValue(InstTy, Args[0]);
// Check to make sure we have a pointer to function type
const PointerType *PTy = dyn_cast<PointerType>(F->getType());
@ -229,45 +178,26 @@ Instruction *BytecodeParser::ParseInstruction(const unsigned char *&Buf,
if (!FTy->isVarArg()) {
FunctionType::ParamTypes::const_iterator It = PL.begin();
switch (Raw->NumOperands) {
case 0: throw std::string("Invalid call instruction encountered!");
case 1: break;
case 2: Params.push_back(getValue(*It++, Raw->Arg2)); break;
case 3: Params.push_back(getValue(*It++, Raw->Arg2));
if (It == PL.end()) throw std::string("Invalid call instruction!");
Params.push_back(getValue(*It++, Raw->Arg3)); break;
default:
Params.push_back(getValue(*It++, Raw->Arg2));
{
std::vector<unsigned> &args = *Raw->VarArgs;
for (unsigned i = 0; i < args.size(); i++) {
if (It == PL.end()) throw std::string("Invalid call instruction!");
Params.push_back(getValue(*It++, args[i]));
}
}
delete Raw->VarArgs;
for (unsigned i = 1, e = Args.size(); i != e; ++i) {
if (It == PL.end()) throw std::string("Invalid call instruction!");
Params.push_back(getValue(*It++, Args[i]));
}
if (It != PL.end()) throw std::string("Invalid call instruction!");
} else {
if (Raw->NumOperands > 2) {
std::vector<unsigned> &args = *Raw->VarArgs;
if (args.size() < 1) throw std::string("Invalid call instruction!");
// FIXME: Args[1] is currently just a dummy padding field!
if ((args.size() & 1) != 0) // Must be pairs of type/value
throw std::string("Invalid call instruction!");
for (unsigned i = 0; i < args.size(); i+=2) {
const Type *Ty = getType(args[i]);
if (Ty == 0) throw std::string("Invalid call instruction!");
Params.push_back(getValue(Ty, args[i+1]));
}
delete Raw->VarArgs;
}
if (Args.size() & 1) // Must be pairs of type/value
throw std::string("Invalid call instruction!");
for (unsigned i = 2, e = Args.size(); i != e; i += 2)
Params.push_back(getValue(getType(Args[i]), Args[i+1]));
}
return new CallInst(F, Params);
}
case Instruction::Invoke: {
Value *F = getValue(Raw->Ty, Raw->Arg1);
if (Args.size() < 3) throw std::string("Invalid invoke instruction!");
Value *F = getValue(InstTy, Args[0]);
// Check to make sure we have a pointer to function type
const PointerType *PTy = dyn_cast<PointerType>(F->getType());
@ -276,131 +206,99 @@ Instruction *BytecodeParser::ParseInstruction(const unsigned char *&Buf,
if (FTy == 0) throw std::string("Invoke to non function pointer value!");
std::vector<Value *> Params;
const FunctionType::ParamTypes &PL = FTy->getParamTypes();
std::vector<unsigned> &args = *Raw->VarArgs;
BasicBlock *Normal, *Except;
const FunctionType::ParamTypes &PL = FTy->getParamTypes();
if (!FTy->isVarArg()) {
if (Raw->NumOperands < 3) throw std::string("Invalid call instruction!");
Normal = getBasicBlock(Args[1]);
Except = getBasicBlock(Args[2]);
Normal = getBasicBlock(Raw->Arg2);
if (Raw->NumOperands == 3)
Except = getBasicBlock(Raw->Arg3);
else {
Except = getBasicBlock(args[0]);
FunctionType::ParamTypes::const_iterator It = PL.begin();
for (unsigned i = 1; i < args.size(); i++) {
if (It == PL.end()) throw std::string("Invalid invoke instruction!");
Params.push_back(getValue(*It++, args[i]));
}
if (It != PL.end()) throw std::string("Invalid invoke instruction!");
FunctionType::ParamTypes::const_iterator It = PL.begin();
for (unsigned i = 3, e = Args.size(); i != e; ++i) {
if (It == PL.end()) throw std::string("Invalid invoke instruction!");
Params.push_back(getValue(*It++, Args[i]));
}
if (It != PL.end()) throw std::string("Invalid invoke instruction!");
} else {
if (args.size() < 4) throw std::string("Invalid invoke instruction!");
if (args[0] != Type::LabelTyID || args[2] != Type::LabelTyID)
// FIXME: Args[1] is a dummy padding field
if (Args.size() < 6) throw std::string("Invalid invoke instruction!");
if (Args[2] != Type::LabelTyID || Args[4] != Type::LabelTyID)
throw std::string("Invalid invoke instruction!");
Normal = getBasicBlock(args[1]);
Except = getBasicBlock(args[3]);
Normal = getBasicBlock(Args[3]);
Except = getBasicBlock(Args[5]);
if ((args.size() & 1) != 0) // Must be pairs of type/value
if (Args.size() & 1) // Must be pairs of type/value
throw std::string("Invalid invoke instruction!");
for (unsigned i = 4; i < args.size(); i += 2)
Params.push_back(getValue(args[i], args[i+1]));
for (unsigned i = 6; i < Args.size(); i += 2)
Params.push_back(getValue(Args[i], Args[i+1]));
}
if (Raw->NumOperands > 3)
delete Raw->VarArgs;
return new InvokeInst(F, Normal, Except, Params);
}
case Instruction::Malloc:
if (Raw->NumOperands > 2) throw std::string("Invalid malloc instruction!");
if (!isa<PointerType>(Raw->Ty))
if (Args.size() > 2) throw std::string("Invalid malloc instruction!");
if (!isa<PointerType>(InstTy))
throw std::string("Invalid malloc instruction!");
return new MallocInst(cast<PointerType>(Raw->Ty)->getElementType(),
Raw->NumOperands ? getValue(Type::UIntTyID,
Raw->Arg1) : 0);
return new MallocInst(cast<PointerType>(InstTy)->getElementType(),
Args.size() ? getValue(Type::UIntTyID,
Args[0]) : 0);
case Instruction::Alloca:
if (Raw->NumOperands > 2) throw std::string("Invalid alloca instruction!");
if (!isa<PointerType>(Raw->Ty))
if (Args.size() > 2) throw std::string("Invalid alloca instruction!");
if (!isa<PointerType>(InstTy))
throw std::string("Invalid alloca instruction!");
return new AllocaInst(cast<PointerType>(Raw->Ty)->getElementType(),
Raw->NumOperands ? getValue(Type::UIntTyID,
Raw->Arg1) : 0);
return new AllocaInst(cast<PointerType>(InstTy)->getElementType(),
Args.size() ? getValue(Type::UIntTyID,
Args[0]) : 0);
case Instruction::Free:
if (!isa<PointerType>(Raw->Ty))
if (!isa<PointerType>(InstTy))
throw std::string("Invalid free instruction!");
return new FreeInst(getValue(Raw->Ty, Raw->Arg1));
return new FreeInst(getValue(InstTy, Args[0]));
case Instruction::GetElementPtr: {
std::vector<Value*> Idx;
if (!isa<PointerType>(Raw->Ty))
if (Args.size() == 0 || !isa<PointerType>(InstTy))
throw std::string("Invalid getelementptr instruction!");
const CompositeType *TopTy = dyn_cast<CompositeType>(Raw->Ty);
switch (Raw->NumOperands) {
case 0: throw std::string("Invalid getelementptr instruction!");
case 1: break;
case 2:
if (!TopTy) throw std::string("Invalid getelementptr instruction!");
Idx.push_back(getValue(TopTy->getIndexType(), Raw->Arg2));
break;
case 3: {
if (!TopTy) throw std::string("Invalid getelementptr instruction!");
Idx.push_back(getValue(TopTy->getIndexType(), Raw->Arg2));
std::vector<Value*> Idx;
const Type *ETy = GetElementPtrInst::getIndexedType(TopTy, Idx, true);
const CompositeType *ElTy = dyn_cast_or_null<CompositeType>(ETy);
if (!ElTy) throw std::string("Invalid getelementptr instruction!");
Idx.push_back(getValue(ElTy->getIndexType(), Raw->Arg3));
break;
}
default:
if (!TopTy) throw std::string("Invalid getelementptr instruction!");
Idx.push_back(getValue(TopTy->getIndexType(), Raw->Arg2));
std::vector<unsigned> &args = *Raw->VarArgs;
for (unsigned i = 0, E = args.size(); i != E; ++i) {
const Type *ETy = GetElementPtrInst::getIndexedType(Raw->Ty, Idx, true);
const CompositeType *ElTy = dyn_cast_or_null<CompositeType>(ETy);
if (!ElTy) throw std::string("Invalid getelementptr instruction!");
Idx.push_back(getValue(ElTy->getIndexType(), args[i]));
}
delete Raw->VarArgs;
break;
const Type *NextTy = InstTy;
for (unsigned i = 1, e = Args.size(); i != e; ++i) {
const CompositeType *TopTy = dyn_cast_or_null<CompositeType>(NextTy);
if (!TopTy) throw std::string("Invalid getelementptr instruction!");
Idx.push_back(getValue(TopTy->getIndexType(), Args[i]));
NextTy = GetElementPtrInst::getIndexedType(InstTy, Idx, true);
}
return new GetElementPtrInst(getValue(Raw->Ty, Raw->Arg1), Idx);
return new GetElementPtrInst(getValue(InstTy, Args[0]), Idx);
}
case 62: // volatile load
case Instruction::Load:
if (Raw->NumOperands != 1 || !isa<PointerType>(Raw->Ty))
if (Args.size() != 1 || !isa<PointerType>(InstTy))
throw std::string("Invalid load instruction!");
return new LoadInst(getValue(Raw->Ty, Raw->Arg1), "", Raw->Opcode == 62);
return new LoadInst(getValue(InstTy, Args[0]), "", RI.Opcode == 62);
case 63: // volatile store
case Instruction::Store: {
if (!isa<PointerType>(Raw->Ty) || Raw->NumOperands != 2)
if (!isa<PointerType>(InstTy) || Args.size() != 2)
throw std::string("Invalid store instruction!");
Value *Ptr = getValue(Raw->Ty, Raw->Arg2);
Value *Ptr = getValue(InstTy, Args[1]);
const Type *ValTy = cast<PointerType>(Ptr->getType())->getElementType();
return new StoreInst(getValue(ValTy, Raw->Arg1), Ptr, Raw->Opcode == 63);
return new StoreInst(getValue(ValTy, Args[0]), Ptr, RI.Opcode == 63);
}
case Instruction::Unwind:
if (Raw->NumOperands != 0) throw std::string("Invalid unwind instruction!");
if (Args.size() != 0) throw std::string("Invalid unwind instruction!");
return new UnwindInst();
} // end switch(Raw->Opcode)
} // end switch(RI.Opcode)
std::cerr << "Unrecognized instruction! " << Raw->Opcode
std::cerr << "Unrecognized instruction! " << RI.Opcode
<< " ADDR = 0x" << (void*)Buf << "\n";
throw std::string("Unrecognized instruction!");
}

49
lib/Bytecode/Reader/Reader.cpp
View File

@ -49,17 +49,15 @@ unsigned BytecodeParser::getTypeSlot(const Type *Ty) {
}
const Type *BytecodeParser::getType(unsigned ID) {
if (ID < Type::NumPrimitiveIDs) {
const Type *T = Type::getPrimitiveType((Type::PrimitiveID)ID);
if (T) return T;
}
if (ID < Type::NumPrimitiveIDs)
if (const Type *T = Type::getPrimitiveType((Type::PrimitiveID)ID))
return T;
//cerr << "Looking up Type ID: " << ID << "\n";
if (ID < Type::NumPrimitiveIDs) {
const Type *T = Type::getPrimitiveType((Type::PrimitiveID)ID);
if (T) return T; // Asked for a primitive type...
}
if (ID < Type::NumPrimitiveIDs)
if (const Type *T = Type::getPrimitiveType((Type::PrimitiveID)ID))
return T; // Asked for a primitive type...
// Otherwise, derived types need offset...
ID -= FirstDerivedTyID;
@ -73,10 +71,10 @@ const Type *BytecodeParser::getType(unsigned ID) {
if (ID < FunctionTypeValues.size())
return FunctionTypeValues[ID].get();
return 0;
throw std::string("Illegal type reference!");
}
int BytecodeParser::insertValue(Value *Val, ValueTable &ValueTab) {
unsigned BytecodeParser::insertValue(Value *Val, ValueTable &ValueTab) {
assert((!HasImplicitZeroInitializer || !isa<Constant>(Val) ||
Val->getType()->isPrimitiveType() ||
!cast<Constant>(Val)->isNullValue()) &&
@ -200,10 +198,7 @@ BasicBlock *BytecodeParser::ParseBasicBlock(const unsigned char *&Buf,
while (Buf < EndBuf) {
Instruction *Inst = ParseInstruction(Buf, EndBuf);
if (insertValue(Inst, Values) == -1) {
throw std::string("Could not insert value.");
}
insertValue(Inst, Values);
BB->getInstList().push_back(Inst);
BCR_TRACE(4, Inst);
}
@ -221,9 +216,7 @@ void BytecodeParser::ParseSymbolTable(const unsigned char *&Buf,
if (read_vbr(Buf, EndBuf, NumEntries) ||
read_vbr(Buf, EndBuf, Typ)) throw Error_readvbr;
const Type *Ty = getType(Typ);
if (Ty == 0) throw std::string("Invalid type read in symbol table.");
BCR_TRACE(3, "Plane Type: '" << Ty << "' with " << NumEntries <<
BCR_TRACE(3, "Plane Type: '" << *Ty << "' with " << NumEntries <<
" entries\n");
for (unsigned i = 0; i < NumEntries; ++i) {
@ -328,10 +321,8 @@ void BytecodeParser::materializeFunction(Function* F) {
const FunctionType::ParamTypes &Params =F->getFunctionType()->getParamTypes();
Function::aiterator AI = F->abegin();
for (FunctionType::ParamTypes::const_iterator It = Params.begin();
It != Params.end(); ++It, ++AI) {
if (insertValue(AI, Values) == -1)
throw std::string("Error reading function arguments!");
}
It != Params.end(); ++It, ++AI)
insertValue(AI, Values);
// Keep track of how many basic blocks we have read in...
unsigned BlockNum = 0;
@ -435,7 +426,7 @@ void BytecodeParser::ParseModuleGlobalInfo(const unsigned char *&Buf,
}
const Type *Ty = getType(SlotNo);
if (!Ty || !isa<PointerType>(Ty))
if (!isa<PointerType>(Ty))
throw std::string("Global not pointer type! Ty = " +
Ty->getDescription());
@ -444,10 +435,8 @@ void BytecodeParser::ParseModuleGlobalInfo(const unsigned char *&Buf,
// Create the global variable...
GlobalVariable *GV = new GlobalVariable(ElTy, VarType & 1, Linkage,
0, "", TheModule);
int DestSlot = insertValue(GV, ModuleValues);
if (DestSlot == -1) throw Error_DestSlot;
BCR_TRACE(2, "Global Variable of type: " << *Ty << "\n");
ResolveReferencesToValue(GV, (unsigned)DestSlot);
ResolveReferencesToValue(GV, insertValue(GV, ModuleValues));
if (VarType & 2) { // Does it have an initializer?
unsigned InitSlot;
@ -462,11 +451,10 @@ void BytecodeParser::ParseModuleGlobalInfo(const unsigned char *&Buf,
if (read_vbr(Buf, End, FnSignature)) throw Error_readvbr;
while (FnSignature != Type::VoidTyID) { // List is terminated by Void
const Type *Ty = getType(FnSignature);
if (!Ty || !isa<PointerType>(Ty) ||
!isa<FunctionType>(cast<PointerType>(Ty)->getElementType())) {
if (!isa<PointerType>(Ty) ||
!isa<FunctionType>(cast<PointerType>(Ty)->getElementType()))
throw std::string("Function not ptr to func type! Ty = " +
Ty->getDescription());
}
// We create functions by passing the underlying FunctionType to create...
Ty = cast<PointerType>(Ty)->getElementType();
@ -479,9 +467,8 @@ void BytecodeParser::ParseModuleGlobalInfo(const unsigned char *&Buf,
// Insert the placeholder...
Function *Func = new Function(cast<FunctionType>(Ty),
GlobalValue::InternalLinkage, "", TheModule);
int DestSlot = insertValue(Func, ModuleValues);
if (DestSlot == -1) throw Error_DestSlot;
ResolveReferencesToValue(Func, (unsigned)DestSlot);
unsigned DestSlot = insertValue(Func, ModuleValues);
ResolveReferencesToValue(Func, DestSlot);
// Keep track of this information in a list that is emptied as functions are
// loaded...

23
lib/Bytecode/Reader/ReaderInternals.h
View File

@ -14,8 +14,6 @@
#include "llvm/Bytecode/Primitives.h"
#include <utility>
#include <map>
#include <memory>
class Module;
// Enable to trace to figure out what the heck is going on when parsing fails
//#define TRACE_LEVEL 10
@ -27,17 +25,6 @@ class Module;
#define BCR_TRACE(n, X)
#endif
struct RawInst { // The raw fields out of the bytecode stream...
unsigned NumOperands;
unsigned Opcode;
const Type *Ty;
unsigned Arg1, Arg2;
union {
unsigned Arg3;
std::vector<unsigned> *VarArgs; // Contains arg #3,4,5... if NumOperands > 3
};
};
struct LazyFunctionInfo {
const unsigned char *Buf, *EndBuf;
unsigned FunctionSlot;
@ -62,11 +49,9 @@ public:
Module* releaseModule() {
// Since we're losing control of this Module, we must hand it back complete
materializeModule();
Module *M = ModuleProvider::releaseModule();
freeState();
Module *tempM = TheModule;
TheModule = 0;
return tempM;
return M;
}
void ParseBytecode(const unsigned char *Buf, unsigned Length,
@ -165,8 +150,6 @@ private:
Instruction *ParseInstruction(const unsigned char *&Buf,
const unsigned char *End);
std::auto_ptr<RawInst> ParseRawInst(const unsigned char *&Buf,
const unsigned char *End);
void ParseConstantPool(const unsigned char *&Buf, const unsigned char *EndBuf,
ValueTable &Tab, TypeValuesListTy &TypeTab);
@ -185,7 +168,7 @@ private:
BasicBlock *getBasicBlock(unsigned ID);
Constant *getConstantValue(const Type *Ty, unsigned num);
int insertValue(Value *V, ValueTable &Table); // -1 = Failure
unsigned insertValue(Value *V, ValueTable &Table);
unsigned getTypeSlot(const Type *Ty);