mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-10-19 02:25:35 +00:00
* Remove CInstPrintVisitor class, incorporating it into the CWriter class
* Reorder code in the file to make it more logically laid out. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2586 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
497e19aee0
commit
4fbf26d2fc
@ -45,20 +45,10 @@ static std::string getConstArrayStrValue(const Constant* CPV) {
|
|||||||
const Type *ETy = cast<ArrayType>(CPV->getType())->getElementType();
|
const Type *ETy = cast<ArrayType>(CPV->getType())->getElementType();
|
||||||
bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy);
|
bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy);
|
||||||
|
|
||||||
if (ETy == Type::SByteTy) {
|
|
||||||
for (unsigned i = 0; i < CPV->getNumOperands(); ++i)
|
|
||||||
if (ETy == Type::SByteTy &&
|
|
||||||
cast<ConstantSInt>(CPV->getOperand(i))->getValue() < 0) {
|
|
||||||
isString = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (isString) {
|
|
||||||
// Make sure the last character is a null char, as automatically added by C
|
// Make sure the last character is a null char, as automatically added by C
|
||||||
if (CPV->getNumOperands() == 0 ||
|
if (CPV->getNumOperands() == 0 ||
|
||||||
!cast<Constant>(*(CPV->op_end()-1))->isNullValue())
|
!cast<Constant>(*(CPV->op_end()-1))->isNullValue())
|
||||||
isString = false;
|
isString = false;
|
||||||
}
|
|
||||||
|
|
||||||
if (isString) {
|
if (isString) {
|
||||||
Result = "\"";
|
Result = "\"";
|
||||||
@ -101,30 +91,21 @@ static std::string getConstArrayStrValue(const Constant* CPV) {
|
|||||||
|
|
||||||
static std::string getConstStrValue(const Constant* CPV) {
|
static std::string getConstStrValue(const Constant* CPV) {
|
||||||
switch (CPV->getType()->getPrimitiveID()) {
|
switch (CPV->getType()->getPrimitiveID()) {
|
||||||
case Type::BoolTyID:
|
case Type::BoolTyID: return CPV == ConstantBool::False ? "0" : "1";
|
||||||
return CPV == ConstantBool::False ? "0" : "1";
|
|
||||||
case Type::SByteTyID:
|
case Type::SByteTyID:
|
||||||
case Type::ShortTyID:
|
case Type::ShortTyID:
|
||||||
case Type::IntTyID:
|
case Type::IntTyID: return itostr(cast<ConstantSInt>(CPV)->getValue());
|
||||||
return itostr(cast<ConstantSInt>(CPV)->getValue());
|
case Type::LongTyID: return itostr(cast<ConstantSInt>(CPV)->getValue())+"ll";
|
||||||
case Type::LongTyID:
|
|
||||||
return itostr(cast<ConstantSInt>(CPV)->getValue()) + "ll";
|
|
||||||
|
|
||||||
case Type::UByteTyID:
|
case Type::UByteTyID:
|
||||||
return utostr(cast<ConstantUInt>(CPV)->getValue());
|
case Type::UShortTyID:return utostr(cast<ConstantUInt>(CPV)->getValue());
|
||||||
case Type::UShortTyID:
|
case Type::UIntTyID: return utostr(cast<ConstantUInt>(CPV)->getValue())+"u";
|
||||||
return utostr(cast<ConstantUInt>(CPV)->getValue());
|
case Type::ULongTyID:return utostr(cast<ConstantUInt>(CPV)->getValue())+"ull";
|
||||||
case Type::UIntTyID:
|
|
||||||
return utostr(cast<ConstantUInt>(CPV)->getValue())+"u";
|
|
||||||
case Type::ULongTyID:
|
|
||||||
return utostr(cast<ConstantUInt>(CPV)->getValue())+"ull";
|
|
||||||
|
|
||||||
case Type::FloatTyID:
|
case Type::FloatTyID:
|
||||||
case Type::DoubleTyID:
|
case Type::DoubleTyID: return ftostr(cast<ConstantFP>(CPV)->getValue());
|
||||||
return ftostr(cast<ConstantFP>(CPV)->getValue());
|
|
||||||
|
|
||||||
case Type::ArrayTyID:
|
case Type::ArrayTyID: return getConstArrayStrValue(CPV);
|
||||||
return getConstArrayStrValue(CPV);
|
|
||||||
|
|
||||||
case Type::StructTyID: {
|
case Type::StructTyID: {
|
||||||
std::string Result = "{";
|
std::string Result = "{";
|
||||||
@ -192,8 +173,7 @@ static string calcTypeNameVar(const Type *Ty,
|
|||||||
Result += ", ";
|
Result += ", ";
|
||||||
Result += "...";
|
Result += "...";
|
||||||
}
|
}
|
||||||
Result += ")";
|
return Result + ")";
|
||||||
break;
|
|
||||||
}
|
}
|
||||||
case Type::StructTyID: {
|
case Type::StructTyID: {
|
||||||
const StructType *STy = cast<const StructType>(Ty);
|
const StructType *STy = cast<const StructType>(Ty);
|
||||||
@ -205,33 +185,30 @@ static string calcTypeNameVar(const Type *Ty,
|
|||||||
Result += " " +calcTypeNameVar(*I, TypeNames, "field" + utostr(indx++));
|
Result += " " +calcTypeNameVar(*I, TypeNames, "field" + utostr(indx++));
|
||||||
Result += ";\n";
|
Result += ";\n";
|
||||||
}
|
}
|
||||||
Result += "}";
|
return Result + "}";
|
||||||
break;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
case Type::PointerTyID: {
|
case Type::PointerTyID: {
|
||||||
Result = calcTypeNameVar(cast<const PointerType>(Ty)->getElementType(),
|
return calcTypeNameVar(cast<const PointerType>(Ty)->getElementType(),
|
||||||
TypeNames, "*" + NameSoFar);
|
TypeNames, "*" + NameSoFar);
|
||||||
break;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
case Type::ArrayTyID: {
|
case Type::ArrayTyID: {
|
||||||
const ArrayType *ATy = cast<const ArrayType>(Ty);
|
const ArrayType *ATy = cast<const ArrayType>(Ty);
|
||||||
int NumElements = ATy->getNumElements();
|
int NumElements = ATy->getNumElements();
|
||||||
Result = calcTypeNameVar(ATy->getElementType(), TypeNames,
|
return calcTypeNameVar(ATy->getElementType(), TypeNames,
|
||||||
NameSoFar + "[" + itostr(NumElements) + "]");
|
NameSoFar + "[" + itostr(NumElements) + "]");
|
||||||
break;
|
|
||||||
}
|
}
|
||||||
default:
|
default:
|
||||||
assert(0 && "Unhandled case in getTypeProps!");
|
assert(0 && "Unhandled case in getTypeProps!");
|
||||||
Result = "<error>";
|
abort();
|
||||||
}
|
}
|
||||||
|
|
||||||
return Result;
|
return Result;
|
||||||
}
|
}
|
||||||
|
|
||||||
namespace {
|
namespace {
|
||||||
class CWriter {
|
class CWriter : public InstVisitor<CWriter> {
|
||||||
ostream& Out;
|
ostream& Out;
|
||||||
SlotCalculator &Table;
|
SlotCalculator &Table;
|
||||||
const Module *TheModule;
|
const Module *TheModule;
|
||||||
@ -254,8 +231,8 @@ namespace {
|
|||||||
void writeOperand(const Value *Operand);
|
void writeOperand(const Value *Operand);
|
||||||
|
|
||||||
string getValueName(const Value *V);
|
string getValueName(const Value *V);
|
||||||
private :
|
|
||||||
|
|
||||||
|
private :
|
||||||
void printModule(Module *M);
|
void printModule(Module *M);
|
||||||
void printSymbolTable(const SymbolTable &ST);
|
void printSymbolTable(const SymbolTable &ST);
|
||||||
void printGlobal(const GlobalVariable *GV);
|
void printGlobal(const GlobalVariable *GV);
|
||||||
@ -263,307 +240,42 @@ namespace {
|
|||||||
void printFunctionDecl(const Function *F); // Print just the forward decl
|
void printFunctionDecl(const Function *F); // Print just the forward decl
|
||||||
|
|
||||||
void printFunction(Function *);
|
void printFunction(Function *);
|
||||||
};
|
|
||||||
/* END class CWriter */
|
|
||||||
}
|
|
||||||
|
|
||||||
namespace {
|
// Instruction visitation functions
|
||||||
/* CLASS CInstPrintVisitor */
|
friend class InstVisitor<CWriter>;
|
||||||
|
|
||||||
class CInstPrintVisitor: public InstVisitor<CInstPrintVisitor> {
|
void visitReturnInst(ReturnInst *I);
|
||||||
CWriter& CW;
|
void visitBranchInst(BranchInst *I);
|
||||||
SlotCalculator& Table;
|
|
||||||
ostream &Out;
|
|
||||||
|
|
||||||
void outputLValue(Instruction *);
|
void visitPHINode(PHINode *I) {}
|
||||||
void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock,
|
void visitNot(GenericUnaryInst *I);
|
||||||
unsigned Indent);
|
void visitBinaryOperator(Instruction *I);
|
||||||
void printIndexingExpr(MemAccessInst *MAI);
|
|
||||||
|
|
||||||
public:
|
|
||||||
CInstPrintVisitor (CWriter &cw, SlotCalculator& table, ostream& o)
|
|
||||||
: CW(cw), Table(table), Out(o) {}
|
|
||||||
|
|
||||||
void visitCastInst(CastInst *I);
|
void visitCastInst(CastInst *I);
|
||||||
void visitCallInst(CallInst *I);
|
void visitCallInst(CallInst *I);
|
||||||
void visitShiftInst(ShiftInst *I) { visitBinaryOperator(I); }
|
void visitShiftInst(ShiftInst *I) { visitBinaryOperator(I); }
|
||||||
void visitReturnInst(ReturnInst *I);
|
|
||||||
void visitBranchInst(BranchInst *I);
|
|
||||||
void visitSwitchInst(SwitchInst *I);
|
|
||||||
void visitInvokeInst(InvokeInst *I) ;
|
|
||||||
void visitMallocInst(MallocInst *I);
|
void visitMallocInst(MallocInst *I);
|
||||||
void visitAllocaInst(AllocaInst *I);
|
void visitAllocaInst(AllocaInst *I);
|
||||||
void visitFreeInst(FreeInst *I);
|
void visitFreeInst(FreeInst *I);
|
||||||
void visitLoadInst(LoadInst *I);
|
void visitLoadInst(LoadInst *I);
|
||||||
void visitStoreInst(StoreInst *I);
|
void visitStoreInst(StoreInst *I);
|
||||||
void visitGetElementPtrInst(GetElementPtrInst *I);
|
void visitGetElementPtrInst(GetElementPtrInst *I);
|
||||||
void visitPHINode(PHINode *I) {}
|
|
||||||
|
|
||||||
void visitNot(GenericUnaryInst *I);
|
void visitInstruction(Instruction *I) {
|
||||||
void visitBinaryOperator(Instruction *I);
|
cerr << "C Writer does not know about " << I;
|
||||||
|
abort();
|
||||||
|
}
|
||||||
|
|
||||||
|
void outputLValue(Instruction *I) {
|
||||||
|
Out << " " << getValueName(I) << " = ";
|
||||||
|
}
|
||||||
|
void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock,
|
||||||
|
unsigned Indent);
|
||||||
|
void printIndexingExpr(MemAccessInst *MAI);
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
void CInstPrintVisitor::outputLValue(Instruction *I) {
|
|
||||||
Out << " " << CW.getValueName(I) << " = ";
|
|
||||||
}
|
|
||||||
|
|
||||||
// Implement all "other" instructions, except for PHINode
|
|
||||||
void CInstPrintVisitor::visitCastInst(CastInst *I) {
|
|
||||||
outputLValue(I);
|
|
||||||
Out << "(";
|
|
||||||
CW.printType(I->getType());
|
|
||||||
Out << ")";
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitCallInst(CallInst *I) {
|
|
||||||
if (I->getType() != Type::VoidTy)
|
|
||||||
outputLValue(I);
|
|
||||||
else
|
|
||||||
Out << " ";
|
|
||||||
|
|
||||||
const PointerType *PTy = cast<PointerType>(I->getCalledValue()->getType());
|
|
||||||
const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
|
|
||||||
const Type *RetTy = FTy->getReturnType();
|
|
||||||
|
|
||||||
Out << CW.getValueName(I->getOperand(0)) << "(";
|
|
||||||
|
|
||||||
if (I->getNumOperands() > 1) {
|
|
||||||
CW.writeOperand(I->getOperand(1));
|
|
||||||
|
|
||||||
for (unsigned op = 2, Eop = I->getNumOperands(); op != Eop; ++op) {
|
|
||||||
Out << ", ";
|
|
||||||
CW.writeOperand(I->getOperand(op));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Out << ");\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
// Specific Instruction type classes... note that all of the casts are
|
|
||||||
// neccesary because we use the instruction classes as opaque types...
|
|
||||||
//
|
|
||||||
void CInstPrintVisitor::visitReturnInst(ReturnInst *I) {
|
|
||||||
// Don't output a void return if this is the last basic block in the function
|
|
||||||
if (I->getNumOperands() == 0 &&
|
|
||||||
*(I->getParent()->getParent()->end()-1) == I->getParent())
|
|
||||||
return;
|
|
||||||
|
|
||||||
Out << " return";
|
|
||||||
if (I->getNumOperands()) {
|
|
||||||
Out << " ";
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
}
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
// Return true if BB1 immediately preceeds BB2.
|
|
||||||
static bool BBFollowsBB(BasicBlock *BB1, BasicBlock *BB2) {
|
|
||||||
Function *F = BB1->getParent();
|
|
||||||
Function::iterator I = find(F->begin(), F->end(), BB1);
|
|
||||||
assert(I != F->end() && "BB not in function!");
|
|
||||||
return *(I+1) == BB2;
|
|
||||||
}
|
|
||||||
|
|
||||||
static bool isGotoCodeNeccessary(BasicBlock *From, BasicBlock *To) {
|
|
||||||
// If PHI nodes need copies, we need the copy code...
|
|
||||||
if (isa<PHINode>(To->front()) ||
|
|
||||||
!BBFollowsBB(From, To)) // Not directly successor, need goto
|
|
||||||
return true;
|
|
||||||
|
|
||||||
// Otherwise we don't need the code.
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ,
|
|
||||||
unsigned Indent) {
|
|
||||||
for (BasicBlock::iterator I = Succ->begin();
|
|
||||||
PHINode *PN = dyn_cast<PHINode>(*I); ++I) {
|
|
||||||
// now we have to do the printing
|
|
||||||
Out << string(Indent, ' ');
|
|
||||||
outputLValue(PN);
|
|
||||||
CW.writeOperand(PN->getIncomingValue(PN->getBasicBlockIndex(CurBB)));
|
|
||||||
Out << "; /* for PHI node */\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!BBFollowsBB(CurBB, Succ)) {
|
|
||||||
Out << string(Indent, ' ') << " goto ";
|
|
||||||
CW.writeOperand(Succ);
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Brach instruction printing - Avoid printing out a brach to a basic block that
|
|
||||||
// immediately succeeds the current one.
|
|
||||||
//
|
|
||||||
void CInstPrintVisitor::visitBranchInst(BranchInst *I) {
|
|
||||||
if (I->isConditional()) {
|
|
||||||
if (isGotoCodeNeccessary(I->getParent(), I->getSuccessor(0))) {
|
|
||||||
Out << " if (";
|
|
||||||
CW.writeOperand(I->getCondition());
|
|
||||||
Out << ") {\n";
|
|
||||||
|
|
||||||
printBranchToBlock(I->getParent(), I->getSuccessor(0), 2);
|
|
||||||
|
|
||||||
if (isGotoCodeNeccessary(I->getParent(), I->getSuccessor(1))) {
|
|
||||||
Out << " } else {\n";
|
|
||||||
printBranchToBlock(I->getParent(), I->getSuccessor(1), 2);
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// First goto not neccesary, assume second one is...
|
|
||||||
Out << " if (!";
|
|
||||||
CW.writeOperand(I->getCondition());
|
|
||||||
Out << ") {\n";
|
|
||||||
|
|
||||||
printBranchToBlock(I->getParent(), I->getSuccessor(1), 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
Out << " }\n";
|
|
||||||
} else {
|
|
||||||
printBranchToBlock(I->getParent(), I->getSuccessor(0), 0);
|
|
||||||
}
|
|
||||||
Out << "\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitSwitchInst(SwitchInst *I) {
|
|
||||||
assert(0 && "Switch not implemented!");
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitInvokeInst(InvokeInst *I) {
|
|
||||||
assert(0 && "Invoke not implemented!");
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitMallocInst(MallocInst *I) {
|
|
||||||
outputLValue(I);
|
|
||||||
Out << "(";
|
|
||||||
CW.printType(I->getType());
|
|
||||||
Out << ")malloc(sizeof(";
|
|
||||||
CW.printType(I->getType()->getElementType());
|
|
||||||
Out << ")";
|
|
||||||
|
|
||||||
if (I->isArrayAllocation()) {
|
|
||||||
Out << " * " ;
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
}
|
|
||||||
Out << ");\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitAllocaInst(AllocaInst *I) {
|
|
||||||
outputLValue(I);
|
|
||||||
Out << "(";
|
|
||||||
CW.printType(I->getType());
|
|
||||||
Out << ") alloca(sizeof(";
|
|
||||||
CW.printType(I->getType()->getElementType());
|
|
||||||
Out << ")";
|
|
||||||
if (I->isArrayAllocation()) {
|
|
||||||
Out << " * " ;
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
}
|
|
||||||
Out << ");\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitFreeInst(FreeInst *I) {
|
|
||||||
Out << " free(";
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
Out << ");\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::printIndexingExpr(MemAccessInst *MAI) {
|
|
||||||
MemAccessInst::op_iterator I = MAI->idx_begin(), E = MAI->idx_end();
|
|
||||||
if (I == E)
|
|
||||||
Out << "*"; // Implicit zero first argument: '*x' is equivalent to 'x[0]'
|
|
||||||
|
|
||||||
CW.writeOperand(MAI->getPointerOperand());
|
|
||||||
|
|
||||||
if (I == E) return;
|
|
||||||
|
|
||||||
// Print out the -> operator if possible...
|
|
||||||
Constant *CI = dyn_cast<Constant>(*I);
|
|
||||||
if (CI && CI->isNullValue() && I+1 != E &&
|
|
||||||
(*(I+1))->getType() == Type::UByteTy) {
|
|
||||||
++I;
|
|
||||||
Out << "->field" << cast<ConstantUInt>(*I)->getValue();
|
|
||||||
++I;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (; I != E; ++I)
|
|
||||||
if ((*I)->getType() == Type::UIntTy) {
|
|
||||||
Out << "[";
|
|
||||||
CW.writeOperand(*I);
|
|
||||||
Out << "]";
|
|
||||||
} else {
|
|
||||||
Out << ".field" << cast<ConstantUInt>(*I)->getValue();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitLoadInst(LoadInst *I) {
|
|
||||||
outputLValue(I);
|
|
||||||
printIndexingExpr(I);
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitStoreInst(StoreInst *I) {
|
|
||||||
Out << " ";
|
|
||||||
printIndexingExpr(I);
|
|
||||||
Out << " = ";
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitGetElementPtrInst(GetElementPtrInst *I) {
|
|
||||||
outputLValue(I);
|
|
||||||
Out << "&";
|
|
||||||
printIndexingExpr(I);
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitNot(GenericUnaryInst *I) {
|
|
||||||
outputLValue(I);
|
|
||||||
Out << "~";
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitBinaryOperator(Instruction *I) {
|
|
||||||
// binary instructions, shift instructions, setCond instructions.
|
|
||||||
outputLValue(I);
|
|
||||||
if (isa<PointerType>(I->getType())) {
|
|
||||||
Out << "(";
|
|
||||||
CW.printType(I->getType());
|
|
||||||
Out << ")";
|
|
||||||
}
|
|
||||||
|
|
||||||
if (isa<PointerType>(I->getType())) Out << "(long long)";
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
|
|
||||||
switch (I->getOpcode()) {
|
|
||||||
case Instruction::Add: Out << " + "; break;
|
|
||||||
case Instruction::Sub: Out << " - "; break;
|
|
||||||
case Instruction::Mul: Out << "*"; break;
|
|
||||||
case Instruction::Div: Out << "/"; break;
|
|
||||||
case Instruction::Rem: Out << "%"; break;
|
|
||||||
case Instruction::And: Out << " & "; break;
|
|
||||||
case Instruction::Or: Out << " | "; break;
|
|
||||||
case Instruction::Xor: Out << " ^ "; break;
|
|
||||||
case Instruction::SetEQ: Out << " == "; break;
|
|
||||||
case Instruction::SetNE: Out << " != "; break;
|
|
||||||
case Instruction::SetLE: Out << " <= "; break;
|
|
||||||
case Instruction::SetGE: Out << " >= "; break;
|
|
||||||
case Instruction::SetLT: Out << " < "; break;
|
|
||||||
case Instruction::SetGT: Out << " > "; break;
|
|
||||||
case Instruction::Shl : Out << " << "; break;
|
|
||||||
case Instruction::Shr : Out << " >> "; break;
|
|
||||||
default: cerr << "Invalid operator type!" << I; abort();
|
|
||||||
}
|
|
||||||
|
|
||||||
if (isa<PointerType>(I->getType())) Out << "(long long)";
|
|
||||||
CW.writeOperand(I->getOperand(1));
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
/* END : CInstPrintVisitor implementation */
|
|
||||||
|
|
||||||
// We dont want identifier names with ., space, - in them.
|
// We dont want identifier names with ., space, - in them.
|
||||||
// So we replace them with _
|
// So we replace them with _
|
||||||
static string makeNameProper(string x) {
|
static string makeNameProper(string x) {
|
||||||
@ -594,6 +306,29 @@ string CWriter::getValueName(const Value *V) {
|
|||||||
return "ltmp_" + itostr(Slot) + "_" + utostr(V->getType()->getUniqueID());
|
return "ltmp_" + itostr(Slot) + "_" + utostr(V->getType()->getUniqueID());
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void CWriter::writeOperand(const Value *Operand) {
|
||||||
|
if (isa<GlobalVariable>(Operand))
|
||||||
|
Out << "(&"; // Global variables are references as their addresses by llvm
|
||||||
|
|
||||||
|
if (Operand->hasName()) {
|
||||||
|
Out << getValueName(Operand);
|
||||||
|
} else if (const Constant *CPV = dyn_cast<const Constant>(Operand)) {
|
||||||
|
if (isa<ConstantPointerNull>(CPV)) {
|
||||||
|
Out << "((";
|
||||||
|
printTypeVar(CPV->getType(), "");
|
||||||
|
Out << ")NULL)";
|
||||||
|
} else
|
||||||
|
Out << getConstStrValue(CPV);
|
||||||
|
} else {
|
||||||
|
int Slot = Table.getValSlot(Operand);
|
||||||
|
assert(Slot >= 0 && "Malformed LLVM!");
|
||||||
|
Out << "ltmp_" << Slot << "_" << Operand->getType()->getUniqueID();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isa<GlobalVariable>(Operand))
|
||||||
|
Out << ")";
|
||||||
|
}
|
||||||
|
|
||||||
void CWriter::printModule(Module *M) {
|
void CWriter::printModule(Module *M) {
|
||||||
// printing stdlib inclusion
|
// printing stdlib inclusion
|
||||||
// Out << "#include <stdlib.h>\n";
|
// Out << "#include <stdlib.h>\n";
|
||||||
@ -762,37 +497,258 @@ void CWriter::printFunction(Function *F) {
|
|||||||
|
|
||||||
// Output all of the instructions in the basic block...
|
// Output all of the instructions in the basic block...
|
||||||
// print the basic blocks
|
// print the basic blocks
|
||||||
CInstPrintVisitor CIPV(*this, Table, Out);
|
visit(BB);
|
||||||
CIPV.visit(BB);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
Out << "}\n\n";
|
Out << "}\n\n";
|
||||||
Table.purgeFunction();
|
Table.purgeFunction();
|
||||||
}
|
}
|
||||||
|
|
||||||
void CWriter::writeOperand(const Value *Operand) {
|
// Specific Instruction type classes... note that all of the casts are
|
||||||
if (isa<GlobalVariable>(Operand))
|
// neccesary because we use the instruction classes as opaque types...
|
||||||
Out << "(&"; // Global variables are references as their addresses by llvm
|
//
|
||||||
|
void CWriter::visitReturnInst(ReturnInst *I) {
|
||||||
|
// Don't output a void return if this is the last basic block in the function
|
||||||
|
if (I->getNumOperands() == 0 &&
|
||||||
|
*(I->getParent()->getParent()->end()-1) == I->getParent())
|
||||||
|
return;
|
||||||
|
|
||||||
if (Operand->hasName()) {
|
Out << " return";
|
||||||
Out << getValueName(Operand);
|
if (I->getNumOperands()) {
|
||||||
} else if (const Constant *CPV = dyn_cast<const Constant>(Operand)) {
|
Out << " ";
|
||||||
if (isa<ConstantPointerNull>(CPV)) {
|
writeOperand(I->getOperand(0));
|
||||||
Out << "((";
|
}
|
||||||
printTypeVar(CPV->getType(), "");
|
Out << ";\n";
|
||||||
Out << ")NULL)";
|
|
||||||
} else
|
|
||||||
Out << getConstStrValue(CPV);
|
|
||||||
} else {
|
|
||||||
int Slot = Table.getValSlot(Operand);
|
|
||||||
assert(Slot >= 0 && "Malformed LLVM!");
|
|
||||||
Out << "ltmp_" << Slot << "_" << Operand->getType()->getUniqueID();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
if (isa<GlobalVariable>(Operand))
|
// Return true if BB1 immediately preceeds BB2.
|
||||||
|
static bool BBFollowsBB(BasicBlock *BB1, BasicBlock *BB2) {
|
||||||
|
Function *F = BB1->getParent();
|
||||||
|
Function::iterator I = find(F->begin(), F->end(), BB1);
|
||||||
|
assert(I != F->end() && "BB not in function!");
|
||||||
|
return *(I+1) == BB2;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool isGotoCodeNeccessary(BasicBlock *From, BasicBlock *To) {
|
||||||
|
// If PHI nodes need copies, we need the copy code...
|
||||||
|
if (isa<PHINode>(To->front()) ||
|
||||||
|
!BBFollowsBB(From, To)) // Not directly successor, need goto
|
||||||
|
return true;
|
||||||
|
|
||||||
|
// Otherwise we don't need the code.
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ,
|
||||||
|
unsigned Indent) {
|
||||||
|
for (BasicBlock::iterator I = Succ->begin();
|
||||||
|
PHINode *PN = dyn_cast<PHINode>(*I); ++I) {
|
||||||
|
// now we have to do the printing
|
||||||
|
Out << string(Indent, ' ');
|
||||||
|
outputLValue(PN);
|
||||||
|
writeOperand(PN->getIncomingValue(PN->getBasicBlockIndex(CurBB)));
|
||||||
|
Out << "; /* for PHI node */\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!BBFollowsBB(CurBB, Succ)) {
|
||||||
|
Out << string(Indent, ' ') << " goto ";
|
||||||
|
writeOperand(Succ);
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Brach instruction printing - Avoid printing out a brach to a basic block that
|
||||||
|
// immediately succeeds the current one.
|
||||||
|
//
|
||||||
|
void CWriter::visitBranchInst(BranchInst *I) {
|
||||||
|
if (I->isConditional()) {
|
||||||
|
if (isGotoCodeNeccessary(I->getParent(), I->getSuccessor(0))) {
|
||||||
|
Out << " if (";
|
||||||
|
writeOperand(I->getCondition());
|
||||||
|
Out << ") {\n";
|
||||||
|
|
||||||
|
printBranchToBlock(I->getParent(), I->getSuccessor(0), 2);
|
||||||
|
|
||||||
|
if (isGotoCodeNeccessary(I->getParent(), I->getSuccessor(1))) {
|
||||||
|
Out << " } else {\n";
|
||||||
|
printBranchToBlock(I->getParent(), I->getSuccessor(1), 2);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// First goto not neccesary, assume second one is...
|
||||||
|
Out << " if (!";
|
||||||
|
writeOperand(I->getCondition());
|
||||||
|
Out << ") {\n";
|
||||||
|
|
||||||
|
printBranchToBlock(I->getParent(), I->getSuccessor(1), 2);
|
||||||
|
}
|
||||||
|
|
||||||
|
Out << " }\n";
|
||||||
|
} else {
|
||||||
|
printBranchToBlock(I->getParent(), I->getSuccessor(0), 0);
|
||||||
|
}
|
||||||
|
Out << "\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void CWriter::visitNot(GenericUnaryInst *I) {
|
||||||
|
outputLValue(I);
|
||||||
|
Out << "~";
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitBinaryOperator(Instruction *I) {
|
||||||
|
// binary instructions, shift instructions, setCond instructions.
|
||||||
|
outputLValue(I);
|
||||||
|
if (isa<PointerType>(I->getType())) {
|
||||||
|
Out << "(";
|
||||||
|
printType(I->getType());
|
||||||
Out << ")";
|
Out << ")";
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if (isa<PointerType>(I->getType())) Out << "(long long)";
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
|
||||||
|
switch (I->getOpcode()) {
|
||||||
|
case Instruction::Add: Out << " + "; break;
|
||||||
|
case Instruction::Sub: Out << " - "; break;
|
||||||
|
case Instruction::Mul: Out << "*"; break;
|
||||||
|
case Instruction::Div: Out << "/"; break;
|
||||||
|
case Instruction::Rem: Out << "%"; break;
|
||||||
|
case Instruction::And: Out << " & "; break;
|
||||||
|
case Instruction::Or: Out << " | "; break;
|
||||||
|
case Instruction::Xor: Out << " ^ "; break;
|
||||||
|
case Instruction::SetEQ: Out << " == "; break;
|
||||||
|
case Instruction::SetNE: Out << " != "; break;
|
||||||
|
case Instruction::SetLE: Out << " <= "; break;
|
||||||
|
case Instruction::SetGE: Out << " >= "; break;
|
||||||
|
case Instruction::SetLT: Out << " < "; break;
|
||||||
|
case Instruction::SetGT: Out << " > "; break;
|
||||||
|
case Instruction::Shl : Out << " << "; break;
|
||||||
|
case Instruction::Shr : Out << " >> "; break;
|
||||||
|
default: cerr << "Invalid operator type!" << I; abort();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isa<PointerType>(I->getType())) Out << "(long long)";
|
||||||
|
writeOperand(I->getOperand(1));
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitCastInst(CastInst *I) {
|
||||||
|
outputLValue(I);
|
||||||
|
Out << "(";
|
||||||
|
printType(I->getType());
|
||||||
|
Out << ")";
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitCallInst(CallInst *I) {
|
||||||
|
if (I->getType() != Type::VoidTy)
|
||||||
|
outputLValue(I);
|
||||||
|
else
|
||||||
|
Out << " ";
|
||||||
|
|
||||||
|
const PointerType *PTy = cast<PointerType>(I->getCalledValue()->getType());
|
||||||
|
const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
|
||||||
|
const Type *RetTy = FTy->getReturnType();
|
||||||
|
|
||||||
|
Out << getValueName(I->getOperand(0)) << "(";
|
||||||
|
|
||||||
|
if (I->getNumOperands() > 1) {
|
||||||
|
writeOperand(I->getOperand(1));
|
||||||
|
|
||||||
|
for (unsigned op = 2, Eop = I->getNumOperands(); op != Eop; ++op) {
|
||||||
|
Out << ", ";
|
||||||
|
writeOperand(I->getOperand(op));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Out << ");\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitMallocInst(MallocInst *I) {
|
||||||
|
outputLValue(I);
|
||||||
|
Out << "(";
|
||||||
|
printType(I->getType());
|
||||||
|
Out << ")malloc(sizeof(";
|
||||||
|
printType(I->getType()->getElementType());
|
||||||
|
Out << ")";
|
||||||
|
|
||||||
|
if (I->isArrayAllocation()) {
|
||||||
|
Out << " * " ;
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
}
|
||||||
|
Out << ");\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitAllocaInst(AllocaInst *I) {
|
||||||
|
outputLValue(I);
|
||||||
|
Out << "(";
|
||||||
|
printType(I->getType());
|
||||||
|
Out << ") alloca(sizeof(";
|
||||||
|
printType(I->getType()->getElementType());
|
||||||
|
Out << ")";
|
||||||
|
if (I->isArrayAllocation()) {
|
||||||
|
Out << " * " ;
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
}
|
||||||
|
Out << ");\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitFreeInst(FreeInst *I) {
|
||||||
|
Out << " free(";
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
Out << ");\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::printIndexingExpr(MemAccessInst *MAI) {
|
||||||
|
MemAccessInst::op_iterator I = MAI->idx_begin(), E = MAI->idx_end();
|
||||||
|
if (I == E)
|
||||||
|
Out << "*"; // Implicit zero first argument: '*x' is equivalent to 'x[0]'
|
||||||
|
|
||||||
|
writeOperand(MAI->getPointerOperand());
|
||||||
|
|
||||||
|
if (I == E) return;
|
||||||
|
|
||||||
|
// Print out the -> operator if possible...
|
||||||
|
Constant *CI = dyn_cast<Constant>(*I);
|
||||||
|
if (CI && CI->isNullValue() && I+1 != E &&
|
||||||
|
(*(I+1))->getType() == Type::UByteTy) {
|
||||||
|
++I;
|
||||||
|
Out << "->field" << cast<ConstantUInt>(*I)->getValue();
|
||||||
|
++I;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (; I != E; ++I)
|
||||||
|
if ((*I)->getType() == Type::UIntTy) {
|
||||||
|
Out << "[";
|
||||||
|
writeOperand(*I);
|
||||||
|
Out << "]";
|
||||||
|
} else {
|
||||||
|
Out << ".field" << cast<ConstantUInt>(*I)->getValue();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitLoadInst(LoadInst *I) {
|
||||||
|
outputLValue(I);
|
||||||
|
printIndexingExpr(I);
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitStoreInst(StoreInst *I) {
|
||||||
|
Out << " ";
|
||||||
|
printIndexingExpr(I);
|
||||||
|
Out << " = ";
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitGetElementPtrInst(GetElementPtrInst *I) {
|
||||||
|
outputLValue(I);
|
||||||
|
Out << "&";
|
||||||
|
printIndexingExpr(I);
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
|
||||||
//===----------------------------------------------------------------------===//
|
//===----------------------------------------------------------------------===//
|
||||||
// External Interface declaration
|
// External Interface declaration
|
||||||
|
@ -45,20 +45,10 @@ static std::string getConstArrayStrValue(const Constant* CPV) {
|
|||||||
const Type *ETy = cast<ArrayType>(CPV->getType())->getElementType();
|
const Type *ETy = cast<ArrayType>(CPV->getType())->getElementType();
|
||||||
bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy);
|
bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy);
|
||||||
|
|
||||||
if (ETy == Type::SByteTy) {
|
|
||||||
for (unsigned i = 0; i < CPV->getNumOperands(); ++i)
|
|
||||||
if (ETy == Type::SByteTy &&
|
|
||||||
cast<ConstantSInt>(CPV->getOperand(i))->getValue() < 0) {
|
|
||||||
isString = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (isString) {
|
|
||||||
// Make sure the last character is a null char, as automatically added by C
|
// Make sure the last character is a null char, as automatically added by C
|
||||||
if (CPV->getNumOperands() == 0 ||
|
if (CPV->getNumOperands() == 0 ||
|
||||||
!cast<Constant>(*(CPV->op_end()-1))->isNullValue())
|
!cast<Constant>(*(CPV->op_end()-1))->isNullValue())
|
||||||
isString = false;
|
isString = false;
|
||||||
}
|
|
||||||
|
|
||||||
if (isString) {
|
if (isString) {
|
||||||
Result = "\"";
|
Result = "\"";
|
||||||
@ -101,30 +91,21 @@ static std::string getConstArrayStrValue(const Constant* CPV) {
|
|||||||
|
|
||||||
static std::string getConstStrValue(const Constant* CPV) {
|
static std::string getConstStrValue(const Constant* CPV) {
|
||||||
switch (CPV->getType()->getPrimitiveID()) {
|
switch (CPV->getType()->getPrimitiveID()) {
|
||||||
case Type::BoolTyID:
|
case Type::BoolTyID: return CPV == ConstantBool::False ? "0" : "1";
|
||||||
return CPV == ConstantBool::False ? "0" : "1";
|
|
||||||
case Type::SByteTyID:
|
case Type::SByteTyID:
|
||||||
case Type::ShortTyID:
|
case Type::ShortTyID:
|
||||||
case Type::IntTyID:
|
case Type::IntTyID: return itostr(cast<ConstantSInt>(CPV)->getValue());
|
||||||
return itostr(cast<ConstantSInt>(CPV)->getValue());
|
case Type::LongTyID: return itostr(cast<ConstantSInt>(CPV)->getValue())+"ll";
|
||||||
case Type::LongTyID:
|
|
||||||
return itostr(cast<ConstantSInt>(CPV)->getValue()) + "ll";
|
|
||||||
|
|
||||||
case Type::UByteTyID:
|
case Type::UByteTyID:
|
||||||
return utostr(cast<ConstantUInt>(CPV)->getValue());
|
case Type::UShortTyID:return utostr(cast<ConstantUInt>(CPV)->getValue());
|
||||||
case Type::UShortTyID:
|
case Type::UIntTyID: return utostr(cast<ConstantUInt>(CPV)->getValue())+"u";
|
||||||
return utostr(cast<ConstantUInt>(CPV)->getValue());
|
case Type::ULongTyID:return utostr(cast<ConstantUInt>(CPV)->getValue())+"ull";
|
||||||
case Type::UIntTyID:
|
|
||||||
return utostr(cast<ConstantUInt>(CPV)->getValue())+"u";
|
|
||||||
case Type::ULongTyID:
|
|
||||||
return utostr(cast<ConstantUInt>(CPV)->getValue())+"ull";
|
|
||||||
|
|
||||||
case Type::FloatTyID:
|
case Type::FloatTyID:
|
||||||
case Type::DoubleTyID:
|
case Type::DoubleTyID: return ftostr(cast<ConstantFP>(CPV)->getValue());
|
||||||
return ftostr(cast<ConstantFP>(CPV)->getValue());
|
|
||||||
|
|
||||||
case Type::ArrayTyID:
|
case Type::ArrayTyID: return getConstArrayStrValue(CPV);
|
||||||
return getConstArrayStrValue(CPV);
|
|
||||||
|
|
||||||
case Type::StructTyID: {
|
case Type::StructTyID: {
|
||||||
std::string Result = "{";
|
std::string Result = "{";
|
||||||
@ -192,8 +173,7 @@ static string calcTypeNameVar(const Type *Ty,
|
|||||||
Result += ", ";
|
Result += ", ";
|
||||||
Result += "...";
|
Result += "...";
|
||||||
}
|
}
|
||||||
Result += ")";
|
return Result + ")";
|
||||||
break;
|
|
||||||
}
|
}
|
||||||
case Type::StructTyID: {
|
case Type::StructTyID: {
|
||||||
const StructType *STy = cast<const StructType>(Ty);
|
const StructType *STy = cast<const StructType>(Ty);
|
||||||
@ -205,33 +185,30 @@ static string calcTypeNameVar(const Type *Ty,
|
|||||||
Result += " " +calcTypeNameVar(*I, TypeNames, "field" + utostr(indx++));
|
Result += " " +calcTypeNameVar(*I, TypeNames, "field" + utostr(indx++));
|
||||||
Result += ";\n";
|
Result += ";\n";
|
||||||
}
|
}
|
||||||
Result += "}";
|
return Result + "}";
|
||||||
break;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
case Type::PointerTyID: {
|
case Type::PointerTyID: {
|
||||||
Result = calcTypeNameVar(cast<const PointerType>(Ty)->getElementType(),
|
return calcTypeNameVar(cast<const PointerType>(Ty)->getElementType(),
|
||||||
TypeNames, "*" + NameSoFar);
|
TypeNames, "*" + NameSoFar);
|
||||||
break;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
case Type::ArrayTyID: {
|
case Type::ArrayTyID: {
|
||||||
const ArrayType *ATy = cast<const ArrayType>(Ty);
|
const ArrayType *ATy = cast<const ArrayType>(Ty);
|
||||||
int NumElements = ATy->getNumElements();
|
int NumElements = ATy->getNumElements();
|
||||||
Result = calcTypeNameVar(ATy->getElementType(), TypeNames,
|
return calcTypeNameVar(ATy->getElementType(), TypeNames,
|
||||||
NameSoFar + "[" + itostr(NumElements) + "]");
|
NameSoFar + "[" + itostr(NumElements) + "]");
|
||||||
break;
|
|
||||||
}
|
}
|
||||||
default:
|
default:
|
||||||
assert(0 && "Unhandled case in getTypeProps!");
|
assert(0 && "Unhandled case in getTypeProps!");
|
||||||
Result = "<error>";
|
abort();
|
||||||
}
|
}
|
||||||
|
|
||||||
return Result;
|
return Result;
|
||||||
}
|
}
|
||||||
|
|
||||||
namespace {
|
namespace {
|
||||||
class CWriter {
|
class CWriter : public InstVisitor<CWriter> {
|
||||||
ostream& Out;
|
ostream& Out;
|
||||||
SlotCalculator &Table;
|
SlotCalculator &Table;
|
||||||
const Module *TheModule;
|
const Module *TheModule;
|
||||||
@ -254,8 +231,8 @@ namespace {
|
|||||||
void writeOperand(const Value *Operand);
|
void writeOperand(const Value *Operand);
|
||||||
|
|
||||||
string getValueName(const Value *V);
|
string getValueName(const Value *V);
|
||||||
private :
|
|
||||||
|
|
||||||
|
private :
|
||||||
void printModule(Module *M);
|
void printModule(Module *M);
|
||||||
void printSymbolTable(const SymbolTable &ST);
|
void printSymbolTable(const SymbolTable &ST);
|
||||||
void printGlobal(const GlobalVariable *GV);
|
void printGlobal(const GlobalVariable *GV);
|
||||||
@ -263,307 +240,42 @@ namespace {
|
|||||||
void printFunctionDecl(const Function *F); // Print just the forward decl
|
void printFunctionDecl(const Function *F); // Print just the forward decl
|
||||||
|
|
||||||
void printFunction(Function *);
|
void printFunction(Function *);
|
||||||
};
|
|
||||||
/* END class CWriter */
|
|
||||||
}
|
|
||||||
|
|
||||||
namespace {
|
// Instruction visitation functions
|
||||||
/* CLASS CInstPrintVisitor */
|
friend class InstVisitor<CWriter>;
|
||||||
|
|
||||||
class CInstPrintVisitor: public InstVisitor<CInstPrintVisitor> {
|
void visitReturnInst(ReturnInst *I);
|
||||||
CWriter& CW;
|
void visitBranchInst(BranchInst *I);
|
||||||
SlotCalculator& Table;
|
|
||||||
ostream &Out;
|
|
||||||
|
|
||||||
void outputLValue(Instruction *);
|
void visitPHINode(PHINode *I) {}
|
||||||
void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock,
|
void visitNot(GenericUnaryInst *I);
|
||||||
unsigned Indent);
|
void visitBinaryOperator(Instruction *I);
|
||||||
void printIndexingExpr(MemAccessInst *MAI);
|
|
||||||
|
|
||||||
public:
|
|
||||||
CInstPrintVisitor (CWriter &cw, SlotCalculator& table, ostream& o)
|
|
||||||
: CW(cw), Table(table), Out(o) {}
|
|
||||||
|
|
||||||
void visitCastInst(CastInst *I);
|
void visitCastInst(CastInst *I);
|
||||||
void visitCallInst(CallInst *I);
|
void visitCallInst(CallInst *I);
|
||||||
void visitShiftInst(ShiftInst *I) { visitBinaryOperator(I); }
|
void visitShiftInst(ShiftInst *I) { visitBinaryOperator(I); }
|
||||||
void visitReturnInst(ReturnInst *I);
|
|
||||||
void visitBranchInst(BranchInst *I);
|
|
||||||
void visitSwitchInst(SwitchInst *I);
|
|
||||||
void visitInvokeInst(InvokeInst *I) ;
|
|
||||||
void visitMallocInst(MallocInst *I);
|
void visitMallocInst(MallocInst *I);
|
||||||
void visitAllocaInst(AllocaInst *I);
|
void visitAllocaInst(AllocaInst *I);
|
||||||
void visitFreeInst(FreeInst *I);
|
void visitFreeInst(FreeInst *I);
|
||||||
void visitLoadInst(LoadInst *I);
|
void visitLoadInst(LoadInst *I);
|
||||||
void visitStoreInst(StoreInst *I);
|
void visitStoreInst(StoreInst *I);
|
||||||
void visitGetElementPtrInst(GetElementPtrInst *I);
|
void visitGetElementPtrInst(GetElementPtrInst *I);
|
||||||
void visitPHINode(PHINode *I) {}
|
|
||||||
|
|
||||||
void visitNot(GenericUnaryInst *I);
|
void visitInstruction(Instruction *I) {
|
||||||
void visitBinaryOperator(Instruction *I);
|
cerr << "C Writer does not know about " << I;
|
||||||
|
abort();
|
||||||
|
}
|
||||||
|
|
||||||
|
void outputLValue(Instruction *I) {
|
||||||
|
Out << " " << getValueName(I) << " = ";
|
||||||
|
}
|
||||||
|
void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock,
|
||||||
|
unsigned Indent);
|
||||||
|
void printIndexingExpr(MemAccessInst *MAI);
|
||||||
};
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
void CInstPrintVisitor::outputLValue(Instruction *I) {
|
|
||||||
Out << " " << CW.getValueName(I) << " = ";
|
|
||||||
}
|
|
||||||
|
|
||||||
// Implement all "other" instructions, except for PHINode
|
|
||||||
void CInstPrintVisitor::visitCastInst(CastInst *I) {
|
|
||||||
outputLValue(I);
|
|
||||||
Out << "(";
|
|
||||||
CW.printType(I->getType());
|
|
||||||
Out << ")";
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitCallInst(CallInst *I) {
|
|
||||||
if (I->getType() != Type::VoidTy)
|
|
||||||
outputLValue(I);
|
|
||||||
else
|
|
||||||
Out << " ";
|
|
||||||
|
|
||||||
const PointerType *PTy = cast<PointerType>(I->getCalledValue()->getType());
|
|
||||||
const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
|
|
||||||
const Type *RetTy = FTy->getReturnType();
|
|
||||||
|
|
||||||
Out << CW.getValueName(I->getOperand(0)) << "(";
|
|
||||||
|
|
||||||
if (I->getNumOperands() > 1) {
|
|
||||||
CW.writeOperand(I->getOperand(1));
|
|
||||||
|
|
||||||
for (unsigned op = 2, Eop = I->getNumOperands(); op != Eop; ++op) {
|
|
||||||
Out << ", ";
|
|
||||||
CW.writeOperand(I->getOperand(op));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Out << ");\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
// Specific Instruction type classes... note that all of the casts are
|
|
||||||
// neccesary because we use the instruction classes as opaque types...
|
|
||||||
//
|
|
||||||
void CInstPrintVisitor::visitReturnInst(ReturnInst *I) {
|
|
||||||
// Don't output a void return if this is the last basic block in the function
|
|
||||||
if (I->getNumOperands() == 0 &&
|
|
||||||
*(I->getParent()->getParent()->end()-1) == I->getParent())
|
|
||||||
return;
|
|
||||||
|
|
||||||
Out << " return";
|
|
||||||
if (I->getNumOperands()) {
|
|
||||||
Out << " ";
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
}
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
// Return true if BB1 immediately preceeds BB2.
|
|
||||||
static bool BBFollowsBB(BasicBlock *BB1, BasicBlock *BB2) {
|
|
||||||
Function *F = BB1->getParent();
|
|
||||||
Function::iterator I = find(F->begin(), F->end(), BB1);
|
|
||||||
assert(I != F->end() && "BB not in function!");
|
|
||||||
return *(I+1) == BB2;
|
|
||||||
}
|
|
||||||
|
|
||||||
static bool isGotoCodeNeccessary(BasicBlock *From, BasicBlock *To) {
|
|
||||||
// If PHI nodes need copies, we need the copy code...
|
|
||||||
if (isa<PHINode>(To->front()) ||
|
|
||||||
!BBFollowsBB(From, To)) // Not directly successor, need goto
|
|
||||||
return true;
|
|
||||||
|
|
||||||
// Otherwise we don't need the code.
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ,
|
|
||||||
unsigned Indent) {
|
|
||||||
for (BasicBlock::iterator I = Succ->begin();
|
|
||||||
PHINode *PN = dyn_cast<PHINode>(*I); ++I) {
|
|
||||||
// now we have to do the printing
|
|
||||||
Out << string(Indent, ' ');
|
|
||||||
outputLValue(PN);
|
|
||||||
CW.writeOperand(PN->getIncomingValue(PN->getBasicBlockIndex(CurBB)));
|
|
||||||
Out << "; /* for PHI node */\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!BBFollowsBB(CurBB, Succ)) {
|
|
||||||
Out << string(Indent, ' ') << " goto ";
|
|
||||||
CW.writeOperand(Succ);
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Brach instruction printing - Avoid printing out a brach to a basic block that
|
|
||||||
// immediately succeeds the current one.
|
|
||||||
//
|
|
||||||
void CInstPrintVisitor::visitBranchInst(BranchInst *I) {
|
|
||||||
if (I->isConditional()) {
|
|
||||||
if (isGotoCodeNeccessary(I->getParent(), I->getSuccessor(0))) {
|
|
||||||
Out << " if (";
|
|
||||||
CW.writeOperand(I->getCondition());
|
|
||||||
Out << ") {\n";
|
|
||||||
|
|
||||||
printBranchToBlock(I->getParent(), I->getSuccessor(0), 2);
|
|
||||||
|
|
||||||
if (isGotoCodeNeccessary(I->getParent(), I->getSuccessor(1))) {
|
|
||||||
Out << " } else {\n";
|
|
||||||
printBranchToBlock(I->getParent(), I->getSuccessor(1), 2);
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// First goto not neccesary, assume second one is...
|
|
||||||
Out << " if (!";
|
|
||||||
CW.writeOperand(I->getCondition());
|
|
||||||
Out << ") {\n";
|
|
||||||
|
|
||||||
printBranchToBlock(I->getParent(), I->getSuccessor(1), 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
Out << " }\n";
|
|
||||||
} else {
|
|
||||||
printBranchToBlock(I->getParent(), I->getSuccessor(0), 0);
|
|
||||||
}
|
|
||||||
Out << "\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitSwitchInst(SwitchInst *I) {
|
|
||||||
assert(0 && "Switch not implemented!");
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitInvokeInst(InvokeInst *I) {
|
|
||||||
assert(0 && "Invoke not implemented!");
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitMallocInst(MallocInst *I) {
|
|
||||||
outputLValue(I);
|
|
||||||
Out << "(";
|
|
||||||
CW.printType(I->getType());
|
|
||||||
Out << ")malloc(sizeof(";
|
|
||||||
CW.printType(I->getType()->getElementType());
|
|
||||||
Out << ")";
|
|
||||||
|
|
||||||
if (I->isArrayAllocation()) {
|
|
||||||
Out << " * " ;
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
}
|
|
||||||
Out << ");\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitAllocaInst(AllocaInst *I) {
|
|
||||||
outputLValue(I);
|
|
||||||
Out << "(";
|
|
||||||
CW.printType(I->getType());
|
|
||||||
Out << ") alloca(sizeof(";
|
|
||||||
CW.printType(I->getType()->getElementType());
|
|
||||||
Out << ")";
|
|
||||||
if (I->isArrayAllocation()) {
|
|
||||||
Out << " * " ;
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
}
|
|
||||||
Out << ");\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitFreeInst(FreeInst *I) {
|
|
||||||
Out << " free(";
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
Out << ");\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::printIndexingExpr(MemAccessInst *MAI) {
|
|
||||||
MemAccessInst::op_iterator I = MAI->idx_begin(), E = MAI->idx_end();
|
|
||||||
if (I == E)
|
|
||||||
Out << "*"; // Implicit zero first argument: '*x' is equivalent to 'x[0]'
|
|
||||||
|
|
||||||
CW.writeOperand(MAI->getPointerOperand());
|
|
||||||
|
|
||||||
if (I == E) return;
|
|
||||||
|
|
||||||
// Print out the -> operator if possible...
|
|
||||||
Constant *CI = dyn_cast<Constant>(*I);
|
|
||||||
if (CI && CI->isNullValue() && I+1 != E &&
|
|
||||||
(*(I+1))->getType() == Type::UByteTy) {
|
|
||||||
++I;
|
|
||||||
Out << "->field" << cast<ConstantUInt>(*I)->getValue();
|
|
||||||
++I;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (; I != E; ++I)
|
|
||||||
if ((*I)->getType() == Type::UIntTy) {
|
|
||||||
Out << "[";
|
|
||||||
CW.writeOperand(*I);
|
|
||||||
Out << "]";
|
|
||||||
} else {
|
|
||||||
Out << ".field" << cast<ConstantUInt>(*I)->getValue();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitLoadInst(LoadInst *I) {
|
|
||||||
outputLValue(I);
|
|
||||||
printIndexingExpr(I);
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitStoreInst(StoreInst *I) {
|
|
||||||
Out << " ";
|
|
||||||
printIndexingExpr(I);
|
|
||||||
Out << " = ";
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitGetElementPtrInst(GetElementPtrInst *I) {
|
|
||||||
outputLValue(I);
|
|
||||||
Out << "&";
|
|
||||||
printIndexingExpr(I);
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitNot(GenericUnaryInst *I) {
|
|
||||||
outputLValue(I);
|
|
||||||
Out << "~";
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
void CInstPrintVisitor::visitBinaryOperator(Instruction *I) {
|
|
||||||
// binary instructions, shift instructions, setCond instructions.
|
|
||||||
outputLValue(I);
|
|
||||||
if (isa<PointerType>(I->getType())) {
|
|
||||||
Out << "(";
|
|
||||||
CW.printType(I->getType());
|
|
||||||
Out << ")";
|
|
||||||
}
|
|
||||||
|
|
||||||
if (isa<PointerType>(I->getType())) Out << "(long long)";
|
|
||||||
CW.writeOperand(I->getOperand(0));
|
|
||||||
|
|
||||||
switch (I->getOpcode()) {
|
|
||||||
case Instruction::Add: Out << " + "; break;
|
|
||||||
case Instruction::Sub: Out << " - "; break;
|
|
||||||
case Instruction::Mul: Out << "*"; break;
|
|
||||||
case Instruction::Div: Out << "/"; break;
|
|
||||||
case Instruction::Rem: Out << "%"; break;
|
|
||||||
case Instruction::And: Out << " & "; break;
|
|
||||||
case Instruction::Or: Out << " | "; break;
|
|
||||||
case Instruction::Xor: Out << " ^ "; break;
|
|
||||||
case Instruction::SetEQ: Out << " == "; break;
|
|
||||||
case Instruction::SetNE: Out << " != "; break;
|
|
||||||
case Instruction::SetLE: Out << " <= "; break;
|
|
||||||
case Instruction::SetGE: Out << " >= "; break;
|
|
||||||
case Instruction::SetLT: Out << " < "; break;
|
|
||||||
case Instruction::SetGT: Out << " > "; break;
|
|
||||||
case Instruction::Shl : Out << " << "; break;
|
|
||||||
case Instruction::Shr : Out << " >> "; break;
|
|
||||||
default: cerr << "Invalid operator type!" << I; abort();
|
|
||||||
}
|
|
||||||
|
|
||||||
if (isa<PointerType>(I->getType())) Out << "(long long)";
|
|
||||||
CW.writeOperand(I->getOperand(1));
|
|
||||||
Out << ";\n";
|
|
||||||
}
|
|
||||||
|
|
||||||
/* END : CInstPrintVisitor implementation */
|
|
||||||
|
|
||||||
// We dont want identifier names with ., space, - in them.
|
// We dont want identifier names with ., space, - in them.
|
||||||
// So we replace them with _
|
// So we replace them with _
|
||||||
static string makeNameProper(string x) {
|
static string makeNameProper(string x) {
|
||||||
@ -594,6 +306,29 @@ string CWriter::getValueName(const Value *V) {
|
|||||||
return "ltmp_" + itostr(Slot) + "_" + utostr(V->getType()->getUniqueID());
|
return "ltmp_" + itostr(Slot) + "_" + utostr(V->getType()->getUniqueID());
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void CWriter::writeOperand(const Value *Operand) {
|
||||||
|
if (isa<GlobalVariable>(Operand))
|
||||||
|
Out << "(&"; // Global variables are references as their addresses by llvm
|
||||||
|
|
||||||
|
if (Operand->hasName()) {
|
||||||
|
Out << getValueName(Operand);
|
||||||
|
} else if (const Constant *CPV = dyn_cast<const Constant>(Operand)) {
|
||||||
|
if (isa<ConstantPointerNull>(CPV)) {
|
||||||
|
Out << "((";
|
||||||
|
printTypeVar(CPV->getType(), "");
|
||||||
|
Out << ")NULL)";
|
||||||
|
} else
|
||||||
|
Out << getConstStrValue(CPV);
|
||||||
|
} else {
|
||||||
|
int Slot = Table.getValSlot(Operand);
|
||||||
|
assert(Slot >= 0 && "Malformed LLVM!");
|
||||||
|
Out << "ltmp_" << Slot << "_" << Operand->getType()->getUniqueID();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isa<GlobalVariable>(Operand))
|
||||||
|
Out << ")";
|
||||||
|
}
|
||||||
|
|
||||||
void CWriter::printModule(Module *M) {
|
void CWriter::printModule(Module *M) {
|
||||||
// printing stdlib inclusion
|
// printing stdlib inclusion
|
||||||
// Out << "#include <stdlib.h>\n";
|
// Out << "#include <stdlib.h>\n";
|
||||||
@ -762,37 +497,258 @@ void CWriter::printFunction(Function *F) {
|
|||||||
|
|
||||||
// Output all of the instructions in the basic block...
|
// Output all of the instructions in the basic block...
|
||||||
// print the basic blocks
|
// print the basic blocks
|
||||||
CInstPrintVisitor CIPV(*this, Table, Out);
|
visit(BB);
|
||||||
CIPV.visit(BB);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
Out << "}\n\n";
|
Out << "}\n\n";
|
||||||
Table.purgeFunction();
|
Table.purgeFunction();
|
||||||
}
|
}
|
||||||
|
|
||||||
void CWriter::writeOperand(const Value *Operand) {
|
// Specific Instruction type classes... note that all of the casts are
|
||||||
if (isa<GlobalVariable>(Operand))
|
// neccesary because we use the instruction classes as opaque types...
|
||||||
Out << "(&"; // Global variables are references as their addresses by llvm
|
//
|
||||||
|
void CWriter::visitReturnInst(ReturnInst *I) {
|
||||||
|
// Don't output a void return if this is the last basic block in the function
|
||||||
|
if (I->getNumOperands() == 0 &&
|
||||||
|
*(I->getParent()->getParent()->end()-1) == I->getParent())
|
||||||
|
return;
|
||||||
|
|
||||||
if (Operand->hasName()) {
|
Out << " return";
|
||||||
Out << getValueName(Operand);
|
if (I->getNumOperands()) {
|
||||||
} else if (const Constant *CPV = dyn_cast<const Constant>(Operand)) {
|
Out << " ";
|
||||||
if (isa<ConstantPointerNull>(CPV)) {
|
writeOperand(I->getOperand(0));
|
||||||
Out << "((";
|
}
|
||||||
printTypeVar(CPV->getType(), "");
|
Out << ";\n";
|
||||||
Out << ")NULL)";
|
|
||||||
} else
|
|
||||||
Out << getConstStrValue(CPV);
|
|
||||||
} else {
|
|
||||||
int Slot = Table.getValSlot(Operand);
|
|
||||||
assert(Slot >= 0 && "Malformed LLVM!");
|
|
||||||
Out << "ltmp_" << Slot << "_" << Operand->getType()->getUniqueID();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
if (isa<GlobalVariable>(Operand))
|
// Return true if BB1 immediately preceeds BB2.
|
||||||
|
static bool BBFollowsBB(BasicBlock *BB1, BasicBlock *BB2) {
|
||||||
|
Function *F = BB1->getParent();
|
||||||
|
Function::iterator I = find(F->begin(), F->end(), BB1);
|
||||||
|
assert(I != F->end() && "BB not in function!");
|
||||||
|
return *(I+1) == BB2;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool isGotoCodeNeccessary(BasicBlock *From, BasicBlock *To) {
|
||||||
|
// If PHI nodes need copies, we need the copy code...
|
||||||
|
if (isa<PHINode>(To->front()) ||
|
||||||
|
!BBFollowsBB(From, To)) // Not directly successor, need goto
|
||||||
|
return true;
|
||||||
|
|
||||||
|
// Otherwise we don't need the code.
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ,
|
||||||
|
unsigned Indent) {
|
||||||
|
for (BasicBlock::iterator I = Succ->begin();
|
||||||
|
PHINode *PN = dyn_cast<PHINode>(*I); ++I) {
|
||||||
|
// now we have to do the printing
|
||||||
|
Out << string(Indent, ' ');
|
||||||
|
outputLValue(PN);
|
||||||
|
writeOperand(PN->getIncomingValue(PN->getBasicBlockIndex(CurBB)));
|
||||||
|
Out << "; /* for PHI node */\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!BBFollowsBB(CurBB, Succ)) {
|
||||||
|
Out << string(Indent, ' ') << " goto ";
|
||||||
|
writeOperand(Succ);
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Brach instruction printing - Avoid printing out a brach to a basic block that
|
||||||
|
// immediately succeeds the current one.
|
||||||
|
//
|
||||||
|
void CWriter::visitBranchInst(BranchInst *I) {
|
||||||
|
if (I->isConditional()) {
|
||||||
|
if (isGotoCodeNeccessary(I->getParent(), I->getSuccessor(0))) {
|
||||||
|
Out << " if (";
|
||||||
|
writeOperand(I->getCondition());
|
||||||
|
Out << ") {\n";
|
||||||
|
|
||||||
|
printBranchToBlock(I->getParent(), I->getSuccessor(0), 2);
|
||||||
|
|
||||||
|
if (isGotoCodeNeccessary(I->getParent(), I->getSuccessor(1))) {
|
||||||
|
Out << " } else {\n";
|
||||||
|
printBranchToBlock(I->getParent(), I->getSuccessor(1), 2);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// First goto not neccesary, assume second one is...
|
||||||
|
Out << " if (!";
|
||||||
|
writeOperand(I->getCondition());
|
||||||
|
Out << ") {\n";
|
||||||
|
|
||||||
|
printBranchToBlock(I->getParent(), I->getSuccessor(1), 2);
|
||||||
|
}
|
||||||
|
|
||||||
|
Out << " }\n";
|
||||||
|
} else {
|
||||||
|
printBranchToBlock(I->getParent(), I->getSuccessor(0), 0);
|
||||||
|
}
|
||||||
|
Out << "\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void CWriter::visitNot(GenericUnaryInst *I) {
|
||||||
|
outputLValue(I);
|
||||||
|
Out << "~";
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitBinaryOperator(Instruction *I) {
|
||||||
|
// binary instructions, shift instructions, setCond instructions.
|
||||||
|
outputLValue(I);
|
||||||
|
if (isa<PointerType>(I->getType())) {
|
||||||
|
Out << "(";
|
||||||
|
printType(I->getType());
|
||||||
Out << ")";
|
Out << ")";
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if (isa<PointerType>(I->getType())) Out << "(long long)";
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
|
||||||
|
switch (I->getOpcode()) {
|
||||||
|
case Instruction::Add: Out << " + "; break;
|
||||||
|
case Instruction::Sub: Out << " - "; break;
|
||||||
|
case Instruction::Mul: Out << "*"; break;
|
||||||
|
case Instruction::Div: Out << "/"; break;
|
||||||
|
case Instruction::Rem: Out << "%"; break;
|
||||||
|
case Instruction::And: Out << " & "; break;
|
||||||
|
case Instruction::Or: Out << " | "; break;
|
||||||
|
case Instruction::Xor: Out << " ^ "; break;
|
||||||
|
case Instruction::SetEQ: Out << " == "; break;
|
||||||
|
case Instruction::SetNE: Out << " != "; break;
|
||||||
|
case Instruction::SetLE: Out << " <= "; break;
|
||||||
|
case Instruction::SetGE: Out << " >= "; break;
|
||||||
|
case Instruction::SetLT: Out << " < "; break;
|
||||||
|
case Instruction::SetGT: Out << " > "; break;
|
||||||
|
case Instruction::Shl : Out << " << "; break;
|
||||||
|
case Instruction::Shr : Out << " >> "; break;
|
||||||
|
default: cerr << "Invalid operator type!" << I; abort();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isa<PointerType>(I->getType())) Out << "(long long)";
|
||||||
|
writeOperand(I->getOperand(1));
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitCastInst(CastInst *I) {
|
||||||
|
outputLValue(I);
|
||||||
|
Out << "(";
|
||||||
|
printType(I->getType());
|
||||||
|
Out << ")";
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitCallInst(CallInst *I) {
|
||||||
|
if (I->getType() != Type::VoidTy)
|
||||||
|
outputLValue(I);
|
||||||
|
else
|
||||||
|
Out << " ";
|
||||||
|
|
||||||
|
const PointerType *PTy = cast<PointerType>(I->getCalledValue()->getType());
|
||||||
|
const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
|
||||||
|
const Type *RetTy = FTy->getReturnType();
|
||||||
|
|
||||||
|
Out << getValueName(I->getOperand(0)) << "(";
|
||||||
|
|
||||||
|
if (I->getNumOperands() > 1) {
|
||||||
|
writeOperand(I->getOperand(1));
|
||||||
|
|
||||||
|
for (unsigned op = 2, Eop = I->getNumOperands(); op != Eop; ++op) {
|
||||||
|
Out << ", ";
|
||||||
|
writeOperand(I->getOperand(op));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Out << ");\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitMallocInst(MallocInst *I) {
|
||||||
|
outputLValue(I);
|
||||||
|
Out << "(";
|
||||||
|
printType(I->getType());
|
||||||
|
Out << ")malloc(sizeof(";
|
||||||
|
printType(I->getType()->getElementType());
|
||||||
|
Out << ")";
|
||||||
|
|
||||||
|
if (I->isArrayAllocation()) {
|
||||||
|
Out << " * " ;
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
}
|
||||||
|
Out << ");\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitAllocaInst(AllocaInst *I) {
|
||||||
|
outputLValue(I);
|
||||||
|
Out << "(";
|
||||||
|
printType(I->getType());
|
||||||
|
Out << ") alloca(sizeof(";
|
||||||
|
printType(I->getType()->getElementType());
|
||||||
|
Out << ")";
|
||||||
|
if (I->isArrayAllocation()) {
|
||||||
|
Out << " * " ;
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
}
|
||||||
|
Out << ");\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitFreeInst(FreeInst *I) {
|
||||||
|
Out << " free(";
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
Out << ");\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::printIndexingExpr(MemAccessInst *MAI) {
|
||||||
|
MemAccessInst::op_iterator I = MAI->idx_begin(), E = MAI->idx_end();
|
||||||
|
if (I == E)
|
||||||
|
Out << "*"; // Implicit zero first argument: '*x' is equivalent to 'x[0]'
|
||||||
|
|
||||||
|
writeOperand(MAI->getPointerOperand());
|
||||||
|
|
||||||
|
if (I == E) return;
|
||||||
|
|
||||||
|
// Print out the -> operator if possible...
|
||||||
|
Constant *CI = dyn_cast<Constant>(*I);
|
||||||
|
if (CI && CI->isNullValue() && I+1 != E &&
|
||||||
|
(*(I+1))->getType() == Type::UByteTy) {
|
||||||
|
++I;
|
||||||
|
Out << "->field" << cast<ConstantUInt>(*I)->getValue();
|
||||||
|
++I;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (; I != E; ++I)
|
||||||
|
if ((*I)->getType() == Type::UIntTy) {
|
||||||
|
Out << "[";
|
||||||
|
writeOperand(*I);
|
||||||
|
Out << "]";
|
||||||
|
} else {
|
||||||
|
Out << ".field" << cast<ConstantUInt>(*I)->getValue();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitLoadInst(LoadInst *I) {
|
||||||
|
outputLValue(I);
|
||||||
|
printIndexingExpr(I);
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitStoreInst(StoreInst *I) {
|
||||||
|
Out << " ";
|
||||||
|
printIndexingExpr(I);
|
||||||
|
Out << " = ";
|
||||||
|
writeOperand(I->getOperand(0));
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
|
||||||
|
void CWriter::visitGetElementPtrInst(GetElementPtrInst *I) {
|
||||||
|
outputLValue(I);
|
||||||
|
Out << "&";
|
||||||
|
printIndexingExpr(I);
|
||||||
|
Out << ";\n";
|
||||||
|
}
|
||||||
|
|
||||||
//===----------------------------------------------------------------------===//
|
//===----------------------------------------------------------------------===//
|
||||||
// External Interface declaration
|
// External Interface declaration
|
||||||
|
Loading…
Reference in New Issue
Block a user