Initial support for the Emscripten driver

Author: ehsan

lib/Basic/Targets.cpp

@@ -2510,6 +2510,29 @@ class HaikuX86_32TargetInfo : public X86_32TargetInfo {
 };
 } // end anonymous namespace
 
+namespace {
+// Emscripten target
+class EmscriptenTargetInfo : public LinuxTargetInfo<X86_32TargetInfo> {
+protected:
+  virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
+                            MacroBuilder &Builder) const {
+    LinuxTargetInfo<X86_32TargetInfo>::getOSDefines(Opts, Triple, Builder);
+    Builder.defineMacro("EMSCRIPTEN");
+    Builder.undefineMacro("linux");
+    Builder.undefineMacro("__linux");
+    Builder.undefineMacro("__linux__");
+  }
+public:
+  EmscriptenTargetInfo(const std::string& triple)
+    : LinuxTargetInfo(triple) {
+  }
+
+  virtual const char *getStaticInitSectionSpecifier() const {
+    return 0;
+  }
+};
+} // end anonymous namespace
+
 // RTEMS Target
 template<typename Target>
 class RTEMSTargetInfo : public OSTargetInfo<Target> {
@@ -4198,6 +4221,8 @@ static TargetInfo *AllocateTarget(const std::string &T) {
       return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
     case llvm::Triple::Minix:
       return new MinixTargetInfo<X86_32TargetInfo>(T);
+    case llvm::Triple::Emscripten:
+      return new EmscriptenTargetInfo(T);
     case llvm::Triple::Solaris:
       return new SolarisTargetInfo<X86_32TargetInfo>(T);
     case llvm::Triple::Cygwin:

lib/Driver/Driver.cpp

@@ -1687,7 +1687,8 @@ static llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple,
   // Skip further flag support on OSes which don't support '-m32' or '-m64'.
   if (Target.getArchName() == "tce" ||
       Target.getOS() == llvm::Triple::AuroraUX ||
-      Target.getOS() == llvm::Triple::Minix)
+      Target.getOS() == llvm::Triple::Minix ||
+      Target.getOS() == llvm::Triple::Emscripten)
     return Target;
 
   // Handle pseudo-target flags '-m32' and '-m64'.
@@ -1746,6 +1747,9 @@ const ToolChain &Driver::getToolChain(const ArgList &Args,
     case llvm::Triple::Minix:
       TC = new toolchains::Minix(*this, Target, Args);
       break;
+    case llvm::Triple::Emscripten:
+      TC = new toolchains::Emscripten(*this, Target);
+      break;
     case llvm::Triple::Linux:
       if (Target.getArch() == llvm::Triple::hexagon)
         TC = new toolchains::Hexagon_TC(*this, Target);

lib/Driver/ToolChains.cpp

@@ -1681,6 +1681,72 @@ Tool &Minix::SelectTool(const Compilation &C, const JobAction &JA,
   return *T;
 }
 
+Tool &Emscripten::SelectTool(const Compilation &C,
+                             const JobAction &JA,
+                             const ActionList &Inputs) const {
+  Action::ActionClass Key;
+  Key = Action::AnalyzeJobClass;
+
+  Tool *&T = Tools[Key];
+  if (!T) {
+    switch (Key) {
+    case Action::PreprocessJobClass:
+    case Action::CompileJobClass:
+      T = new tools::Clang(*this); break;
+    default:
+     llvm_unreachable("Unsupported action for TCE target.");
+    }
+  }
+  return *T;
+}
+
+bool Emscripten::HasNativeLLVMSupport() const {
+  return false;
+}
+
+bool Emscripten::IsUnwindTablesDefault() const {
+  return false;
+}
+
+const char *Emscripten::GetDefaultRelocationModel() const {
+  return "static";
+}
+
+const char *Emscripten::GetForcedPicModel() const {
+  return 0;
+}
+
+bool Emscripten::SupportsProfiling() const {
+  return false;
+}
+
+bool Emscripten::hasBlocksRuntime() const {
+  return false;
+}
+
+void Emscripten::AddClangSystemIncludeArgs(const ArgList &DriverArgs,
+                                           ArgStringList &CC1Args) const {
+  std::string EmscriptenRoot;
+  // TODO: Get EmscriptenRoot somehow
+
+  const StringRef EmscriptenIncludeDirs[] = {
+    "/system/include",
+    "/system/include/emscripten",
+    "/system/include/bsd",
+    "/system/include/libc",
+    "/system/include/libcxx",
+    "/system/include/gfx",
+    "/system/include/net",
+    "/system/include/SDL"
+  };
+  ArrayRef<StringRef> IncludeDirs = EmscriptenIncludeDirs;
+  for (ArrayRef<StringRef>::iterator I = IncludeDirs.begin(),
+                                     E = IncludeDirs.end();
+       I != E; ++I) {
+    addSystemInclude(DriverArgs, CC1Args, EmscriptenRoot + *I);
+  }
+}
+
 /// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly.
 
 AuroraUX::AuroraUX(const Driver &D, const llvm::Triple& Triple,

lib/Driver/ToolChains.h

@@ -538,6 +538,27 @@ class LLVM_LIBRARY_VISIBILITY Linux : public Generic_ELF {
                                        ArgStringList &CC1Args);
 };
 
+class LLVM_LIBRARY_VISIBILITY Emscripten : public ToolChain {
+public:
+  Emscripten(const Driver &D, const llvm::Triple &Triple)
+    : ToolChain(D, Triple) {
+  }
+
+  virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
+                           const ActionList &Inputs) const;
+  virtual bool HasNativeLLVMSupport() const;
+  virtual bool IsUnwindTablesDefault() const;
+  virtual const char *GetDefaultRelocationModel() const;
+  virtual const char *GetForcedPicModel() const;
+  virtual bool SupportsProfiling() const;
+  virtual bool hasBlocksRuntime() const;
+  virtual void AddClangSystemIncludeArgs(const ArgList &DriverArgs,
+                                         ArgStringList &CC1Args) const;
+
+private:
+  mutable llvm::DenseMap<unsigned, Tool*> Tools;
+};
+
 
 /// TCEToolChain - A tool chain using the llvm bitcode tools to perform
 /// all subcommands. See http://tce.cs.tut.fi for our peculiar target.

lib/Frontend/InitHeaderSearch.cpp

@@ -369,6 +369,7 @@ AddDefaultCPlusPlusIncludePaths(const llvm::Triple &triple, const HeaderSearchOp
   }
 
   switch (os) {
+  case llvm::Triple::Emscripten:
   case llvm::Triple::Linux:
   case llvm::Triple::Win32:
     llvm_unreachable("Include management is handled in the driver.");