Add clang support for AAP

[edward-jones]

Summary

AAP is a Harvard architecture, with features representative of a large range of deeply embedded microprocessors. It aims to aid the development and maintenance of other out-of-tree deeply embedded systems.

[edward-jones]

This rolls the clang patch for AAP forwards to top of tree.

[edward-jones]

This updates the Clang support of AAP to top of tree.

[edward-jones]

This rolls AAP forward to top-of-tree.

[edward-jones]

We have closed the accompanying LLVM patch D12191, so this patch is no longer relevant.

lib/Basic/Targets.cpp

 const char *const MSP430TargetInfo::GCCRegNames[] = {
     "r0", "r1", "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"};
 
 ArrayRef<const char *> MSP430TargetInfo::getGCCRegNames() const {
   return llvm::makeArrayRef(GCCRegNames);
 }
 
+class AAPTargetInfo : public TargetInfo {
+public:
+  AAPTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
+    BigEndian = false;
+    TLSSupported = false;
+    IntWidth = 16;
+    IntAlign = 16;
+    LongWidth = 32;
+    LongLongWidth = 64;
+    LongAlign = LongLongAlign = 16;
+    PointerWidth = 16;
+    PointerAlign = 16;
+
+    // float/double alignment needed when accessing va_args
+    FloatWidth  = 32;
+    FloatAlign  = 16;
+    DoubleWidth = 64;
+    DoubleAlign = 16;
+
+    SuitableAlign = 16;
+    SizeType = UnsignedInt;
+    IntMaxType = SignedLongLong;
+    IntPtrType = SignedInt;
+    PtrDiffType = SignedInt;
+    SigAtomicType = SignedLong;
+    resetDataLayout("e-m:e-p:16:16-i32:16-i64:16-f32:16-f64:16-n16");
+  }
+  void getTargetDefines(const LangOptions &Opts,
+                        MacroBuilder &Builder) const override {
+    Builder.defineMacro("AAP");
+    Builder.defineMacro("__AAP__");
+  }
+
+  ArrayRef<Builtin::Info> getTargetBuiltins() const override {
+    return None;
+  }
+  bool hasFeature(StringRef Feature) const override {
+    return Feature == "AAP";
+  }
+  ArrayRef<const char *> getGCCRegNames() const override {
+    const char * const GCCRegNames[] = {
+       "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
+       "r8",  "r9", "r10", "r11", "r12", "r13", "r14", "r15",
+      "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
+      "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
+      "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39",
+      "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47",
+      "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55",
+      "r56", "r57", "r58", "r59", "r60", "r61", "r62", "r63",
+    };
+    return llvm::makeArrayRef(GCCRegNames);
+  }
+  ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
+    // No aliases
+    return None;
+  }
+  bool
+  validateAsmConstraint(const char *&Name,
+                        TargetInfo::ConstraintInfo &Info) const override {
+    switch (*Name) {
+    default:
+      return false;
+    case 'r': // CPU registers.
+      Info.setAllowsRegister();
+      return true;
+    }
+  }
+  const char *getClobbers() const override {
+    // FIXME: Is this really right?
+    return "";
+  }
+  BuiltinVaListKind getBuiltinVaListKind() const override {
+    // FIXME: implement
+    return TargetInfo::CharPtrBuiltinVaList;
+ }
+};
+
 // LLVM and Clang cannot be used directly to output native binaries for
 // target, but is used to compile C code to llvm bitcode with correct
 // type and alignment information.
 //
 // TCE uses the llvm bitcode as input and uses it for generating customized
 // target processor and program binary. TCE co-design environment is
 // publicly available in http://tce.cs.tut.fi
 
case llvm::Triple::xcore:
     return new XCoreTargetInfo(Triple);
 
   case llvm::Triple::hexagon:
     return new HexagonTargetInfo(Triple);
 
   case llvm::Triple::lanai:
     return new LanaiTargetInfo(Triple);
 
+  case llvm::Triple::aap:
+    return new AAPTargetInfo(Triple);
+
   case llvm::Triple::aarch64:
     if (Triple.isOSDarwin())
       return new DarwinAArch64TargetInfo(Triple);
 
     switch (os) {
     case llvm::Triple::CloudABI:
       return new CloudABITargetInfo<AArch64leTargetInfo>(Triple);
     case llvm::Triple::FreeBSD:

lib/Driver/Driver.cpp

case llvm::Triple::PS4:
       break;
     default:
       // Of these targets, Hexagon is the only one that might have
       // an OS of Linux, in which case it got handled above already.
       switch (Target.getArch()) {
       case llvm::Triple::tce:
         TC = new toolchains::TCEToolChain(*this, Target, Args);
         break;
+      case llvm::Triple::aap:
+        TC = new toolchains::AAP(*this, Target, Args);
+        break;
       case llvm::Triple::hexagon:
         TC = new toolchains::HexagonToolChain(*this, Target, Args);
         break;
       case llvm::Triple::lanai:
         TC = new toolchains::LanaiToolChain(*this, Target, Args);
         break;
       case llvm::Triple::xcore:
         TC = new toolchains::XCoreToolChain(*this, Target, Args);

lib/Driver/ToolChains.h

public:
 
   SanitizerMask getSupportedSanitizers() const override;
 
 protected:
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
 };
 
+class LLVM_LIBRARY_VISIBILITY AAP : public ToolChain {
+public:
+  AAP(const Driver &D, const llvm::Triple &Triple,
+      const llvm::opt::ArgList &Args);
+protected:
+  Tool *buildAssembler() const override;
+  Tool *buildLinker() const override;
+public:
+  bool isPICDefault() const override { return false; }
+  bool isPIEDefault() const override { return false; }
+  bool isPICDefaultForced() const override { return true; }
+  bool HasNativeLLVMSupport() const override;
+
+  bool IsIntegratedAssemblerDefault() const override { return true; }
+  bool SupportsProfiling() const override { return false; }
+  bool hasBlocksRuntime() const override { return false; }
+
+  void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                                 llvm::opt::ArgStringList &CC1Args) const override;
+  void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
+                             llvm::opt::ArgStringList &CC1Args) const override;
+};
+
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_H

lib/Driver/ToolChains.cpp

 bool Generic_GCC::isPICDefaultForced() const {
   return getArch() == llvm::Triple::x86_64 && getTriple().isOSWindows();
 }
 
 bool Generic_GCC::IsIntegratedAssemblerDefault() const {
   switch (getTriple().getArch()) {
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
+  case llvm::Triple::aap:
   case llvm::Triple::aarch64:
   case llvm::Triple::aarch64_be:
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::bpfel:
   case llvm::Triple::bpfeb:
   case llvm::Triple::thumb:
   case llvm::Triple::thumbeb:

 bool PS4CPU::HasNativeLLVMSupport() const { return true; }
 
 SanitizerMask PS4CPU::getSupportedSanitizers() const {
   SanitizerMask Res = ToolChain::getSupportedSanitizers();
   Res |= SanitizerKind::Address;
   Res |= SanitizerKind::Vptr;
   return Res;
 }
+
+/// AAP tool chain
+AAP::AAP(const Driver &D, const llvm::Triple &Triple,
+         const ArgList &Args) : ToolChain(D, Triple, Args) {
+  // Program paths are assumed to be locatable through the 'PATH' env variable
+}
+
+Tool *AAP::buildAssembler() const {
+  return new tools::AAP::Assemble(*this);
+}
+
+Tool *AAP::buildLinker() const {
+  return new tools::AAP::Link(*this);
+}
+
+bool AAP::HasNativeLLVMSupport() const {
+  return true;
+}
+
+void AAP::AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                                    llvm::opt::ArgStringList &CC1Args) const {
+  const Driver &D = getDriver();
+
+  if (DriverArgs.hasArg(options::OPT_nostdinc) ||
+      DriverArgs.hasArg(options::OPT_nostdlibinc)) {
+    return;
+  }
+
+  // standard system includes are disabled, so we add our own
+  const std::string InstallPrefix = D.InstalledDir;
+  const std::string IncludeDir = InstallPrefix + "/../aap/include";
+  StringRef IncludeDirStr(IncludeDir);
+
+  addSystemIncludes(DriverArgs, CC1Args, IncludeDirStr);
+}
+
+void AAP::addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
+                                llvm::opt::ArgStringList &CC1Args) const {
+  CC1Args.push_back("-nostdsysteminc");
+  CC1Args.push_back("-dwarf-column-info");
+}
 No newline at end of file

lib/Driver/Tools.h

 private:
   void AddPreprocessingOptions(Compilation &C, const JobAction &JA,
                                const Driver &D, const llvm::opt::ArgList &Args,
                                llvm::opt::ArgStringList &CmdArgs,
                                const InputInfo &Output,
                                const InputInfoList &Inputs,
                                const ToolChain *AuxToolChain) const;
 
+  void AddAAPTargetArgs(const llvm::opt::ArgList &Args,
+                        llvm::opt::ArgStringList &CmdArgs) const;
   void AddAArch64TargetArgs(const llvm::opt::ArgList &Args,
                             llvm::opt::ArgStringList &CmdArgs) const;
   void AddARMTargetArgs(const llvm::Triple &Triple,
                         const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs,
                         bool KernelOrKext) const;
   void AddARM64TargetArgs(const llvm::opt::ArgList &Args,
                           llvm::opt::ArgStringList &CmdArgs) const;
public:
    void ConstructJob(Compilation &C, const JobAction &JA,
                      const InputInfo &Output, const InputInfoList &Inputs,
                      const llvm::opt::ArgList &TCArgs,
                      const char *LinkingOutput) const override;
 };
 
 }  // end namespace NVPTX
 
+namespace AAP {
+  class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
+  public:
+    Assemble(const ToolChain &TC) : Tool("AAP::Assemble", "aap-as", TC)
+    {}
+
+    bool hasIntegratedCPP() const override { return false; }
+    void ConstructJob(Compilation &C, const JobAction &JA,
+                      const InputInfo &Output,
+                      const InputInfoList &Inputs,
+                      const llvm::opt::ArgList &TCArgs,
+                      const char *LinkingOutput) const override;
+  };
+  class LLVM_LIBRARY_VISIBILITY Link : public Tool {
+  public:
+    Link(const ToolChain &TC) : Tool("AAP::Link", "aap-ld", TC)
+    {}
+
+    bool hasIntegratedCPP() const override { return false; }
+    bool isLinkJob() const override { return true; }
+    void ConstructJob(Compilation &C, const JobAction &JA,
+                      const InputInfo &Output,
+                      const InputInfoList &Inputs,
+                      const llvm::opt::ArgList &TCArgs,
+                      const char *LinkingOutput) const override;
+  };
+} // end namespace AAP
+
 } // end namespace tools
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLS_H

lib/Driver/Tools.cpp

if (Value.getAsInteger(10, Mregparm)) {
         getToolChain().getDriver().Diag(
             diag::err_drv_unsupported_option_argument)
             << A->getOption().getName() << Value;
       }
     }
   }
 }
 
+void Clang::AddAAPTargetArgs(const ArgList &Args,
+                             ArgStringList &CmdArgs) const {
+  return;
+}
+
 void Clang::AddWebAssemblyTargetArgs(const ArgList &Args,
                                      ArgStringList &CmdArgs) const {
   // Default to "hidden" visibility.
   if (!Args.hasArg(options::OPT_fvisibility_EQ,
                    options::OPT_fvisibility_ms_compat)) {
     CmdArgs.push_back("-fvisibility");
     CmdArgs.push_back("hidden");
   }

 }
 
 static bool shouldUseFramePointerForTarget(const ArgList &Args,
                                            const llvm::Triple &Triple) {
   switch (Triple.getArch()) {
   case llvm::Triple::xcore:
   case llvm::Triple::wasm32:
   case llvm::Triple::wasm64:
+  case llvm::Triple::aap:
     // XCore never wants frame pointers, regardless of OS.
     // WebAssembly never wants frame pointers.
+    // AAP never wants frame pointers
     return false;
   default:
     break;
   }
 
   if (Triple.isOSLinux()) {
     switch (Triple.getArch()) {
     // Don't use a frame pointer on linux if optimizing for certain targets.
#endif
   // Add the target features
   getTargetFeatures(getToolChain(), Triple, Args, CmdArgs, false);
 
   // Add target specific flags.
   switch (getToolChain().getArch()) {
   default:
     break;
 
+  case llvm::Triple::aap:
+    AddAAPTargetArgs(Args, CmdArgs);
+    break;
+
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::thumb:
   case llvm::Triple::thumbeb:
     // Use the effective triple, which takes into account the deployment target.
     AddARMTargetArgs(Triple, Args, CmdArgs, KernelOrKext);
     break;
 
void NVPTX::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   }
 
   for (const auto& A : Args.getAllArgValues(options::OPT_Xcuda_fatbinary))
     CmdArgs.push_back(Args.MakeArgString(A));
 
   const char *Exec = Args.MakeArgString(TC.GetProgramPath("fatbinary"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
+
+void AAP::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
+                                 const InputInfo &Output,
+                                 const InputInfoList &Inputs,
+                                 const ArgList &Args,
+                                 const char *LinkingOutput) const {
+  ArgStringList CmdArgs;
+
+  // Add input assembly files to command line
+  for (InputInfoList::const_iterator it = Inputs.begin(), ie = Inputs.end();
+       it != ie;
+       ++it) {
+    const InputInfo &II = *it;
+    CmdArgs.push_back(II.getFilename());
+  }
+
+  const char *Exec =
+    Args.MakeArgString(getToolChain().GetProgramPath("aap-as"));
+
+  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
+}
+
+void AAP::Link::ConstructJob(Compilation &C, const JobAction &JA,
+                             const InputInfo &Output,
+                             const InputInfoList &Inputs,
+                             const ArgList &Args,
+                             const char *LinkingOutput) const {
+  ArgStringList CmdArgs;
+
+  // Add crt0 and libc
+  const toolchains::AAP& ToolChain =
+    static_cast<const toolchains::AAP&>(getToolChain());
+  const Driver &D = ToolChain.getDriver();
+
+  const std::string InstallPrefix = D.InstalledDir;
+  const std::string LibFilesDir = InstallPrefix + "/../aap/lib";
+  const std::string crt0 = LibFilesDir + "/crt0.o";
+  const std::string libpath = "-L" + LibFilesDir;
+
+  if (!Args.hasArg(options::OPT_nostdlib) &&
+      !Args.hasArg(options::OPT_nostartfiles)) {
+    CmdArgs.push_back(Args.MakeArgString(crt0));
+  }
+  AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
+
+  CmdArgs.push_back(Args.MakeArgString(libpath));
+  if (!Args.hasArg(options::OPT_nostdlib)) {
+    CmdArgs.push_back("-lc");
+    CmdArgs.push_back("-laap");
+    CmdArgs.push_back("-lcompiler_rt");
+
+    // This may need to link a second time to resolve interdependencies
+  }
+
+  Args.AddAllArgs(CmdArgs, options::OPT_L);
+
+  if (Output.isFilename()) {
+    CmdArgs.push_back("-o");
+    CmdArgs.push_back(Output.getFilename());
+  }
+  else {
+    assert(Output.isNothing() && "Input output");
+  }
+
+  const char *Exec =
+    Args.MakeArgString(getToolChain().GetProgramPath("aap-ld"));
+  C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
+}

lib/Headers/float.h

 #    undef DBL_DECIMAL_DIG
 #    undef LDBL_DECIMAL_DIG
 #  endif
 #endif
 
 /* Characteristics of floating point types, C99 5.2.4.2.2 */
 
 #define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
+
+/* __builtin_flt_rounds is not supported by AAP, and the rounding mode cannot
+   be changed anyway so we just default to 'to nearest' */
+#ifdef __AAP__
+  #define FLT_ROUNDS 1
+#else
   #define FLT_ROUNDS (__builtin_flt_rounds())
+#endif
 #define FLT_RADIX __FLT_RADIX__
 
 #define FLT_MANT_DIG __FLT_MANT_DIG__
 #define DBL_MANT_DIG __DBL_MANT_DIG__
 #define LDBL_MANT_DIG __LDBL_MANT_DIG__
 
 #if __STDC_VERSION__ >= 199901L || !defined(__STRICT_ANSI__)
 #  define DECIMAL_DIG __DECIMAL_DIG__