Implementation of Store & GetElementPtr
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@164 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Bytecode/Reader/InstructionReader.cpp b/lib/Bytecode/Reader/InstructionReader.cpp
index 9dc5c6f..3af40f2 100644
--- a/lib/Bytecode/Reader/InstructionReader.cpp
+++ b/lib/Bytecode/Reader/InstructionReader.cpp
@@ -242,7 +242,8 @@
Res = new FreeInst(V);
return false;
- case Instruction::Load: {
+ case Instruction::Load:
+ case Instruction::GetElementPtr: {
vector<ConstPoolVal*> Idx;
switch (Raw.NumOperands) {
case 0: cerr << "Invalid load encountered!\n"; return true;
@@ -271,7 +272,39 @@
delete Raw.VarArgs;
break;
}
- Res = new LoadInst(getValue(Raw.Ty, Raw.Arg1), Idx);
+ if (Raw.Opcode == Instruction::Load)
+ Res = new LoadInst(getValue(Raw.Ty, Raw.Arg1), Idx);
+ else if (Raw.Opcode == Instruction::GetElementPtr)
+ Res = new GetElementPtrInst(getValue(Raw.Ty, Raw.Arg1), Idx);
+ else
+ abort();
+ return false;
+ }
+ case Instruction::Store: {
+ vector<ConstPoolVal*> Idx;
+ switch (Raw.NumOperands) {
+ case 0:
+ case 1: cerr << "Invalid store encountered!\n"; return true;
+ case 2: break;
+ case 3: V = getValue(Type::UByteTy, Raw.Arg3);
+ if (!V->isConstant()) return true;
+ Idx.push_back(V->castConstant());
+ break;
+ default:
+ vector<unsigned> &args = *Raw.VarArgs;
+ for (unsigned i = 0, E = args.size(); i != E; ++i) {
+ V = getValue(Type::UByteTy, args[i]);
+ if (!V->isConstant()) return true;
+ Idx.push_back(V->castConstant());
+ }
+ delete Raw.VarArgs;
+ break;
+ }
+
+ const Type *ElType = StoreInst::getIndexedType(Raw.Ty, Idx);
+ if (ElType == 0) return true;
+ Res = new StoreInst(getValue(ElType, Raw.Arg1), getValue(Raw.Ty, Raw.Arg2),
+ Idx);
return false;
}
} // end switch(Raw.Opcode)
diff --git a/lib/Bytecode/Writer/InstructionWriter.cpp b/lib/Bytecode/Writer/InstructionWriter.cpp
index 34d9568..73969e6 100644
--- a/lib/Bytecode/Writer/InstructionWriter.cpp
+++ b/lib/Bytecode/Writer/InstructionWriter.cpp
@@ -135,10 +135,19 @@
// the first param is actually interesting). But if we have no arguments
// we take the type of the instruction itself.
//
- const Type *Ty = NumOperands ? I->getOperand(0)->getType() : I->getType();
- if (I->getOpcode() == Instruction::Malloc ||
- I->getOpcode() == Instruction::Alloca)
+ const Type *Ty;
+ switch (I->getOpcode()) {
+ case Instruction::Malloc:
+ case Instruction::Alloca:
Ty = I->getType(); // Malloc & Alloca ALWAYS want to encode the return type
+ break;
+ case Instruction::Store:
+ Ty = I->getOperand(1)->getType(); // Encode the pointer type...
+ break;
+ default: // Otherwise use the default behavior...
+ Ty = NumOperands ? I->getOperand(0)->getType() : I->getType();
+ break;
+ }
unsigned Type;
int Slot = Table.getValSlot(Ty);
@@ -184,8 +193,8 @@
break;
}
- // If we weren't handled before here, we either have a large number of operands
- // or a large operand index that we are refering to.
+ // If we weren't handled before here, we either have a large number of
+ // operands or a large operand index that we are refering to.
outputInstructionFormat0(I, Table, Type, Out);
return false;
}