lib/Target/CBackend/CBackend.cpp

   1 //===-- Writer.cpp - Library for writing C files --------------------------===//
   2 //
   3 // This library implements the functionality defined in llvm/Assembly/CWriter.h
   4 // and CLocalVars.h
   5 //
   6 // TODO : Recursive types.
   7 //
   8 //===-----------------------------------------------------------------------==//
   9
  10 #include "llvm/Assembly/CWriter.h"
  11 #include "llvm/SlotCalculator.h"
  12 #include "llvm/Constants.h"
  13 #include "llvm/DerivedTypes.h"
  14 #include "llvm/Module.h"
  15 #include "llvm/GlobalVariable.h"
  16 #include "llvm/Function.h"
  17 #include "llvm/Argument.h"
  18 #include "llvm/BasicBlock.h"
  19 #include "llvm/iMemory.h"
  20 #include "llvm/iTerminators.h"
  21 #include "llvm/iPHINode.h"
  22 #include "llvm/iOther.h"
  23 #include "llvm/iOperators.h"
  24 #include "llvm/SymbolTable.h"
  25 #include "llvm/Support/InstVisitor.h"
  26 #include "llvm/Support/InstIterator.h"
  27 #include "Support/StringExtras.h"
  28 #include "Support/STLExtras.h"
  29
  30 #include <algorithm>
  31 #include <strstream>
  32 using std::string;
  33 using std::map;
  34 using std::ostream;
  35
  36 static std::string getConstStrValue(const Constant* CPV);
  37
  38
  39 static std::string getConstArrayStrValue(const Constant* CPV) {
  40   std::string Result;
  41
  42   // As a special case, print the array as a string if it is an array of
  43   // ubytes or an array of sbytes with positive values.
  44   //
  45   const Type *ETy = cast<ArrayType>(CPV->getType())->getElementType();
  46   bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy);
  47
  48   // Make sure the last character is a null char, as automatically added by C
  49   if (CPV->getNumOperands() == 0 ||
  50       !cast<Constant>(*(CPV->op_end()-1))->isNullValue())
  51     isString = false;
  52
  53   if (isString) {
  54     Result = "\"";
  55     // Do not include the last character, which we know is null
  56     for (unsigned i = 0, e = CPV->getNumOperands()-1; i != e; ++i) {
  57       unsigned char C = (ETy == Type::SByteTy) ?
  58         (unsigned char)cast<ConstantSInt>(CPV->getOperand(i))->getValue() :
  59         (unsigned char)cast<ConstantUInt>(CPV->getOperand(i))->getValue();
  60
  61       if (isprint(C)) {
  62         Result += C;
  63       } else {
  64         switch (C) {
  65         case '\n': Result += "\\n"; break;
  66         case '\t': Result += "\\t"; break;
  67         case '\r': Result += "\\r"; break;
  68         case '\v': Result += "\\v"; break;
  69         case '\a': Result += "\\a"; break;
  70         default:
  71           Result += "\\x";
  72           Result += ( C/16  < 10) ? ( C/16 +'0') : ( C/16 -10+'A');
  73           Result += ((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A');
  74           break;
  75         }
  76       }
  77     }
  78     Result += "\"";
  79   } else {
  80     Result = "{";
  81     if (CPV->getNumOperands()) {
  82       Result += " " +  getConstStrValue(cast<Constant>(CPV->getOperand(0)));
  83       for (unsigned i = 1; i < CPV->getNumOperands(); i++)
  84         Result += ", " + getConstStrValue(cast<Constant>(CPV->getOperand(i)));
  85     }
  86     Result += " }";
  87   }
  88
  89   return Result;
  90 }
  91
  92 static std::string getConstStrValue(const Constant* CPV) {
  93   switch (CPV->getType()->getPrimitiveID()) {
  94   case Type::BoolTyID:  return CPV == ConstantBool::False ? "0" : "1";
  95   case Type::SByteTyID:
  96   case Type::ShortTyID:
  97   case Type::IntTyID:   return itostr(cast<ConstantSInt>(CPV)->getValue());
  98   case Type::LongTyID:  return itostr(cast<ConstantSInt>(CPV)->getValue())+"ll";
  99
 100   case Type::UByteTyID:
 101   case Type::UShortTyID:return utostr(cast<ConstantUInt>(CPV)->getValue());
 102   case Type::UIntTyID:  return utostr(cast<ConstantUInt>(CPV)->getValue())+"u";
 103   case Type::ULongTyID:return utostr(cast<ConstantUInt>(CPV)->getValue())+"ull";
 104
 105   case Type::FloatTyID:
 106   case Type::DoubleTyID: return ftostr(cast<ConstantFP>(CPV)->getValue());
 107
 108   case Type::ArrayTyID:  return getConstArrayStrValue(CPV);
 109
 110   case Type::StructTyID: {
 111     std::string Result = "{";
 112     if (CPV->getNumOperands()) {
 113       Result += " " + getConstStrValue(cast<Constant>(CPV->getOperand(0)));
 114       for (unsigned i = 1; i < CPV->getNumOperands(); i++)
 115         Result += ", " + getConstStrValue(cast<Constant>(CPV->getOperand(i)));
 116     }
 117     return Result + " }";
 118   }
 119
 120   default:
 121     cerr << "Unknown constant type: " << CPV << "\n";
 122     abort();
 123   }
 124 }
 125
 126 // Pass the Type* variable and and the variable name and this prints out the
 127 // variable declaration.
 128 //
 129 static string calcTypeNameVar(const Type *Ty,
 130                               map<const Type *, string> &TypeNames,
 131                               const string &NameSoFar, bool ignoreName = false){
 132   if (Ty->isPrimitiveType())
 133     switch (Ty->getPrimitiveID()) {
 134     case Type::VoidTyID:   return "void " + NameSoFar;
 135     case Type::BoolTyID:   return "bool " + NameSoFar;
 136     case Type::UByteTyID:  return "unsigned char " + NameSoFar;
 137     case Type::SByteTyID:  return "signed char " + NameSoFar;
 138     case Type::UShortTyID: return "unsigned short " + NameSoFar;
 139     case Type::ShortTyID:  return "short " + NameSoFar;
 140     case Type::UIntTyID:   return "unsigned " + NameSoFar;
 141     case Type::IntTyID:    return "int " + NameSoFar;
 142     case Type::ULongTyID:  return "unsigned long long " + NameSoFar;
 143     case Type::LongTyID:   return "signed long long " + NameSoFar;
 144     case Type::FloatTyID:  return "float " + NameSoFar;
 145     case Type::DoubleTyID: return "double " + NameSoFar;
 146     default :
 147       cerr << "Unknown primitive type: " << Ty << "\n";
 148       abort();
 149     }
 150
 151   // Check to see if the type is named.
 152   if (!ignoreName) {
 153     map<const Type *, string>::iterator I = TypeNames.find(Ty);
 154     if (I != TypeNames.end())
 155       return I->second + " " + NameSoFar;
 156   }
 157
 158   string Result;
 159   switch (Ty->getPrimitiveID()) {
 160   case Type::FunctionTyID: {
 161     const FunctionType *MTy = cast<FunctionType>(Ty);
 162     Result += calcTypeNameVar(MTy->getReturnType(), TypeNames, "");
 163     Result += " " + NameSoFar + " (";
 164     for (FunctionType::ParamTypes::const_iterator
 165            I = MTy->getParamTypes().begin(),
 166            E = MTy->getParamTypes().end(); I != E; ++I) {
 167       if (I != MTy->getParamTypes().begin())
 168         Result += ", ";
 169       Result += calcTypeNameVar(*I, TypeNames, "");
 170     }
 171     if (MTy->isVarArg()) {
 172       if (!MTy->getParamTypes().empty())
 173         Result += ", ";
 174       Result += "...";
 175     }
 176     return Result + ")";
 177   }
 178   case Type::StructTyID: {
 179     const StructType *STy = cast<const StructType>(Ty);
 180     Result = NameSoFar + " {\n";
 181     unsigned indx = 0;
 182     for (StructType::ElementTypes::const_iterator
 183            I = STy->getElementTypes().begin(),
 184            E = STy->getElementTypes().end(); I != E; ++I) {
 185       Result += "  " +calcTypeNameVar(*I, TypeNames, "field" + utostr(indx++));
 186       Result += ";\n";
 187     }
 188     return Result + "}";
 189   }
 190
 191   case Type::PointerTyID: {
 192     return calcTypeNameVar(cast<const PointerType>(Ty)->getElementType(),
 193                            TypeNames, "*" + NameSoFar);
 194   }
 195
 196   case Type::ArrayTyID: {
 197     const ArrayType *ATy = cast<const ArrayType>(Ty);
 198     int NumElements = ATy->getNumElements();
 199     return calcTypeNameVar(ATy->getElementType(), TypeNames,
 200                            NameSoFar + "[" + itostr(NumElements) + "]");
 201   }
 202   default:
 203     assert(0 && "Unhandled case in getTypeProps!");
 204     abort();
 205   }
 206
 207   return Result;
 208 }
 209
 210 namespace {
 211   class CWriter : public InstVisitor<CWriter> {
 212     ostream& Out;
 213     SlotCalculator &Table;
 214     const Module *TheModule;
 215     map<const Type *, string> TypeNames;
 216   public:
 217     inline CWriter(ostream &o, SlotCalculator &Tab, const Module *M)
 218       : Out(o), Table(Tab), TheModule(M) {
 219     }
 220
 221     inline void write(Module *M) { printModule(M); }
 222
 223     ostream& printTypeVar(const Type *Ty, const string &VariableName) {
 224       return Out << calcTypeNameVar(Ty, TypeNames, VariableName);
 225     }
 226
 227     ostream& printType(const Type *Ty) {
 228       return Out << calcTypeNameVar(Ty, TypeNames, "");
 229     }
 230
 231     void writeOperand(const Value *Operand);
 232
 233     string getValueName(const Value *V);
 234
 235   private :
 236     void printModule(Module *M);
 237     void printSymbolTable(const SymbolTable &ST);
 238     void printGlobal(const GlobalVariable *GV);
 239     void printFunctionSignature(const Function *F);
 240     void printFunctionDecl(const Function *F); // Print just the forward decl
 241
 242     void printFunction(Function *);
 243
 244     // Instruction visitation functions
 245     friend class InstVisitor<CWriter>;
 246
 247     void visitReturnInst(ReturnInst *I);
 248     void visitBranchInst(BranchInst *I);
 249
 250     void visitPHINode(PHINode *I) {}
 251     void visitNot(GenericUnaryInst *I);
 252     void visitBinaryOperator(Instruction *I);
 253
 254     void visitCastInst(CastInst *I);
 255     void visitCallInst(CallInst *I);
 256     void visitShiftInst(ShiftInst *I) { visitBinaryOperator(I); }
 257
 258     void visitMallocInst(MallocInst *I);
 259     void visitAllocaInst(AllocaInst *I);
 260     void visitFreeInst(FreeInst   *I);
 261     void visitLoadInst(LoadInst   *I);
 262     void visitStoreInst(StoreInst  *I);
 263     void visitGetElementPtrInst(GetElementPtrInst *I);
 264
 265     void visitInstruction(Instruction *I) {
 266       cerr << "C Writer does not know about " << I;
 267       abort();
 268     }
 269
 270     void outputLValue(Instruction *I) {
 271       Out << "  " << getValueName(I) << " = ";
 272     }
 273     void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock,
 274                             unsigned Indent);
 275     void printIndexingExpr(MemAccessInst *MAI);
 276   };
 277 }
 278
 279 // We dont want identifier names with ., space, -  in them.
 280 // So we replace them with _
 281 static string makeNameProper(string x) {
 282   string tmp;
 283   for (string::iterator sI = x.begin(), sEnd = x.end(); sI != sEnd; sI++)
 284     switch (*sI) {
 285     case '.': tmp += "d_"; break;
 286     case ' ': tmp += "s_"; break;
 287     case '-': tmp += "D_"; break;
 288     case '_': tmp += "__"; break;
 289     default:  tmp += *sI;
 290     }
 291
 292   return tmp;
 293 }
 294
 295 string CWriter::getValueName(const Value *V) {
 296   if (V->hasName()) {             // Print out the label if it exists...
 297     if (isa<GlobalValue>(V))  // Do not mangle globals...
 298       return makeNameProper(V->getName());
 299
 300     return "l" + utostr(V->getType()->getUniqueID()) + "_" +
 301            makeNameProper(V->getName());
 302   }
 303
 304   int Slot = Table.getValSlot(V);
 305   assert(Slot >= 0 && "Invalid value!");
 306   return "ltmp_" + itostr(Slot) + "_" + utostr(V->getType()->getUniqueID());
 307 }
 308
 309 void CWriter::writeOperand(const Value *Operand) {
 310   if (isa<GlobalVariable>(Operand))
 311     Out << "(&";  // Global variables are references as their addresses by llvm
 312
 313   if (Operand->hasName()) {
 314     Out << getValueName(Operand);
 315   } else if (const Constant *CPV = dyn_cast<const Constant>(Operand)) {
 316     if (isa<ConstantPointerNull>(CPV)) {
 317       Out << "((";
 318       printTypeVar(CPV->getType(), "");
 319       Out << ")NULL)";
 320     } else
 321       Out << getConstStrValue(CPV);
 322   } else {
 323     int Slot = Table.getValSlot(Operand);
 324     assert(Slot >= 0 && "Malformed LLVM!");
 325     Out << "ltmp_" << Slot << "_" << Operand->getType()->getUniqueID();
 326   }
 327
 328   if (isa<GlobalVariable>(Operand))
 329     Out << ")";
 330 }
 331
 332 void CWriter::printModule(Module *M) {
 333   // printing stdlib inclusion
 334   // Out << "#include <stdlib.h>\n";
 335
 336   // get declaration for alloca
 337   Out << "/* Provide Declarations */\n"
 338       << "#include <alloca.h>\n\n"
 339
 340     // Provide a definition for null if one does not already exist.
 341       << "#ifndef NULL\n#define NULL 0\n#endif\n\n"
 342       << "typedef unsigned char bool;\n"
 343
 344       << "\n\n/* Global Symbols */\n";
 345
 346   // Loop over the symbol table, emitting all named constants...
 347   if (M->hasSymbolTable())
 348     printSymbolTable(*M->getSymbolTable());
 349
 350   Out << "\n\n/* Global Data */\n";
 351   for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I) {
 352     GlobalVariable *GV = *I;
 353     if (GV->hasInternalLinkage()) Out << "static ";
 354     printTypeVar(GV->getType()->getElementType(), getValueName(GV));
 355
 356     if (GV->hasInitializer()) {
 357       Out << " = " ;
 358       writeOperand(GV->getInitializer());
 359     }
 360     Out << ";\n";
 361   }
 362
 363   // First output all the declarations of the functions as C requires Functions
 364   // be declared before they are used.
 365   //
 366   Out << "\n\n/* Function Declarations */\n";
 367   for_each(M->begin(), M->end(), bind_obj(this, &CWriter::printFunctionDecl));
 368
 369   // Output all of the functions...
 370   Out << "\n\n/* Function Bodies */\n";
 371   for_each(M->begin(), M->end(), bind_obj(this, &CWriter::printFunction));
 372 }
 373
 374
 375 // printSymbolTable - Run through symbol table looking for named constants
 376 // if a named constant is found, emit it's declaration...
 377 // Assuming that symbol table has only types and constants.
 378 void CWriter::printSymbolTable(const SymbolTable &ST) {
 379   for (SymbolTable::const_iterator TI = ST.begin(); TI != ST.end(); ++TI) {
 380     SymbolTable::type_const_iterator I = ST.type_begin(TI->first);
 381     SymbolTable::type_const_iterator End = ST.type_end(TI->first);
 382
 383     for (; I != End; ++I)
 384       if (const Type *Ty = dyn_cast<const StructType>(I->second)) {
 385         string Name = "struct l_" + I->first;
 386         Out << Name << ";\n";
 387
 388         TypeNames.insert(std::make_pair(Ty, Name));
 389       }
 390   }
 391
 392   Out << "\n";
 393
 394   for (SymbolTable::const_iterator TI = ST.begin(); TI != ST.end(); ++TI) {
 395     SymbolTable::type_const_iterator I = ST.type_begin(TI->first);
 396     SymbolTable::type_const_iterator End = ST.type_end(TI->first);
 397
 398     for (; I != End; ++I) {
 399       const Value *V = I->second;
 400       if (const Type *Ty = dyn_cast<const Type>(V)) {
 401         string Name = "l_" + I->first;
 402         if (isa<StructType>(Ty))
 403           Name = "struct " + Name;
 404         else
 405           Out << "typedef ";
 406
 407         Out << calcTypeNameVar(Ty, TypeNames, Name, true) << ";\n";
 408       }
 409     }
 410   }
 411 }
 412
 413
 414 // printFunctionDecl - Print function declaration
 415 //
 416 void CWriter::printFunctionDecl(const Function *F) {
 417   printFunctionSignature(F);
 418   Out << ";\n";
 419 }
 420
 421 void CWriter::printFunctionSignature(const Function *F) {
 422   if (F->hasInternalLinkage()) Out << "static ";
 423
 424   // Loop over the arguments, printing them...
 425   const FunctionType *FT = cast<FunctionType>(F->getFunctionType());
 426
 427   // Print out the return type and name...
 428   printType(F->getReturnType());
 429   Out << getValueName(F) << "(";
 430
 431   if (!F->isExternal()) {
 432     if (!F->getArgumentList().empty()) {
 433       printTypeVar(F->getArgumentList().front()->getType(),
 434                    getValueName(F->getArgumentList().front()));
 435
 436       for (Function::ArgumentListType::const_iterator
 437              I = F->getArgumentList().begin()+1,
 438              E = F->getArgumentList().end(); I != E; ++I) {
 439         Out << ", ";
 440         printTypeVar((*I)->getType(), getValueName(*I));
 441       }
 442     }
 443   } else {
 444     // Loop over the arguments, printing them...
 445     for (FunctionType::ParamTypes::const_iterator I =
 446            FT->getParamTypes().begin(),
 447            E = FT->getParamTypes().end(); I != E; ++I) {
 448       if (I != FT->getParamTypes().begin()) Out << ", ";
 449       printType(*I);
 450     }
 451   }
 452
 453   // Finish printing arguments...
 454   if (FT->isVarArg()) {
 455     if (FT->getParamTypes().size()) Out << ", ";
 456     Out << "...";  // Output varargs portion of signature!
 457   }
 458   Out << ")";
 459 }
 460
 461
 462 void CWriter::printFunction(Function *F) {
 463   if (F->isExternal()) return;
 464
 465   Table.incorporateFunction(F);
 466
 467   printFunctionSignature(F);
 468   Out << " {\n";
 469
 470   // print local variable information for the function
 471   for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I)
 472     if ((*I)->getType() != Type::VoidTy) {
 473       Out << "  ";
 474       printTypeVar((*I)->getType(), getValueName(*I));
 475       Out << ";\n";
 476     }
 477
 478   // print the basic blocks
 479   for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) {
 480     BasicBlock *BB = *I, *Prev = I != F->begin() ? *(I-1) : 0;
 481
 482     // Don't print the label for the basic block if there are no uses, or if the
 483     // only terminator use is the precessor basic block's terminator.  We have
 484     // to scan the use list because PHI nodes use basic blocks too but do not
 485     // require a label to be generated.
 486     //
 487     bool NeedsLabel = false;
 488     for (Value::use_iterator UI = BB->use_begin(), UE = BB->use_end();
 489          UI != UE; ++UI)
 490       if (TerminatorInst *TI = dyn_cast<TerminatorInst>(*UI))
 491         if (TI != Prev->getTerminator()) {
 492           NeedsLabel = true;
 493           break;
 494         }
 495
 496     if (NeedsLabel) Out << getValueName(BB) << ":\n";
 497
 498     // Output all of the instructions in the basic block...
 499     // print the basic blocks
 500     visit(BB);
 501   }
 502
 503   Out << "}\n\n";
 504   Table.purgeFunction();
 505 }
 506
 507 // Specific Instruction type classes... note that all of the casts are
 508 // neccesary because we use the instruction classes as opaque types...
 509 //
 510 void CWriter::visitReturnInst(ReturnInst *I) {
 511   // Don't output a void return if this is the last basic block in the function
 512   if (I->getNumOperands() == 0 &&
 513       *(I->getParent()->getParent()->end()-1) == I->getParent())
 514     return;
 515
 516   Out << "  return";
 517   if (I->getNumOperands()) {
 518     Out << " ";
 519     writeOperand(I->getOperand(0));
 520   }
 521   Out << ";\n";
 522 }
 523
 524 // Return true if BB1 immediately preceeds BB2.
 525 static bool BBFollowsBB(BasicBlock *BB1, BasicBlock *BB2) {
 526   Function *F = BB1->getParent();
 527   Function::iterator I = find(F->begin(), F->end(), BB1);
 528   assert(I != F->end() && "BB not in function!");
 529   return *(I+1) == BB2;
 530 }
 531
 532 static bool isGotoCodeNeccessary(BasicBlock *From, BasicBlock *To) {
 533   // If PHI nodes need copies, we need the copy code...
 534   if (isa<PHINode>(To->front()) ||
 535       !BBFollowsBB(From, To))      // Not directly successor, need goto
 536     return true;
 537
 538   // Otherwise we don't need the code.
 539   return false;
 540 }
 541
 542 void CWriter::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ,
 543                                            unsigned Indent) {
 544   for (BasicBlock::iterator I = Succ->begin();
 545        PHINode *PN = dyn_cast<PHINode>(*I); ++I) {
 546     //  now we have to do the printing
 547     Out << string(Indent, ' ');
 548     outputLValue(PN);
 549     writeOperand(PN->getIncomingValue(PN->getBasicBlockIndex(CurBB)));
 550     Out << ";   /* for PHI node */\n";
 551   }
 552
 553   if (!BBFollowsBB(CurBB, Succ)) {
 554     Out << string(Indent, ' ') << "  goto ";
 555     writeOperand(Succ);
 556     Out << ";\n";
 557   }
 558 }
 559
 560 // Brach instruction printing - Avoid printing out a brach to a basic block that
 561 // immediately succeeds the current one.
 562 //
 563 void CWriter::visitBranchInst(BranchInst *I) {
 564   if (I->isConditional()) {
 565     if (isGotoCodeNeccessary(I->getParent(), I->getSuccessor(0))) {
 566       Out << "  if (";
 567       writeOperand(I->getCondition());
 568       Out << ") {\n";
 569
 570       printBranchToBlock(I->getParent(), I->getSuccessor(0), 2);
 571
 572       if (isGotoCodeNeccessary(I->getParent(), I->getSuccessor(1))) {
 573         Out << "  } else {\n";
 574         printBranchToBlock(I->getParent(), I->getSuccessor(1), 2);
 575       }
 576     } else {
 577       // First goto not neccesary, assume second one is...
 578       Out << "  if (!";
 579       writeOperand(I->getCondition());
 580       Out << ") {\n";
 581
 582       printBranchToBlock(I->getParent(), I->getSuccessor(1), 2);
 583     }
 584
 585     Out << "  }\n";
 586   } else {
 587     printBranchToBlock(I->getParent(), I->getSuccessor(0), 0);
 588   }
 589   Out << "\n";
 590 }
 591
 592
 593 void CWriter::visitNot(GenericUnaryInst *I) {
 594   outputLValue(I);
 595   Out << "~";
 596   writeOperand(I->getOperand(0));
 597   Out << ";\n";
 598 }
 599
 600 void CWriter::visitBinaryOperator(Instruction *I) {
 601   // binary instructions, shift instructions, setCond instructions.
 602   outputLValue(I);
 603   if (isa<PointerType>(I->getType())) {
 604     Out << "(";
 605     printType(I->getType());
 606     Out << ")";
 607   }
 608
 609   if (isa<PointerType>(I->getType())) Out << "(long long)";
 610   writeOperand(I->getOperand(0));
 611
 612   switch (I->getOpcode()) {
 613   case Instruction::Add: Out << " + "; break;
 614   case Instruction::Sub: Out << " - "; break;
 615   case Instruction::Mul: Out << "*"; break;
 616   case Instruction::Div: Out << "/"; break;
 617   case Instruction::Rem: Out << "%"; break;
 618   case Instruction::And: Out << " & "; break;
 619   case Instruction::Or: Out << " | "; break;
 620   case Instruction::Xor: Out << " ^ "; break;
 621   case Instruction::SetEQ: Out << " == "; break;
 622   case Instruction::SetNE: Out << " != "; break;
 623   case Instruction::SetLE: Out << " <= "; break;
 624   case Instruction::SetGE: Out << " >= "; break;
 625   case Instruction::SetLT: Out << " < "; break;
 626   case Instruction::SetGT: Out << " > "; break;
 627   case Instruction::Shl : Out << " << "; break;
 628   case Instruction::Shr : Out << " >> "; break;
 629   default: cerr << "Invalid operator type!" << I; abort();
 630   }
 631
 632   if (isa<PointerType>(I->getType())) Out << "(long long)";
 633   writeOperand(I->getOperand(1));
 634   Out << ";\n";
 635 }
 636
 637 void CWriter::visitCastInst(CastInst *I) {
 638   outputLValue(I);
 639   Out << "(";
 640   printType(I->getType());
 641   Out << ")";
 642   writeOperand(I->getOperand(0));
 643   Out << ";\n";
 644 }
 645
 646 void CWriter::visitCallInst(CallInst *I) {
 647   if (I->getType() != Type::VoidTy)
 648     outputLValue(I);
 649   else
 650     Out << "  ";
 651
 652   const PointerType  *PTy   = cast<PointerType>(I->getCalledValue()->getType());
 653   const FunctionType *FTy   = cast<FunctionType>(PTy->getElementType());
 654   const Type         *RetTy = FTy->getReturnType();
 655
 656   Out << getValueName(I->getOperand(0)) << "(";
 657
 658   if (I->getNumOperands() > 1) {
 659     writeOperand(I->getOperand(1));
 660
 661     for (unsigned op = 2, Eop = I->getNumOperands(); op != Eop; ++op) {
 662       Out << ", ";
 663       writeOperand(I->getOperand(op));
 664     }
 665   }
 666   Out << ");\n";
 667 }
 668
 669 void CWriter::visitMallocInst(MallocInst *I) {
 670   outputLValue(I);
 671   Out << "(";
 672   printType(I->getType());
 673   Out << ")malloc(sizeof(";
 674   printType(I->getType()->getElementType());
 675   Out << ")";
 676
 677   if (I->isArrayAllocation()) {
 678     Out << " * " ;
 679     writeOperand(I->getOperand(0));
 680   }
 681   Out << ");\n";
 682 }
 683
 684 void CWriter::visitAllocaInst(AllocaInst *I) {
 685   outputLValue(I);
 686   Out << "(";
 687   printType(I->getType());
 688   Out << ") alloca(sizeof(";
 689   printType(I->getType()->getElementType());
 690   Out << ")";
 691   if (I->isArrayAllocation()) {
 692     Out << " * " ;
 693     writeOperand(I->getOperand(0));
 694   }
 695   Out << ");\n";
 696 }
 697
 698 void CWriter::visitFreeInst(FreeInst *I) {
 699   Out << "  free(";
 700   writeOperand(I->getOperand(0));
 701   Out << ");\n";
 702 }
 703
 704 void CWriter::printIndexingExpr(MemAccessInst *MAI) {
 705   MemAccessInst::op_iterator I = MAI->idx_begin(), E = MAI->idx_end();
 706   if (I == E)
 707     Out << "*";  // Implicit zero first argument: '*x' is equivalent to 'x[0]'
 708
 709   writeOperand(MAI->getPointerOperand());
 710
 711   if (I == E) return;
 712
 713   // Print out the -> operator if possible...
 714   Constant *CI = dyn_cast<Constant>(*I);
 715   if (CI && CI->isNullValue() && I+1 != E &&
 716       (*(I+1))->getType() == Type::UByteTy) {
 717     ++I;
 718     Out << "->field" << cast<ConstantUInt>(*I)->getValue();
 719     ++I;
 720   }
 721
 722   for (; I != E; ++I)
 723     if ((*I)->getType() == Type::UIntTy) {
 724       Out << "[";
 725       writeOperand(*I);
 726       Out << "]";
 727     } else {
 728       Out << ".field" << cast<ConstantUInt>(*I)->getValue();
 729     }
 730 }
 731
 732 void CWriter::visitLoadInst(LoadInst *I) {
 733   outputLValue(I);
 734   printIndexingExpr(I);
 735   Out << ";\n";
 736 }
 737
 738 void CWriter::visitStoreInst(StoreInst *I) {
 739   Out << "  ";
 740   printIndexingExpr(I);
 741   Out << " = ";
 742   writeOperand(I->getOperand(0));
 743   Out << ";\n";
 744 }
 745
 746 void CWriter::visitGetElementPtrInst(GetElementPtrInst *I) {
 747   outputLValue(I);
 748   Out << "&";
 749   printIndexingExpr(I);
 750   Out << ";\n";
 751 }
 752
 753 //===----------------------------------------------------------------------===//
 754 //                       External Interface declaration
 755 //===----------------------------------------------------------------------===//
 756
 757 void WriteToC(const Module *M, ostream &Out) {
 758   assert(M && "You can't write a null module!!");
 759   SlotCalculator SlotTable(M, false);
 760   CWriter W(Out, SlotTable, M);
 761   W.write((Module*)M);
 762   Out.flush();
 763 }