Changes from 3.7 merge to files not in upstream

lib/Target/JSBackend/JSBackend.cpp

 //===-- JSBackend.cpp - Library for converting LLVM code to JS       -----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements compiling of LLVM IR, which is assumed to have been
@@ skipping 14 matching lines @@
 #include "llvm/Config/config.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/Pass.h"
-#include "llvm/PassManager.h"
+#include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/FormattedStream.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/Transforms/NaCl.h"
 #include <algorithm>
 #include <cstdio>
 #include <map>
 #include <set> // TODO: unordered_set?
 using namespace llvm;
@@ skipping 72 matching lines @@
   typedef std::map<std::string, FunctionTable> FunctionTableMap;
   typedef std::map<std::string, std::string> StringMap;
   typedef std::map<std::string, unsigned> NameIntMap;
   typedef std::map<const BasicBlock*, unsigned> BlockIndexMap;
   typedef std::map<const Function*, BlockIndexMap> BlockAddressMap;
   typedef std::map<const BasicBlock*, Block*> LLVMToRelooperMap;
 
   /// JSWriter - This class is the main chunk of code that converts an LLVM
   /// module to JavaScript.
   class JSWriter : public ModulePass {
-    formatted_raw_ostream &Out;
+    raw_pwrite_stream &Out;
     const Module *TheModule;
     unsigned UniqueNum;
     unsigned NextFunctionIndex; // used with NoAliasingFunctionPointers
     ValueMap ValueNames;
     VarMap UsedVars;
     AllocaManager Allocas;
     HeapData GlobalData8;
     HeapData GlobalData32;
     HeapData GlobalData64;
     GlobalAddressMap GlobalAddresses;
     NameSet Externals; // vars
     NameSet Declares; // funcs
     StringMap Redirects; // library function redirects actually used, needed for wrapper funcs in tables
     std::string PostSets;
     NameIntMap NamedGlobals; // globals that we export as metadata to JS, so it can access them by name
     std::map<std::string, unsigned> IndexedFunctions; // name -> index
     FunctionTableMap FunctionTables; // sig => list of functions
     std::vector<std::string> GlobalInitializers;
     std::vector<std::string> Exports; // additional exports
     BlockAddressMap BlockAddresses;
 
     std::string CantValidate;
     bool UsesSIMD;
     int InvokeState; // cycles between 0, 1 after preInvoke, 2 after call, 0 again after postInvoke. hackish, no argument there.
     CodeGenOpt::Level OptLevel;
-    const DataLayout *DL;
+   const DataLayout *DL;

[jvoung (off chromium), 2015/05/26 20:39:45]

Upstream whitespace change, or leave the space alone and keep lined up?

[Derek Schuff, 2015/05/26 22:01:32]

Done.

     bool StackBumped;
 
     #include "CallHandlers.h"
 
   public:
     static char ID;
-    JSWriter(formatted_raw_ostream &o, CodeGenOpt::Level OptLevel)
+    JSWriter(raw_pwrite_stream &o, CodeGenOpt::Level OptLevel)
       : ModulePass(ID), Out(o), UniqueNum(0), NextFunctionIndex(0), CantValidate(""), UsesSIMD(false), InvokeState(0),
         OptLevel(OptLevel), StackBumped(false) {}
 
     virtual const char *getPassName() const { return "JavaScript backend"; }
 
     virtual bool runOnModule(Module &M);
 
     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
       AU.setPreservesAll();
-      AU.addRequired<DataLayoutPass>();
       ModulePass::getAnalysisUsage(AU);
     }
 
     void printProgram(const std::string& fname, const std::string& modName );
     void printModule(const std::string& fname, const std::string& modName );
     void printFunction(const Function *F);
 
     LLVM_ATTRIBUTE_NORETURN void error(const std::string& msg);
 
-    formatted_raw_ostream& nl(formatted_raw_ostream &Out, int delta = 0);
+    raw_pwrite_stream& nl(raw_pwrite_stream &Out, int delta = 0);
 
   private:
     void printCommaSeparated(const HeapData v);
 
     // parsing of constants has two phases: calculate, and then emit
     void parseConstant(const std::string& name, const Constant* CV, bool calculate);
 
     #define MEM_ALIGN 8
     #define MEM_ALIGN_BITS 64
     #define STACK_ALIGN 16
@@ skipping 279 matching lines @@
     // special analyses
 
     bool canReloop(const Function *F);
 
     // main entry point
 
     void printModuleBody();
   };
 } // end anonymous namespace.
 
-formatted_raw_ostream &JSWriter::nl(formatted_raw_ostream &Out, int delta) {
+raw_pwrite_stream &JSWriter::nl(raw_pwrite_stream &Out, int delta) {
   Out << '\n';
   return Out;
 }
 
 static inline char halfCharToHex(unsigned char half) {
   assert(half <= 15);
   if (half <= 9) {
     return '0' + half;
   } else {
     return 'A' + half - 10;
@@ skipping 60 matching lines @@
 }
 
 static inline std::string ensureFloat(const std::string &S, Type *T) {
   if (PreciseF32 && T->isFloatTy()) {
     return "Math_fround(" + S + ")";
   }
   return S;
 }
 
 static void emitDebugInfo(raw_ostream& Code, const Instruction *I) {
-  if (MDNode *N = I->getMetadata("dbg")) {
-    DILocation Loc(N);
-    unsigned Line = Loc.getLineNumber();
-    StringRef File = Loc.getFilename();
+  auto &Loc = I->getDebugLoc();
+  if (Loc) {
+    unsigned Line = Loc.getLine();
+    StringRef File = cast<MDLocation>(Loc.getScope())->getFilename();
     Code << " //@line " << utostr(Line) << " \"" << (File.size() > 0 ? File.str() : "?") << "\"";
   }
 }
 
 void JSWriter::error(const std::string& msg) {
   report_fatal_error(msg);
 }
 
 std::string JSWriter::getPhiCode(const BasicBlock *From, const BasicBlock *To) {
   // FIXME this is all quite inefficient, and also done once per incoming to each phi
@@ skipping 2258 matching lines @@
           Data = cast<ConstantInt>(CE->getOperand(1))->getZExtValue();
           CE = cast<ConstantExpr>(CE->getOperand(0));
         }
         const Value *V = CE;
         if (CE->getOpcode() == Instruction::PtrToInt) {
           V = CE->getOperand(0);
         }
 
         // Deconstruct getelementptrs.
         int64_t BaseOffset;
-        V = GetPointerBaseWithConstantOffset(V, BaseOffset, DL);
+        V = GetPointerBaseWithConstantOffset(V, BaseOffset, *DL);
         Data += (uint64_t)BaseOffset;
 
         Data += getConstAsOffset(V, getGlobalAddress(name));
         union { unsigned i; unsigned char b[sizeof(unsigned)]; } integer;
         integer.i = Data;
         unsigned Offset = getRelativeGlobalAddress(name);
         assert(Offset+4 <= GlobalData64.size());
         for (unsigned i = 0; i < 4; ++i) {
           GlobalData64[Offset++] = integer.b[i];
         }
@@ skipping 61 matching lines @@
   printModule(fname,mName);
 }
 
 void JSWriter::printModule(const std::string& fname,
                             const std::string& mName) {
   printModuleBody();
 }
 
 bool JSWriter::runOnModule(Module &M) {
   TheModule = &M;
-  DL = &getAnalysis<DataLayoutPass>().getDataLayout();
+  DL = &M.getDataLayout();
 
   setupCallHandlers();
 
   printProgram("", "");
 
   return false;
 }
 
 char JSWriter::ID = 0;
 
@@ skipping 13 matching lines @@
 
 Pass *createCheckTriplePass() {
   return new CheckTriple();
 }
 
 //===----------------------------------------------------------------------===//
 //                       External Interface declaration
 //===----------------------------------------------------------------------===//
 
 bool JSTargetMachine::addPassesToEmitFile(PassManagerBase &PM,
-                                          formatted_raw_ostream &o,
+                                          raw_pwrite_stream &o,
                                           CodeGenFileType FileType,
                                           bool DisableVerify,
                                           AnalysisID StartAfter,
                                           AnalysisID StopAfter) {
   assert(FileType == TargetMachine::CGFT_AssemblyFile);
 
   PM.add(createCheckTriplePass());
   PM.add(createExpandInsertExtractElementPass());
   PM.add(createExpandI64Pass());
 
   CodeGenOpt::Level OptLevel = getOptLevel();
 
   // When optimizing, there shouldn't be any opportunities for SimplifyAllocas
   // because the regular optimizer should have taken them all (GVN, and possibly
   // also SROA).
   if (OptLevel == CodeGenOpt::None)
     PM.add(createEmscriptenSimplifyAllocasPass());
 
   PM.add(new JSWriter(o, OptLevel));
 
   return false;
 }