lib/Target/CBackend/CBackend.cpp

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