lib/Target/CBackend/CBackend.cpp

   1 //===-- Writer.cpp - Library for converting LLVM code to C ----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This library converts LLVM code to C code, compilable by GCC and other C
  11 // compilers.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "CTargetMachine.h"
  16 #include "llvm/CallingConv.h"
  17 #include "llvm/Constants.h"
  18 #include "llvm/DerivedTypes.h"
  19 #include "llvm/Module.h"
  20 #include "llvm/Instructions.h"
  21 #include "llvm/Pass.h"
  22 #include "llvm/PassManager.h"
  23 #include "llvm/SymbolTable.h"
  24 #include "llvm/Intrinsics.h"
  25 #include "llvm/IntrinsicInst.h"
  26 #include "llvm/Analysis/ConstantsScanner.h"
  27 #include "llvm/Analysis/FindUsedTypes.h"
  28 #include "llvm/Analysis/LoopInfo.h"
  29 #include "llvm/CodeGen/IntrinsicLowering.h"
  30 #include "llvm/Transforms/Scalar.h"
  31 #include "llvm/Target/TargetMachineRegistry.h"
  32 #include "llvm/Support/CallSite.h"
  33 #include "llvm/Support/CFG.h"
  34 #include "llvm/Support/GetElementPtrTypeIterator.h"
  35 #include "llvm/Support/InstVisitor.h"
  36 #include "llvm/Support/Mangler.h"
  37 #include "llvm/Support/MathExtras.h"
  38 #include "llvm/ADT/StringExtras.h"
  39 #include "llvm/ADT/STLExtras.h"
  40 #include "llvm/Support/MathExtras.h"
  41 #include "llvm/Config/config.h"
  42 #include <algorithm>
  43 #include <iostream>
  44 #include <ios>
  45 #include <sstream>
  46 using namespace llvm;
  47
  48 namespace {
  49   // Register the target.
  50   RegisterTarget<CTargetMachine> X("c", "  C backend");
  51
  52   /// CBackendNameAllUsedStructsAndMergeFunctions - This pass inserts names for
  53   /// any unnamed structure types that are used by the program, and merges
  54   /// external functions with the same name.
  55   ///
  56   class CBackendNameAllUsedStructsAndMergeFunctions : public ModulePass {
  57     void getAnalysisUsage(AnalysisUsage &AU) const {
  58       AU.addRequired<FindUsedTypes>();
  59     }
  60
  61     virtual const char *getPassName() const {
  62       return "C backend type canonicalizer";
  63     }
  64
  65     virtual bool runOnModule(Module &M);
  66   };
  67
  68   /// CWriter - This class is the main chunk of code that converts an LLVM
  69   /// module to a C translation unit.
  70   class CWriter : public FunctionPass, public InstVisitor<CWriter> {
  71     std::ostream &Out;
  72     DefaultIntrinsicLowering IL;
  73     Mangler *Mang;
  74     LoopInfo *LI;
  75     const Module *TheModule;
  76     std::map<const Type *, std::string> TypeNames;
  77
  78     std::map<const ConstantFP *, unsigned> FPConstantMap;
  79   public:
  80     CWriter(std::ostream &o) : Out(o) {}
  81
  82     virtual const char *getPassName() const { return "C backend"; }
  83
  84     void getAnalysisUsage(AnalysisUsage &AU) const {
  85       AU.addRequired<LoopInfo>();
  86       AU.setPreservesAll();
  87     }
  88
  89     virtual bool doInitialization(Module &M);
  90
  91     bool runOnFunction(Function &F) {
  92       LI = &getAnalysis<LoopInfo>();
  93
  94       // Get rid of intrinsics we can't handle.
  95       lowerIntrinsics(F);
  96
  97       // Output all floating point constants that cannot be printed accurately.
  98       printFloatingPointConstants(F);
  99
 100       // Ensure that no local symbols conflict with global symbols.
 101       F.renameLocalSymbols();
 102
 103       printFunction(F);
 104       FPConstantMap.clear();
 105       return false;
 106     }
 107
 108     virtual bool doFinalization(Module &M) {
 109       // Free memory...
 110       delete Mang;
 111       TypeNames.clear();
 112       return false;
 113     }
 114
 115     std::ostream &printType(std::ostream &Out, const Type *Ty,
 116                             const std::string &VariableName = "",
 117                             bool IgnoreName = false);
 118
 119     void printStructReturnPointerFunctionType(std::ostream &Out,
 120                                               const PointerType *Ty);
 121
 122     void writeOperand(Value *Operand);
 123     void writeOperandInternal(Value *Operand);
 124     void writeOperandWithCast(Value* Operand, unsigned Opcode);
 125     bool writeInstructionCast(const Instruction &I);
 126
 127   private :
 128     void lowerIntrinsics(Function &F);
 129
 130     void printModule(Module *M);
 131     void printModuleTypes(const SymbolTable &ST);
 132     void printContainedStructs(const Type *Ty, std::set<const StructType *> &);
 133     void printFloatingPointConstants(Function &F);
 134     void printFunctionSignature(const Function *F, bool Prototype);
 135
 136     void printFunction(Function &);
 137     void printBasicBlock(BasicBlock *BB);
 138     void printLoop(Loop *L);
 139
 140     void printConstant(Constant *CPV);
 141     void printConstantWithCast(Constant *CPV, unsigned Opcode);
 142     bool printConstExprCast(const ConstantExpr *CE);
 143     void printConstantArray(ConstantArray *CPA);
 144     void printConstantPacked(ConstantPacked *CP);
 145
 146     // isInlinableInst - Attempt to inline instructions into their uses to build
 147     // trees as much as possible.  To do this, we have to consistently decide
 148     // what is acceptable to inline, so that variable declarations don't get
 149     // printed and an extra copy of the expr is not emitted.
 150     //
 151     static bool isInlinableInst(const Instruction &I) {
 152       // Always inline setcc instructions, even if they are shared by multiple
 153       // expressions.  GCC generates horrible code if we don't.
 154       if (isa<SetCondInst>(I)) return true;
 155
 156       // Must be an expression, must be used exactly once.  If it is dead, we
 157       // emit it inline where it would go.
 158       if (I.getType() == Type::VoidTy || !I.hasOneUse() ||
 159           isa<TerminatorInst>(I) || isa<CallInst>(I) || isa<PHINode>(I) ||
 160           isa<LoadInst>(I) || isa<VAArgInst>(I))
 161         // Don't inline a load across a store or other bad things!
 162         return false;
 163
 164       // Only inline instruction it it's use is in the same BB as the inst.
 165       return I.getParent() == cast<Instruction>(I.use_back())->getParent();
 166     }
 167
 168     // isDirectAlloca - Define fixed sized allocas in the entry block as direct
 169     // variables which are accessed with the & operator.  This causes GCC to
 170     // generate significantly better code than to emit alloca calls directly.
 171     //
 172     static const AllocaInst *isDirectAlloca(const Value *V) {
 173       const AllocaInst *AI = dyn_cast<AllocaInst>(V);
 174       if (!AI) return false;
 175       if (AI->isArrayAllocation())
 176         return 0;   // FIXME: we can also inline fixed size array allocas!
 177       if (AI->getParent() != &AI->getParent()->getParent()->getEntryBlock())
 178         return 0;
 179       return AI;
 180     }
 181
 182     // Instruction visitation functions
 183     friend class InstVisitor<CWriter>;
 184
 185     void visitReturnInst(ReturnInst &I);
 186     void visitBranchInst(BranchInst &I);
 187     void visitSwitchInst(SwitchInst &I);
 188     void visitInvokeInst(InvokeInst &I) {
 189       assert(0 && "Lowerinvoke pass didn't work!");
 190     }
 191
 192     void visitUnwindInst(UnwindInst &I) {
 193       assert(0 && "Lowerinvoke pass didn't work!");
 194     }
 195     void visitUnreachableInst(UnreachableInst &I);
 196
 197     void visitPHINode(PHINode &I);
 198     void visitBinaryOperator(Instruction &I);
 199
 200     void visitCastInst (CastInst &I);
 201     void visitSelectInst(SelectInst &I);
 202     void visitCallInst (CallInst &I);
 203     void visitShiftInst(ShiftInst &I) { visitBinaryOperator(I); }
 204
 205     void visitMallocInst(MallocInst &I);
 206     void visitAllocaInst(AllocaInst &I);
 207     void visitFreeInst  (FreeInst   &I);
 208     void visitLoadInst  (LoadInst   &I);
 209     void visitStoreInst (StoreInst  &I);
 210     void visitGetElementPtrInst(GetElementPtrInst &I);
 211     void visitVAArgInst (VAArgInst &I);
 212
 213     void visitInstruction(Instruction &I) {
 214       std::cerr << "C Writer does not know about " << I;
 215       abort();
 216     }
 217
 218     void outputLValue(Instruction *I) {
 219       Out << "  " << Mang->getValueName(I) << " = ";
 220     }
 221
 222     bool isGotoCodeNecessary(BasicBlock *From, BasicBlock *To);
 223     void printPHICopiesForSuccessor(BasicBlock *CurBlock,
 224                                     BasicBlock *Successor, unsigned Indent);
 225     void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock,
 226                             unsigned Indent);
 227     void printIndexingExpression(Value *Ptr, gep_type_iterator I,
 228                                  gep_type_iterator E);
 229   };
 230 }
 231
 232 /// This method inserts names for any unnamed structure types that are used by
 233 /// the program, and removes names from structure types that are not used by the
 234 /// program.
 235 ///
 236 bool CBackendNameAllUsedStructsAndMergeFunctions::runOnModule(Module &M) {
 237   // Get a set of types that are used by the program...
 238   std::set<const Type *> UT = getAnalysis<FindUsedTypes>().getTypes();
 239
 240   // Loop over the module symbol table, removing types from UT that are
 241   // already named, and removing names for types that are not used.
 242   //
 243   SymbolTable &MST = M.getSymbolTable();
 244   for (SymbolTable::type_iterator TI = MST.type_begin(), TE = MST.type_end();
 245        TI != TE; ) {
 246     SymbolTable::type_iterator I = TI++;
 247
 248     // If this is not used, remove it from the symbol table.
 249     std::set<const Type *>::iterator UTI = UT.find(I->second);
 250     if (UTI == UT.end())
 251       MST.remove(I);
 252     else
 253       UT.erase(UTI);    // Only keep one name for this type.
 254   }
 255
 256   // UT now contains types that are not named.  Loop over it, naming
 257   // structure types.
 258   //
 259   bool Changed = false;
 260   unsigned RenameCounter = 0;
 261   for (std::set<const Type *>::const_iterator I = UT.begin(), E = UT.end();
 262        I != E; ++I)
 263     if (const StructType *ST = dyn_cast<StructType>(*I)) {
 264       while (M.addTypeName("unnamed"+utostr(RenameCounter), ST))
 265         ++RenameCounter;
 266       Changed = true;
 267     }
 268
 269
 270   // Loop over all external functions and globals.  If we have two with
 271   // identical names, merge them.
 272   // FIXME: This code should disappear when we don't allow values with the same
 273   // names when they have different types!
 274   std::map<std::string, GlobalValue*> ExtSymbols;
 275   for (Module::iterator I = M.begin(), E = M.end(); I != E;) {
 276     Function *GV = I++;
 277     if (GV->isExternal() && GV->hasName()) {
 278       std::pair<std::map<std::string, GlobalValue*>::iterator, bool> X
 279         = ExtSymbols.insert(std::make_pair(GV->getName(), GV));
 280       if (!X.second) {
 281         // Found a conflict, replace this global with the previous one.
 282         GlobalValue *OldGV = X.first->second;
 283         GV->replaceAllUsesWith(ConstantExpr::getCast(OldGV, GV->getType()));
 284         GV->eraseFromParent();
 285         Changed = true;
 286       }
 287     }
 288   }
 289   // Do the same for globals.
 290   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
 291        I != E;) {
 292     GlobalVariable *GV = I++;
 293     if (GV->isExternal() && GV->hasName()) {
 294       std::pair<std::map<std::string, GlobalValue*>::iterator, bool> X
 295         = ExtSymbols.insert(std::make_pair(GV->getName(), GV));
 296       if (!X.second) {
 297         // Found a conflict, replace this global with the previous one.
 298         GlobalValue *OldGV = X.first->second;
 299         GV->replaceAllUsesWith(ConstantExpr::getCast(OldGV, GV->getType()));
 300         GV->eraseFromParent();
 301         Changed = true;
 302       }
 303     }
 304   }
 305
 306   return Changed;
 307 }
 308
 309 /// printStructReturnPointerFunctionType - This is like printType for a struct
 310 /// return type, except, instead of printing the type as void (*)(Struct*, ...)
 311 /// print it as "Struct (*)(...)", for struct return functions.
 312 void CWriter::printStructReturnPointerFunctionType(std::ostream &Out,
 313                                                    const PointerType *TheTy) {
 314   const FunctionType *FTy = cast<FunctionType>(TheTy->getElementType());
 315   std::stringstream FunctionInnards;
 316   FunctionInnards << " (*) (";
 317   bool PrintedType = false;
 318
 319   FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end();
 320   const Type *RetTy = cast<PointerType>(I->get())->getElementType();
 321   for (++I; I != E; ++I) {
 322     if (PrintedType)
 323       FunctionInnards << ", ";
 324     printType(FunctionInnards, *I, "");
 325     PrintedType = true;
 326   }
 327   if (FTy->isVarArg()) {
 328     if (PrintedType)
 329       FunctionInnards << ", ...";
 330   } else if (!PrintedType) {
 331     FunctionInnards << "void";
 332   }
 333   FunctionInnards << ')';
 334   std::string tstr = FunctionInnards.str();
 335   printType(Out, RetTy, tstr);
 336 }
 337
 338
 339 // Pass the Type* and the variable name and this prints out the variable
 340 // declaration.
 341 //
 342 std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty,
 343                                  const std::string &NameSoFar,
 344                                  bool IgnoreName) {
 345   if (Ty->isPrimitiveType())
 346     switch (Ty->getTypeID()) {
 347     case Type::VoidTyID:   return Out << "void "               << NameSoFar;
 348     case Type::BoolTyID:   return Out << "bool "               << NameSoFar;
 349     case Type::UByteTyID:  return Out << "unsigned char "      << NameSoFar;
 350     case Type::SByteTyID:  return Out << "signed char "        << NameSoFar;
 351     case Type::UShortTyID: return Out << "unsigned short "     << NameSoFar;
 352     case Type::ShortTyID:  return Out << "short "              << NameSoFar;
 353     case Type::UIntTyID:   return Out << "unsigned "           << NameSoFar;
 354     case Type::IntTyID:    return Out << "int "                << NameSoFar;
 355     case Type::ULongTyID:  return Out << "unsigned long long " << NameSoFar;
 356     case Type::LongTyID:   return Out << "signed long long "   << NameSoFar;
 357     case Type::FloatTyID:  return Out << "float "              << NameSoFar;
 358     case Type::DoubleTyID: return Out << "double "             << NameSoFar;
 359     default :
 360       std::cerr << "Unknown primitive type: " << *Ty << "\n";
 361       abort();
 362     }
 363
 364   // Check to see if the type is named.
 365   if (!IgnoreName || isa<OpaqueType>(Ty)) {
 366     std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
 367     if (I != TypeNames.end()) return Out << I->second << ' ' << NameSoFar;
 368   }
 369
 370   switch (Ty->getTypeID()) {
 371   case Type::FunctionTyID: {
 372     const FunctionType *FTy = cast<FunctionType>(Ty);
 373     std::stringstream FunctionInnards;
 374     FunctionInnards << " (" << NameSoFar << ") (";
 375     for (FunctionType::param_iterator I = FTy->param_begin(),
 376            E = FTy->param_end(); I != E; ++I) {
 377       if (I != FTy->param_begin())
 378         FunctionInnards << ", ";
 379       printType(FunctionInnards, *I, "");
 380     }
 381     if (FTy->isVarArg()) {
 382       if (FTy->getNumParams())
 383         FunctionInnards << ", ...";
 384     } else if (!FTy->getNumParams()) {
 385       FunctionInnards << "void";
 386     }
 387     FunctionInnards << ')';
 388     std::string tstr = FunctionInnards.str();
 389     printType(Out, FTy->getReturnType(), tstr);
 390     return Out;
 391   }
 392   case Type::StructTyID: {
 393     const StructType *STy = cast<StructType>(Ty);
 394     Out << NameSoFar + " {\n";
 395     unsigned Idx = 0;
 396     for (StructType::element_iterator I = STy->element_begin(),
 397            E = STy->element_end(); I != E; ++I) {
 398       Out << "  ";
 399       printType(Out, *I, "field" + utostr(Idx++));
 400       Out << ";\n";
 401     }
 402     return Out << '}';
 403   }
 404
 405   case Type::PointerTyID: {
 406     const PointerType *PTy = cast<PointerType>(Ty);
 407     std::string ptrName = "*" + NameSoFar;
 408
 409     if (isa<ArrayType>(PTy->getElementType()) ||
 410         isa<PackedType>(PTy->getElementType()))
 411       ptrName = "(" + ptrName + ")";
 412
 413     return printType(Out, PTy->getElementType(), ptrName);
 414   }
 415
 416   case Type::ArrayTyID: {
 417     const ArrayType *ATy = cast<ArrayType>(Ty);
 418     unsigned NumElements = ATy->getNumElements();
 419     if (NumElements == 0) NumElements = 1;
 420     return printType(Out, ATy->getElementType(),
 421                      NameSoFar + "[" + utostr(NumElements) + "]");
 422   }
 423
 424   case Type::PackedTyID: {
 425     const PackedType *PTy = cast<PackedType>(Ty);
 426     unsigned NumElements = PTy->getNumElements();
 427     if (NumElements == 0) NumElements = 1;
 428     return printType(Out, PTy->getElementType(),
 429                      NameSoFar + "[" + utostr(NumElements) + "]");
 430   }
 431
 432   case Type::OpaqueTyID: {
 433     static int Count = 0;
 434     std::string TyName = "struct opaque_" + itostr(Count++);
 435     assert(TypeNames.find(Ty) == TypeNames.end());
 436     TypeNames[Ty] = TyName;
 437     return Out << TyName << ' ' << NameSoFar;
 438   }
 439   default:
 440     assert(0 && "Unhandled case in getTypeProps!");
 441     abort();
 442   }
 443
 444   return Out;
 445 }
 446
 447 void CWriter::printConstantArray(ConstantArray *CPA) {
 448
 449   // As a special case, print the array as a string if it is an array of
 450   // ubytes or an array of sbytes with positive values.
 451   //
 452   const Type *ETy = CPA->getType()->getElementType();
 453   bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy);
 454
 455   // Make sure the last character is a null char, as automatically added by C
 456   if (isString && (CPA->getNumOperands() == 0 ||
 457                    !cast<Constant>(*(CPA->op_end()-1))->isNullValue()))
 458     isString = false;
 459
 460   if (isString) {
 461     Out << '\"';
 462     // Keep track of whether the last number was a hexadecimal escape
 463     bool LastWasHex = false;
 464
 465     // Do not include the last character, which we know is null
 466     for (unsigned i = 0, e = CPA->getNumOperands()-1; i != e; ++i) {
 467       unsigned char C = cast<ConstantInt>(CPA->getOperand(i))->getZExtValue();
 468
 469       // Print it out literally if it is a printable character.  The only thing
 470       // to be careful about is when the last letter output was a hex escape
 471       // code, in which case we have to be careful not to print out hex digits
 472       // explicitly (the C compiler thinks it is a continuation of the previous
 473       // character, sheesh...)
 474       //
 475       if (isprint(C) && (!LastWasHex || !isxdigit(C))) {
 476         LastWasHex = false;
 477         if (C == '"' || C == '\\')
 478           Out << "\\" << C;
 479         else
 480           Out << C;
 481       } else {
 482         LastWasHex = false;
 483         switch (C) {
 484         case '\n': Out << "\\n"; break;
 485         case '\t': Out << "\\t"; break;
 486         case '\r': Out << "\\r"; break;
 487         case '\v': Out << "\\v"; break;
 488         case '\a': Out << "\\a"; break;
 489         case '\"': Out << "\\\""; break;
 490         case '\'': Out << "\\\'"; break;
 491         default:
 492           Out << "\\x";
 493           Out << (char)(( C/16  < 10) ? ( C/16 +'0') : ( C/16 -10+'A'));
 494           Out << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
 495           LastWasHex = true;
 496           break;
 497         }
 498       }
 499     }
 500     Out << '\"';
 501   } else {
 502     Out << '{';
 503     if (CPA->getNumOperands()) {
 504       Out << ' ';
 505       printConstant(cast<Constant>(CPA->getOperand(0)));
 506       for (unsigned i = 1, e = CPA->getNumOperands(); i != e; ++i) {
 507         Out << ", ";
 508         printConstant(cast<Constant>(CPA->getOperand(i)));
 509       }
 510     }
 511     Out << " }";
 512   }
 513 }
 514
 515 void CWriter::printConstantPacked(ConstantPacked *CP) {
 516   Out << '{';
 517   if (CP->getNumOperands()) {
 518     Out << ' ';
 519     printConstant(cast<Constant>(CP->getOperand(0)));
 520     for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) {
 521       Out << ", ";
 522       printConstant(cast<Constant>(CP->getOperand(i)));
 523     }
 524   }
 525   Out << " }";
 526 }
 527
 528 // isFPCSafeToPrint - Returns true if we may assume that CFP may be written out
 529 // textually as a double (rather than as a reference to a stack-allocated
 530 // variable). We decide this by converting CFP to a string and back into a
 531 // double, and then checking whether the conversion results in a bit-equal
 532 // double to the original value of CFP. This depends on us and the target C
 533 // compiler agreeing on the conversion process (which is pretty likely since we
 534 // only deal in IEEE FP).
 535 //
 536 static bool isFPCSafeToPrint(const ConstantFP *CFP) {
 537 #if HAVE_PRINTF_A
 538   char Buffer[100];
 539   sprintf(Buffer, "%a", CFP->getValue());
 540
 541   if (!strncmp(Buffer, "0x", 2) ||
 542       !strncmp(Buffer, "-0x", 3) ||
 543       !strncmp(Buffer, "+0x", 3))
 544     return atof(Buffer) == CFP->getValue();
 545   return false;
 546 #else
 547   std::string StrVal = ftostr(CFP->getValue());
 548
 549   while (StrVal[0] == ' ')
 550     StrVal.erase(StrVal.begin());
 551
 552   // Check to make sure that the stringized number is not some string like "Inf"
 553   // or NaN.  Check that the string matches the "[-+]?[0-9]" regex.
 554   if ((StrVal[0] >= '0' && StrVal[0] <= '9') ||
 555       ((StrVal[0] == '-' || StrVal[0] == '+') &&
 556        (StrVal[1] >= '0' && StrVal[1] <= '9')))
 557     // Reparse stringized version!
 558     return atof(StrVal.c_str()) == CFP->getValue();
 559   return false;
 560 #endif
 561 }
 562
 563 // printConstant - The LLVM Constant to C Constant converter.
 564 void CWriter::printConstant(Constant *CPV) {
 565   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
 566     switch (CE->getOpcode()) {
 567     case Instruction::Cast:
 568       Out << "((";
 569       printType(Out, CPV->getType());
 570       Out << ')';
 571       printConstant(CE->getOperand(0));
 572       Out << ')';
 573       return;
 574
 575     case Instruction::GetElementPtr:
 576       Out << "(&(";
 577       printIndexingExpression(CE->getOperand(0), gep_type_begin(CPV),
 578                               gep_type_end(CPV));
 579       Out << "))";
 580       return;
 581     case Instruction::Select:
 582       Out << '(';
 583       printConstant(CE->getOperand(0));
 584       Out << '?';
 585       printConstant(CE->getOperand(1));
 586       Out << ':';
 587       printConstant(CE->getOperand(2));
 588       Out << ')';
 589       return;
 590     case Instruction::Add:
 591     case Instruction::Sub:
 592     case Instruction::Mul:
 593     case Instruction::SDiv:
 594     case Instruction::UDiv:
 595     case Instruction::FDiv:
 596     case Instruction::URem:
 597     case Instruction::SRem:
 598     case Instruction::FRem:
 599     case Instruction::And:
 600     case Instruction::Or:
 601     case Instruction::Xor:
 602     case Instruction::SetEQ:
 603     case Instruction::SetNE:
 604     case Instruction::SetLT:
 605     case Instruction::SetLE:
 606     case Instruction::SetGT:
 607     case Instruction::SetGE:
 608     case Instruction::Shl:
 609     case Instruction::Shr:
 610     {
 611       Out << '(';
 612       bool NeedsClosingParens = printConstExprCast(CE);
 613       printConstantWithCast(CE->getOperand(0), CE->getOpcode());
 614       switch (CE->getOpcode()) {
 615       case Instruction::Add: Out << " + "; break;
 616       case Instruction::Sub: Out << " - "; break;
 617       case Instruction::Mul: Out << " * "; break;
 618       case Instruction::URem:
 619       case Instruction::SRem:
 620       case Instruction::FRem: Out << " % "; break;
 621       case Instruction::UDiv:
 622       case Instruction::SDiv:
 623       case Instruction::FDiv: Out << " / "; break;
 624       case Instruction::And: Out << " & "; break;
 625       case Instruction::Or:  Out << " | "; break;
 626       case Instruction::Xor: Out << " ^ "; break;
 627       case Instruction::SetEQ: Out << " == "; break;
 628       case Instruction::SetNE: Out << " != "; break;
 629       case Instruction::SetLT: Out << " < "; break;
 630       case Instruction::SetLE: Out << " <= "; break;
 631       case Instruction::SetGT: Out << " > "; break;
 632       case Instruction::SetGE: Out << " >= "; break;
 633       case Instruction::Shl: Out << " << "; break;
 634       case Instruction::Shr: Out << " >> "; break;
 635       default: assert(0 && "Illegal opcode here!");
 636       }
 637       printConstantWithCast(CE->getOperand(1), CE->getOpcode());
 638       if (NeedsClosingParens)
 639         Out << "))";
 640       Out << ')';
 641       return;
 642     }
 643
 644     default:
 645       std::cerr << "CWriter Error: Unhandled constant expression: "
 646                 << *CE << "\n";
 647       abort();
 648     }
 649   } else if (isa<UndefValue>(CPV) && CPV->getType()->isFirstClassType()) {
 650     Out << "((";
 651     printType(Out, CPV->getType());
 652     Out << ")/*UNDEF*/0)";
 653     return;
 654   }
 655
 656   switch (CPV->getType()->getTypeID()) {
 657   case Type::BoolTyID:
 658     Out << (cast<ConstantBool>(CPV)->getValue() ? '1' : '0');
 659     break;
 660   case Type::SByteTyID:
 661   case Type::ShortTyID:
 662     Out << cast<ConstantInt>(CPV)->getSExtValue();
 663     break;
 664   case Type::IntTyID:
 665     if ((int)cast<ConstantInt>(CPV)->getSExtValue() == (int)0x80000000)
 666       Out << "((int)0x80000000U)";   // Handle MININT specially to avoid warning
 667     else
 668       Out << cast<ConstantInt>(CPV)->getSExtValue();
 669     break;
 670
 671   case Type::LongTyID:
 672     if (cast<ConstantInt>(CPV)->isMinValue())
 673       Out << "(/*INT64_MIN*/(-9223372036854775807LL)-1)";
 674     else
 675       Out << cast<ConstantInt>(CPV)->getSExtValue() << "ll";
 676     break;
 677
 678   case Type::UByteTyID:
 679   case Type::UShortTyID:
 680     Out << cast<ConstantInt>(CPV)->getZExtValue();
 681     break;
 682   case Type::UIntTyID:
 683     Out << cast<ConstantInt>(CPV)->getZExtValue() << 'u';
 684     break;
 685   case Type::ULongTyID:
 686     Out << cast<ConstantInt>(CPV)->getZExtValue() << "ull";
 687     break;
 688
 689   case Type::FloatTyID:
 690   case Type::DoubleTyID: {
 691     ConstantFP *FPC = cast<ConstantFP>(CPV);
 692     std::map<const ConstantFP*, unsigned>::iterator I = FPConstantMap.find(FPC);
 693     if (I != FPConstantMap.end()) {
 694       // Because of FP precision problems we must load from a stack allocated
 695       // value that holds the value in hex.
 696       Out << "(*(" << (FPC->getType() == Type::FloatTy ? "float" : "double")
 697           << "*)&FPConstant" << I->second << ')';
 698     } else {
 699       if (IsNAN(FPC->getValue())) {
 700         // The value is NaN
 701
 702         // The prefix for a quiet NaN is 0x7FF8. For a signalling NaN,
 703         // it's 0x7ff4.
 704         const unsigned long QuietNaN = 0x7ff8UL;
 705         const unsigned long SignalNaN = 0x7ff4UL;
 706
 707         // We need to grab the first part of the FP #
 708         char Buffer[100];
 709
 710         uint64_t ll = DoubleToBits(FPC->getValue());
 711         sprintf(Buffer, "0x%llx", static_cast<long long>(ll));
 712
 713         std::string Num(&Buffer[0], &Buffer[6]);
 714         unsigned long Val = strtoul(Num.c_str(), 0, 16);
 715
 716         if (FPC->getType() == Type::FloatTy)
 717           Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "F(\""
 718               << Buffer << "\") /*nan*/ ";
 719         else
 720           Out << "LLVM_NAN" << (Val == QuietNaN ? "" : "S") << "(\""
 721               << Buffer << "\") /*nan*/ ";
 722       } else if (IsInf(FPC->getValue())) {
 723         // The value is Inf
 724         if (FPC->getValue() < 0) Out << '-';
 725         Out << "LLVM_INF" << (FPC->getType() == Type::FloatTy ? "F" : "")
 726             << " /*inf*/ ";
 727       } else {
 728         std::string Num;
 729 #if HAVE_PRINTF_A
 730         // Print out the constant as a floating point number.
 731         char Buffer[100];
 732         sprintf(Buffer, "%a", FPC->getValue());
 733         Num = Buffer;
 734 #else
 735         Num = ftostr(FPC->getValue());
 736 #endif
 737         Out << Num;
 738       }
 739     }
 740     break;
 741   }
 742
 743   case Type::ArrayTyID:
 744     if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
 745       const ArrayType *AT = cast<ArrayType>(CPV->getType());
 746       Out << '{';
 747       if (AT->getNumElements()) {
 748         Out << ' ';
 749         Constant *CZ = Constant::getNullValue(AT->getElementType());
 750         printConstant(CZ);
 751         for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) {
 752           Out << ", ";
 753           printConstant(CZ);
 754         }
 755       }
 756       Out << " }";
 757     } else {
 758       printConstantArray(cast<ConstantArray>(CPV));
 759     }
 760     break;
 761
 762   case Type::PackedTyID:
 763     if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
 764       const PackedType *AT = cast<PackedType>(CPV->getType());
 765       Out << '{';
 766       if (AT->getNumElements()) {
 767         Out << ' ';
 768         Constant *CZ = Constant::getNullValue(AT->getElementType());
 769         printConstant(CZ);
 770         for (unsigned i = 1, e = AT->getNumElements(); i != e; ++i) {
 771           Out << ", ";
 772           printConstant(CZ);
 773         }
 774       }
 775       Out << " }";
 776     } else {
 777       printConstantPacked(cast<ConstantPacked>(CPV));
 778     }
 779     break;
 780
 781   case Type::StructTyID:
 782     if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
 783       const StructType *ST = cast<StructType>(CPV->getType());
 784       Out << '{';
 785       if (ST->getNumElements()) {
 786         Out << ' ';
 787         printConstant(Constant::getNullValue(ST->getElementType(0)));
 788         for (unsigned i = 1, e = ST->getNumElements(); i != e; ++i) {
 789           Out << ", ";
 790           printConstant(Constant::getNullValue(ST->getElementType(i)));
 791         }
 792       }
 793       Out << " }";
 794     } else {
 795       Out << '{';
 796       if (CPV->getNumOperands()) {
 797         Out << ' ';
 798         printConstant(cast<Constant>(CPV->getOperand(0)));
 799         for (unsigned i = 1, e = CPV->getNumOperands(); i != e; ++i) {
 800           Out << ", ";
 801           printConstant(cast<Constant>(CPV->getOperand(i)));
 802         }
 803       }
 804       Out << " }";
 805     }
 806     break;
 807
 808   case Type::PointerTyID:
 809     if (isa<ConstantPointerNull>(CPV)) {
 810       Out << "((";
 811       printType(Out, CPV->getType());
 812       Out << ")/*NULL*/0)";
 813       break;
 814     } else if (GlobalValue *GV = dyn_cast<GlobalValue>(CPV)) {
 815       writeOperand(GV);
 816       break;
 817     }
 818     // FALL THROUGH
 819   default:
 820     std::cerr << "Unknown constant type: " << *CPV << "\n";
 821     abort();
 822   }
 823 }
 824
 825 // Some constant expressions need to be casted back to the original types
 826 // because their operands were casted to the expected type. This function takes
 827 // care of detecting that case and printing the cast for the ConstantExpr.
 828 bool CWriter::printConstExprCast(const ConstantExpr* CE) {
 829   bool Result = false;
 830   const Type* Ty = CE->getOperand(0)->getType();
 831   switch (CE->getOpcode()) {
 832   case Instruction::UDiv:
 833   case Instruction::URem:
 834     Result = Ty->isSigned(); break;
 835   case Instruction::SDiv:
 836   case Instruction::SRem:
 837     Result = Ty->isUnsigned(); break;
 838   default: break;
 839   }
 840   if (Result) {
 841     Out << "((";
 842     printType(Out, Ty);
 843     Out << ")(";
 844   }
 845   return Result;
 846 }
 847
 848 //  Print a constant assuming that it is the operand for a given Opcode. The
 849 //  opcodes that care about sign need to cast their operands to the expected
 850 //  type before the operation proceeds. This function does the casting.
 851 void CWriter::printConstantWithCast(Constant* CPV, unsigned Opcode) {
 852
 853   // Extract the operand's type, we'll need it.
 854   const Type* OpTy = CPV->getType();
 855
 856   // Indicate whether to do the cast or not.
 857   bool shouldCast = false;
 858
 859   // Based on the Opcode for which this Constant is being written, determine
 860   // the new type to which the operand should be casted by setting the value
 861   // of OpTy. If we change OpTy, also set shouldCast to true.
 862   switch (Opcode) {
 863     default:
 864       // for most instructions, it doesn't matter
 865       break;
 866     case Instruction::UDiv:
 867     case Instruction::URem:
 868       // For UDiv/URem get correct type
 869       if (OpTy->isSigned()) {
 870         OpTy = OpTy->getUnsignedVersion();
 871         shouldCast = true;
 872       }
 873       break;
 874     case Instruction::SDiv:
 875     case Instruction::SRem:
 876       // For SDiv/SRem get correct type
 877       if (OpTy->isUnsigned()) {
 878         OpTy = OpTy->getSignedVersion();
 879         shouldCast = true;
 880       }
 881       break;
 882   }
 883
 884   // Write out the casted constnat if we should, otherwise just write the
 885   // operand.
 886   if (shouldCast) {
 887     Out << "((";
 888     printType(Out, OpTy);
 889     Out << ")";
 890     printConstant(CPV);
 891     Out << ")";
 892   } else
 893     writeOperand(CPV);
 894
 895 }
 896
 897 void CWriter::writeOperandInternal(Value *Operand) {
 898   if (Instruction *I = dyn_cast<Instruction>(Operand))
 899     if (isInlinableInst(*I) && !isDirectAlloca(I)) {
 900       // Should we inline this instruction to build a tree?
 901       Out << '(';
 902       visit(*I);
 903       Out << ')';
 904       return;
 905     }
 906
 907   Constant* CPV = dyn_cast<Constant>(Operand);
 908   if (CPV && !isa<GlobalValue>(CPV)) {
 909     printConstant(CPV);
 910   } else {
 911     Out << Mang->getValueName(Operand);
 912   }
 913 }
 914
 915 void CWriter::writeOperand(Value *Operand) {
 916   if (isa<GlobalVariable>(Operand) || isDirectAlloca(Operand))
 917     Out << "(&";  // Global variables are references as their addresses by llvm
 918
 919   writeOperandInternal(Operand);
 920
 921   if (isa<GlobalVariable>(Operand) || isDirectAlloca(Operand))
 922     Out << ')';
 923 }
 924
 925 // Some instructions need to have their result value casted back to the
 926 // original types because their operands were casted to the expected type.
 927 // This function takes care of detecting that case and printing the cast
 928 // for the Instruction.
 929 bool CWriter::writeInstructionCast(const Instruction &I) {
 930   bool Result = false;
 931   const Type* Ty = I.getOperand(0)->getType();
 932   switch (I.getOpcode()) {
 933   case Instruction::UDiv:
 934   case Instruction::URem:
 935     Result = Ty->isSigned(); break;
 936   case Instruction::SDiv:
 937   case Instruction::SRem:
 938     Result = Ty->isUnsigned(); break;
 939   default: break;
 940   }
 941   if (Result) {
 942     Out << "((";
 943     printType(Out, Ty);
 944     Out << ")(";
 945   }
 946   return Result;
 947 }
 948
 949 // Write the operand with a cast to another type based on the Opcode being used.
 950 // This will be used in cases where an instruction has specific type
 951 // requirements (usually signedness) for its operands.
 952 void CWriter::writeOperandWithCast(Value* Operand, unsigned Opcode) {
 953
 954   // Extract the operand's type, we'll need it.
 955   const Type* OpTy = Operand->getType();
 956
 957   // Indicate whether to do the cast or not.
 958   bool shouldCast = false;
 959
 960   // Based on the Opcode for which this Operand is being written, determine
 961   // the new type to which the operand should be casted by setting the value
 962   // of OpTy. If we change OpTy, also set shouldCast to true.
 963   switch (Opcode) {
 964     default:
 965       // for most instructions, it doesn't matter
 966       break;
 967     case Instruction::UDiv:
 968     case Instruction::URem:
 969       // For UDiv to have unsigned operands
 970       if (OpTy->isSigned()) {
 971         OpTy = OpTy->getUnsignedVersion();
 972         shouldCast = true;
 973       }
 974       break;
 975     case Instruction::SDiv:
 976     case Instruction::SRem:
 977       if (OpTy->isUnsigned()) {
 978         OpTy = OpTy->getSignedVersion();
 979         shouldCast = true;
 980       }
 981       break;
 982   }
 983
 984   // Write out the casted operand if we should, otherwise just write the
 985   // operand.
 986   if (shouldCast) {
 987     Out << "((";
 988     printType(Out, OpTy);
 989     Out << ")";
 990     writeOperand(Operand);
 991     Out << ")";
 992   } else
 993     writeOperand(Operand);
 994
 995 }
 996
 997 // generateCompilerSpecificCode - This is where we add conditional compilation
 998 // directives to cater to specific compilers as need be.
 999 //
1000 static void generateCompilerSpecificCode(std::ostream& Out) {
1001   // Alloca is hard to get, and we don't want to include stdlib.h here.
1002   Out << "/* get a declaration for alloca */\n"
1003       << "#if defined(__CYGWIN__) || defined(__MINGW32__)\n"
1004       << "extern void *_alloca(unsigned long);\n"
1005       << "#define alloca(x) _alloca(x)\n"
1006       << "#elif defined(__APPLE__)\n"
1007       << "extern void *__builtin_alloca(unsigned long);\n"
1008       << "#define alloca(x) __builtin_alloca(x)\n"
1009       << "#elif defined(__sun__)\n"
1010       << "#if defined(__sparcv9)\n"
1011       << "extern void *__builtin_alloca(unsigned long);\n"
1012       << "#else\n"
1013       << "extern void *__builtin_alloca(unsigned int);\n"
1014       << "#endif\n"
1015       << "#define alloca(x) __builtin_alloca(x)\n"
1016       << "#elif defined(__FreeBSD__) || defined(__OpenBSD__)\n"
1017       << "#define alloca(x) __builtin_alloca(x)\n"
1018       << "#elif !defined(_MSC_VER)\n"
1019       << "#include <alloca.h>\n"
1020       << "#endif\n\n";
1021
1022   // We output GCC specific attributes to preserve 'linkonce'ness on globals.
1023   // If we aren't being compiled with GCC, just drop these attributes.
1024   Out << "#ifndef __GNUC__  /* Can only support \"linkonce\" vars with GCC */\n"
1025       << "#define __attribute__(X)\n"
1026       << "#endif\n\n";
1027
1028 #if 0
1029   // At some point, we should support "external weak" vs. "weak" linkages.
1030   // On Mac OS X, "external weak" is spelled "__attribute__((weak_import))".
1031   Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n"
1032       << "#define __EXTERNAL_WEAK__ __attribute__((weak_import))\n"
1033       << "#elif defined(__GNUC__)\n"
1034       << "#define __EXTERNAL_WEAK__ __attribute__((weak))\n"
1035       << "#else\n"
1036       << "#define __EXTERNAL_WEAK__\n"
1037       << "#endif\n\n";
1038 #endif
1039
1040   // For now, turn off the weak linkage attribute on Mac OS X. (See above.)
1041   Out << "#if defined(__GNUC__) && defined(__APPLE_CC__)\n"
1042       << "#define __ATTRIBUTE_WEAK__\n"
1043       << "#elif defined(__GNUC__)\n"
1044       << "#define __ATTRIBUTE_WEAK__ __attribute__((weak))\n"
1045       << "#else\n"
1046       << "#define __ATTRIBUTE_WEAK__\n"
1047       << "#endif\n\n";
1048
1049   // Define NaN and Inf as GCC builtins if using GCC, as 0 otherwise
1050   // From the GCC documentation:
1051   //
1052   //   double __builtin_nan (const char *str)
1053   //
1054   // This is an implementation of the ISO C99 function nan.
1055   //
1056   // Since ISO C99 defines this function in terms of strtod, which we do
1057   // not implement, a description of the parsing is in order. The string is
1058   // parsed as by strtol; that is, the base is recognized by leading 0 or
1059   // 0x prefixes. The number parsed is placed in the significand such that
1060   // the least significant bit of the number is at the least significant
1061   // bit of the significand. The number is truncated to fit the significand
1062   // field provided. The significand is forced to be a quiet NaN.
1063   //
1064   // This function, if given a string literal, is evaluated early enough
1065   // that it is considered a compile-time constant.
1066   //
1067   //   float __builtin_nanf (const char *str)
1068   //
1069   // Similar to __builtin_nan, except the return type is float.
1070   //
1071   //   double __builtin_inf (void)
1072   //
1073   // Similar to __builtin_huge_val, except a warning is generated if the
1074   // target floating-point format does not support infinities. This
1075   // function is suitable for implementing the ISO C99 macro INFINITY.
1076   //
1077   //   float __builtin_inff (void)
1078   //
1079   // Similar to __builtin_inf, except the return type is float.
1080   Out << "#ifdef __GNUC__\n"
1081       << "#define LLVM_NAN(NanStr)   __builtin_nan(NanStr)   /* Double */\n"
1082       << "#define LLVM_NANF(NanStr)  __builtin_nanf(NanStr)  /* Float */\n"
1083       << "#define LLVM_NANS(NanStr)  __builtin_nans(NanStr)  /* Double */\n"
1084       << "#define LLVM_NANSF(NanStr) __builtin_nansf(NanStr) /* Float */\n"
1085       << "#define LLVM_INF           __builtin_inf()         /* Double */\n"
1086       << "#define LLVM_INFF          __builtin_inff()        /* Float */\n"
1087       << "#define LLVM_PREFETCH(addr,rw,locality) "
1088                               "__builtin_prefetch(addr,rw,locality)\n"
1089       << "#define __ATTRIBUTE_CTOR__ __attribute__((constructor))\n"
1090       << "#define __ATTRIBUTE_DTOR__ __attribute__((destructor))\n"
1091       << "#define LLVM_ASM           __asm__\n"
1092       << "#else\n"
1093       << "#define LLVM_NAN(NanStr)   ((double)0.0)           /* Double */\n"
1094       << "#define LLVM_NANF(NanStr)  0.0F                    /* Float */\n"
1095       << "#define LLVM_NANS(NanStr)  ((double)0.0)           /* Double */\n"
1096       << "#define LLVM_NANSF(NanStr) 0.0F                    /* Float */\n"
1097       << "#define LLVM_INF           ((double)0.0)           /* Double */\n"
1098       << "#define LLVM_INFF          0.0F                    /* Float */\n"
1099       << "#define LLVM_PREFETCH(addr,rw,locality)            /* PREFETCH */\n"
1100       << "#define __ATTRIBUTE_CTOR__\n"
1101       << "#define __ATTRIBUTE_DTOR__\n"
1102       << "#define LLVM_ASM(X)\n"
1103       << "#endif\n\n";
1104
1105   // Output target-specific code that should be inserted into main.
1106   Out << "#define CODE_FOR_MAIN() /* Any target-specific code for main()*/\n";
1107   // On X86, set the FP control word to 64-bits of precision instead of 80 bits.
1108   Out << "#if defined(__GNUC__) && !defined(__llvm__)\n"
1109       << "#if defined(i386) || defined(__i386__) || defined(__i386) || "
1110       << "defined(__x86_64__)\n"
1111       << "#undef CODE_FOR_MAIN\n"
1112       << "#define CODE_FOR_MAIN() \\\n"
1113       << "  {short F;__asm__ (\"fnstcw %0\" : \"=m\" (*&F)); \\\n"
1114       << "  F=(F&~0x300)|0x200;__asm__(\"fldcw %0\"::\"m\"(*&F));}\n"
1115       << "#endif\n#endif\n";
1116
1117 }
1118
1119 /// FindStaticTors - Given a static ctor/dtor list, unpack its contents into
1120 /// the StaticTors set.
1121 static void FindStaticTors(GlobalVariable *GV, std::set<Function*> &StaticTors){
1122   ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer());
1123   if (!InitList) return;
1124
1125   for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i)
1126     if (ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i))){
1127       if (CS->getNumOperands() != 2) return;  // Not array of 2-element structs.
1128
1129       if (CS->getOperand(1)->isNullValue())
1130         return;  // Found a null terminator, exit printing.
1131       Constant *FP = CS->getOperand(1);
1132       if (ConstantExpr *CE = dyn_cast<ConstantExpr>(FP))
1133         if (CE->getOpcode() == Instruction::Cast)
1134           FP = CE->getOperand(0);
1135       if (Function *F = dyn_cast<Function>(FP))
1136         StaticTors.insert(F);
1137     }
1138 }
1139
1140 enum SpecialGlobalClass {
1141   NotSpecial = 0,
1142   GlobalCtors, GlobalDtors,
1143   NotPrinted
1144 };
1145
1146 /// getGlobalVariableClass - If this is a global that is specially recognized
1147 /// by LLVM, return a code that indicates how we should handle it.
1148 static SpecialGlobalClass getGlobalVariableClass(const GlobalVariable *GV) {
1149   // If this is a global ctors/dtors list, handle it now.
1150   if (GV->hasAppendingLinkage() && GV->use_empty()) {
1151     if (GV->getName() == "llvm.global_ctors")
1152       return GlobalCtors;
1153     else if (GV->getName() == "llvm.global_dtors")
1154       return GlobalDtors;
1155   }
1156
1157   // Otherwise, it it is other metadata, don't print it.  This catches things
1158   // like debug information.
1159   if (GV->getSection() == "llvm.metadata")
1160     return NotPrinted;
1161
1162   return NotSpecial;
1163 }
1164
1165
1166 bool CWriter::doInitialization(Module &M) {
1167   // Initialize
1168   TheModule = &M;
1169
1170   IL.AddPrototypes(M);
1171
1172   // Ensure that all structure types have names...
1173   Mang = new Mangler(M);
1174   Mang->markCharUnacceptable('.');
1175
1176   // Keep track of which functions are static ctors/dtors so they can have
1177   // an attribute added to their prototypes.
1178   std::set<Function*> StaticCtors, StaticDtors;
1179   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1180        I != E; ++I) {
1181     switch (getGlobalVariableClass(I)) {
1182     default: break;
1183     case GlobalCtors:
1184       FindStaticTors(I, StaticCtors);
1185       break;
1186     case GlobalDtors:
1187       FindStaticTors(I, StaticDtors);
1188       break;
1189     }
1190   }
1191
1192   // get declaration for alloca
1193   Out << "/* Provide Declarations */\n";
1194   Out << "#include <stdarg.h>\n";      // Varargs support
1195   Out << "#include <setjmp.h>\n";      // Unwind support
1196   generateCompilerSpecificCode(Out);
1197
1198   // Provide a definition for `bool' if not compiling with a C++ compiler.
1199   Out << "\n"
1200       << "#ifndef __cplusplus\ntypedef unsigned char bool;\n#endif\n"
1201
1202       << "\n\n/* Support for floating point constants */\n"
1203       << "typedef unsigned long long ConstantDoubleTy;\n"
1204       << "typedef unsigned int        ConstantFloatTy;\n"
1205
1206       << "\n\n/* Global Declarations */\n";
1207
1208   // First output all the declarations for the program, because C requires
1209   // Functions & globals to be declared before they are used.
1210   //
1211
1212   // Loop over the symbol table, emitting all named constants...
1213   printModuleTypes(M.getSymbolTable());
1214
1215   // Global variable declarations...
1216   if (!M.global_empty()) {
1217     Out << "\n/* External Global Variable Declarations */\n";
1218     for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1219          I != E; ++I) {
1220       if (I->hasExternalLinkage()) {
1221         Out << "extern ";
1222         printType(Out, I->getType()->getElementType(), Mang->getValueName(I));
1223         Out << ";\n";
1224       } else if (I->hasDLLImportLinkage()) {
1225         Out << "__declspec(dllimport) ";
1226         printType(Out, I->getType()->getElementType(), Mang->getValueName(I));
1227         Out << ";\n";
1228       }
1229     }
1230   }
1231
1232   // Function declarations
1233   Out << "\n/* Function Declarations */\n";
1234   Out << "double fmod(double, double);\n";   // Support for FP rem
1235   Out << "float fmodf(float, float);\n";
1236
1237   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
1238     // Don't print declarations for intrinsic functions.
1239     if (!I->getIntrinsicID() && I->getName() != "setjmp" &&
1240         I->getName() != "longjmp" && I->getName() != "_setjmp") {
1241       printFunctionSignature(I, true);
1242       if (I->hasWeakLinkage() || I->hasLinkOnceLinkage())
1243         Out << " __ATTRIBUTE_WEAK__";
1244       if (StaticCtors.count(I))
1245         Out << " __ATTRIBUTE_CTOR__";
1246       if (StaticDtors.count(I))
1247         Out << " __ATTRIBUTE_DTOR__";
1248
1249       if (I->hasName() && I->getName()[0] == 1)
1250         Out << " LLVM_ASM(\"" << I->getName().c_str()+1 << "\")";
1251
1252       Out << ";\n";
1253     }
1254   }
1255
1256   // Output the global variable declarations
1257   if (!M.global_empty()) {
1258     Out << "\n\n/* Global Variable Declarations */\n";
1259     for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1260          I != E; ++I)
1261       if (!I->isExternal()) {
1262         // Ignore special globals, such as debug info.
1263         if (getGlobalVariableClass(I))
1264           continue;
1265
1266         if (I->hasInternalLinkage())
1267           Out << "static ";
1268         else
1269           Out << "extern ";
1270         printType(Out, I->getType()->getElementType(), Mang->getValueName(I));
1271
1272         if (I->hasLinkOnceLinkage())
1273           Out << " __attribute__((common))";
1274         else if (I->hasWeakLinkage())
1275           Out << " __ATTRIBUTE_WEAK__";
1276         Out << ";\n";
1277       }
1278   }
1279
1280   // Output the global variable definitions and contents...
1281   if (!M.global_empty()) {
1282     Out << "\n\n/* Global Variable Definitions and Initialization */\n";
1283     for (Module::global_iterator I = M.global_begin(), E = M.global_end();
1284          I != E; ++I)
1285       if (!I->isExternal()) {
1286         // Ignore special globals, such as debug info.
1287         if (getGlobalVariableClass(I))
1288           continue;
1289
1290         if (I->hasInternalLinkage())
1291           Out << "static ";
1292         else if (I->hasDLLImportLinkage())
1293           Out << "__declspec(dllimport) ";
1294         else if (I->hasDLLExportLinkage())
1295           Out << "__declspec(dllexport) ";
1296
1297         printType(Out, I->getType()->getElementType(), Mang->getValueName(I));
1298         if (I->hasLinkOnceLinkage())
1299           Out << " __attribute__((common))";
1300         else if (I->hasWeakLinkage())
1301           Out << " __ATTRIBUTE_WEAK__";
1302
1303         // If the initializer is not null, emit the initializer.  If it is null,
1304         // we try to avoid emitting large amounts of zeros.  The problem with
1305         // this, however, occurs when the variable has weak linkage.  In this
1306         // case, the assembler will complain about the variable being both weak
1307         // and common, so we disable this optimization.
1308         if (!I->getInitializer()->isNullValue()) {
1309           Out << " = " ;
1310           writeOperand(I->getInitializer());
1311         } else if (I->hasWeakLinkage()) {
1312           // We have to specify an initializer, but it doesn't have to be
1313           // complete.  If the value is an aggregate, print out { 0 }, and let
1314           // the compiler figure out the rest of the zeros.
1315           Out << " = " ;
1316           if (isa<StructType>(I->getInitializer()->getType()) ||
1317               isa<ArrayType>(I->getInitializer()->getType()) ||
1318               isa<PackedType>(I->getInitializer()->getType())) {
1319             Out << "{ 0 }";
1320           } else {
1321             // Just print it out normally.
1322             writeOperand(I->getInitializer());
1323           }
1324         }
1325         Out << ";\n";
1326       }
1327   }
1328
1329   if (!M.empty())
1330     Out << "\n\n/* Function Bodies */\n";
1331   return false;
1332 }
1333
1334
1335 /// Output all floating point constants that cannot be printed accurately...
1336 void CWriter::printFloatingPointConstants(Function &F) {
1337   // Scan the module for floating point constants.  If any FP constant is used
1338   // in the function, we want to redirect it here so that we do not depend on
1339   // the precision of the printed form, unless the printed form preserves
1340   // precision.
1341   //
1342   static unsigned FPCounter = 0;
1343   for (constant_iterator I = constant_begin(&F), E = constant_end(&F);
1344        I != E; ++I)
1345     if (const ConstantFP *FPC = dyn_cast<ConstantFP>(*I))
1346       if (!isFPCSafeToPrint(FPC) && // Do not put in FPConstantMap if safe.
1347           !FPConstantMap.count(FPC)) {
1348         double Val = FPC->getValue();
1349
1350         FPConstantMap[FPC] = FPCounter;  // Number the FP constants
1351
1352         if (FPC->getType() == Type::DoubleTy) {
1353           Out << "static const ConstantDoubleTy FPConstant" << FPCounter++
1354               << " = 0x" << std::hex << DoubleToBits(Val) << std::dec
1355               << "ULL;    /* " << Val << " */\n";
1356         } else if (FPC->getType() == Type::FloatTy) {
1357           Out << "static const ConstantFloatTy FPConstant" << FPCounter++
1358               << " = 0x" << std::hex << FloatToBits(Val) << std::dec
1359               << "U;    /* " << Val << " */\n";
1360         } else
1361           assert(0 && "Unknown float type!");
1362       }
1363
1364   Out << '\n';
1365 }
1366
1367
1368 /// printSymbolTable - Run through symbol table looking for type names.  If a
1369 /// type name is found, emit its declaration...
1370 ///
1371 void CWriter::printModuleTypes(const SymbolTable &ST) {
1372   // We are only interested in the type plane of the symbol table.
1373   SymbolTable::type_const_iterator I   = ST.type_begin();
1374   SymbolTable::type_const_iterator End = ST.type_end();
1375
1376   // If there are no type names, exit early.
1377   if (I == End) return;
1378
1379   // Print out forward declarations for structure types before anything else!
1380   Out << "/* Structure forward decls */\n";
1381   for (; I != End; ++I)
1382     if (const Type *STy = dyn_cast<StructType>(I->second)) {
1383       std::string Name = "struct l_" + Mang->makeNameProper(I->first);
1384       Out << Name << ";\n";
1385       TypeNames.insert(std::make_pair(STy, Name));
1386     }
1387
1388   Out << '\n';
1389
1390   // Now we can print out typedefs...
1391   Out << "/* Typedefs */\n";
1392   for (I = ST.type_begin(); I != End; ++I) {
1393     const Type *Ty = cast<Type>(I->second);
1394     std::string Name = "l_" + Mang->makeNameProper(I->first);
1395     Out << "typedef ";
1396     printType(Out, Ty, Name);
1397     Out << ";\n";
1398   }
1399
1400   Out << '\n';
1401
1402   // Keep track of which structures have been printed so far...
1403   std::set<const StructType *> StructPrinted;
1404
1405   // Loop over all structures then push them into the stack so they are
1406   // printed in the correct order.
1407   //
1408   Out << "/* Structure contents */\n";
1409   for (I = ST.type_begin(); I != End; ++I)
1410     if (const StructType *STy = dyn_cast<StructType>(I->second))
1411       // Only print out used types!
1412       printContainedStructs(STy, StructPrinted);
1413 }
1414
1415 // Push the struct onto the stack and recursively push all structs
1416 // this one depends on.
1417 //
1418 // TODO:  Make this work properly with packed types
1419 //
1420 void CWriter::printContainedStructs(const Type *Ty,
1421                                     std::set<const StructType*> &StructPrinted){
1422   // Don't walk through pointers.
1423   if (isa<PointerType>(Ty) || Ty->isPrimitiveType()) return;
1424
1425   // Print all contained types first.
1426   for (Type::subtype_iterator I = Ty->subtype_begin(),
1427        E = Ty->subtype_end(); I != E; ++I)
1428     printContainedStructs(*I, StructPrinted);
1429
1430   if (const StructType *STy = dyn_cast<StructType>(Ty)) {
1431     // Check to see if we have already printed this struct.
1432     if (StructPrinted.insert(STy).second) {
1433       // Print structure type out.
1434       std::string Name = TypeNames[STy];
1435       printType(Out, STy, Name, true);
1436       Out << ";\n\n";
1437     }
1438   }
1439 }
1440
1441 void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
1442   /// isCStructReturn - Should this function actually return a struct by-value?
1443   bool isCStructReturn = F->getCallingConv() == CallingConv::CSRet;
1444
1445   if (F->hasInternalLinkage()) Out << "static ";
1446   if (F->hasDLLImportLinkage()) Out << "__declspec(dllimport) ";
1447   if (F->hasDLLExportLinkage()) Out << "__declspec(dllexport) ";
1448   switch (F->getCallingConv()) {
1449    case CallingConv::X86_StdCall:
1450     Out << "__stdcall ";
1451     break;
1452    case CallingConv::X86_FastCall:
1453     Out << "__fastcall ";
1454     break;
1455   }
1456
1457   // Loop over the arguments, printing them...
1458   const FunctionType *FT = cast<FunctionType>(F->getFunctionType());
1459
1460   std::stringstream FunctionInnards;
1461
1462   // Print out the name...
1463   FunctionInnards << Mang->getValueName(F) << '(';
1464
1465   bool PrintedArg = false;
1466   if (!F->isExternal()) {
1467     if (!F->arg_empty()) {
1468       Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
1469
1470       // If this is a struct-return function, don't print the hidden
1471       // struct-return argument.
1472       if (isCStructReturn) {
1473         assert(I != E && "Invalid struct return function!");
1474         ++I;
1475       }
1476
1477       std::string ArgName;
1478       for (; I != E; ++I) {
1479         if (PrintedArg) FunctionInnards << ", ";
1480         if (I->hasName() || !Prototype)
1481           ArgName = Mang->getValueName(I);
1482         else
1483           ArgName = "";
1484         printType(FunctionInnards, I->getType(), ArgName);
1485         PrintedArg = true;
1486       }
1487     }
1488   } else {
1489     // Loop over the arguments, printing them.
1490     FunctionType::param_iterator I = FT->param_begin(), E = FT->param_end();
1491
1492     // If this is a struct-return function, don't print the hidden
1493     // struct-return argument.
1494     if (isCStructReturn) {
1495       assert(I != E && "Invalid struct return function!");
1496       ++I;
1497     }
1498
1499     for (; I != E; ++I) {
1500       if (PrintedArg) FunctionInnards << ", ";
1501       printType(FunctionInnards, *I);
1502       PrintedArg = true;
1503     }
1504   }
1505
1506   // Finish printing arguments... if this is a vararg function, print the ...,
1507   // unless there are no known types, in which case, we just emit ().
1508   //
1509   if (FT->isVarArg() && PrintedArg) {
1510     if (PrintedArg) FunctionInnards << ", ";
1511     FunctionInnards << "...";  // Output varargs portion of signature!
1512   } else if (!FT->isVarArg() && !PrintedArg) {
1513     FunctionInnards << "void"; // ret() -> ret(void) in C.
1514   }
1515   FunctionInnards << ')';
1516
1517   // Get the return tpe for the function.
1518   const Type *RetTy;
1519   if (!isCStructReturn)
1520     RetTy = F->getReturnType();
1521   else {
1522     // If this is a struct-return function, print the struct-return type.
1523     RetTy = cast<PointerType>(FT->getParamType(0))->getElementType();
1524   }
1525
1526   // Print out the return type and the signature built above.
1527   printType(Out, RetTy, FunctionInnards.str());
1528 }
1529
1530 void CWriter::printFunction(Function &F) {
1531   printFunctionSignature(&F, false);
1532   Out << " {\n";
1533
1534   // If this is a struct return function, handle the result with magic.
1535   if (F.getCallingConv() == CallingConv::CSRet) {
1536     const Type *StructTy =
1537       cast<PointerType>(F.arg_begin()->getType())->getElementType();
1538     Out << "  ";
1539     printType(Out, StructTy, "StructReturn");
1540     Out << ";  /* Struct return temporary */\n";
1541
1542     Out << "  ";
1543     printType(Out, F.arg_begin()->getType(), Mang->getValueName(F.arg_begin()));
1544     Out << " = &StructReturn;\n";
1545   }
1546
1547   bool PrintedVar = false;
1548
1549   // print local variable information for the function
1550   for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ++I)
1551     if (const AllocaInst *AI = isDirectAlloca(&*I)) {
1552       Out << "  ";
1553       printType(Out, AI->getAllocatedType(), Mang->getValueName(AI));
1554       Out << ";    /* Address-exposed local */\n";
1555       PrintedVar = true;
1556     } else if (I->getType() != Type::VoidTy && !isInlinableInst(*I)) {
1557       Out << "  ";
1558       printType(Out, I->getType(), Mang->getValueName(&*I));
1559       Out << ";\n";
1560
1561       if (isa<PHINode>(*I)) {  // Print out PHI node temporaries as well...
1562         Out << "  ";
1563         printType(Out, I->getType(),
1564                   Mang->getValueName(&*I)+"__PHI_TEMPORARY");
1565         Out << ";\n";
1566       }
1567       PrintedVar = true;
1568     }
1569
1570   if (PrintedVar)
1571     Out << '\n';
1572
1573   if (F.hasExternalLinkage() && F.getName() == "main")
1574     Out << "  CODE_FOR_MAIN();\n";
1575
1576   // print the basic blocks
1577   for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
1578     if (Loop *L = LI->getLoopFor(BB)) {
1579       if (L->getHeader() == BB && L->getParentLoop() == 0)
1580         printLoop(L);
1581     } else {
1582       printBasicBlock(BB);
1583     }
1584   }
1585
1586   Out << "}\n\n";
1587 }
1588
1589 void CWriter::printLoop(Loop *L) {
1590   Out << "  do {     /* Syntactic loop '" << L->getHeader()->getName()
1591       << "' to make GCC happy */\n";
1592   for (unsigned i = 0, e = L->getBlocks().size(); i != e; ++i) {
1593     BasicBlock *BB = L->getBlocks()[i];
1594     Loop *BBLoop = LI->getLoopFor(BB);
1595     if (BBLoop == L)
1596       printBasicBlock(BB);
1597     else if (BB == BBLoop->getHeader() && BBLoop->getParentLoop() == L)
1598       printLoop(BBLoop);
1599   }
1600   Out << "  } while (1); /* end of syntactic loop '"
1601       << L->getHeader()->getName() << "' */\n";
1602 }
1603
1604 void CWriter::printBasicBlock(BasicBlock *BB) {
1605
1606   // Don't print the label for the basic block if there are no uses, or if
1607   // the only terminator use is the predecessor basic block's terminator.
1608   // We have to scan the use list because PHI nodes use basic blocks too but
1609   // do not require a label to be generated.
1610   //
1611   bool NeedsLabel = false;
1612   for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
1613     if (isGotoCodeNecessary(*PI, BB)) {
1614       NeedsLabel = true;
1615       break;
1616     }
1617
1618   if (NeedsLabel) Out << Mang->getValueName(BB) << ":\n";
1619
1620   // Output all of the instructions in the basic block...
1621   for (BasicBlock::iterator II = BB->begin(), E = --BB->end(); II != E;
1622        ++II) {
1623     if (!isInlinableInst(*II) && !isDirectAlloca(II)) {
1624       if (II->getType() != Type::VoidTy)
1625         outputLValue(II);
1626       else
1627         Out << "  ";
1628       visit(*II);
1629       Out << ";\n";
1630     }
1631   }
1632
1633   // Don't emit prefix or suffix for the terminator...
1634   visit(*BB->getTerminator());
1635 }
1636
1637
1638 // Specific Instruction type classes... note that all of the casts are
1639 // necessary because we use the instruction classes as opaque types...
1640 //
1641 void CWriter::visitReturnInst(ReturnInst &I) {
1642   // If this is a struct return function, return the temporary struct.
1643   if (I.getParent()->getParent()->getCallingConv() == CallingConv::CSRet) {
1644     Out << "  return StructReturn;\n";
1645     return;
1646   }
1647
1648   // Don't output a void return if this is the last basic block in the function
1649   if (I.getNumOperands() == 0 &&
1650       &*--I.getParent()->getParent()->end() == I.getParent() &&
1651       !I.getParent()->size() == 1) {
1652     return;
1653   }
1654
1655   Out << "  return";
1656   if (I.getNumOperands()) {
1657     Out << ' ';
1658     writeOperand(I.getOperand(0));
1659   }
1660   Out << ";\n";
1661 }
1662
1663 void CWriter::visitSwitchInst(SwitchInst &SI) {
1664
1665   Out << "  switch (";
1666   writeOperand(SI.getOperand(0));
1667   Out << ") {\n  default:\n";
1668   printPHICopiesForSuccessor (SI.getParent(), SI.getDefaultDest(), 2);
1669   printBranchToBlock(SI.getParent(), SI.getDefaultDest(), 2);
1670   Out << ";\n";
1671   for (unsigned i = 2, e = SI.getNumOperands(); i != e; i += 2) {
1672     Out << "  case ";
1673     writeOperand(SI.getOperand(i));
1674     Out << ":\n";
1675     BasicBlock *Succ = cast<BasicBlock>(SI.getOperand(i+1));
1676     printPHICopiesForSuccessor (SI.getParent(), Succ, 2);
1677     printBranchToBlock(SI.getParent(), Succ, 2);
1678     if (Function::iterator(Succ) == next(Function::iterator(SI.getParent())))
1679       Out << "    break;\n";
1680   }
1681   Out << "  }\n";
1682 }
1683
1684 void CWriter::visitUnreachableInst(UnreachableInst &I) {
1685   Out << "  /*UNREACHABLE*/;\n";
1686 }
1687
1688 bool CWriter::isGotoCodeNecessary(BasicBlock *From, BasicBlock *To) {
1689   /// FIXME: This should be reenabled, but loop reordering safe!!
1690   return true;
1691
1692   if (next(Function::iterator(From)) != Function::iterator(To))
1693     return true;  // Not the direct successor, we need a goto.
1694
1695   //isa<SwitchInst>(From->getTerminator())
1696
1697   if (LI->getLoopFor(From) != LI->getLoopFor(To))
1698     return true;
1699   return false;
1700 }
1701
1702 void CWriter::printPHICopiesForSuccessor (BasicBlock *CurBlock,
1703                                           BasicBlock *Successor,
1704                                           unsigned Indent) {
1705   for (BasicBlock::iterator I = Successor->begin(); isa<PHINode>(I); ++I) {
1706     PHINode *PN = cast<PHINode>(I);
1707     // Now we have to do the printing.
1708     Value *IV = PN->getIncomingValueForBlock(CurBlock);
1709     if (!isa<UndefValue>(IV)) {
1710       Out << std::string(Indent, ' ');
1711       Out << "  " << Mang->getValueName(I) << "__PHI_TEMPORARY = ";
1712       writeOperand(IV);
1713       Out << ";   /* for PHI node */\n";
1714     }
1715   }
1716 }
1717
1718 void CWriter::printBranchToBlock(BasicBlock *CurBB, BasicBlock *Succ,
1719                                  unsigned Indent) {
1720   if (isGotoCodeNecessary(CurBB, Succ)) {
1721     Out << std::string(Indent, ' ') << "  goto ";
1722     writeOperand(Succ);
1723     Out << ";\n";
1724   }
1725 }
1726
1727 // Branch instruction printing - Avoid printing out a branch to a basic block
1728 // that immediately succeeds the current one.
1729 //
1730 void CWriter::visitBranchInst(BranchInst &I) {
1731
1732   if (I.isConditional()) {
1733     if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(0))) {
1734       Out << "  if (";
1735       writeOperand(I.getCondition());
1736       Out << ") {\n";
1737
1738       printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 2);
1739       printBranchToBlock(I.getParent(), I.getSuccessor(0), 2);
1740
1741       if (isGotoCodeNecessary(I.getParent(), I.getSuccessor(1))) {
1742         Out << "  } else {\n";
1743         printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2);
1744         printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
1745       }
1746     } else {
1747       // First goto not necessary, assume second one is...
1748       Out << "  if (!";
1749       writeOperand(I.getCondition());
1750       Out << ") {\n";
1751
1752       printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(1), 2);
1753       printBranchToBlock(I.getParent(), I.getSuccessor(1), 2);
1754     }
1755
1756     Out << "  }\n";
1757   } else {
1758     printPHICopiesForSuccessor (I.getParent(), I.getSuccessor(0), 0);
1759     printBranchToBlock(I.getParent(), I.getSuccessor(0), 0);
1760   }
1761   Out << "\n";
1762 }
1763
1764 // PHI nodes get copied into temporary values at the end of predecessor basic
1765 // blocks.  We now need to copy these temporary values into the REAL value for
1766 // the PHI.
1767 void CWriter::visitPHINode(PHINode &I) {
1768   writeOperand(&I);
1769   Out << "__PHI_TEMPORARY";
1770 }
1771
1772
1773 void CWriter::visitBinaryOperator(Instruction &I) {
1774   // binary instructions, shift instructions, setCond instructions.
1775   assert(!isa<PointerType>(I.getType()));
1776
1777   // We must cast the results of binary operations which might be promoted.
1778   bool needsCast = false;
1779   if ((I.getType() == Type::UByteTy) || (I.getType() == Type::SByteTy)
1780       || (I.getType() == Type::UShortTy) || (I.getType() == Type::ShortTy)
1781       || (I.getType() == Type::FloatTy)) {
1782     needsCast = true;
1783     Out << "((";
1784     printType(Out, I.getType());
1785     Out << ")(";
1786   }
1787
1788   // If this is a negation operation, print it out as such.  For FP, we don't
1789   // want to print "-0.0 - X".
1790   if (BinaryOperator::isNeg(&I)) {
1791     Out << "-(";
1792     writeOperand(BinaryOperator::getNegArgument(cast<BinaryOperator>(&I)));
1793     Out << ")";
1794   } else if (I.getOpcode() == Instruction::FRem) {
1795     // Output a call to fmod/fmodf instead of emitting a%b
1796     if (I.getType() == Type::FloatTy)
1797       Out << "fmodf(";
1798     else
1799       Out << "fmod(";
1800     writeOperand(I.getOperand(0));
1801     Out << ", ";
1802     writeOperand(I.getOperand(1));
1803     Out << ")";
1804   } else {
1805
1806     // Write out the cast of the instruction's value back to the proper type
1807     // if necessary.
1808     bool NeedsClosingParens = writeInstructionCast(I);
1809
1810     // Certain instructions require the operand to be forced to a specific type
1811     // so we use writeOperandWithCast here instead of writeOperand. Similarly
1812     // below for operand 1
1813     writeOperandWithCast(I.getOperand(0), I.getOpcode());
1814
1815     switch (I.getOpcode()) {
1816     case Instruction::Add: Out << " + "; break;
1817     case Instruction::Sub: Out << " - "; break;
1818     case Instruction::Mul: Out << '*'; break;
1819     case Instruction::URem:
1820     case Instruction::SRem:
1821     case Instruction::FRem: Out << '%'; break;
1822     case Instruction::UDiv:
1823     case Instruction::SDiv:
1824     case Instruction::FDiv: Out << '/'; break;
1825     case Instruction::And: Out << " & "; break;
1826     case Instruction::Or: Out << " | "; break;
1827     case Instruction::Xor: Out << " ^ "; break;
1828     case Instruction::SetEQ: Out << " == "; break;
1829     case Instruction::SetNE: Out << " != "; break;
1830     case Instruction::SetLE: Out << " <= "; break;
1831     case Instruction::SetGE: Out << " >= "; break;
1832     case Instruction::SetLT: Out << " < "; break;
1833     case Instruction::SetGT: Out << " > "; break;
1834     case Instruction::Shl : Out << " << "; break;
1835     case Instruction::Shr : Out << " >> "; break;
1836     default: std::cerr << "Invalid operator type!" << I; abort();
1837     }
1838
1839     writeOperandWithCast(I.getOperand(1), I.getOpcode());
1840     if (NeedsClosingParens)
1841       Out << "))";
1842   }
1843
1844   if (needsCast) {
1845     Out << "))";
1846   }
1847 }
1848
1849 void CWriter::visitCastInst(CastInst &I) {
1850   if (I.getType() == Type::BoolTy) {
1851     Out << '(';
1852     writeOperand(I.getOperand(0));
1853     Out << " != 0)";
1854     return;
1855   }
1856   Out << '(';
1857   printType(Out, I.getType());
1858   Out << ')';
1859   if (isa<PointerType>(I.getType())&&I.getOperand(0)->getType()->isIntegral() ||
1860       isa<PointerType>(I.getOperand(0)->getType())&&I.getType()->isIntegral()) {
1861     // Avoid "cast to pointer from integer of different size" warnings
1862     Out << "(long)";
1863   }
1864
1865   writeOperand(I.getOperand(0));
1866 }
1867
1868 void CWriter::visitSelectInst(SelectInst &I) {
1869   Out << "((";
1870   writeOperand(I.getCondition());
1871   Out << ") ? (";
1872   writeOperand(I.getTrueValue());
1873   Out << ") : (";
1874   writeOperand(I.getFalseValue());
1875   Out << "))";
1876 }
1877
1878
1879 void CWriter::lowerIntrinsics(Function &F) {
1880   for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
1881     for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; )
1882       if (CallInst *CI = dyn_cast<CallInst>(I++))
1883         if (Function *F = CI->getCalledFunction())
1884           switch (F->getIntrinsicID()) {
1885           case Intrinsic::not_intrinsic:
1886           case Intrinsic::vastart:
1887           case Intrinsic::vacopy:
1888           case Intrinsic::vaend:
1889           case Intrinsic::returnaddress:
1890           case Intrinsic::frameaddress:
1891           case Intrinsic::setjmp:
1892           case Intrinsic::longjmp:
1893           case Intrinsic::prefetch:
1894           case Intrinsic::dbg_stoppoint:
1895           case Intrinsic::powi_f32:
1896           case Intrinsic::powi_f64:
1897             // We directly implement these intrinsics
1898             break;
1899           default:
1900             // If this is an intrinsic that directly corresponds to a GCC
1901             // builtin, we handle it.
1902             const char *BuiltinName = "";
1903 #define GET_GCC_BUILTIN_NAME
1904 #include "llvm/Intrinsics.gen"
1905 #undef GET_GCC_BUILTIN_NAME
1906             // If we handle it, don't lower it.
1907             if (BuiltinName[0]) break;
1908
1909             // All other intrinsic calls we must lower.
1910             Instruction *Before = 0;
1911             if (CI != &BB->front())
1912               Before = prior(BasicBlock::iterator(CI));
1913
1914             IL.LowerIntrinsicCall(CI);
1915             if (Before) {        // Move iterator to instruction after call
1916               I = Before; ++I;
1917             } else {
1918               I = BB->begin();
1919             }
1920             break;
1921           }
1922 }
1923
1924
1925
1926 void CWriter::visitCallInst(CallInst &I) {
1927   bool WroteCallee = false;
1928
1929   // Handle intrinsic function calls first...
1930   if (Function *F = I.getCalledFunction())
1931     if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID()) {
1932       switch (ID) {
1933       default: {
1934         // If this is an intrinsic that directly corresponds to a GCC
1935         // builtin, we emit it here.
1936         const char *BuiltinName = "";
1937 #define GET_GCC_BUILTIN_NAME
1938 #include "llvm/Intrinsics.gen"
1939 #undef GET_GCC_BUILTIN_NAME
1940         assert(BuiltinName[0] && "Unknown LLVM intrinsic!");
1941
1942         Out << BuiltinName;
1943         WroteCallee = true;
1944         break;
1945       }
1946       case Intrinsic::vastart:
1947         Out << "0; ";
1948
1949         Out << "va_start(*(va_list*)";
1950         writeOperand(I.getOperand(1));
1951         Out << ", ";
1952         // Output the last argument to the enclosing function...
1953         if (I.getParent()->getParent()->arg_empty()) {
1954           std::cerr << "The C backend does not currently support zero "
1955                     << "argument varargs functions, such as '"
1956                     << I.getParent()->getParent()->getName() << "'!\n";
1957           abort();
1958         }
1959         writeOperand(--I.getParent()->getParent()->arg_end());
1960         Out << ')';
1961         return;
1962       case Intrinsic::vaend:
1963         if (!isa<ConstantPointerNull>(I.getOperand(1))) {
1964           Out << "0; va_end(*(va_list*)";
1965           writeOperand(I.getOperand(1));
1966           Out << ')';
1967         } else {
1968           Out << "va_end(*(va_list*)0)";
1969         }
1970         return;
1971       case Intrinsic::vacopy:
1972         Out << "0; ";
1973         Out << "va_copy(*(va_list*)";
1974         writeOperand(I.getOperand(1));
1975         Out << ", *(va_list*)";
1976         writeOperand(I.getOperand(2));
1977         Out << ')';
1978         return;
1979       case Intrinsic::returnaddress:
1980         Out << "__builtin_return_address(";
1981         writeOperand(I.getOperand(1));
1982         Out << ')';
1983         return;
1984       case Intrinsic::frameaddress:
1985         Out << "__builtin_frame_address(";
1986         writeOperand(I.getOperand(1));
1987         Out << ')';
1988         return;
1989       case Intrinsic::powi_f32:
1990       case Intrinsic::powi_f64:
1991         Out << "__builtin_powi(";
1992         writeOperand(I.getOperand(1));
1993         Out << ", ";
1994         writeOperand(I.getOperand(2));
1995         Out << ')';
1996         return;
1997       case Intrinsic::setjmp:
1998 #if defined(HAVE__SETJMP) && defined(HAVE__LONGJMP)
1999         Out << "_";  // Use _setjmp on systems that support it!
2000 #endif
2001         Out << "setjmp(*(jmp_buf*)";
2002         writeOperand(I.getOperand(1));
2003         Out << ')';
2004         return;
2005       case Intrinsic::longjmp:
2006 #if defined(HAVE__SETJMP) && defined(HAVE__LONGJMP)
2007         Out << "_";  // Use _longjmp on systems that support it!
2008 #endif
2009         Out << "longjmp(*(jmp_buf*)";
2010         writeOperand(I.getOperand(1));
2011         Out << ", ";
2012         writeOperand(I.getOperand(2));
2013         Out << ')';
2014         return;
2015       case Intrinsic::prefetch:
2016         Out << "LLVM_PREFETCH((const void *)";
2017         writeOperand(I.getOperand(1));
2018         Out << ", ";
2019         writeOperand(I.getOperand(2));
2020         Out << ", ";
2021         writeOperand(I.getOperand(3));
2022         Out << ")";
2023         return;
2024       case Intrinsic::dbg_stoppoint: {
2025         // If we use writeOperand directly we get a "u" suffix which is rejected
2026         // by gcc.
2027         DbgStopPointInst &SPI = cast<DbgStopPointInst>(I);
2028
2029         Out << "\n#line "
2030             << SPI.getLine()
2031             << " \"" << SPI.getDirectory()
2032             << SPI.getFileName() << "\"\n";
2033         return;
2034       }
2035       }
2036     }
2037
2038   Value *Callee = I.getCalledValue();
2039
2040   // If this is a call to a struct-return function, assign to the first
2041   // parameter instead of passing it to the call.
2042   bool isStructRet = I.getCallingConv() == CallingConv::CSRet;
2043   if (isStructRet) {
2044     Out << "*(";
2045     writeOperand(I.getOperand(1));
2046     Out << ") = ";
2047   }
2048
2049   if (I.isTailCall()) Out << " /*tail*/ ";
2050
2051   const PointerType  *PTy   = cast<PointerType>(Callee->getType());
2052   const FunctionType *FTy   = cast<FunctionType>(PTy->getElementType());
2053
2054   if (!WroteCallee) {
2055     // If this is an indirect call to a struct return function, we need to cast
2056     // the pointer.
2057     bool NeedsCast = isStructRet && !isa<Function>(Callee);
2058
2059     // GCC is a real PITA.  It does not permit codegening casts of functions to
2060     // function pointers if they are in a call (it generates a trap instruction
2061     // instead!).  We work around this by inserting a cast to void* in between
2062     // the function and the function pointer cast.  Unfortunately, we can't just
2063     // form the constant expression here, because the folder will immediately
2064     // nuke it.
2065     //
2066     // Note finally, that this is completely unsafe.  ANSI C does not guarantee
2067     // that void* and function pointers have the same size. :( To deal with this
2068     // in the common case, we handle casts where the number of arguments passed
2069     // match exactly.
2070     //
2071     if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Callee))
2072       if (CE->getOpcode() == Instruction::Cast)
2073         if (Function *RF = dyn_cast<Function>(CE->getOperand(0))) {
2074           NeedsCast = true;
2075           Callee = RF;
2076         }
2077
2078     if (NeedsCast) {
2079       // Ok, just cast the pointer type.
2080       Out << "((";
2081       if (!isStructRet)
2082         printType(Out, I.getCalledValue()->getType());
2083       else
2084         printStructReturnPointerFunctionType(Out,
2085                              cast<PointerType>(I.getCalledValue()->getType()));
2086       Out << ")(void*)";
2087     }
2088     writeOperand(Callee);
2089     if (NeedsCast) Out << ')';
2090   }
2091
2092   Out << '(';
2093
2094   unsigned NumDeclaredParams = FTy->getNumParams();
2095
2096   CallSite::arg_iterator AI = I.op_begin()+1, AE = I.op_end();
2097   unsigned ArgNo = 0;
2098   if (isStructRet) {   // Skip struct return argument.
2099     ++AI;
2100     ++ArgNo;
2101   }
2102
2103   bool PrintedArg = false;
2104   for (; AI != AE; ++AI, ++ArgNo) {
2105     if (PrintedArg) Out << ", ";
2106     if (ArgNo < NumDeclaredParams &&
2107         (*AI)->getType() != FTy->getParamType(ArgNo)) {
2108       Out << '(';
2109       printType(Out, FTy->getParamType(ArgNo));
2110       Out << ')';
2111     }
2112     writeOperand(*AI);
2113     PrintedArg = true;
2114   }
2115   Out << ')';
2116 }
2117
2118 void CWriter::visitMallocInst(MallocInst &I) {
2119   assert(0 && "lowerallocations pass didn't work!");
2120 }
2121
2122 void CWriter::visitAllocaInst(AllocaInst &I) {
2123   Out << '(';
2124   printType(Out, I.getType());
2125   Out << ") alloca(sizeof(";
2126   printType(Out, I.getType()->getElementType());
2127   Out << ')';
2128   if (I.isArrayAllocation()) {
2129     Out << " * " ;
2130     writeOperand(I.getOperand(0));
2131   }
2132   Out << ')';
2133 }
2134
2135 void CWriter::visitFreeInst(FreeInst &I) {
2136   assert(0 && "lowerallocations pass didn't work!");
2137 }
2138
2139 void CWriter::printIndexingExpression(Value *Ptr, gep_type_iterator I,
2140                                       gep_type_iterator E) {
2141   bool HasImplicitAddress = false;
2142   // If accessing a global value with no indexing, avoid *(&GV) syndrome
2143   if (GlobalValue *V = dyn_cast<GlobalValue>(Ptr)) {
2144     HasImplicitAddress = true;
2145   } else if (isDirectAlloca(Ptr)) {
2146     HasImplicitAddress = true;
2147   }
2148
2149   if (I == E) {
2150     if (!HasImplicitAddress)
2151       Out << '*';  // Implicit zero first argument: '*x' is equivalent to 'x[0]'
2152
2153     writeOperandInternal(Ptr);
2154     return;
2155   }
2156
2157   const Constant *CI = dyn_cast<Constant>(I.getOperand());
2158   if (HasImplicitAddress && (!CI || !CI->isNullValue()))
2159     Out << "(&";
2160
2161   writeOperandInternal(Ptr);
2162
2163   if (HasImplicitAddress && (!CI || !CI->isNullValue())) {
2164     Out << ')';
2165     HasImplicitAddress = false;  // HIA is only true if we haven't addressed yet
2166   }
2167
2168   assert(!HasImplicitAddress || (CI && CI->isNullValue()) &&
2169          "Can only have implicit address with direct accessing");
2170
2171   if (HasImplicitAddress) {
2172     ++I;
2173   } else if (CI && CI->isNullValue()) {
2174     gep_type_iterator TmpI = I; ++TmpI;
2175
2176     // Print out the -> operator if possible...
2177     if (TmpI != E && isa<StructType>(*TmpI)) {
2178       Out << (HasImplicitAddress ? "." : "->");
2179       Out << "field" << cast<ConstantInt>(TmpI.getOperand())->getZExtValue();
2180       I = ++TmpI;
2181     }
2182   }
2183
2184   for (; I != E; ++I)
2185     if (isa<StructType>(*I)) {
2186       Out << ".field" << cast<ConstantInt>(I.getOperand())->getZExtValue();
2187     } else {
2188       Out << '[';
2189       writeOperand(I.getOperand());
2190       Out << ']';
2191     }
2192 }
2193
2194 void CWriter::visitLoadInst(LoadInst &I) {
2195   Out << '*';
2196   if (I.isVolatile()) {
2197     Out << "((";
2198     printType(Out, I.getType(), "volatile*");
2199     Out << ")";
2200   }
2201
2202   writeOperand(I.getOperand(0));
2203
2204   if (I.isVolatile())
2205     Out << ')';
2206 }
2207
2208 void CWriter::visitStoreInst(StoreInst &I) {
2209   Out << '*';
2210   if (I.isVolatile()) {
2211     Out << "((";
2212     printType(Out, I.getOperand(0)->getType(), " volatile*");
2213     Out << ")";
2214   }
2215   writeOperand(I.getPointerOperand());
2216   if (I.isVolatile()) Out << ')';
2217   Out << " = ";
2218   writeOperand(I.getOperand(0));
2219 }
2220
2221 void CWriter::visitGetElementPtrInst(GetElementPtrInst &I) {
2222   Out << '&';
2223   printIndexingExpression(I.getPointerOperand(), gep_type_begin(I),
2224                           gep_type_end(I));
2225 }
2226
2227 void CWriter::visitVAArgInst(VAArgInst &I) {
2228   Out << "va_arg(*(va_list*)";
2229   writeOperand(I.getOperand(0));
2230   Out << ", ";
2231   printType(Out, I.getType());
2232   Out << ");\n ";
2233 }
2234
2235 //===----------------------------------------------------------------------===//
2236 //                       External Interface declaration
2237 //===----------------------------------------------------------------------===//
2238
2239 bool CTargetMachine::addPassesToEmitWholeFile(PassManager &PM,
2240                                               std::ostream &o,
2241                                               CodeGenFileType FileType,
2242                                               bool Fast) {
2243   if (FileType != TargetMachine::AssemblyFile) return true;
2244
2245   PM.add(createLowerGCPass());
2246   PM.add(createLowerAllocationsPass(true));
2247   PM.add(createLowerInvokePass());
2248   PM.add(createCFGSimplificationPass());   // clean up after lower invoke.
2249   PM.add(new CBackendNameAllUsedStructsAndMergeFunctions());
2250   PM.add(new CWriter(o));
2251   return false;
2252 }