/**
* Load a value from the given address.
*
* @param v the address
*/
void JVMWriter::printIndirectLoad(const Value *v) {
printValueLoad(v);
const Type *ty = v->getType();
if(const PointerType *p = dyn_cast<PointerType>(ty))
ty = p->getElementType();
printIndirectLoad(ty);
}
/**
* Print a va_arg instruction.
*
* @param inst the instruction
*/
void JVMWriter::printVAArgInstruction(const VAArgInst *inst) {
printIndirectLoad(inst->getOperand(0));
printSimpleInstruction("dup");
// op op
printLoadMemoryToStack( );
// op op memory
printSimpleInstruction("swap");
// op memory op
printConstLoad(
APInt(32, targetData->getTypeAllocSize(inst->getType()), false));
// op memory op const
printSimpleInstruction("iadd");
// op memory added
printValueLoad(inst->getOperand(0));
// op memory added loaded
printSimpleInstruction("swap");
// op memory loaded added
printIndirectStore(PointerType::getUnqual(
IntegerType::get(inst->getContext(), 8)));
// op
printIndirectLoad(inst->getType());
}
/**
* Print a vararg intrinsic function.
*
* @param inst the instruction
*/
void JVMWriter::printVAIntrinsic(const IntrinsicInst *inst) {
const Type *valistTy = PointerType::getUnqual(
IntegerType::get(inst->getContext(), 8));
switch(inst->getIntrinsicID()) {
case Intrinsic::vastart:
printLoadMemoryToStack( );
printValueLoad(inst->getOperand(1));
printSimpleInstruction("iload", utostr(vaArgNum) + " ; varargptr");
printIndirectStore(valistTy);
break;
case Intrinsic::vacopy:
printLoadMemoryToStack( );
printValueLoad(inst->getOperand(1));
printValueLoad(inst->getOperand(2));
printIndirectLoad(valistTy);
printIndirectStore(valistTy);
break;
case Intrinsic::vaend:
break;
}
}
/**
* 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");
}
}
