/** * 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 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 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"); } }
/** * Store a value at the given address. * * @param ptr the address at which to store the value * @param val the value to store */ void JVMWriter::printIndirectStore(const Value *ptr, const Value *val) { printValueLoad(ptr); printValueLoad(val); printIndirectStore(val->getType()); }