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