1 //===-- Writer.cpp - Library for writing C files --------------------------===//
3 // This library implements the functionality defined in llvm/Assembly/CWriter.h
6 // TODO : Recursive types.
8 //===-----------------------------------------------------------------------==//
10 #include "llvm/Assembly/CWriter.h"
11 #include "CLocalVars.h"
12 #include "llvm/SlotCalculator.h"
13 #include "llvm/Module.h"
14 #include "llvm/Argument.h"
15 #include "llvm/Function.h"
16 #include "llvm/DerivedTypes.h"
17 #include "llvm/Constants.h"
18 #include "llvm/GlobalVariable.h"
19 #include "llvm/BasicBlock.h"
20 #include "llvm/iMemory.h"
21 #include "llvm/iTerminators.h"
22 #include "llvm/iPHINode.h"
23 #include "llvm/iOther.h"
24 #include "llvm/SymbolTable.h"
25 #include "llvm/Support/InstVisitor.h"
26 #include "Support/StringExtras.h"
27 #include "Support/STLExtras.h"
36 //===-----------------------------------------------------------------------==//
38 // Implementation of the CLocalVars methods
40 // Appends a variable to the LocalVars map if it does not already exist
41 // Also check that the type exists on the map.
42 void CLocalVars::addLocalVar(const Type *t, const string & var) {
43 if (!LocalVars.count(t) ||
44 find(LocalVars[t].begin(), LocalVars[t].end(), var)
45 == LocalVars[t].end()) {
46 LocalVars[t].push_back(var);
50 static string calcTypeNameVar(const Type *Ty,
51 map<const Type *, string> &TypeNames,
52 string VariableName, string NameSoFar);
54 static std::string getConstStrValue(const Constant* CPV);
58 //Getting opcodes in terms of the operator
60 static const char *getOpcodeOperName(const Instruction *I) {
61 switch (I->getOpcode()) {
62 // Standard binary operators...
63 case Instruction::Add: return "+";
64 case Instruction::Sub: return "-";
65 case Instruction::Mul: return "*";
66 case Instruction::Div: return "/";
67 case Instruction::Rem: return "%";
69 // Logical operators...
70 case Instruction::And: return "&";
71 case Instruction::Or: return "|";
72 case Instruction::Xor: return "^";
74 // SetCond operators...
75 case Instruction::SetEQ: return "==";
76 case Instruction::SetNE: return "!=";
77 case Instruction::SetLE: return "<=";
78 case Instruction::SetGE: return ">=";
79 case Instruction::SetLT: return "<";
80 case Instruction::SetGT: return ">";
84 case Instruction::Shl : return "<<";
85 case Instruction::Shr : return ">>";
88 cerr << "Invalid operator type!" << I->getOpcode() << "\n";
95 // We dont want identifier names with ., space, - in them.
96 // So we replace them with _
97 static string makeNameProper(string x) {
99 for (string::iterator sI = x.begin(), sEnd = x.end(); sI != sEnd; sI++) {
112 static string getConstantName(const Constant *CPV) {
113 return CPV->getName();
117 static std::string getConstArrayStrValue(const Constant* CPV) {
120 // As a special case, print the array as a string if it is an array of
121 // ubytes or an array of sbytes with positive values.
123 const Type *ETy = cast<ArrayType>(CPV->getType())->getElementType();
124 bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy);
126 if (ETy == Type::SByteTy) {
127 for (unsigned i = 0; i < CPV->getNumOperands(); ++i)
128 if (ETy == Type::SByteTy &&
129 cast<ConstantSInt>(CPV->getOperand(i))->getValue() < 0) {
137 for (unsigned i = 0; i < CPV->getNumOperands(); ++i) {
138 unsigned char C = (ETy == Type::SByteTy) ?
139 (unsigned char)cast<ConstantSInt>(CPV->getOperand(i))->getValue() :
140 (unsigned char)cast<ConstantUInt>(CPV->getOperand(i))->getValue();
146 Result += ( C/16 < 10) ? ( C/16 +'0') : ( C/16 -10+'A');
147 Result += ((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A');
154 if (CPV->getNumOperands()) {
155 Result += " " + getConstStrValue(cast<Constant>(CPV->getOperand(0)));
156 for (unsigned i = 1; i < CPV->getNumOperands(); i++)
157 Result += ", " + getConstStrValue(cast<Constant>(CPV->getOperand(i)));
165 static std::string getConstStructStrValue(const Constant* CPV) {
166 std::string Result = "{";
167 if (CPV->getNumOperands()) {
168 Result += " " + getConstStrValue(cast<Constant>(CPV->getOperand(0)));
169 for (unsigned i = 1; i < CPV->getNumOperands(); i++)
170 Result += ", " + getConstStrValue(cast<Constant>(CPV->getOperand(i)));
173 return Result + " }";
176 // our own getStrValue function for constant initializers
177 static std::string getConstStrValue(const Constant* CPV) {
178 // Does not handle null pointers, that needs to be checked explicitly
180 if (CPV == ConstantBool::False)
182 else if (CPV == ConstantBool::True)
185 else if (isa<ConstantArray>(CPV)) {
186 tempstr = getConstArrayStrValue(CPV);
188 else if (isa<ConstantStruct>(CPV)) {
189 tempstr = getConstStructStrValue(CPV);
191 else if (ConstantUInt *CUI = dyn_cast<ConstantUInt>(CPV)) {
192 tempstr = utostr(CUI->getValue());
194 else if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CPV)) {
195 tempstr = itostr(CSI->getValue());
197 else if (ConstantFP *CFP = dyn_cast<ConstantFP>(CPV)) {
198 tempstr = ftostr(CFP->getValue());
201 if (CPV->getType() == Type::ULongTy)
203 else if (CPV->getType() == Type::LongTy)
205 else if (CPV->getType() == Type::UIntTy ||
206 CPV->getType() == Type::UShortTy)
214 // Essentially pass the Type* variable, an empty typestack and this prints
216 static string calcTypeName(const Type *Ty, map<const Type *, string> &TypeNames,
217 string &FunctionInfo) {
219 // Takin' care of the fact that boolean would be int in C
220 // and that ushort would be unsigned short etc.
223 if (Ty->isPrimitiveType())
224 switch (Ty->getPrimitiveID()) {
225 case Type::VoidTyID: return "void";
226 case Type::BoolTyID: return "bool";
227 case Type::UByteTyID: return "unsigned char";
228 case Type::SByteTyID: return "signed char";
229 case Type::UShortTyID: return "unsigned short";
230 case Type::ShortTyID: return "short";
231 case Type::UIntTyID: return "unsigned";
232 case Type::IntTyID: return "int";
233 case Type::ULongTyID: return "unsigned long long";
234 case Type::LongTyID: return "signed long long";
235 case Type::FloatTyID: return "float";
236 case Type::DoubleTyID: return "double";
237 default : assert(0 && "Unknown primitive type!");
240 // Check to see if the type is named.
241 map<const Type *, string>::iterator I = TypeNames.find(Ty);
242 if (I != TypeNames.end())
247 switch (Ty->getPrimitiveID()) {
248 case Type::FunctionTyID: {
249 const FunctionType *MTy = cast<const FunctionType>(Ty);
250 Result = calcTypeName(MTy->getReturnType(), TypeNames, MInfo);
252 Result += ") " + MInfo;
254 FunctionInfo += " (";
255 for (FunctionType::ParamTypes::const_iterator
256 I = MTy->getParamTypes().begin(),
257 E = MTy->getParamTypes().end(); I != E; ++I) {
258 if (I != MTy->getParamTypes().begin())
259 FunctionInfo += ", ";
261 FunctionInfo += calcTypeName(*I, TypeNames, MInfo);
263 Result += ") " + MInfo;
265 if (MTy->isVarArg()) {
266 if (!MTy->getParamTypes().empty())
267 FunctionInfo += ", ";
268 FunctionInfo += "...";
273 case Type::StructTyID: {
275 const StructType *STy = cast<const StructType>(Ty);
276 Result = " struct {\n ";
278 for (StructType::ElementTypes::const_iterator
279 I = STy->getElementTypes().begin(),
280 E = STy->getElementTypes().end(); I != E; ++I) {
281 Result += calcTypeNameVar(*I, TypeNames,
282 "field" + itostr(indx++), tempstr);
288 case Type::PointerTyID:
289 Result = calcTypeName(cast<const PointerType>(Ty)->getElementType(),
293 case Type::ArrayTyID: {
294 const ArrayType *ATy = cast<const ArrayType>(Ty);
295 int NumElements = ATy->getNumElements();
296 Result = calcTypeName(ATy->getElementType(), TypeNames, MInfo);
301 assert(0 && "Unhandled case in getTypeProps!");
309 // Pass the Type* variable and and the variable name and this prints out the
310 // variable declaration.
311 // This is different from calcTypeName because if you need to declare an array
312 // the size of the array would appear after the variable name itself
313 // For eg. int a[10];
314 static string calcTypeNameVar(const Type *Ty,
315 map<const Type *, string> &TypeNames,
316 string VariableName, string NameSoFar) {
317 if (Ty->isPrimitiveType())
318 switch (Ty->getPrimitiveID()) {
320 return "bool " + NameSoFar + VariableName;
321 case Type::UByteTyID:
322 return "unsigned char " + NameSoFar + VariableName;
323 case Type::SByteTyID:
324 return "signed char " + NameSoFar + VariableName;
325 case Type::UShortTyID:
326 return "unsigned long long " + NameSoFar + VariableName;
327 case Type::ULongTyID:
328 return "unsigned long long " + NameSoFar + VariableName;
330 return "signed long long " + NameSoFar + VariableName;
332 return "unsigned " + NameSoFar + VariableName;
334 return Ty->getDescription() + " " + NameSoFar + VariableName;
337 // Check to see if the type is named.
338 map<const Type *, string>::iterator I = TypeNames.find(Ty);
339 if (I != TypeNames.end())
340 return I->second + " " + NameSoFar + VariableName;
345 switch (Ty->getPrimitiveID()) {
346 case Type::FunctionTyID: {
348 const FunctionType *MTy = cast<const FunctionType>(Ty);
349 Result += calcTypeName(MTy->getReturnType(), TypeNames, MInfo);
351 Result += ") " + MInfo;
352 Result += " " + NameSoFar + VariableName;
354 for (FunctionType::ParamTypes::const_iterator
355 I = MTy->getParamTypes().begin(),
356 E = MTy->getParamTypes().end(); I != E; ++I) {
357 if (I != MTy->getParamTypes().begin())
360 Result += calcTypeName(*I, TypeNames, MInfo);
362 Result += ") " + MInfo;
364 if (MTy->isVarArg()) {
365 if (!MTy->getParamTypes().empty())
372 case Type::StructTyID: {
373 const StructType *STy = cast<const StructType>(Ty);
374 Result = " struct {\n ";
376 for (StructType::ElementTypes::const_iterator
377 I = STy->getElementTypes().begin(),
378 E = STy->getElementTypes().end(); I != E; ++I) {
379 Result += calcTypeNameVar(*I, TypeNames,
380 "field" + itostr(indx++), "");
384 Result += " " + NameSoFar + VariableName;
388 case Type::PointerTyID: {
389 Result = calcTypeNameVar(cast<const PointerType>(Ty)->getElementType(),
391 "(*" + NameSoFar + VariableName + ")");
395 case Type::ArrayTyID: {
396 const ArrayType *ATy = cast<const ArrayType>(Ty);
397 int NumElements = ATy->getNumElements();
398 Result = calcTypeNameVar(ATy->getElementType(), TypeNames,
399 tempstr, NameSoFar + VariableName + "[" +
400 itostr(NumElements) + "]");
404 assert(0 && "Unhandled case in getTypeProps!");
411 // printTypeVarInt - The internal guts of printing out a type that has a
412 // potentially named portion and the variable associated with the type.
413 static ostream &printTypeVarInt(ostream &Out, const Type *Ty,
414 map<const Type *, string> &TypeNames,
415 const string &VariableName) {
416 // Primitive types always print out their description, regardless of whether
417 // they have been named or not.
419 if (Ty->isPrimitiveType())
420 switch (Ty->getPrimitiveID()) {
422 return Out << "bool " << VariableName;
423 case Type::UByteTyID:
424 return Out << "unsigned char " << VariableName;
425 case Type::SByteTyID:
426 return Out << "signed char " << VariableName;
427 case Type::UShortTyID:
428 return Out << "unsigned long long " << VariableName;
429 case Type::ULongTyID:
430 return Out << "unsigned long long " << VariableName;
432 return Out << "signed long long " << VariableName;
434 return Out << "unsigned " << VariableName;
436 return Out << Ty->getDescription() << " " << VariableName;
439 // Check to see if the type is named.
440 map<const Type *, string>::iterator I = TypeNames.find(Ty);
441 if (I != TypeNames.end()) return Out << I->second << " " << VariableName;
443 // Otherwise we have a type that has not been named but is a derived type.
444 // Carefully recurse the type hierarchy to print out any contained symbolic
447 string TypeNameVar, tempstr = "";
448 TypeNameVar = calcTypeNameVar(Ty, TypeNames, VariableName, tempstr);
449 return Out << TypeNameVar;
452 // Internal guts of printing a type name
453 static ostream &printTypeInt(ostream &Out, const Type *Ty,
454 map<const Type *, string> &TypeNames) {
455 // Primitive types always print out their description, regardless of whether
456 // they have been named or not.
458 if (Ty->isPrimitiveType())
459 switch (Ty->getPrimitiveID()) {
461 return Out << "bool";
462 case Type::UByteTyID:
463 return Out << "unsigned char";
464 case Type::SByteTyID:
465 return Out << "signed char";
466 case Type::UShortTyID:
467 return Out << "unsigned short";
468 case Type::ULongTyID:
469 return Out << "unsigned long long";
471 return Out << "signed long long";
473 return Out << "unsigned";
475 return Out << Ty->getDescription();
478 // Check to see if the type is named.
479 map<const Type *, string>::iterator I = TypeNames.find(Ty);
480 if (I != TypeNames.end()) return Out << I->second;
482 // Otherwise we have a type that has not been named but is a derived type.
483 // Carefully recurse the type hierarchy to print out any contained symbolic
487 string TypeName = calcTypeName(Ty, TypeNames, MInfo);
488 // TypeNames.insert(std::make_pair(Ty, TypeName));
489 //Cache type name for later use
491 return Out << TypeName << ")" << MInfo;
493 return Out << TypeName;
498 //Internal CWriter class mimics AssemblyWriter.
501 SlotCalculator &Table;
502 const Module *TheModule;
503 map<const Type *, string> TypeNames;
505 inline CWriter(ostream &o, SlotCalculator &Tab, const Module *M)
506 : Out(o), Table(Tab), TheModule(M) {
509 inline void write(const Module *M) { printModule(M); }
511 ostream& printTypeVar(const Type *Ty, const string &VariableName) {
512 return printTypeVarInt(Out, Ty, TypeNames, VariableName);
517 ostream& printType(const Type *Ty, ostream &Out);
518 void writeOperand(const Value *Operand, ostream &Out,bool PrintName = true);
520 string getValueName(const Value *V);
523 void printModule(const Module *M);
524 void printSymbolTable(const SymbolTable &ST);
525 void printConstant(const Constant *CPV);
526 void printGlobal(const GlobalVariable *GV);
527 void printFunctionSignature(const Function *F);
528 void printFunctionDecl(const Function *F); // Print just the forward decl
529 void printFunctionArgument(const Argument *FA);
531 void printFunction(const Function *);
533 void outputBasicBlock(const BasicBlock *);
535 /* END class CWriter */
538 /* CLASS InstLocalVarsVisitor */
539 class InstLocalVarsVisitor : public InstVisitor<InstLocalVarsVisitor> {
541 void handleTerminator(TerminatorInst *tI, int indx);
545 InstLocalVarsVisitor(CWriter &cw) : CW(cw) {}
547 void visitInstruction(Instruction *I) {
548 if (I->getType() != Type::VoidTy) {
549 string tempostr = CW.getValueName(I);
550 CLV.addLocalVar(I->getType(), tempostr);
554 void visitBranchInst(BranchInst *I) {
555 handleTerminator(I, 0);
556 if (I->isConditional())
557 handleTerminator(I, 1);
562 void InstLocalVarsVisitor::handleTerminator(TerminatorInst *tI,int indx) {
563 BasicBlock *bb = tI->getSuccessor(indx);
565 BasicBlock::const_iterator insIt = bb->begin();
566 while (insIt != bb->end()) {
567 if (const PHINode *pI = dyn_cast<PHINode>(*insIt)) {
569 // Calculate the incoming index for this
570 assert(pI->getBasicBlockIndex(tI->getParent()) != -1);
572 CLV.addLocalVar(pI->getType(), CW.getValueName(pI));
580 /* CLASS CInstPrintVisitor */
582 class CInstPrintVisitor: public InstVisitor<CInstPrintVisitor> {
584 SlotCalculator& Table;
586 const Value *Operand;
588 void outputLValue(Instruction *);
589 void printPhiFromNextBlock(TerminatorInst *tI, int indx);
592 CInstPrintVisitor (CWriter &cw, SlotCalculator& table, ostream& o)
593 : CW(cw), Table(table), Out(o) {
597 void visitCastInst(CastInst *I);
598 void visitCallInst(CallInst *I);
599 void visitShr(ShiftInst *I);
600 void visitShl(ShiftInst *I);
601 void visitReturnInst(ReturnInst *I);
602 void visitBranchInst(BranchInst *I);
603 void visitSwitchInst(SwitchInst *I);
604 void visitInvokeInst(InvokeInst *I) ;
605 void visitMallocInst(MallocInst *I);
606 void visitAllocaInst(AllocaInst *I);
607 void visitFreeInst(FreeInst *I);
608 void visitLoadInst(LoadInst *I);
609 void visitStoreInst(StoreInst *I);
610 void visitGetElementPtrInst(GetElementPtrInst *I);
611 void visitPHINode(PHINode *I);
612 void visitUnaryOperator (UnaryOperator *I);
613 void visitBinaryOperator(BinaryOperator *I);
617 void CInstPrintVisitor::outputLValue(Instruction *I) {
618 Out << " " << CW.getValueName(I) << " = ";
621 void CInstPrintVisitor::printPhiFromNextBlock(TerminatorInst *tI, int indx) {
622 BasicBlock *bb = tI->getSuccessor(indx);
623 BasicBlock::const_iterator insIt = bb->begin();
624 while (insIt != bb->end()) {
625 if (PHINode *pI = dyn_cast<PHINode>(*insIt)) {
627 //Calculate the incoming index for this
628 int incindex = pI->getBasicBlockIndex(tI->getParent());
629 if (incindex != -1) {
630 //now we have to do the printing
632 CW.writeOperand(pI->getIncomingValue(incindex), Out);
641 // Implement all "other" instructions, except for PHINode
642 void CInstPrintVisitor::visitCastInst(CastInst *I) {
644 Operand = I->getNumOperands() ? I->getOperand(0) : 0;
646 CW.printType(I->getType(), Out);
648 CW.writeOperand(Operand, Out);
652 void CInstPrintVisitor::visitCallInst(CallInst *I) {
654 Operand = I->getNumOperands() ? I->getOperand(0) : 0;
655 const PointerType *PTy = dyn_cast<PointerType>(Operand->getType());
656 const FunctionType *MTy = PTy
657 ? dyn_cast<FunctionType>(PTy->getElementType()):0;
658 const Type *RetTy = MTy ? MTy->getReturnType() : 0;
660 // If possible, print out the short form of the call instruction, but we can
661 // only do this if the first argument is a pointer to a nonvararg method,
662 // and if the value returned is not a pointer to a method.
664 if (RetTy && !MTy->isVarArg() &&
665 (!isa<PointerType>(RetTy)||
666 !isa<FunctionType>(cast<PointerType>(RetTy)))){
668 Out << makeNameProper(Operand->getName());
670 Out << makeNameProper(Operand->getName());
673 if (I->getNumOperands() > 1)
674 CW.writeOperand(I->getOperand(1), Out);
675 for (unsigned op = 2, Eop = I->getNumOperands(); op < Eop; ++op) {
677 CW.writeOperand(I->getOperand(op), Out);
683 void CInstPrintVisitor::visitShr(ShiftInst *I) {
685 Operand = I->getNumOperands() ? I->getOperand(0) : 0;
687 CW.writeOperand(Operand, Out);
690 CW.writeOperand(I->getOperand(1), Out);
694 void CInstPrintVisitor::visitShl(ShiftInst *I) {
696 Operand = I->getNumOperands() ? I->getOperand(0) : 0;
698 CW.writeOperand(Operand, Out);
701 CW.writeOperand(I->getOperand(1), Out);
705 // Specific Instruction type classes... note that all of the casts are
706 // neccesary because we use the instruction classes as opaque types...
708 void CInstPrintVisitor::visitReturnInst(ReturnInst *I) {
710 if (I->getNumOperands())
711 CW.writeOperand(I->getOperand(0), Out);
715 void CInstPrintVisitor::visitBranchInst(BranchInst *I) {
716 TerminatorInst *tI = cast<TerminatorInst>(I);
717 if (I->isConditional()) {
719 CW.writeOperand(I->getCondition(), Out);
721 printPhiFromNextBlock(tI,0);
723 CW.writeOperand(I->getOperand(0), Out);
726 printPhiFromNextBlock(tI,1);
728 CW.writeOperand(I->getOperand(1), Out);
731 printPhiFromNextBlock(tI,0);
733 CW.writeOperand(I->getOperand(0), Out);
739 void CInstPrintVisitor::visitSwitchInst(SwitchInst *I) {
743 void CInstPrintVisitor::visitInvokeInst(InvokeInst *I) {
747 void CInstPrintVisitor::visitMallocInst(MallocInst *I) {
749 Operand = I->getNumOperands() ? I->getOperand(0) : 0;
752 CW.printType(cast<const PointerType>(I->getType())->getElementType(), Out);
753 Out << "*) malloc(sizeof(";
754 CW.printTypeVar(cast<const PointerType>(I->getType())->getElementType(),
757 if (I->getNumOperands()) {
759 CW.writeOperand(Operand, Out);
764 void CInstPrintVisitor::visitAllocaInst(AllocaInst *I) {
766 Operand = I->getNumOperands() ? I->getOperand(0) : 0;
769 CW.printTypeVar(I->getType(), tempstr);
770 Out << ") alloca(sizeof(";
771 CW.printTypeVar(cast<PointerType>(I->getType())->getElementType(),
774 if (I->getNumOperands()) {
776 CW.writeOperand(Operand, Out);
781 void CInstPrintVisitor::visitFreeInst(FreeInst *I) {
782 Operand = I->getNumOperands() ? I->getOperand(0) : 0;
784 CW.writeOperand(Operand, Out);
788 void CInstPrintVisitor::visitLoadInst(LoadInst *I) {
790 Operand = I->getNumOperands() ? I->getOperand(0) : 0;
791 if (I->getNumOperands() <= 1) {
793 CW.writeOperand(Operand, Out);
796 //Check if it is an array type or struct type ptr!
798 const PointerType *PTy = dyn_cast<PointerType>(I->getType());
799 if (cast<const PointerType>(Operand->getType())->getElementType()->getPrimitiveID() == Type::StructTyID)
801 if (arrtype && isa<GlobalValue>(Operand))
803 CW.writeOperand(Operand,Out);
804 for (unsigned i = 1, E = I->getNumOperands(); i != E; ++i) {
806 if (arrtype || !isa<GlobalValue>(Operand)) {
808 CW.writeOperand(I->getOperand(i), Out);
811 if (isa<GlobalValue>(Operand) && arrtype)
815 if (arrtype == 1) Out << "[";
818 CW.writeOperand(I->getOperand(i), Out);
819 if (arrtype == 1) Out << "]";
826 void CInstPrintVisitor::visitStoreInst(StoreInst *I) {
827 Operand = I->getNumOperands() ? I->getOperand(0) : 0;
828 if (I->getNumOperands() <= 2) {
830 CW.writeOperand(I->getOperand(1), Out);
833 //Check if it is an array type or struct type ptr!
835 if (cast<const PointerType>(I->getOperand(1)->getType())->getElementType()->getPrimitiveID() == Type::StructTyID)
837 if (isa<GlobalValue>(I->getOperand(1)) && arrtype)
839 CW.writeOperand(I->getOperand(1), Out);
840 for (unsigned i = 2, E = I->getNumOperands(); i != E; ++i) {
842 if (arrtype || !isa<GlobalValue>(I->getOperand(1))) {
844 CW.writeOperand(I->getOperand(i), Out);
847 if (isa<GlobalValue>(I->getOperand(1)) && arrtype)
851 if (arrtype == 1) Out << "[";
854 CW.writeOperand(I->getOperand(i), Out);
855 if (arrtype == 1) Out << "]";
860 CW.writeOperand(Operand, Out);
864 void CInstPrintVisitor::visitGetElementPtrInst(GetElementPtrInst *I) {
866 Operand = I->getNumOperands() ? I->getOperand(0) : 0;
868 if (I->getNumOperands() <= 1)
869 CW.writeOperand(Operand, Out);
871 //Check if it is an array type or struct type ptr!
873 if ((cast<const PointerType>(Operand->getType()))->getElementType()->getPrimitiveID() == Type::StructTyID)
875 if ((isa<GlobalValue>(Operand)) && arrtype)
877 CW.writeOperand(Operand, Out);
878 for (unsigned i = 1, E = I->getNumOperands(); i != E; ++i) {
880 if (arrtype || !isa<GlobalValue>(Operand)){
882 CW.writeOperand(I->getOperand(i), Out);
885 if (isa<GlobalValue>(Operand) && arrtype)
889 if (arrtype == 1) Out << "[";
892 CW.writeOperand(I->getOperand(i), Out);
893 if (arrtype == 1) Out << "]";
900 void CInstPrintVisitor::visitPHINode(PHINode *I) {
904 void CInstPrintVisitor::visitUnaryOperator (UnaryOperator *I) {
905 if (I->getOpcode() == Instruction::Not) {
907 Operand = I->getNumOperands() ? I->getOperand(0) : 0;
909 CW.writeOperand(Operand, Out);
913 Out << "<bad unary inst>\n";
917 void CInstPrintVisitor::visitBinaryOperator(BinaryOperator *I) {
918 //binary instructions, shift instructions, setCond instructions.
920 Operand = I->getNumOperands() ? I->getOperand(0) : 0;
921 if (I->getType()->getPrimitiveID() == Type::PointerTyID) {
923 CW.printType(I->getType(), Out);
927 if (Operand->getType()->getPrimitiveID() == Type::PointerTyID)
928 Out << "(long long)";
929 CW.writeOperand(Operand, Out);
930 Out << getOpcodeOperName(I);
931 // Need the extra parenthisis if the second operand is < 0
933 if (I->getOperand(1)->getType()->getPrimitiveID() == Type::PointerTyID)
934 Out << "(long long)";
935 CW.writeOperand(I->getOperand(1), Out);
940 /* END : CInstPrintVisitor implementation */
942 string CWriter::getValueName(const Value *V) {
943 if (V->hasName()) // Print out the label if it exists...
944 return "llvm__" + makeNameProper(V->getName()) + "_" +
945 utostr(V->getType()->getUniqueID());
947 int Slot = Table.getValSlot(V);
948 assert(Slot >= 0 && "Invalid value!");
949 return "llvm__tmp_" + itostr(Slot) + "_" +
950 utostr(V->getType()->getUniqueID());
953 void CWriter::printModule(const Module *M) {
954 // printing stdlib inclusion
955 // Out << "#include <stdlib.h>\n";
957 // get declaration for alloca
958 Out << "/* Provide Declarations */\n"
959 << "#include <alloca.h>\n\n"
961 // Provide a definition for null if one does not already exist.
962 << "#ifndef NULL\n#define NULL 0\n#endif\n\n"
963 << "typedef unsigned char bool;\n"
965 << "\n\n/* Global Symbols */\n";
967 // Loop over the symbol table, emitting all named constants...
968 if (M->hasSymbolTable())
969 printSymbolTable(*M->getSymbolTable());
971 Out << "\n\n/* Global Data */\n";
972 for_each(M->gbegin(), M->gend(),
973 bind_obj(this, &CWriter::printGlobal));
975 // First output all the declarations of the functions as C requires Functions
976 // be declared before they are used.
978 Out << "\n\n/* Function Declarations */\n";
979 for_each(M->begin(), M->end(), bind_obj(this, &CWriter::printFunctionDecl));
981 // Output all of the functions...
982 Out << "\n\n/* Function Bodies */\n";
983 for_each(M->begin(), M->end(), bind_obj(this, &CWriter::printFunction));
986 // prints the global constants
987 void CWriter::printGlobal(const GlobalVariable *GV) {
988 string tempostr = getValueName(GV);
989 if (GV->hasInternalLinkage()) Out << "static ";
991 printTypeVar(GV->getType()->getElementType(), tempostr);
993 if (GV->hasInitializer()) {
995 writeOperand(GV->getInitializer(), Out, false);
1001 // printSymbolTable - Run through symbol table looking for named constants
1002 // if a named constant is found, emit it's declaration...
1003 // Assuming that symbol table has only types and constants.
1004 void CWriter::printSymbolTable(const SymbolTable &ST) {
1006 for (SymbolTable::const_iterator TI = ST.begin(); TI != ST.end(); ++TI) {
1007 SymbolTable::type_const_iterator I = ST.type_begin(TI->first);
1008 SymbolTable::type_const_iterator End = ST.type_end(TI->first);
1011 // Need to run through all the used types in the program
1012 // FindUsedTypes &FUT = new FindUsedTypes();
1013 // const std::set<const Type *> &UsedTypes = FUT.getTypes();
1014 // Filter out the structures printing forward definitions for each of them
1015 // and creating the dependency graph.
1016 // Print forward definitions to all of them
1017 // print the typedefs topologically sorted
1019 // But for now we have
1020 for (; I != End; ++I) {
1021 const Value *V = I->second;
1022 if (const Constant *CPV = dyn_cast<const Constant>(V)) {
1024 } else if (const Type *Ty = dyn_cast<const Type>(V)) {
1026 string tempstr = "";
1028 tempostr = "llvm__" + I->first;
1029 string TypeNameVar = calcTypeNameVar(Ty, TypeNames,
1031 Out << TypeNameVar << ";\n";
1032 if (!isa<PointerType>(Ty) ||
1033 !cast<PointerType>(Ty)->getElementType()->isPrimitiveType())
1034 TypeNames.insert(std::make_pair(Ty, "llvm__"+I->first));
1041 // printConstant - Print out a constant pool entry...
1043 void CWriter::printConstant(const Constant *CPV) {
1045 // Dinakar : Don't know what to do with unnamed constants
1046 // should do something about it later.
1048 string tempostr = getValueName(CPV);
1050 // Print out the constant type...
1051 printTypeVar(CPV->getType(), tempostr);
1054 // Write the value out now...
1055 writeOperand(CPV, Out, false);
1060 // printFunctionDecl - Print function declaration
1062 void CWriter::printFunctionDecl(const Function *F) {
1063 printFunctionSignature(F);
1067 void CWriter::printFunctionSignature(const Function *F) {
1068 if (F->hasInternalLinkage()) Out << "static ";
1070 // Loop over the arguments, printing them...
1071 const FunctionType *FT = cast<FunctionType>(F->getFunctionType());
1073 // Print out the return type and name...
1074 printType(F->getReturnType(), Out);
1075 Out << " " << makeNameProper(F->getName()) << "(";
1077 if (!F->isExternal()) {
1078 for_each(F->getArgumentList().begin(), F->getArgumentList().end(),
1079 bind_obj(this, &CWriter::printFunctionArgument));
1081 // Loop over the arguments, printing them...
1082 for (FunctionType::ParamTypes::const_iterator I =
1083 FT->getParamTypes().begin(),
1084 E = FT->getParamTypes().end(); I != E; ++I) {
1085 if (I != FT->getParamTypes().begin()) Out << ", ";
1090 // Finish printing arguments...
1091 if (FT->isVarArg()) {
1092 if (FT->getParamTypes().size()) Out << ", ";
1093 Out << "..."; // Output varargs portion of signature!
1099 // printFunctionArgument - This member is called for every argument that
1100 // is passed into the method. Simply print it out
1102 void CWriter::printFunctionArgument(const Argument *Arg) {
1103 // Insert commas as we go... the first arg doesn't get a comma
1104 if (Arg != Arg->getParent()->getArgumentList().front()) Out << ", ";
1107 printTypeVar(Arg->getType(), getValueName(Arg));
1110 void CWriter::printFunction(const Function *F) {
1111 if (F->isExternal()) return;
1113 // Process each of the basic blocks, gather information and call the
1114 // output methods on the CLocalVars and Function* objects.
1116 // gather local variable information for each basic block
1117 InstLocalVarsVisitor ILV(*this);
1118 ILV.visit((Function *)F);
1120 printFunctionSignature(F);
1123 // Loop over the symbol table, emitting all named constants...
1124 if (F->hasSymbolTable())
1125 printSymbolTable(*F->getSymbolTable());
1127 // print the local variables
1128 // we assume that every local variable is alloca'ed in the C code.
1129 std::map<const Type*, VarListType> &locals = ILV.CLV.LocalVars;
1131 map<const Type*, VarListType>::iterator iter;
1132 for (iter = locals.begin(); iter != locals.end(); ++iter) {
1133 VarListType::iterator listiter;
1134 for (listiter = iter->second.begin(); listiter != iter->second.end();
1137 printTypeVar(iter->first, *listiter);
1142 // print the basic blocks
1143 for_each(F->begin(), F->end(), bind_obj(this, &CWriter::outputBasicBlock));
1148 void CWriter::outputBasicBlock(const BasicBlock* BB) {
1149 Out << getValueName(BB) << ":\n";
1151 // Output all of the instructions in the basic block...
1152 // print the basic blocks
1153 CInstPrintVisitor CIPV(*this, Table, Out);
1154 CIPV.visit((BasicBlock *) BB);
1157 // printType - Go to extreme measures to attempt to print out a short, symbolic
1158 // version of a type name.
1159 ostream& CWriter::printType(const Type *Ty, ostream &Out) {
1160 return printTypeInt(Out, Ty, TypeNames);
1164 void CWriter::writeOperand(const Value *Operand,
1165 ostream &Out, bool PrintName = true) {
1166 if (PrintName && Operand->hasName()) {
1167 // If Operand has a name.
1168 Out << "llvm__" << makeNameProper(Operand->getName()) << "_" <<
1169 Operand->getType()->getUniqueID();
1172 else if (const Constant *CPV = dyn_cast<const Constant>(Operand)) {
1173 if (isa<ConstantPointerNull>(CPV))
1176 Out << getConstStrValue(CPV);
1179 int Slot = Table.getValSlot(Operand);
1181 Out << "llvm__tmp_" << Slot << "_" << Operand->getType()->getUniqueID();
1188 //===----------------------------------------------------------------------===//
1189 // External Interface declaration
1190 //===----------------------------------------------------------------------===//
1192 void WriteToC(const Module *C, ostream &Out) {
1193 assert(C && "You can't write a null module!!");
1194 SlotCalculator SlotTable(C, true);
1195 CWriter W(Out, SlotTable, C);