* Use new style casts more
* Add real support for global variable addresses initializing constants
* Fix encoding/decoding of VarArgs calls
* Support the Invoke instruction
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@761 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Bytecode/Writer/ConstantWriter.cpp b/lib/Bytecode/Writer/ConstantWriter.cpp
index d0c58f1..8a252dd 100644
--- a/lib/Bytecode/Writer/ConstantWriter.cpp
+++ b/lib/Bytecode/Writer/ConstantWriter.cpp
@@ -101,14 +101,14 @@
case Type::UShortTyID:
case Type::UIntTyID:
case Type::ULongTyID:
- output_vbr(((const ConstPoolUInt*)CPV)->getValue(), Out);
+ output_vbr(cast<const ConstPoolUInt>(CPV)->getValue(), Out);
break;
case Type::SByteTyID: // Signed integer types...
case Type::ShortTyID:
case Type::IntTyID:
case Type::LongTyID:
- output_vbr(((const ConstPoolSInt*)CPV)->getValue(), Out);
+ output_vbr(cast<const ConstPoolSInt>(CPV)->getValue(), Out);
break;
case Type::TypeTyID: // Serialize type type
@@ -116,7 +116,7 @@
break;
case Type::ArrayTyID: {
- const ConstPoolArray *CPA = (const ConstPoolArray *)CPV;
+ const ConstPoolArray *CPA = cast<const ConstPoolArray>(CPV);
unsigned size = CPA->getValues().size();
if (!((const ArrayType *)CPA->getType())->isSized())
output_vbr(size, Out); // Not for sized arrays!!!
@@ -130,7 +130,7 @@
}
case Type::StructTyID: {
- const ConstPoolStruct *CPS = (const ConstPoolStruct*)CPV;
+ const ConstPoolStruct *CPS = cast<const ConstPoolStruct>(CPV);
const vector<Use> &Vals = CPS->getValues();
for (unsigned i = 0; i < Vals.size(); ++i) {
@@ -142,17 +142,28 @@
}
case Type::PointerTyID: {
- output_vbr((unsigned)0, Out);
+ const ConstPoolPointer *CPP = cast<const ConstPoolPointer>(CPV);
+ if (isa<ConstPoolPointerNull>(CPP)) {
+ output_vbr((unsigned)0, Out);
+ } else if (const ConstPoolPointerReference *CPR =
+ dyn_cast<ConstPoolPointerReference>(CPP)) {
+ output_vbr((unsigned)1, Out);
+ int Slot = Table.getValSlot((Value*)CPR->getValue());
+ assert(Slot != -1 && "Global used but not available!!");
+ output_vbr((unsigned)Slot, Out);
+ } else {
+ assert(0 && "Unknown ConstPoolPointer Subclass!");
+ }
break;
}
case Type::FloatTyID: { // Floating point types...
- float Tmp = (float)((const ConstPoolFP*)CPV)->getValue();
+ float Tmp = (float)cast<ConstPoolFP>(CPV)->getValue();
output_data(&Tmp, &Tmp+1, Out);
break;
}
case Type::DoubleTyID: {
- double Tmp = ((const ConstPoolFP*)CPV)->getValue();
+ double Tmp = cast<ConstPoolFP>(CPV)->getValue();
output_data(&Tmp, &Tmp+1, Out);
break;
}
diff --git a/lib/Bytecode/Writer/InstructionWriter.cpp b/lib/Bytecode/Writer/InstructionWriter.cpp
index d8e17e2..c972a7c 100644
--- a/lib/Bytecode/Writer/InstructionWriter.cpp
+++ b/lib/Bytecode/Writer/InstructionWriter.cpp
@@ -16,6 +16,7 @@
#include "llvm/Instruction.h"
#include "llvm/DerivedTypes.h"
#include "llvm/iOther.h"
+#include "llvm/iTerminators.h"
#include <algorithm>
typedef unsigned char uchar;
@@ -56,26 +57,29 @@
static void outputInstrVarArgsCall(const Instruction *I,
const SlotCalculator &Table, unsigned Type,
deque<uchar> &Out) {
- assert(I->getOpcode() == Instruction::Call /*||
- I->getOpcode() == Instruction::ICall */);
+ assert(isa<CallInst>(I) || isa<InvokeInst>(I));
// Opcode must have top two bits clear...
output_vbr(I->getOpcode(), Out); // Instruction Opcode ID
output_vbr(Type, Out); // Result type (varargs type)
unsigned NumArgs = I->getNumOperands();
- output_vbr((NumArgs-2)*2+2, Out); // Don't duplicate method & Arg1 types
+ output_vbr(NumArgs*2, Out);
+ // TODO: Don't need to emit types for the fixed types of the varargs method
+ // prototype...
- // Output the method type without an extra type argument.
+ // The type for the method has already been emitted in the type field of the
+ // instruction. Just emit the slot # now.
int Slot = Table.getValSlot(I->getOperand(0));
assert(Slot >= 0 && "No slot number for value!?!?");
output_vbr((unsigned)Slot, Out);
- // VarArgs methods must have at least one specified operand
- Slot = Table.getValSlot(I->getOperand(1));
- assert(Slot >= 0 && "No slot number for value!?!?");
- output_vbr((unsigned)Slot, Out);
+ // Output a dummy field to fill Arg#2 in the reader that is currently unused
+ // for varargs calls. This is a gross hack to make the code simpler, but we
+ // aren't really doing very small bytecode for varargs calls anyways.
+ // FIXME in the future: Smaller bytecode for varargs calls
+ output_vbr(0, Out);
- for (unsigned i = 2; i < NumArgs; ++i) {
+ for (unsigned i = 1; i < NumArgs; ++i) {
// Output Arg Type ID
Slot = Table.getValSlot(I->getOperand(i)->getType());
assert(Slot >= 0 && "No slot number for value!?!?");
@@ -159,8 +163,6 @@
output(Opcode, Out);
}
-#include "llvm/Assembly/Writer.h"
-
void BytecodeWriter::processInstruction(const Instruction *I) {
assert(I->getOpcode() < 64 && "Opcode too big???");
@@ -216,7 +218,14 @@
if (Slots[1] > MaxOpSlot) MaxOpSlot = Slots[1];
NumOperands++;
} else if (const CallInst *CI = dyn_cast<CallInst>(I)) {// Handle VarArg calls
- if (CI->getCalledMethod()->getMethodType()->isVarArg()) {
+ PointerType *Ty = cast<PointerType>(CI->getCalledValue()->getType());
+ if (cast<MethodType>(Ty->getValueType())->isVarArg()) {
+ outputInstrVarArgsCall(I, Table, Type, Out);
+ return;
+ }
+ } else if (const InvokeInst *II = dyn_cast<InvokeInst>(I)) { // ... & Invokes
+ PointerType *Ty = cast<PointerType>(II->getCalledValue()->getType());
+ if (cast<MethodType>(Ty->getValueType())->isVarArg()) {
outputInstrVarArgsCall(I, Table, Type, Out);
return;
}
diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp
index 5df2fda..ffe67a3 100644
--- a/lib/Bytecode/Writer/Writer.cpp
+++ b/lib/Bytecode/Writer/Writer.cpp
@@ -61,9 +61,6 @@
outputSymbolTable(*M->getSymbolTable());
}
-// TODO: REMOVE
-#include "llvm/Assembly/Writer.h"
-
void BytecodeWriter::outputConstants(bool isMethod) {
BytecodeBlock CPool(BytecodeFormat::ConstantPool, Out);
@@ -109,8 +106,7 @@
// << Out.size() << "\n";
outputConstant(CPV);
} else {
- const Type *Ty = cast<const Type>(V);
- outputType(Ty);
+ outputType(cast<const Type>(V));
}
}
}
@@ -130,7 +126,7 @@
isa<ConstPoolVal>(GV);
output_vbr(oSlot, Out);
- // If we have an initialized, output it now.
+ // If we have an initializer, output it now.
if (GV->hasInitializer()) {
Slot = Table.getValSlot(GV->getInitializer());
assert(Slot != -1 && "No slot for global var initializer!");