/**
* Print a getelementptr instruction.
*
* @param v the aggregate data structure to index
* @param i an iterator to the first type indexed by the instruction
* @param e an iterator specifying the upper bound on the types indexed by the
* instruction
*/
void JVMWriter::printGepInstruction(const Value *v,
gep_type_iterator i,
gep_type_iterator e) {
// load address
printCastInstruction(Instruction::IntToPtr, v, NULL, v->getType());
// calculate offset
for(; i != e; i++) {
unsigned int size = 0;
const Value *indexValue = i.getOperand();
if(const StructType *structTy = dyn_cast<StructType>(*i)) {
for(unsigned int f = 0,
fieldIndex = cast<ConstantInt>(indexValue)->getZExtValue();
f < fieldIndex; f++)
size = alignOffset(
size + targetData->getTypeAllocSize(
structTy->getContainedType(f)),
targetData->getABITypeAlignment(
structTy->getContainedType(f + 1)));
printPtrLoad(size);
printSimpleInstruction("iadd");
} else {
if(const SequentialType *seqTy = dyn_cast<SequentialType>(*i))
size = targetData->getTypeAllocSize(seqTy->getElementType());
else
size = targetData->getTypeAllocSize(*i);
if(const ConstantInt *c = dyn_cast<ConstantInt>(indexValue)) {
// constant optimisation
if(c->isNullValue()) {
// do nothing
} else if(c->getValue().isNegative()) {
printPtrLoad(c->getValue().abs().getZExtValue() * size);
printSimpleInstruction("isub");
} else {
printPtrLoad(c->getZExtValue() * size);
printSimpleInstruction("iadd");
}
} else {
printPtrLoad(size);
printCastInstruction(Instruction::IntToPtr, indexValue,
NULL, indexValue->getType());
printSimpleInstruction("imul");
printSimpleInstruction("iadd");
}
}
}
}
/**
* Print a cast instruction.
*
* @param op the opcode for the instruction
* @param v the value to be casted
* @param ty the destination type
* @param srcTy the source type
*/
void JVMWriter::printCastInstruction(unsigned int op, const Value *v,
const Type *ty, const Type *srcTy) {
printValueLoad(v);
switch(op) {
case Instruction::SIToFP:
case Instruction::FPToSI:
case Instruction::FPTrunc:
case Instruction::FPExt:
case Instruction::SExt:
if(getBitWidth(srcTy) < 32)
printCastInstruction(getTypePrefix(srcTy), "i");
printCastInstruction(getTypePrefix(ty, true),
getTypePrefix(srcTy, true));
break;
case Instruction::Trunc:
if(getBitWidth(srcTy) == 64 && getBitWidth(ty) < 32) {
printSimpleInstruction("l2i");
printCastInstruction(getTypePrefix(ty), "i");
} else
printCastInstruction(getTypePrefix(ty),
getTypePrefix(srcTy, true));
break;
case Instruction::IntToPtr:
printCastInstruction("i", getTypePrefix(srcTy, true));
break;
case Instruction::PtrToInt:
printCastInstruction(getTypePrefix(ty), "i");
break;
case Instruction::ZExt:
printVirtualInstruction("zext_" + getTypePostfix(ty, true)
+ "(" + getTypeDescriptor(srcTy) + ")"
+ getTypeDescriptor(ty, true));
break;
case Instruction::UIToFP:
printVirtualInstruction("uitofp_" + getTypePostfix(ty)
+ "(" + getTypeDescriptor(srcTy) + ")" + getTypeDescriptor(ty));
break;
case Instruction::FPToUI:
printVirtualInstruction("fptoui_" + getTypePostfix(ty)
+ "(" + getTypeDescriptor(srcTy) + ")" + getTypeDescriptor(ty));
break;
case Instruction::BitCast:
printBitCastInstruction(ty, srcTy);
break;
default:
errs() << "Opcode = " << op << '\n';
llvm_unreachable("Invalid cast instruction");
}
}
/**
* Print the given instruction.
*
* @param inst the instruction
*/
void JVMWriter::printInstruction(const Instruction *inst) {
const Value *left, *right;
if(inst->getNumOperands() >= 1) left = inst->getOperand(0);
if(inst->getNumOperands() >= 2) right = inst->getOperand(1);
switch(inst->getOpcode()) {
case Instruction::Ret:
printStartInvocationTag();
printEndInvocationTag("lljvm/runtime/Memory/destroyStackFrame()V");
if(inst->getNumOperands() >= 1) {
printValueLoad(left);
printSimpleInstruction(
getTypePrefix(left->getType(), true) + "return");
} else {
printSimpleInstruction("return");
}
break;
case Instruction::Unwind:
printSimpleInstruction("getstatic",
"lljvm/runtime/Instruction$Unwind/instance "
"Llljvm/runtime/Instruction$Unwind;");
printSimpleInstruction("athrow");
// TODO: need to destroy stack frames
break;
case Instruction::Unreachable:
printSimpleInstruction("getstatic",
"lljvm/runtime/Instruction$Unreachable/instance "
"Llljvm/runtime/Instruction$Unreachable;");
printSimpleInstruction("athrow");
break;
case Instruction::Add:
case Instruction::FAdd:
case Instruction::Sub:
case Instruction::FSub:
case Instruction::Mul:
case Instruction::FMul:
case Instruction::UDiv:
case Instruction::SDiv:
case Instruction::FDiv:
case Instruction::URem:
case Instruction::SRem:
case Instruction::FRem:
case Instruction::And:
case Instruction::Or:
case Instruction::Xor:
case Instruction::Shl:
case Instruction::LShr:
case Instruction::AShr:
printArithmeticInstruction(inst->getOpcode(), left, right);
break;
case Instruction::SExt:
case Instruction::Trunc:
case Instruction::ZExt:
case Instruction::FPTrunc:
case Instruction::FPExt:
case Instruction::UIToFP:
case Instruction::SIToFP:
case Instruction::FPToUI:
case Instruction::FPToSI:
case Instruction::PtrToInt:
case Instruction::IntToPtr:
case Instruction::BitCast:
printCastInstruction(inst->getOpcode(), left,
cast<CastInst>(inst)->getDestTy(),
cast<CastInst>(inst)->getSrcTy()); break;
case Instruction::ICmp:
case Instruction::FCmp:
printCmpInstruction(cast<CmpInst>(inst)->getPredicate(),
left, right); break;
case Instruction::Br:
printBranchInstruction(cast<BranchInst>(inst)); break;
case Instruction::Select:
printSelectInstruction(inst->getOperand(0),
inst->getOperand(1),
inst->getOperand(2)); break;
case Instruction::Load:
printIndirectLoad(inst->getOperand(0)); break;
case Instruction::Store:
printIndirectStore(inst->getOperand(1), inst->getOperand(0)); break;
case Instruction::GetElementPtr:
printGepInstruction(inst->getOperand(0),
gep_type_begin(inst),
gep_type_end(inst)); break;
case Instruction::Call:
printCallInstruction(cast<CallInst>(inst)); break;
case Instruction::Invoke:
printInvokeInstruction(cast<InvokeInst>(inst)); break;
case Instruction::Switch:
printSwitchInstruction(cast<SwitchInst>(inst)); break;
case Instruction::Alloca:
printAllocaInstruction(cast<AllocaInst>(inst)); break;
case Instruction::VAArg:
printVAArgInstruction(cast<VAArgInst>(inst)); break;
default:
errs() << "Instruction = " << *inst << '\n';
llvm_unreachable("Unsupported instruction");
}
}
