github
/
AROS-v0
mirror of https://github.com/deadw00d/AROS.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Update the llvm build to version 11.0.0 Added extra diffs for 10.0.1 and 11.0.1

This commit is contained in:
David Gilmore 2021-01-17 14:35:32 +11:00 committed by deadwood
parent 59014dbe06
commit 45d4ac9d2d
12 changed files with 2911 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
config/llvm_def
View File

@ -1 +1 @@
9.0.0
11.0.0

6
tools/crosstools/llvm.cfg
View File

@ -1 +1,5 @@
LLVM_VERSION :=9.0.0
LLVM_VERSION :=11.0.0
LLVM_RELEASE :=
LLVM_REPO :=$(LLVM_RELEASE)
CLANG_NAME :=clang
# version <= 9 the name was "cfe"

4
tools/crosstools/llvm.deps
View File

@ -1,4 +1,4 @@
LLVM_DEPS=$(SRCDIR)/tools/crosstools/llvm/llvm-$(LLVM_VERSION).src-aros.diff
CLANG_DEPS=$(SRCDIR)/tools/crosstools/llvm/cfe-$(LLVM_VERSION).src-aros.diff
LLVM_DEPS=$(SRCDIR)/tools/crosstools/llvm/llvm-$(LLVM_VERSION)$(LLVM_RELEASE).src-aros.diff
CLANG_DEPS=$(SRCDIR)/tools/crosstools/llvm/$(CLANG_NAME)-$(LLVM_VERSION)$(LLVM_RELEASE).src-aros.diff
LLD_DEPS=
AROS_TOOLCHAIN_DEPS:=$(LLVM_DEPS) $(CLANG_DEPS) $(LLD_DEPS)

682
tools/crosstools/llvm/clang-10.0.1.src-aros.diff Normal file
View File

@ -0,0 +1,682 @@
diff --git a/include/clang/Driver/Options.td b/include/clang/Driver/Options.td
index 7213af1731..0c0a10b657 100644
--- a/include/clang/Driver/Options.td
+++ b/include/clang/Driver/Options.td
@@ -640,6 +640,7 @@ def dependency_dot : Separate<["-"], "dependency-dot">, Flags<[CC1Option]>,
HelpText<"Filename to write DOT-formatted header dependencies to">;
def module_dependency_dir : Separate<["-"], "module-dependency-dir">,
Flags<[CC1Option]>, HelpText<"Directory to dump module dependencies to">;
+def detach : Flag<["-"], "detach">, Flags<[DriverOption,NoArgumentUnused]>;
def dumpmachine : Flag<["-"], "dumpmachine">;
def dumpspecs : Flag<["-"], "dumpspecs">, Flags<[Unsupported]>;
def dumpversion : Flag<["-"], "dumpversion">;
@@ -2742,11 +2743,15 @@ def multi__module : Flag<["-"], "multi_module">;
def multiply__defined__unused : Separate<["-"], "multiply_defined_unused">;
def multiply__defined : Separate<["-"], "multiply_defined">;
def mwarn_nonportable_cfstrings : Flag<["-"], "mwarn-nonportable-cfstrings">, Group<m_Group>;
+def nix : Flag<["-"], "nix">, Flags<[DriverOption,NoArgumentUnused]>;
def no_canonical_prefixes : Flag<["-"], "no-canonical-prefixes">, Flags<[HelpHidden, CoreOption]>,
HelpText<"Use relative instead of canonical paths">;
def no_cpp_precomp : Flag<["-"], "no-cpp-precomp">, Group<clang_ignored_f_Group>;
def no_integrated_cpp : Flag<["-", "--"], "no-integrated-cpp">, Flags<[DriverOption]>;
def no_pedantic : Flag<["-", "--"], "no-pedantic">, Group<pedantic_Group>;
+def no_posixc : Flag<["-"], "no-posixc">, Flags<[DriverOption,NoArgumentUnused]>;
+def no_stdc : Flag<["-"], "no-stdc">, Flags<[DriverOption,NoArgumentUnused]>;
+def no_sysbase : Flag<["-"], "no_sysbase">, Flags<[DriverOption,NoArgumentUnused]>;
def no__dead__strip__inits__and__terms : Flag<["-"], "no_dead_strip_inits_and_terms">;
def nobuiltininc : Flag<["-"], "nobuiltininc">, Flags<[CC1Option, CoreOption]>,
HelpText<"Disable builtin #include directories">;
@@ -2760,16 +2765,19 @@ def nolibc : Flag<["-"], "nolibc">;
def nomultidefs : Flag<["-"], "nomultidefs">;
def nopie : Flag<["-"], "nopie">;
def no_pie : Flag<["-"], "no-pie">, Alias<nopie>;
+def noposixc : Flag<["-"], "noposixc">, Alias<no_posixc>;
def noprebind : Flag<["-"], "noprebind">;
def noprofilelib : Flag<["-"], "noprofilelib">;
def noseglinkedit : Flag<["-"], "noseglinkedit">;
def nostartfiles : Flag<["-"], "nostartfiles">;
+def nostdc : Flag<["-"], "nostdc">, Alias<no_stdc>;
def nostdinc : Flag<["-"], "nostdinc">, Flags<[CoreOption]>;
def nostdlibinc : Flag<["-"], "nostdlibinc">;
def nostdincxx : Flag<["-"], "nostdinc++">, Flags<[CC1Option]>,
HelpText<"Disable standard #include directories for the C++ standard library">;
def nostdlib : Flag<["-"], "nostdlib">;
def nostdlibxx : Flag<["-"], "nostdlib++">;
+def nosysbase : Flag<["-"], "nosysbase">, Alias<no_sysbase>;
def object : Flag<["-"], "object">;
def o : JoinedOrSeparate<["-"], "o">, Flags<[DriverOption, RenderAsInput, CC1Option, CC1AsOption]>,
HelpText<"Write output to <file>">, MetaVarName<"<file>">;
@@ -2780,6 +2788,7 @@ def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1O
def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>;
def pipe : Flag<["-", "--"], "pipe">,
HelpText<"Use pipes between commands, when possible">;
+def posixc : Flag<["-"], "posixc">, Flags<[DriverOption,NoArgumentUnused]>;
def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">;
def prebind : Flag<["-"], "prebind">;
def preload : Flag<["-"], "preload">;
@@ -2869,6 +2878,7 @@ def specs : Separate<["-", "--"], "specs">, Flags<[Unsupported]>;
def static_libgcc : Flag<["-"], "static-libgcc">;
def static_libstdcxx : Flag<["-"], "static-libstdc++">;
def static : Flag<["-", "--"], "static">, Flags<[NoArgumentUnused]>;
+def stdc : Flag<["-"], "stdc">, Flags<[DriverOption,NoArgumentUnused]>;
def std_default_EQ : Joined<["-"], "std-default=">;
def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option]>,
Group<CompileOnly_Group>, HelpText<"Language standard to compile for">,
diff --git a/lib/Basic/Targets.cpp b/lib/Basic/Targets.cpp
index 69133ca31f..119a32543d 100644
--- a/lib/Basic/Targets.cpp
+++ b/lib/Basic/Targets.cpp
@@ -135,6 +135,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
return new DarwinAArch64TargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS AArch64
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<AArch64leTargetInfo>(Triple, Opts);
+
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts);
case llvm::Triple::FreeBSD:
@@ -179,6 +185,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
return new DarwinARMTargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS ARMle
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<ARMleTargetInfo>(Triple, Opts);
+
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts);
case llvm::Triple::Linux:
@@ -215,6 +227,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
return new DarwinARMTargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS ARMbe
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<ARMbeTargetInfo>(Triple, Opts);
+
case llvm::Triple::Linux:
return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts);
case llvm::Triple::FreeBSD:
@@ -317,6 +335,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
if (Triple.isOSDarwin())
return new DarwinPPC32TargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS PPC32
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<PPC32TargetInfo>(Triple, Opts);
+
case llvm::Triple::Linux:
return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts);
case llvm::Triple::FreeBSD:
@@ -337,6 +361,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
if (Triple.isOSDarwin())
return new DarwinPPC64TargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS PPC64
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<PPC64TargetInfo>(Triple, Opts);
+
case llvm::Triple::Linux:
return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
case llvm::Triple::Lv2:
@@ -462,6 +492,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
switch (os) {
case llvm::Triple::Ananas:
return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts);
+ // FIXME:
+ // Needs to be tested!!!
+ // New Target AROS X86_32
+ case llvm::Triple::AROS:
+ return new AROSTargetInfo<X86_32TargetInfo>(Triple, Opts);
+
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts);
case llvm::Triple::Linux: {
@@ -521,6 +557,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
switch (os) {
case llvm::Triple::Ananas:
return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts);
+ // FIXME:
+ // Needs to be tested!!!
+ // New Target AROS X86_64
+ case llvm::Triple::AROS:
+ return new AROSTargetInfo<X86_64TargetInfo>(Triple, Opts);
+
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts);
case llvm::Triple::Linux: {
diff --git a/lib/Basic/Targets/OSTargets.h b/lib/Basic/Targets/OSTargets.h
index e57ad7b9ee..feaa97b362 100644
--- a/lib/Basic/Targets/OSTargets.h
+++ b/lib/Basic/Targets/OSTargets.h
@@ -71,6 +71,26 @@ public:
: OSTargetInfo<Target>(Triple, Opts) {}
};
+// AROS target
+template <typename Target>
+class LLVM_LIBRARY_VISIBILITY AROSTargetInfo : public OSTargetInfo<Target> {
+protected:
+ void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
+ MacroBuilder &Builder) const override {
+ // FIXME:
+ // Are these Macros correct ???
+ // AROS defines
+ Builder.defineMacro("__AROS__");
+ Builder.defineMacro("__ELF__");
+ }
+
+public:
+ // FIXME:
+ // Is this correct ???
+ AROSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
+ : OSTargetInfo<Target>(Triple, Opts) {}
+};
+
void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
const llvm::Triple &Triple, StringRef &PlatformName,
VersionTuple &PlatformMinVersion);
diff --git a/lib/Driver/CMakeLists.txt b/lib/Driver/CMakeLists.txt
index 6f25d3588e..dae0f676e5 100644
--- a/lib/Driver/CMakeLists.txt
+++ b/lib/Driver/CMakeLists.txt
@@ -35,6 +35,7 @@ add_clang_library(clangDriver
ToolChains/AIX.cpp
ToolChains/Ananas.cpp
ToolChains/AMDGPU.cpp
+ ToolChains/AROS.cpp
ToolChains/AVR.cpp
ToolChains/BareMetal.cpp
ToolChains/Clang.cpp
diff --git a/lib/Driver/Driver.cpp b/lib/Driver/Driver.cpp
index 5c726b2314..c3586727ee 100644
--- a/lib/Driver/Driver.cpp
+++ b/lib/Driver/Driver.cpp
@@ -10,6 +10,7 @@
#include "InputInfo.h"
#include "ToolChains/AIX.h"
#include "ToolChains/AMDGPU.h"
+#include "ToolChains/AROS.h"
#include "ToolChains/AVR.h"
#include "ToolChains/Ananas.h"
#include "ToolChains/BareMetal.h"
@@ -4810,6 +4811,9 @@ const ToolChain &Driver::getToolChain(const ArgList &Args,
case llvm::Triple::Ananas:
TC = std::make_unique<toolchains::Ananas>(*this, Target, Args);
break;
+ case llvm::Triple::AROS:
+ TC = std::make_unique<toolchains::AROSToolChain>(*this, Target, Args);
+ break;
case llvm::Triple::CloudABI:
TC = std::make_unique<toolchains::CloudABI>(*this, Target, Args);
break;
diff --git a/lib/Driver/ToolChains/AROS.cpp b/lib/Driver/ToolChains/AROS.cpp
new file mode 100644
index 0000000000..57cdd8fb33
--- /dev/null
+++ b/lib/Driver/ToolChains/AROS.cpp
@@ -0,0 +1,325 @@
+//===--- AROS.cpp - AROS Tool Chain -------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AROS.h"
+#include "InputInfo.h"
+#include "CommonArgs.h"
+#include "clang/Config/config.h"
+#include "clang/Driver/Compilation.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Options.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+using namespace clang::driver;
+using namespace clang::driver::tools;
+using namespace clang::driver::toolchains;
+using namespace clang;
+using namespace llvm::opt;
+
+
+void
+AROS::Assembler::ConstructJob(Compilation &C,
+ const JobAction &JA,
+ const InputInfo &Output,
+ const InputInfoList &Inputs,
+ const ArgList &Args,
+ const char *LinkingOutput) const {
+ claimNoWarnArgs(Args);
+ ArgStringList CmdArgs;
+
+ Args.AddAllArgValues(CmdArgs,
+ options::OPT_Wa_COMMA,
+ options::OPT_Xassembler);
+
+ CmdArgs.push_back("-o");
+ CmdArgs.push_back(Output.getFilename());
+
+ for (const auto &II : Inputs)
+ CmdArgs.push_back(II.getFilename());
+
+ const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+ C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
+}
+
+void
+AROS::Linker::ConstructJob(Compilation &C,
+ const JobAction &JA,
+ const InputInfo &Output,
+ const InputInfoList &Inputs,
+ const ArgList &Args,
+ const char *LinkingOutput) const {
+ const toolchains::AROSToolChain &AROSTC =
+ static_cast<const toolchains::AROSToolChain &>(getToolChain());
+ const char *Exec = Args.MakeArgString(AROSTC.GetLinkerPath());
+ const Driver &D = AROSTC.getDriver();
+ const std::string &SysRoot = D.SysRoot;
+ ArgStringList CmdArgs;
+
+ if (llvm::sys::path::filename(Exec) == "lld") {
+ CmdArgs.push_back("-flavor");
+ CmdArgs.push_back("gnu");
+ if (!D.SysRoot.empty())
+ CmdArgs.push_back(Args.MakeArgString("--sysroot=" + SysRoot));
+ }
+
+ // When building 32-bit code on AROS/pc64,
+ // we have to explicitly instruct ld in
+ // the base system to link 32-bit code.
+ if (AROSTC.getArch() == llvm::Triple::x86) {
+ CmdArgs.push_back("-m");
+ CmdArgs.push_back("elf_i386");
+ }
+
+ if (Output.isFilename()) {
+ CmdArgs.push_back("-o");
+ CmdArgs.push_back(Output.getFilename());
+ } else {
+ assert(Output.isNothing() && "Invalid output.");
+ }
+
+ AROSTC.addStartObjectFileArgs(Args, CmdArgs);
+
+ Args.AddAllArgs(CmdArgs,
+ {options::OPT_L,
+ options::OPT_T_Group,
+ options::OPT_e});
+
+ AddLinkerInputs(AROSTC, Inputs, Args, CmdArgs, JA);
+
+ if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
+ SmallString<128> LibPath(SysRoot);
+ llvm::sys::path::append(LibPath, "lib");
+ CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
+
+ if (D.CCCIsCXX()) {
+ AROSTC.AddCXXStdlibLibArgs(Args, CmdArgs);
+ CmdArgs.push_back("-lpthread");
+ }
+ CmdArgs.push_back("--start-group");
+ CmdArgs.push_back("-lmui");
+ CmdArgs.push_back("-larossupport");
+ CmdArgs.push_back("-lamiga");
+ if (!Args.hasArg(options::OPT_nostartfiles)) {
+ if (!Args.hasArg(options::OPT_static)) {
+ if (!Args.hasArg(options::OPT_no_stdc)) {
+ if (!Args.hasArg(options::OPT_no_posixc)) {
+ CmdArgs.push_back("-lposixc");
+ }
+
+ CmdArgs.push_back("-lstdcio");
+ CmdArgs.push_back("-lstdc");
+ }// OPT_no_stdc endif
+ } else {
+ if (!Args.hasArg(options::OPT_no_stdc)) {
+ CmdArgs.push_back("-lstdc.static");
+ }
+ }// OPT_static endif
+ }// OPT_nostartfiles endif
+ CmdArgs.push_back("-lcodesets");
+ CmdArgs.push_back("-lkeymap");
+ CmdArgs.push_back("-lexpansion");
+ CmdArgs.push_back("-lcommodities");
+ CmdArgs.push_back("-ldiskfont");
+ CmdArgs.push_back("-lasl");
+ CmdArgs.push_back("-lmuimaster");
+ CmdArgs.push_back("-ldatatypes");
+ CmdArgs.push_back("-lcybergraphics");
+ CmdArgs.push_back("-lworkbench");
+ CmdArgs.push_back("-licon");
+ CmdArgs.push_back("-lintuition");
+ CmdArgs.push_back("-lgadtools");
+ CmdArgs.push_back("-llayers");
+ CmdArgs.push_back("-laros");
+ CmdArgs.push_back("-lpartition");
+ CmdArgs.push_back("-liffparse");
+ CmdArgs.push_back("-lgraphics");
+ CmdArgs.push_back("-llocale");
+ CmdArgs.push_back("-ldos");
+ CmdArgs.push_back("-lutility");
+ CmdArgs.push_back("-loop");
+ if (!Args.hasArg(options::OPT_nosysbase)) {
+ CmdArgs.push_back("-lexec");
+ }
+ CmdArgs.push_back("-lautoinit");
+ CmdArgs.push_back("-llibinit");
+ if (Args.hasArg(options::OPT_nostartfiles)) {
+ if (!Args.hasArg(options::OPT_no_stdc)) {
+ CmdArgs.push_back("-lstdc.static");
+ }
+ }// 2nd OPT_nostartfiles endif
+ CmdArgs.push_back("--end-group");
+ }
+
+ C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
+}
+
+
+//------------------------------------------------------------------------------------------------------//
+
+
+AROSToolChain::AROSToolChain(const Driver &D,
+ const llvm::Triple &Triple,
+ const llvm::opt::ArgList &Args)
+ : Generic_ELF(D, Triple, Args) {
+ if (GetCXXStdlibType(Args) == ToolChain::CST_Libstdcxx) {
+
+ }
+
+ // FIXME:
+ // Now declared in AROS.h with the function getDefaultLinker() ???
+ // Is this the correct way to implement this ???
+ // This is an unused variable in clang 7 Driver. Delete this ???
+ // Use LLD by default.
+ // DefaultLinker = "collect-aros";
+
+
+}
+
+#if (0)
+bool AROSToolChain::IsUnwindTablesDefault() const {
+ // FIXME:
+
+ // all non-x86 targets need unwind tables, however,
+ // LLVM currently does not know how to emit them.
+
+ // FIXME:
+ // Is this the correct implementation of this function ???
+// bool AROSToolChain::IsUnwindTablesDefault(const ArgList &Args) const {
+ //// Unwind tables are not emitted if -fno-exceptions
+ //// is supplied (except when targeting x86_64).
+ //return getArch() == llvm::Triple::x86_64 ||
+ // (GetExceptionModel(Args) != llvm::ExceptionHandling::SjLj &&
+ // Args.hasFlag(options::OPT_fexceptions,
+ // options::OPT_fno_exceptions,
+ // true));
+
+ return getArch() == llvm::Triple::x86_64;
+}
+
+bool AROSToolChain::isPICDefault() const {
+ return getArch() == llvm::Triple::x86_64;
+}
+
+bool AROSToolChain::isPIEDefault() const {
+ return getArch() == llvm::Triple::x86_64;
+}
+
+bool AROSToolChain::isPICDefaultForced() const {
+ return getArch() == llvm::Triple::x86_64;
+}
+#endif
+
+void AROSToolChain::
+AddAROSSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ const Driver &D = getDriver();
+ const std::string &SysRoot = D.SysRoot;
+
+ if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
+ addSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
+ if (!DriverArgs.hasArg(options::OPT_no_posixc)) {
+ SmallString<128> ResourceDir(SysRoot);
+ llvm::sys::path::append(ResourceDir, "include/aros/posixc");
+ addSystemInclude(DriverArgs, CC1Args, ResourceDir);
+ }// OPT_no_posixc endif
+ if (!DriverArgs.hasArg(options::OPT_no_stdc)) {
+ SmallString<128> ResourceDir(SysRoot);
+ llvm::sys::path::append(ResourceDir, "include/aros/stdc");
+ addSystemInclude(DriverArgs, CC1Args, ResourceDir);
+ }// OPT_no_stdc endif
+ }// OPT_nobuiltininc endif
+}
+
+void AROSToolChain::
+AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ if (DriverArgs.hasArg(options::OPT_nostdlibinc))
+ return;
+
+ AddAROSSystemIncludeArgs(DriverArgs, CC1Args);
+}
+
+void AROSToolChain::
+addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args,
+ Action::OffloadKind DeviceOffloadingKind) const {
+ CC1Args.push_back("-D__AROS__");
+ CC1Args.push_back("-D__AROS");
+ CC1Args.push_back("-DAROS");
+ CC1Args.push_back("-D__AMIGA__");
+ CC1Args.push_back("-D_AMIGA");
+ CC1Args.push_back("-DAMIGA");
+ CC1Args.push_back("-D__ELF__");
+ CC1Args.push_back("-Dsystem=posix");
+}
+
+
+void AROSToolChain::
+AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
+ DriverArgs.hasArg(options::OPT_nostdincxx))
+ return;
+
+ switch (GetCXXStdlibType(DriverArgs)) {
+ case ToolChain::CST_Libcxx:
+ AddAROSSystemIncludeArgs(DriverArgs, CC1Args);
+ break;
+
+ case ToolChain::CST_Libstdcxx:
+ AddAROSSystemIncludeArgs(DriverArgs, CC1Args);
+ break;
+ }
+}
+
+void AROSToolChain::
+AddCXXStdlibLibArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ switch (GetCXXStdlibType(DriverArgs)) {
+ case ToolChain::CST_Libcxx:
+ CC1Args.push_back("-lc++");
+ break;
+ case ToolChain::CST_Libstdcxx:
+ CC1Args.push_back("-lstdc++");
+ break;
+ }
+}
+
+void AROSToolChain::
+addStartObjectFileArgs(const llvm::opt::ArgList &Args,
+ llvm::opt::ArgStringList &CmdArgs) const {
+ if (Args.hasArg(options::OPT_nostartfiles))
+ return;
+
+ const Driver &D = getDriver();
+ const std::string &SysRoot = D.SysRoot;
+ SmallString<128> LibPath(SysRoot);
+ llvm::sys::path::append(LibPath, "lib/");
+
+ // Derived from startfile spec.
+ CmdArgs.push_back(Args.MakeArgString(LibPath + "startup.o"));
+ if (Args.hasArg(options::OPT_detach)) {
+ CmdArgs.push_back(Args.MakeArgString(LibPath + "detach.o"));
+ }
+ if (Args.hasArg(options::OPT_nix)) {
+ CmdArgs.push_back(Args.MakeArgString(LibPath + "nixmain.o"));
+ }
+}
+
+
+Tool *AROSToolChain::buildAssembler() const {
+ return new tools::AROS::Assembler(*this);
+}
+
+Tool *AROSToolChain::buildLinker() const {
+ return new tools::AROS::Linker(*this);
+}
diff --git a/lib/Driver/ToolChains/AROS.h b/lib/Driver/ToolChains/AROS.h
new file mode 100644
index 0000000000..dd8d6d4bc6
--- /dev/null
+++ b/lib/Driver/ToolChains/AROS.h
@@ -0,0 +1,98 @@
+//===--- AROS.h - AROS ToolChain Implementations ----------*- C -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AROS_H
+#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AROS_H
+
+#include "Gnu.h"
+#include "clang/Driver/Tool.h"
+#include "clang/Driver/ToolChain.h"
+
+namespace clang {
+namespace driver {
+namespace tools {
+
+/// AROS -- Directly call GNU Binutils assembler and linker
+namespace AROS {
+class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
+public:
+ Assembler(const ToolChain &TC)
+ : GnuTool("AROS::Assembler", "assembler", 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 Linker : public GnuTool {
+public:
+ Linker(const ToolChain &TC)
+ : GnuTool("AROS::Linker", "linker", 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 AROS
+} // end namespace tools
+
+namespace toolchains {
+// FIXME:
+// AROS - The base AROS tool chain. I changed it to => (Generic_ELF)
+// Should it be changed back to => Generic_GCC ???
+class LLVM_LIBRARY_VISIBILITY AROSToolChain : public Generic_ELF {
+public:
+ AROSToolChain(const Driver &D,
+ const llvm::Triple &Triple,
+ const llvm::opt::ArgList &Args);
+
+ void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const override;
+
+ void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args,
+ Action::OffloadKind DeviceOffloadKind) const override;
+
+ void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const override;
+
+ void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
+ llvm::opt::ArgStringList &CmdArgs) const override;
+
+ void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
+ llvm::opt::ArgStringList &CmdArgs) const;
+ // FIXME:
+ // Is this the correct use of this function in this header?
+ // Moved from AROS.cpp as it was an unused variable "DefaultLinker=collect-aros"
+ // Should "ld.lld" be declare here ???
+ // Use LLD by default.? "ld.lld" ???
+ const char *getDefaultLinker() const override { return "collect-aros"; }
+
+private:
+ void AddAROSSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const;
+
+protected:
+ Tool *buildAssembler() const override;
+ Tool *buildLinker() const override;
+};
+
+
+} // end namespace toolchains
+} // end namespace driver
+} // end namespace clang
+
+#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AROS_H
diff --git a/lib/Frontend/InitHeaderSearch.cpp b/lib/Frontend/InitHeaderSearch.cpp
index 159cd47f78..b9dddf7f30 100644
--- a/lib/Frontend/InitHeaderSearch.cpp
+++ b/lib/Frontend/InitHeaderSearch.cpp
@@ -221,6 +221,10 @@ void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple,
if (HSOpts.UseStandardSystemIncludes) {
switch (os) {
+ case llvm::Triple::AROS:
+ // FIXME:
+ // Fill this in with your default include paths...
+ // AddPath("??/??/??/??", System, false);
case llvm::Triple::CloudABI:
case llvm::Triple::FreeBSD:
case llvm::Triple::NetBSD:
@@ -332,6 +336,7 @@ void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple,
}
switch (os) {
+ case llvm::Triple::AROS:
case llvm::Triple::CloudABI:
case llvm::Triple::RTEMS:
case llvm::Triple::NaCl:

682
tools/crosstools/llvm/clang-10.0.1rc1.src-aros.diff Normal file
View File

@ -0,0 +1,682 @@
diff --git a/include/clang/Driver/Options.td b/include/clang/Driver/Options.td
index 7213af1731..0c0a10b657 100644
--- a/include/clang/Driver/Options.td
+++ b/include/clang/Driver/Options.td
@@ -640,6 +640,7 @@ def dependency_dot : Separate<["-"], "dependency-dot">, Flags<[CC1Option]>,
HelpText<"Filename to write DOT-formatted header dependencies to">;
def module_dependency_dir : Separate<["-"], "module-dependency-dir">,
Flags<[CC1Option]>, HelpText<"Directory to dump module dependencies to">;
+def detach : Flag<["-"], "detach">, Flags<[DriverOption,NoArgumentUnused]>;
def dumpmachine : Flag<["-"], "dumpmachine">;
def dumpspecs : Flag<["-"], "dumpspecs">, Flags<[Unsupported]>;
def dumpversion : Flag<["-"], "dumpversion">;
@@ -2742,11 +2743,15 @@ def multi__module : Flag<["-"], "multi_module">;
def multiply__defined__unused : Separate<["-"], "multiply_defined_unused">;
def multiply__defined : Separate<["-"], "multiply_defined">;
def mwarn_nonportable_cfstrings : Flag<["-"], "mwarn-nonportable-cfstrings">, Group<m_Group>;
+def nix : Flag<["-"], "nix">, Flags<[DriverOption,NoArgumentUnused]>;
def no_canonical_prefixes : Flag<["-"], "no-canonical-prefixes">, Flags<[HelpHidden, CoreOption]>,
HelpText<"Use relative instead of canonical paths">;
def no_cpp_precomp : Flag<["-"], "no-cpp-precomp">, Group<clang_ignored_f_Group>;
def no_integrated_cpp : Flag<["-", "--"], "no-integrated-cpp">, Flags<[DriverOption]>;
def no_pedantic : Flag<["-", "--"], "no-pedantic">, Group<pedantic_Group>;
+def no_posixc : Flag<["-"], "no-posixc">, Flags<[DriverOption,NoArgumentUnused]>;
+def no_stdc : Flag<["-"], "no-stdc">, Flags<[DriverOption,NoArgumentUnused]>;
+def no_sysbase : Flag<["-"], "no_sysbase">, Flags<[DriverOption,NoArgumentUnused]>;
def no__dead__strip__inits__and__terms : Flag<["-"], "no_dead_strip_inits_and_terms">;
def nobuiltininc : Flag<["-"], "nobuiltininc">, Flags<[CC1Option, CoreOption]>,
HelpText<"Disable builtin #include directories">;
@@ -2760,16 +2765,19 @@ def nolibc : Flag<["-"], "nolibc">;
def nomultidefs : Flag<["-"], "nomultidefs">;
def nopie : Flag<["-"], "nopie">;
def no_pie : Flag<["-"], "no-pie">, Alias<nopie>;
+def noposixc : Flag<["-"], "noposixc">, Alias<no_posixc>;
def noprebind : Flag<["-"], "noprebind">;
def noprofilelib : Flag<["-"], "noprofilelib">;
def noseglinkedit : Flag<["-"], "noseglinkedit">;
def nostartfiles : Flag<["-"], "nostartfiles">;
+def nostdc : Flag<["-"], "nostdc">, Alias<no_stdc>;
def nostdinc : Flag<["-"], "nostdinc">, Flags<[CoreOption]>;
def nostdlibinc : Flag<["-"], "nostdlibinc">;
def nostdincxx : Flag<["-"], "nostdinc++">, Flags<[CC1Option]>,
HelpText<"Disable standard #include directories for the C++ standard library">;
def nostdlib : Flag<["-"], "nostdlib">;
def nostdlibxx : Flag<["-"], "nostdlib++">;
+def nosysbase : Flag<["-"], "nosysbase">, Alias<no_sysbase>;
def object : Flag<["-"], "object">;
def o : JoinedOrSeparate<["-"], "o">, Flags<[DriverOption, RenderAsInput, CC1Option, CC1AsOption]>,
HelpText<"Write output to <file>">, MetaVarName<"<file>">;
@@ -2780,6 +2788,7 @@ def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1O
def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>;
def pipe : Flag<["-", "--"], "pipe">,
HelpText<"Use pipes between commands, when possible">;
+def posixc : Flag<["-"], "posixc">, Flags<[DriverOption,NoArgumentUnused]>;
def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">;
def prebind : Flag<["-"], "prebind">;
def preload : Flag<["-"], "preload">;
@@ -2869,6 +2878,7 @@ def specs : Separate<["-", "--"], "specs">, Flags<[Unsupported]>;
def static_libgcc : Flag<["-"], "static-libgcc">;
def static_libstdcxx : Flag<["-"], "static-libstdc++">;
def static : Flag<["-", "--"], "static">, Flags<[NoArgumentUnused]>;
+def stdc : Flag<["-"], "stdc">, Flags<[DriverOption,NoArgumentUnused]>;
def std_default_EQ : Joined<["-"], "std-default=">;
def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option]>,
Group<CompileOnly_Group>, HelpText<"Language standard to compile for">,
diff --git a/lib/Basic/Targets.cpp b/lib/Basic/Targets.cpp
index 69133ca31f..119a32543d 100644
--- a/lib/Basic/Targets.cpp
+++ b/lib/Basic/Targets.cpp
@@ -135,6 +135,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
return new DarwinAArch64TargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS AArch64
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<AArch64leTargetInfo>(Triple, Opts);
+
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts);
case llvm::Triple::FreeBSD:
@@ -179,6 +185,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
return new DarwinARMTargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS ARMle
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<ARMleTargetInfo>(Triple, Opts);
+
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts);
case llvm::Triple::Linux:
@@ -215,6 +227,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
return new DarwinARMTargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS ARMbe
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<ARMbeTargetInfo>(Triple, Opts);
+
case llvm::Triple::Linux:
return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts);
case llvm::Triple::FreeBSD:
@@ -317,6 +335,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
if (Triple.isOSDarwin())
return new DarwinPPC32TargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS PPC32
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<PPC32TargetInfo>(Triple, Opts);
+
case llvm::Triple::Linux:
return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts);
case llvm::Triple::FreeBSD:
@@ -337,6 +361,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
if (Triple.isOSDarwin())
return new DarwinPPC64TargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS PPC64
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<PPC64TargetInfo>(Triple, Opts);
+
case llvm::Triple::Linux:
return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
case llvm::Triple::Lv2:
@@ -462,6 +492,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
switch (os) {
case llvm::Triple::Ananas:
return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts);
+ // FIXME:
+ // Needs to be tested!!!
+ // New Target AROS X86_32
+ case llvm::Triple::AROS:
+ return new AROSTargetInfo<X86_32TargetInfo>(Triple, Opts);
+
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts);
case llvm::Triple::Linux: {
@@ -521,6 +557,12 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
switch (os) {
case llvm::Triple::Ananas:
return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts);
+ // FIXME:
+ // Needs to be tested!!!
+ // New Target AROS X86_64
+ case llvm::Triple::AROS:
+ return new AROSTargetInfo<X86_64TargetInfo>(Triple, Opts);
+
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts);
case llvm::Triple::Linux: {
diff --git a/lib/Basic/Targets/OSTargets.h b/lib/Basic/Targets/OSTargets.h
index e57ad7b9ee..feaa97b362 100644
--- a/lib/Basic/Targets/OSTargets.h
+++ b/lib/Basic/Targets/OSTargets.h
@@ -71,6 +71,26 @@ public:
: OSTargetInfo<Target>(Triple, Opts) {}
};
+// AROS target
+template <typename Target>
+class LLVM_LIBRARY_VISIBILITY AROSTargetInfo : public OSTargetInfo<Target> {
+protected:
+ void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
+ MacroBuilder &Builder) const override {
+ // FIXME:
+ // Are these Macros correct ???
+ // AROS defines
+ Builder.defineMacro("__AROS__");
+ Builder.defineMacro("__ELF__");
+ }
+
+public:
+ // FIXME:
+ // Is this correct ???
+ AROSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
+ : OSTargetInfo<Target>(Triple, Opts) {}
+};
+
void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
const llvm::Triple &Triple, StringRef &PlatformName,
VersionTuple &PlatformMinVersion);
diff --git a/lib/Driver/CMakeLists.txt b/lib/Driver/CMakeLists.txt
index 6f25d3588e..dae0f676e5 100644
--- a/lib/Driver/CMakeLists.txt
+++ b/lib/Driver/CMakeLists.txt
@@ -35,6 +35,7 @@ add_clang_library(clangDriver
ToolChains/AIX.cpp
ToolChains/Ananas.cpp
ToolChains/AMDGPU.cpp
+ ToolChains/AROS.cpp
ToolChains/AVR.cpp
ToolChains/BareMetal.cpp
ToolChains/Clang.cpp
diff --git a/lib/Driver/Driver.cpp b/lib/Driver/Driver.cpp
index 5c726b2314..c3586727ee 100644
--- a/lib/Driver/Driver.cpp
+++ b/lib/Driver/Driver.cpp
@@ -10,6 +10,7 @@
#include "InputInfo.h"
#include "ToolChains/AIX.h"
#include "ToolChains/AMDGPU.h"
+#include "ToolChains/AROS.h"
#include "ToolChains/AVR.h"
#include "ToolChains/Ananas.h"
#include "ToolChains/BareMetal.h"
@@ -4810,6 +4811,9 @@ const ToolChain &Driver::getToolChain(const ArgList &Args,
case llvm::Triple::Ananas:
TC = std::make_unique<toolchains::Ananas>(*this, Target, Args);
break;
+ case llvm::Triple::AROS:
+ TC = std::make_unique<toolchains::AROSToolChain>(*this, Target, Args);
+ break;
case llvm::Triple::CloudABI:
TC = std::make_unique<toolchains::CloudABI>(*this, Target, Args);
break;
diff --git a/lib/Driver/ToolChains/AROS.cpp b/lib/Driver/ToolChains/AROS.cpp
new file mode 100644
index 0000000000..57cdd8fb33
--- /dev/null
+++ b/lib/Driver/ToolChains/AROS.cpp
@@ -0,0 +1,325 @@
+//===--- AROS.cpp - AROS Tool Chain -------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AROS.h"
+#include "InputInfo.h"
+#include "CommonArgs.h"
+#include "clang/Config/config.h"
+#include "clang/Driver/Compilation.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Options.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+using namespace clang::driver;
+using namespace clang::driver::tools;
+using namespace clang::driver::toolchains;
+using namespace clang;
+using namespace llvm::opt;
+
+
+void
+AROS::Assembler::ConstructJob(Compilation &C,
+ const JobAction &JA,
+ const InputInfo &Output,
+ const InputInfoList &Inputs,
+ const ArgList &Args,
+ const char *LinkingOutput) const {
+ claimNoWarnArgs(Args);
+ ArgStringList CmdArgs;
+
+ Args.AddAllArgValues(CmdArgs,
+ options::OPT_Wa_COMMA,
+ options::OPT_Xassembler);
+
+ CmdArgs.push_back("-o");
+ CmdArgs.push_back(Output.getFilename());
+
+ for (const auto &II : Inputs)
+ CmdArgs.push_back(II.getFilename());
+
+ const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+ C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
+}
+
+void
+AROS::Linker::ConstructJob(Compilation &C,
+ const JobAction &JA,
+ const InputInfo &Output,
+ const InputInfoList &Inputs,
+ const ArgList &Args,
+ const char *LinkingOutput) const {
+ const toolchains::AROSToolChain &AROSTC =
+ static_cast<const toolchains::AROSToolChain &>(getToolChain());
+ const char *Exec = Args.MakeArgString(AROSTC.GetLinkerPath());
+ const Driver &D = AROSTC.getDriver();
+ const std::string &SysRoot = D.SysRoot;
+ ArgStringList CmdArgs;
+
+ if (llvm::sys::path::filename(Exec) == "lld") {
+ CmdArgs.push_back("-flavor");
+ CmdArgs.push_back("gnu");
+ if (!D.SysRoot.empty())
+ CmdArgs.push_back(Args.MakeArgString("--sysroot=" + SysRoot));
+ }
+
+ // When building 32-bit code on AROS/pc64,
+ // we have to explicitly instruct ld in
+ // the base system to link 32-bit code.
+ if (AROSTC.getArch() == llvm::Triple::x86) {
+ CmdArgs.push_back("-m");
+ CmdArgs.push_back("elf_i386");
+ }
+
+ if (Output.isFilename()) {
+ CmdArgs.push_back("-o");
+ CmdArgs.push_back(Output.getFilename());
+ } else {
+ assert(Output.isNothing() && "Invalid output.");
+ }
+
+ AROSTC.addStartObjectFileArgs(Args, CmdArgs);
+
+ Args.AddAllArgs(CmdArgs,
+ {options::OPT_L,
+ options::OPT_T_Group,
+ options::OPT_e});
+
+ AddLinkerInputs(AROSTC, Inputs, Args, CmdArgs, JA);
+
+ if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
+ SmallString<128> LibPath(SysRoot);
+ llvm::sys::path::append(LibPath, "lib");
+ CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
+
+ if (D.CCCIsCXX()) {
+ AROSTC.AddCXXStdlibLibArgs(Args, CmdArgs);
+ CmdArgs.push_back("-lpthread");
+ }
+ CmdArgs.push_back("--start-group");
+ CmdArgs.push_back("-lmui");
+ CmdArgs.push_back("-larossupport");
+ CmdArgs.push_back("-lamiga");
+ if (!Args.hasArg(options::OPT_nostartfiles)) {
+ if (!Args.hasArg(options::OPT_static)) {
+ if (!Args.hasArg(options::OPT_no_stdc)) {
+ if (!Args.hasArg(options::OPT_no_posixc)) {
+ CmdArgs.push_back("-lposixc");
+ }
+
+ CmdArgs.push_back("-lstdcio");
+ CmdArgs.push_back("-lstdc");
+ }// OPT_no_stdc endif
+ } else {
+ if (!Args.hasArg(options::OPT_no_stdc)) {
+ CmdArgs.push_back("-lstdc.static");
+ }
+ }// OPT_static endif
+ }// OPT_nostartfiles endif
+ CmdArgs.push_back("-lcodesets");
+ CmdArgs.push_back("-lkeymap");
+ CmdArgs.push_back("-lexpansion");
+ CmdArgs.push_back("-lcommodities");
+ CmdArgs.push_back("-ldiskfont");
+ CmdArgs.push_back("-lasl");
+ CmdArgs.push_back("-lmuimaster");
+ CmdArgs.push_back("-ldatatypes");
+ CmdArgs.push_back("-lcybergraphics");
+ CmdArgs.push_back("-lworkbench");
+ CmdArgs.push_back("-licon");
+ CmdArgs.push_back("-lintuition");
+ CmdArgs.push_back("-lgadtools");
+ CmdArgs.push_back("-llayers");
+ CmdArgs.push_back("-laros");
+ CmdArgs.push_back("-lpartition");
+ CmdArgs.push_back("-liffparse");
+ CmdArgs.push_back("-lgraphics");
+ CmdArgs.push_back("-llocale");
+ CmdArgs.push_back("-ldos");
+ CmdArgs.push_back("-lutility");
+ CmdArgs.push_back("-loop");
+ if (!Args.hasArg(options::OPT_nosysbase)) {
+ CmdArgs.push_back("-lexec");
+ }
+ CmdArgs.push_back("-lautoinit");
+ CmdArgs.push_back("-llibinit");
+ if (Args.hasArg(options::OPT_nostartfiles)) {
+ if (!Args.hasArg(options::OPT_no_stdc)) {
+ CmdArgs.push_back("-lstdc.static");
+ }
+ }// 2nd OPT_nostartfiles endif
+ CmdArgs.push_back("--end-group");
+ }
+
+ C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
+}
+
+
+//------------------------------------------------------------------------------------------------------//
+
+
+AROSToolChain::AROSToolChain(const Driver &D,
+ const llvm::Triple &Triple,
+ const llvm::opt::ArgList &Args)
+ : Generic_ELF(D, Triple, Args) {
+ if (GetCXXStdlibType(Args) == ToolChain::CST_Libstdcxx) {
+
+ }
+
+ // FIXME:
+ // Now declared in AROS.h with the function getDefaultLinker() ???
+ // Is this the correct way to implement this ???
+ // This is an unused variable in clang 7 Driver. Delete this ???
+ // Use LLD by default.
+ // DefaultLinker = "collect-aros";
+
+
+}
+
+#if (0)
+bool AROSToolChain::IsUnwindTablesDefault() const {
+ // FIXME:
+
+ // all non-x86 targets need unwind tables, however,
+ // LLVM currently does not know how to emit them.
+
+ // FIXME:
+ // Is this the correct implementation of this function ???
+// bool AROSToolChain::IsUnwindTablesDefault(const ArgList &Args) const {
+ //// Unwind tables are not emitted if -fno-exceptions
+ //// is supplied (except when targeting x86_64).
+ //return getArch() == llvm::Triple::x86_64 ||
+ // (GetExceptionModel(Args) != llvm::ExceptionHandling::SjLj &&
+ // Args.hasFlag(options::OPT_fexceptions,
+ // options::OPT_fno_exceptions,
+ // true));
+
+ return getArch() == llvm::Triple::x86_64;
+}
+
+bool AROSToolChain::isPICDefault() const {
+ return getArch() == llvm::Triple::x86_64;
+}
+
+bool AROSToolChain::isPIEDefault() const {
+ return getArch() == llvm::Triple::x86_64;
+}
+
+bool AROSToolChain::isPICDefaultForced() const {
+ return getArch() == llvm::Triple::x86_64;
+}
+#endif
+
+void AROSToolChain::
+AddAROSSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ const Driver &D = getDriver();
+ const std::string &SysRoot = D.SysRoot;
+
+ if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
+ addSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
+ if (!DriverArgs.hasArg(options::OPT_no_posixc)) {
+ SmallString<128> ResourceDir(SysRoot);
+ llvm::sys::path::append(ResourceDir, "include/aros/posixc");
+ addSystemInclude(DriverArgs, CC1Args, ResourceDir);
+ }// OPT_no_posixc endif
+ if (!DriverArgs.hasArg(options::OPT_no_stdc)) {
+ SmallString<128> ResourceDir(SysRoot);
+ llvm::sys::path::append(ResourceDir, "include/aros/stdc");
+ addSystemInclude(DriverArgs, CC1Args, ResourceDir);
+ }// OPT_no_stdc endif
+ }// OPT_nobuiltininc endif
+}
+
+void AROSToolChain::
+AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ if (DriverArgs.hasArg(options::OPT_nostdlibinc))
+ return;
+
+ AddAROSSystemIncludeArgs(DriverArgs, CC1Args);
+}
+
+void AROSToolChain::
+addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args,
+ Action::OffloadKind DeviceOffloadingKind) const {
+ CC1Args.push_back("-D__AROS__");
+ CC1Args.push_back("-D__AROS");
+ CC1Args.push_back("-DAROS");
+ CC1Args.push_back("-D__AMIGA__");
+ CC1Args.push_back("-D_AMIGA");
+ CC1Args.push_back("-DAMIGA");
+ CC1Args.push_back("-D__ELF__");
+ CC1Args.push_back("-Dsystem=posix");
+}
+
+
+void AROSToolChain::
+AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
+ DriverArgs.hasArg(options::OPT_nostdincxx))
+ return;
+
+ switch (GetCXXStdlibType(DriverArgs)) {
+ case ToolChain::CST_Libcxx:
+ AddAROSSystemIncludeArgs(DriverArgs, CC1Args);
+ break;
+
+ case ToolChain::CST_Libstdcxx:
+ AddAROSSystemIncludeArgs(DriverArgs, CC1Args);
+ break;
+ }
+}
+
+void AROSToolChain::
+AddCXXStdlibLibArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ switch (GetCXXStdlibType(DriverArgs)) {
+ case ToolChain::CST_Libcxx:
+ CC1Args.push_back("-lc++");
+ break;
+ case ToolChain::CST_Libstdcxx:
+ CC1Args.push_back("-lstdc++");
+ break;
+ }
+}
+
+void AROSToolChain::
+addStartObjectFileArgs(const llvm::opt::ArgList &Args,
+ llvm::opt::ArgStringList &CmdArgs) const {
+ if (Args.hasArg(options::OPT_nostartfiles))
+ return;
+
+ const Driver &D = getDriver();
+ const std::string &SysRoot = D.SysRoot;
+ SmallString<128> LibPath(SysRoot);
+ llvm::sys::path::append(LibPath, "lib/");
+
+ // Derived from startfile spec.
+ CmdArgs.push_back(Args.MakeArgString(LibPath + "startup.o"));
+ if (Args.hasArg(options::OPT_detach)) {
+ CmdArgs.push_back(Args.MakeArgString(LibPath + "detach.o"));
+ }
+ if (Args.hasArg(options::OPT_nix)) {
+ CmdArgs.push_back(Args.MakeArgString(LibPath + "nixmain.o"));
+ }
+}
+
+
+Tool *AROSToolChain::buildAssembler() const {
+ return new tools::AROS::Assembler(*this);
+}
+
+Tool *AROSToolChain::buildLinker() const {
+ return new tools::AROS::Linker(*this);
+}
diff --git a/lib/Driver/ToolChains/AROS.h b/lib/Driver/ToolChains/AROS.h
new file mode 100644
index 0000000000..dd8d6d4bc6
--- /dev/null
+++ b/lib/Driver/ToolChains/AROS.h
@@ -0,0 +1,98 @@
+//===--- AROS.h - AROS ToolChain Implementations ----------*- C -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AROS_H
+#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AROS_H
+
+#include "Gnu.h"
+#include "clang/Driver/Tool.h"
+#include "clang/Driver/ToolChain.h"
+
+namespace clang {
+namespace driver {
+namespace tools {
+
+/// AROS -- Directly call GNU Binutils assembler and linker
+namespace AROS {
+class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
+public:
+ Assembler(const ToolChain &TC)
+ : GnuTool("AROS::Assembler", "assembler", 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 Linker : public GnuTool {
+public:
+ Linker(const ToolChain &TC)
+ : GnuTool("AROS::Linker", "linker", 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 AROS
+} // end namespace tools
+
+namespace toolchains {
+// FIXME:
+// AROS - The base AROS tool chain. I changed it to => (Generic_ELF)
+// Should it be changed back to => Generic_GCC ???
+class LLVM_LIBRARY_VISIBILITY AROSToolChain : public Generic_ELF {
+public:
+ AROSToolChain(const Driver &D,
+ const llvm::Triple &Triple,
+ const llvm::opt::ArgList &Args);
+
+ void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const override;
+
+ void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args,
+ Action::OffloadKind DeviceOffloadKind) const override;
+
+ void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const override;
+
+ void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
+ llvm::opt::ArgStringList &CmdArgs) const override;
+
+ void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
+ llvm::opt::ArgStringList &CmdArgs) const;
+ // FIXME:
+ // Is this the correct use of this function in this header?
+ // Moved from AROS.cpp as it was an unused variable "DefaultLinker=collect-aros"
+ // Should "ld.lld" be declare here ???
+ // Use LLD by default.? "ld.lld" ???
+ const char *getDefaultLinker() const override { return "collect-aros"; }
+
+private:
+ void AddAROSSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const;
+
+protected:
+ Tool *buildAssembler() const override;
+ Tool *buildLinker() const override;
+};
+
+
+} // end namespace toolchains
+} // end namespace driver
+} // end namespace clang
+
+#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AROS_H
diff --git a/lib/Frontend/InitHeaderSearch.cpp b/lib/Frontend/InitHeaderSearch.cpp
index 159cd47f78..b9dddf7f30 100644
--- a/lib/Frontend/InitHeaderSearch.cpp
+++ b/lib/Frontend/InitHeaderSearch.cpp
@@ -221,6 +221,10 @@ void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple,
if (HSOpts.UseStandardSystemIncludes) {
switch (os) {
+ case llvm::Triple::AROS:
+ // FIXME:
+ // Fill this in with your default include paths...
+ // AddPath("??/??/??/??", System, false);
case llvm::Triple::CloudABI:
case llvm::Triple::FreeBSD:
case llvm::Triple::NetBSD:
@@ -332,6 +336,7 @@ void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple,
}
switch (os) {
+ case llvm::Triple::AROS:
case llvm::Triple::CloudABI:
case llvm::Triple::RTEMS:
case llvm::Triple::NaCl:

677
tools/crosstools/llvm/clang-11.0.0.src-aros.diff Normal file
View File

@ -0,0 +1,677 @@
diff --git a/include/clang/Driver/Options.td b/include/clang/Driver/Options.td
index 966cb907b7e2..868e83734551 100644
--- a/include/clang/Driver/Options.td
+++ b/include/clang/Driver/Options.td
@@ -668,6 +668,7 @@ def dependency_dot : Separate<["-"], "dependency-dot">, Flags<[CC1Option]>,
HelpText<"Filename to write DOT-formatted header dependencies to">;
def module_dependency_dir : Separate<["-"], "module-dependency-dir">,
Flags<[CC1Option]>, HelpText<"Directory to dump module dependencies to">;
+def detach : Flag<["-"], "detach">, Flags<[DriverOption,NoArgumentUnused]>;
def dumpmachine : Flag<["-"], "dumpmachine">;
def dumpspecs : Flag<["-"], "dumpspecs">, Flags<[Unsupported]>;
def dumpversion : Flag<["-"], "dumpversion">;
@@ -2690,11 +2691,15 @@ def multi__module : Flag<["-"], "multi_module">;
def multiply__defined__unused : Separate<["-"], "multiply_defined_unused">;
def multiply__defined : Separate<["-"], "multiply_defined">;
def mwarn_nonportable_cfstrings : Flag<["-"], "mwarn-nonportable-cfstrings">, Group<m_Group>;
+def nix : Flag<["-"], "nix">, Flags<[DriverOption,NoArgumentUnused]>;
def no_canonical_prefixes : Flag<["-"], "no-canonical-prefixes">, Flags<[HelpHidden, CoreOption]>,
HelpText<"Use relative instead of canonical paths">;
def no_cpp_precomp : Flag<["-"], "no-cpp-precomp">, Group<clang_ignored_f_Group>;
def no_integrated_cpp : Flag<["-", "--"], "no-integrated-cpp">, Flags<[DriverOption]>;
def no_pedantic : Flag<["-", "--"], "no-pedantic">, Group<pedantic_Group>;
+def no_posixc : Flag<["-"], "no-posixc">, Flags<[DriverOption,NoArgumentUnused]>;
+def no_stdc : Flag<["-"], "no-stdc">, Flags<[DriverOption,NoArgumentUnused]>;
+def no_sysbase : Flag<["-"], "no_sysbase">, Flags<[DriverOption,NoArgumentUnused]>;
def no__dead__strip__inits__and__terms : Flag<["-"], "no_dead_strip_inits_and_terms">;
def nobuiltininc : Flag<["-"], "nobuiltininc">, Flags<[CC1Option, CoreOption]>,
HelpText<"Disable builtin #include directories">;
@@ -2709,16 +2714,19 @@ def nolibc : Flag<["-"], "nolibc">;
def nomultidefs : Flag<["-"], "nomultidefs">;
def nopie : Flag<["-"], "nopie">;
def no_pie : Flag<["-"], "no-pie">, Alias<nopie>;
+def noposixc : Flag<["-"], "noposixc">, Alias<no_posixc>;
def noprebind : Flag<["-"], "noprebind">;
def noprofilelib : Flag<["-"], "noprofilelib">;
def noseglinkedit : Flag<["-"], "noseglinkedit">;
def nostartfiles : Flag<["-"], "nostartfiles">;
+def nostdc : Flag<["-"], "nostdc">, Alias<no_stdc>;
def nostdinc : Flag<["-"], "nostdinc">, Flags<[CoreOption]>;
def nostdlibinc : Flag<["-"], "nostdlibinc">;
def nostdincxx : Flag<["-"], "nostdinc++">, Flags<[CC1Option]>,
HelpText<"Disable standard #include directories for the C++ standard library">;
def nostdlib : Flag<["-"], "nostdlib">;
def nostdlibxx : Flag<["-"], "nostdlib++">;
+def nosysbase : Flag<["-"], "nosysbase">, Alias<no_sysbase>;
def object : Flag<["-"], "object">;
def o : JoinedOrSeparate<["-"], "o">, Flags<[DriverOption, RenderAsInput, CC1Option, CC1AsOption]>,
HelpText<"Write output to <file>">, MetaVarName<"<file>">;
@@ -2729,6 +2737,7 @@ def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1O
def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>;
def pipe : Flag<["-", "--"], "pipe">,
HelpText<"Use pipes between commands, when possible">;
+def posixc : Flag<["-"], "posixc">, Flags<[DriverOption,NoArgumentUnused]>;
def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">;
def prebind : Flag<["-"], "prebind">;
def preload : Flag<["-"], "preload">;
@@ -2818,6 +2827,7 @@ def specs : Separate<["-", "--"], "specs">, Flags<[Unsupported]>;
def static_libgcc : Flag<["-"], "static-libgcc">;
def static_libstdcxx : Flag<["-"], "static-libstdc++">;
def static : Flag<["-", "--"], "static">, Flags<[NoArgumentUnused]>;
+def stdc : Flag<["-"], "stdc">, Flags<[DriverOption,NoArgumentUnused]>;
def std_default_EQ : Joined<["-"], "std-default=">;
def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option]>,
Group<CompileOnly_Group>, HelpText<"Language standard to compile for">,
diff --git a/lib/Basic/Targets.cpp b/lib/Basic/Targets.cpp
index 965f273892bd..e4656ce32ef0 100644
--- a/lib/Basic/Targets.cpp
+++ b/lib/Basic/Targets.cpp
@@ -136,6 +136,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
return new DarwinAArch64TargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS AArch64
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<AArch64leTargetInfo>(Triple, Opts);
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts);
case llvm::Triple::FreeBSD:
@@ -180,6 +185,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
return new DarwinARMTargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS ARMle
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<ARMleTargetInfo>(Triple, Opts);
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts);
case llvm::Triple::Linux:
@@ -216,6 +226,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
return new DarwinARMTargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS ARMbe
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<ARMbeTargetInfo>(Triple, Opts);
case llvm::Triple::Linux:
return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts);
case llvm::Triple::FreeBSD:
@@ -318,6 +333,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
if (Triple.isOSDarwin())
return new DarwinPPC32TargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS PPC32
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<PPC32TargetInfo>(Triple, Opts);
case llvm::Triple::Linux:
return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts);
case llvm::Triple::FreeBSD:
@@ -338,6 +358,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
if (Triple.isOSDarwin())
return new DarwinPPC64TargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS PPC64
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<PPC64TargetInfo>(Triple, Opts);
case llvm::Triple::Linux:
return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
case llvm::Triple::Lv2:
@@ -465,6 +490,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
switch (os) {
case llvm::Triple::Ananas:
return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts);
+ // FIXME:
+ // Needs to be tested!!!
+ // New Target AROS X86_32
+ case llvm::Triple::AROS:
+ return new AROSTargetInfo<X86_32TargetInfo>(Triple, Opts);
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts);
case llvm::Triple::Linux: {
@@ -524,6 +554,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
switch (os) {
case llvm::Triple::Ananas:
return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts);
+ // FIXME:
+ // Needs to be tested!!!
+ // New Target AROS X86_64
+ case llvm::Triple::AROS:
+ return new AROSTargetInfo<X86_64TargetInfo>(Triple, Opts);
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts);
case llvm::Triple::Linux: {
diff --git a/lib/Basic/Targets/OSTargets.h b/lib/Basic/Targets/OSTargets.h
index 2a9e4f91d478..07ec77af12dc 100644
--- a/lib/Basic/Targets/OSTargets.h
+++ b/lib/Basic/Targets/OSTargets.h
@@ -71,6 +71,26 @@ public:
: OSTargetInfo<Target>(Triple, Opts) {}
};
+// AROS target
+template <typename Target>
+class LLVM_LIBRARY_VISIBILITY AROSTargetInfo : public OSTargetInfo<Target> {
+protected:
+ void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
+ MacroBuilder &Builder) const override {
+ // FIXME:
+ // Are these Macros correct ???
+ // AROS defines
+ Builder.defineMacro("__AROS__");
+ Builder.defineMacro("__ELF__");
+ }
+
+public:
+ // FIXME:
+ // Is this correct ???
+ AROSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
+ : OSTargetInfo<Target>(Triple, Opts) {}
+};
+
void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
const llvm::Triple &Triple, StringRef &PlatformName,
VersionTuple &PlatformMinVersion);
diff --git a/lib/Driver/CMakeLists.txt b/lib/Driver/CMakeLists.txt
index 9463ca5c109d..164851b0c278 100644
--- a/lib/Driver/CMakeLists.txt
+++ b/lib/Driver/CMakeLists.txt
@@ -36,6 +36,7 @@ add_clang_library(clangDriver
ToolChains/AIX.cpp
ToolChains/Ananas.cpp
ToolChains/AMDGPU.cpp
+ ToolChains/AROS.cpp
ToolChains/AVR.cpp
ToolChains/BareMetal.cpp
ToolChains/Clang.cpp
diff --git a/lib/Driver/Driver.cpp b/lib/Driver/Driver.cpp
index ece8222dcf24..0afcf685e94f 100644
--- a/lib/Driver/Driver.cpp
+++ b/lib/Driver/Driver.cpp
@@ -10,6 +10,7 @@
#include "InputInfo.h"
#include "ToolChains/AIX.h"
#include "ToolChains/AMDGPU.h"
+#include "ToolChains/AROS.h"
#include "ToolChains/AVR.h"
#include "ToolChains/Ananas.h"
#include "ToolChains/BareMetal.h"
@@ -4897,6 +4898,9 @@ const ToolChain &Driver::getToolChain(const ArgList &Args,
case llvm::Triple::Ananas:
TC = std::make_unique<toolchains::Ananas>(*this, Target, Args);
break;
+ case llvm::Triple::AROS:
+ TC = std::make_unique<toolchains::AROSToolChain>(*this, Target, Args);
+ break;
case llvm::Triple::CloudABI:
TC = std::make_unique<toolchains::CloudABI>(*this, Target, Args);
break;
diff --git a/lib/Driver/ToolChains/AROS.cpp b/lib/Driver/ToolChains/AROS.cpp
new file mode 100644
index 000000000000..ed8a93336adb
--- /dev/null
+++ b/lib/Driver/ToolChains/AROS.cpp
@@ -0,0 +1,325 @@
+//===--- AROS.cpp - AROS Tool Chain -------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AROS.h"
+#include "InputInfo.h"
+#include "CommonArgs.h"
+#include "clang/Config/config.h"
+#include "clang/Driver/Compilation.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Options.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+using namespace clang::driver;
+using namespace clang::driver::tools;
+using namespace clang::driver::toolchains;
+using namespace clang;
+using namespace llvm::opt;
+
+
+void
+AROS::Assembler::ConstructJob(Compilation &C,
+ const JobAction &JA,
+ const InputInfo &Output,
+ const InputInfoList &Inputs,
+ const ArgList &Args,
+ const char *LinkingOutput) const {
+ claimNoWarnArgs(Args);
+ ArgStringList CmdArgs;
+
+ Args.AddAllArgValues(CmdArgs,
+ options::OPT_Wa_COMMA,
+ options::OPT_Xassembler);
+
+ CmdArgs.push_back("-o");
+ CmdArgs.push_back(Output.getFilename());
+
+ for (const auto &II : Inputs)
+ CmdArgs.push_back(II.getFilename());
+
+ const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+ C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::None(), Exec, CmdArgs, Inputs));
+}
+
+void
+AROS::Linker::ConstructJob(Compilation &C,
+ const JobAction &JA,
+ const InputInfo &Output,
+ const InputInfoList &Inputs,
+ const ArgList &Args,
+ const char *LinkingOutput) const {
+ const toolchains::AROSToolChain &AROSTC =
+ static_cast<const toolchains::AROSToolChain &>(getToolChain());
+ const char *Exec = Args.MakeArgString(AROSTC.GetLinkerPath());
+ const Driver &D = AROSTC.getDriver();
+ const std::string &SysRoot = D.SysRoot;
+ ArgStringList CmdArgs;
+
+ if (llvm::sys::path::filename(Exec) == "lld") {
+ CmdArgs.push_back("-flavor");
+ CmdArgs.push_back("gnu");
+ if (!D.SysRoot.empty())
+ CmdArgs.push_back(Args.MakeArgString("--sysroot=" + SysRoot));
+ }
+
+ // When building 32-bit code on AROS/pc64,
+ // we have to explicitly instruct ld in
+ // the base system to link 32-bit code.
+ if (AROSTC.getArch() == llvm::Triple::x86) {
+ CmdArgs.push_back("-m");
+ CmdArgs.push_back("elf_i386");
+ }
+
+ if (Output.isFilename()) {
+ CmdArgs.push_back("-o");
+ CmdArgs.push_back(Output.getFilename());
+ } else {
+ assert(Output.isNothing() && "Invalid output.");
+ }
+
+ AROSTC.addStartObjectFileArgs(Args, CmdArgs);
+
+ Args.AddAllArgs(CmdArgs,
+ {options::OPT_L,
+ options::OPT_T_Group,
+ options::OPT_e});
+
+ AddLinkerInputs(AROSTC, Inputs, Args, CmdArgs, JA);
+
+ if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
+ SmallString<128> LibPath(SysRoot);
+ llvm::sys::path::append(LibPath, "lib");
+ CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
+
+ if (D.CCCIsCXX()) {
+ AROSTC.AddCXXStdlibLibArgs(Args, CmdArgs);
+ CmdArgs.push_back("-lpthread");
+ }
+ CmdArgs.push_back("--start-group");
+ CmdArgs.push_back("-lmui");
+ CmdArgs.push_back("-larossupport");
+ CmdArgs.push_back("-lamiga");
+ if (!Args.hasArg(options::OPT_nostartfiles)) {
+ if (!Args.hasArg(options::OPT_static)) {
+ if (!Args.hasArg(options::OPT_no_stdc)) {
+ if (!Args.hasArg(options::OPT_no_posixc)) {
+ CmdArgs.push_back("-lposixc");
+ }
+
+ CmdArgs.push_back("-lstdcio");
+ CmdArgs.push_back("-lstdc");
+ }// OPT_no_stdc endif
+ } else {
+ if (!Args.hasArg(options::OPT_no_stdc)) {
+ CmdArgs.push_back("-lstdc.static");
+ }
+ }// OPT_static endif
+ }// OPT_nostartfiles endif
+ CmdArgs.push_back("-lcodesets");
+ CmdArgs.push_back("-lkeymap");
+ CmdArgs.push_back("-lexpansion");
+ CmdArgs.push_back("-lcommodities");
+ CmdArgs.push_back("-ldiskfont");
+ CmdArgs.push_back("-lasl");
+ CmdArgs.push_back("-lmuimaster");
+ CmdArgs.push_back("-ldatatypes");
+ CmdArgs.push_back("-lcybergraphics");
+ CmdArgs.push_back("-lworkbench");
+ CmdArgs.push_back("-licon");
+ CmdArgs.push_back("-lintuition");
+ CmdArgs.push_back("-lgadtools");
+ CmdArgs.push_back("-llayers");
+ CmdArgs.push_back("-laros");
+ CmdArgs.push_back("-lpartition");
+ CmdArgs.push_back("-liffparse");
+ CmdArgs.push_back("-lgraphics");
+ CmdArgs.push_back("-llocale");
+ CmdArgs.push_back("-ldos");
+ CmdArgs.push_back("-lutility");
+ CmdArgs.push_back("-loop");
+ if (!Args.hasArg(options::OPT_nosysbase)) {
+ CmdArgs.push_back("-lexec");
+ }
+ CmdArgs.push_back("-lautoinit");
+ CmdArgs.push_back("-llibinit");
+ if (Args.hasArg(options::OPT_nostartfiles)) {
+ if (!Args.hasArg(options::OPT_no_stdc)) {
+ CmdArgs.push_back("-lstdc.static");
+ }
+ }// 2nd OPT_nostartfiles endif
+ CmdArgs.push_back("--end-group");
+ }
+
+ C.addCommand(std::make_unique<Command>(JA, *this, ResponseFileSupport::AtFileUTF8(), Exec, CmdArgs, Inputs));
+}
+
+
+//------------------------------------------------------------------------------------------------------//
+
+
+AROSToolChain::AROSToolChain(const Driver &D,
+ const llvm::Triple &Triple,
+ const llvm::opt::ArgList &Args)
+ : Generic_ELF(D, Triple, Args) {
+ if (GetCXXStdlibType(Args) == ToolChain::CST_Libstdcxx) {
+
+ }
+
+ // FIXME:
+ // Now declared in AROS.h with the function getDefaultLinker() ???
+ // Is this the correct way to implement this ???
+ // This is an unused variable in clang 7 Driver. Delete this ???
+ // Use LLD by default.
+ // DefaultLinker = "collect-aros";
+
+
+}
+
+#if (0)
+bool AROSToolChain::IsUnwindTablesDefault() const {
+ // FIXME:
+
+ // all non-x86 targets need unwind tables, however,
+ // LLVM currently does not know how to emit them.
+
+ // FIXME:
+ // Is this the correct implementation of this function ???
+// bool AROSToolChain::IsUnwindTablesDefault(const ArgList &Args) const {
+ //// Unwind tables are not emitted if -fno-exceptions
+ //// is supplied (except when targeting x86_64).
+ //return getArch() == llvm::Triple::x86_64 ||
+ // (GetExceptionModel(Args) != llvm::ExceptionHandling::SjLj &&
+ // Args.hasFlag(options::OPT_fexceptions,
+ // options::OPT_fno_exceptions,
+ // true));
+
+ return getArch() == llvm::Triple::x86_64;
+}
+
+bool AROSToolChain::isPICDefault() const {
+ return getArch() == llvm::Triple::x86_64;
+}
+
+bool AROSToolChain::isPIEDefault() const {
+ return getArch() == llvm::Triple::x86_64;
+}
+
+bool AROSToolChain::isPICDefaultForced() const {
+ return getArch() == llvm::Triple::x86_64;
+}
+#endif
+
+void AROSToolChain::
+AddAROSSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ const Driver &D = getDriver();
+ const std::string &SysRoot = D.SysRoot;
+
+ if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
+ addSystemInclude(DriverArgs, CC1Args, SysRoot + "/include");
+ if (!DriverArgs.hasArg(options::OPT_no_posixc)) {
+ SmallString<128> ResourceDir(SysRoot);
+ llvm::sys::path::append(ResourceDir, "include/aros/posixc");
+ addSystemInclude(DriverArgs, CC1Args, ResourceDir);
+ }// OPT_no_posixc endif
+ if (!DriverArgs.hasArg(options::OPT_no_stdc)) {
+ SmallString<128> ResourceDir(SysRoot);
+ llvm::sys::path::append(ResourceDir, "include/aros/stdc");
+ addSystemInclude(DriverArgs, CC1Args, ResourceDir);
+ }// OPT_no_stdc endif
+ }// OPT_nobuiltininc endif
+}
+
+void AROSToolChain::
+AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ if (DriverArgs.hasArg(options::OPT_nostdlibinc))
+ return;
+
+ AddAROSSystemIncludeArgs(DriverArgs, CC1Args);
+}
+
+void AROSToolChain::
+addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args,
+ Action::OffloadKind DeviceOffloadingKind) const {
+ CC1Args.push_back("-D__AROS__");
+ CC1Args.push_back("-D__AROS");
+ CC1Args.push_back("-DAROS");
+ CC1Args.push_back("-D__AMIGA__");
+ CC1Args.push_back("-D_AMIGA");
+ CC1Args.push_back("-DAMIGA");
+ CC1Args.push_back("-D__ELF__");
+ CC1Args.push_back("-Dsystem=posix");
+}
+
+
+void AROSToolChain::
+AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
+ DriverArgs.hasArg(options::OPT_nostdincxx))
+ return;
+
+ switch (GetCXXStdlibType(DriverArgs)) {
+ case ToolChain::CST_Libcxx:
+ AddAROSSystemIncludeArgs(DriverArgs, CC1Args);
+ break;
+
+ case ToolChain::CST_Libstdcxx:
+ AddAROSSystemIncludeArgs(DriverArgs, CC1Args);
+ break;
+ }
+}
+
+void AROSToolChain::
+AddCXXStdlibLibArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ switch (GetCXXStdlibType(DriverArgs)) {
+ case ToolChain::CST_Libcxx:
+ CC1Args.push_back("-lc++");
+ break;
+ case ToolChain::CST_Libstdcxx:
+ CC1Args.push_back("-lstdc++");
+ break;
+ }
+}
+
+void AROSToolChain::
+addStartObjectFileArgs(const llvm::opt::ArgList &Args,
+ llvm::opt::ArgStringList &CmdArgs) const {
+ if (Args.hasArg(options::OPT_nostartfiles))
+ return;
+
+ const Driver &D = getDriver();
+ const std::string &SysRoot = D.SysRoot;
+ SmallString<128> LibPath(SysRoot);
+ llvm::sys::path::append(LibPath, "lib/");
+
+ // Derived from startfile spec.
+ CmdArgs.push_back(Args.MakeArgString(LibPath + "startup.o"));
+ if (Args.hasArg(options::OPT_detach)) {
+ CmdArgs.push_back(Args.MakeArgString(LibPath + "detach.o"));
+ }
+ if (Args.hasArg(options::OPT_nix)) {
+ CmdArgs.push_back(Args.MakeArgString(LibPath + "nixmain.o"));
+ }
+}
+
+
+Tool *AROSToolChain::buildAssembler() const {
+ return new tools::AROS::Assembler(*this);
+}
+
+Tool *AROSToolChain::buildLinker() const {
+ return new tools::AROS::Linker(*this);
+}
diff --git a/lib/Driver/ToolChains/AROS.h b/lib/Driver/ToolChains/AROS.h
new file mode 100644
index 000000000000..dd8d6d4bc6fa
--- /dev/null
+++ b/lib/Driver/ToolChains/AROS.h
@@ -0,0 +1,98 @@
+//===--- AROS.h - AROS ToolChain Implementations ----------*- C -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AROS_H
+#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AROS_H
+
+#include "Gnu.h"
+#include "clang/Driver/Tool.h"
+#include "clang/Driver/ToolChain.h"
+
+namespace clang {
+namespace driver {
+namespace tools {
+
+/// AROS -- Directly call GNU Binutils assembler and linker
+namespace AROS {
+class LLVM_LIBRARY_VISIBILITY Assembler : public Tool {
+public:
+ Assembler(const ToolChain &TC)
+ : Tool("AROS::Assembler", "assembler", 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 Linker : public Tool {
+public:
+ Linker(const ToolChain &TC)
+ : Tool("AROS::Linker", "linker", 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 AROS
+} // end namespace tools
+
+namespace toolchains {
+// FIXME:
+// AROS - The base AROS tool chain. I changed it to => (Generic_ELF)
+// Should it be changed back to => Generic_GCC ???
+class LLVM_LIBRARY_VISIBILITY AROSToolChain : public Generic_ELF {
+public:
+ AROSToolChain(const Driver &D,
+ const llvm::Triple &Triple,
+ const llvm::opt::ArgList &Args);
+
+ void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const override;
+
+ void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args,
+ Action::OffloadKind DeviceOffloadKind) const override;
+
+ void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const override;
+
+ void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
+ llvm::opt::ArgStringList &CmdArgs) const override;
+
+ void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
+ llvm::opt::ArgStringList &CmdArgs) const;
+ // FIXME:
+ // Is this the correct use of this function in this header?
+ // Moved from AROS.cpp as it was an unused variable "DefaultLinker=collect-aros"
+ // Should "ld.lld" be declare here ???
+ // Use LLD by default.? "ld.lld" ???
+ const char *getDefaultLinker() const override { return "collect-aros"; }
+
+private:
+ void AddAROSSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const;
+
+protected:
+ Tool *buildAssembler() const override;
+ Tool *buildLinker() const override;
+};
+
+
+} // end namespace toolchains
+} // end namespace driver
+} // end namespace clang
+
+#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AROS_H
diff --git a/lib/Frontend/InitHeaderSearch.cpp b/lib/Frontend/InitHeaderSearch.cpp
index bc31445d6d08..e98b57a857df 100644
--- a/lib/Frontend/InitHeaderSearch.cpp
+++ b/lib/Frontend/InitHeaderSearch.cpp
@@ -221,6 +221,11 @@ void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple,
if (HSOpts.UseStandardSystemIncludes) {
switch (os) {
+ case llvm::Triple::AROS:
+ // FIXME:
+ // Fill this in with your default include paths...
+ // AddPath("??/??/??/??", System, false);
+ // AddPath("/usr/include", System, false);
case llvm::Triple::CloudABI:
case llvm::Triple::FreeBSD:
case llvm::Triple::NetBSD:
@@ -333,6 +338,7 @@ void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple,
}
switch (os) {
+ case llvm::Triple::AROS:
case llvm::Triple::CloudABI:
case llvm::Triple::RTEMS:
case llvm::Triple::NaCl:

676
tools/crosstools/llvm/clang-11.0.1.src-aros.diff Normal file
View File

@ -0,0 +1,676 @@
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 0b0def564cf3..b6264cc49139 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -727,6 +727,7 @@ def dependency_dot : Separate<["-"], "dependency-dot">, Flags<[CC1Option]>,
HelpText<"Filename to write DOT-formatted header dependencies to">;
def module_dependency_dir : Separate<["-"], "module-dependency-dir">,
Flags<[CC1Option]>, HelpText<"Directory to dump module dependencies to">;
+def detach : Flag<["-"], "detach">, Flags<[DriverOption,NoArgumentUnused]>;
def dsym_dir : JoinedOrSeparate<["-"], "dsym-dir">,
Flags<[NoXarchOption, RenderAsInput]>,
HelpText<"Directory to output dSYM's (if any) to">, MetaVarName<"<dir>">;
@@ -2837,11 +2838,15 @@ def multi__module : Flag<["-"], "multi_module">;
def multiply__defined__unused : Separate<["-"], "multiply_defined_unused">;
def multiply__defined : Separate<["-"], "multiply_defined">;
def mwarn_nonportable_cfstrings : Flag<["-"], "mwarn-nonportable-cfstrings">, Group<m_Group>;
+def nix : Flag<["-"], "nix">, Flags<[DriverOption,NoArgumentUnused]>;
def no_canonical_prefixes : Flag<["-"], "no-canonical-prefixes">, Flags<[HelpHidden, CoreOption]>,
HelpText<"Use relative instead of canonical paths">;
def no_cpp_precomp : Flag<["-"], "no-cpp-precomp">, Group<clang_ignored_f_Group>;
def no_integrated_cpp : Flag<["-", "--"], "no-integrated-cpp">, Flags<[NoXarchOption]>;
def no_pedantic : Flag<["-", "--"], "no-pedantic">, Group<pedantic_Group>;
+def no_posixc : Flag<["-"], "no-posixc">, Flags<[DriverOption,NoArgumentUnused]>;
+def no_stdc : Flag<["-"], "no-stdc">, Flags<[DriverOption,NoArgumentUnused]>;
+def no_sysbase : Flag<["-"], "no_sysbase">, Flags<[DriverOption,NoArgumentUnused]>;
def no__dead__strip__inits__and__terms : Flag<["-"], "no_dead_strip_inits_and_terms">;
def nobuiltininc : Flag<["-"], "nobuiltininc">, Flags<[CC1Option, CoreOption]>,
HelpText<"Disable builtin #include directories">;
@@ -2856,16 +2861,19 @@ def nolibc : Flag<["-"], "nolibc">;
def nomultidefs : Flag<["-"], "nomultidefs">;
def nopie : Flag<["-"], "nopie">;
def no_pie : Flag<["-"], "no-pie">, Alias<nopie>;
+def noposixc : Flag<["-"], "noposixc">, Alias<no_posixc>;
def noprebind : Flag<["-"], "noprebind">;
def noprofilelib : Flag<["-"], "noprofilelib">;
def noseglinkedit : Flag<["-"], "noseglinkedit">;
def nostartfiles : Flag<["-"], "nostartfiles">, Group<Link_Group>;
+def nostdc : Flag<["-"], "nostdc">, Alias<no_stdc>;
def nostdinc : Flag<["-"], "nostdinc">, Flags<[CoreOption]>;
def nostdlibinc : Flag<["-"], "nostdlibinc">;
def nostdincxx : Flag<["-"], "nostdinc++">, Flags<[CC1Option]>,
HelpText<"Disable standard #include directories for the C++ standard library">;
def nostdlib : Flag<["-"], "nostdlib">, Group<Link_Group>;
def nostdlibxx : Flag<["-"], "nostdlib++">;
+def nosysbase : Flag<["-"], "nosysbase">, Alias<no_sysbase>;
def object : Flag<["-"], "object">;
def o : JoinedOrSeparate<["-"], "o">, Flags<[NoXarchOption, RenderAsInput,
CC1Option, CC1AsOption, FC1Option, FlangOption]>,
@@ -2877,6 +2885,7 @@ def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1O
def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>;
def pipe : Flag<["-", "--"], "pipe">,
HelpText<"Use pipes between commands, when possible">;
+def posixc : Flag<["-"], "posixc">, Flags<[DriverOption,NoArgumentUnused]>;
def prebind__all__twolevel__modules : Flag<["-"], "prebind_all_twolevel_modules">;
def prebind : Flag<["-"], "prebind">;
def preload : Flag<["-"], "preload">;
@@ -2966,6 +2975,7 @@ def specs : Separate<["-", "--"], "specs">, Flags<[Unsupported]>;
def static_libgcc : Flag<["-"], "static-libgcc">;
def static_libstdcxx : Flag<["-"], "static-libstdc++">;
def static : Flag<["-", "--"], "static">, Group<Link_Group>, Flags<[NoArgumentUnused]>;
+def stdc : Flag<["-"], "stdc">, Flags<[DriverOption,NoArgumentUnused]>;
def std_default_EQ : Joined<["-"], "std-default=">;
def std_EQ : Joined<["-", "--"], "std=">, Flags<[CC1Option]>,
Group<CompileOnly_Group>, HelpText<"Language standard to compile for">,
diff --git a/clang/lib/Basic/Targets.cpp b/clang/lib/Basic/Targets.cpp
index 1126b647e37b..0c6e7e003f4e 100644
--- a/clang/lib/Basic/Targets.cpp
+++ b/clang/lib/Basic/Targets.cpp
@@ -136,6 +136,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
return new DarwinAArch64TargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS AArch64
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<AArch64leTargetInfo>(Triple, Opts);
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts);
case llvm::Triple::FreeBSD:
@@ -180,6 +185,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
return new DarwinARMTargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS ARMle
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<ARMleTargetInfo>(Triple, Opts);
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts);
case llvm::Triple::Linux:
@@ -216,6 +226,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
return new DarwinARMTargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS ARMbe
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<ARMbeTargetInfo>(Triple, Opts);
case llvm::Triple::Linux:
return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts);
case llvm::Triple::FreeBSD:
@@ -318,6 +333,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
if (Triple.isOSDarwin())
return new DarwinPPC32TargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS PPC32
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<PPC32TargetInfo>(Triple, Opts);
case llvm::Triple::Linux:
return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts);
case llvm::Triple::FreeBSD:
@@ -338,6 +358,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
if (Triple.isOSDarwin())
return new DarwinPPC64TargetInfo(Triple, Opts);
switch (os) {
+ // FIXME:
+ // Needs to be tested before inclusion!!!
+ // New Target AROS PPC64
+ // case llvm::Triple::AROS:
+ // return new AROSTargetInfo<PPC64TargetInfo>(Triple, Opts);
case llvm::Triple::Linux:
return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
case llvm::Triple::Lv2:
@@ -469,6 +494,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
switch (os) {
case llvm::Triple::Ananas:
return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts);
+ // FIXME:
+ // Needs to be tested!!!
+ // New Target AROS X86_32
+ case llvm::Triple::AROS:
+ return new AROSTargetInfo<X86_32TargetInfo>(Triple, Opts);
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts);
case llvm::Triple::Linux: {
@@ -528,6 +558,11 @@ TargetInfo *AllocateTarget(const llvm::Triple &Triple,
switch (os) {
case llvm::Triple::Ananas:
return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts);
+ // FIXME:
+ // Needs to be tested!!!
+ // New Target AROS X86_64
+ case llvm::Triple::AROS:
+ return new AROSTargetInfo<X86_64TargetInfo>(Triple, Opts);
case llvm::Triple::CloudABI:
return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts);
case llvm::Triple::Linux: {
diff --git a/clang/lib/Basic/Targets/OSTargets.h b/clang/lib/Basic/Targets/OSTargets.h
index 7445dbe72794..4087ed490cae 100644
--- a/clang/lib/Basic/Targets/OSTargets.h
+++ b/clang/lib/Basic/Targets/OSTargets.h
@@ -71,6 +71,26 @@ public:
: OSTargetInfo<Target>(Triple, Opts) {}
};
+// AROS target
+template <typename Target>
+class LLVM_LIBRARY_VISIBILITY AROSTargetInfo : public OSTargetInfo<Target> {
+protected:
+ void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
+ MacroBuilder &Builder) const override {
+ // FIXME:
+ // Are these Macros correct ???
+ // AROS defines
+ Builder.defineMacro("__AROS__");
+ Builder.defineMacro("__ELF__");
+ }
+
+public:
+ // FIXME:
+ // Is this correct ???
+ AROSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
+ : OSTargetInfo<Target>(Triple, Opts) {}
+};
+
void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
const llvm::Triple &Triple, StringRef &PlatformName,
VersionTuple &PlatformMinVersion);
diff --git a/clang/lib/Driver/CMakeLists.txt b/clang/lib/Driver/CMakeLists.txt
index aeffcf0bb43a..7447fb77a6eb 100644
--- a/clang/lib/Driver/CMakeLists.txt
+++ b/clang/lib/Driver/CMakeLists.txt
@@ -36,6 +36,7 @@ add_clang_library(clangDriver
ToolChains/AIX.cpp
ToolChains/Ananas.cpp
ToolChains/AMDGPU.cpp
+ ToolChains/AROS.cpp
ToolChains/AVR.cpp
ToolChains/BareMetal.cpp
ToolChains/Clang.cpp
diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp
index bcea01126e0d..4beedb9acc51 100644
--- a/clang/lib/Driver/Driver.cpp
+++ b/clang/lib/Driver/Driver.cpp
@@ -10,6 +10,7 @@
#include "InputInfo.h"
#include "ToolChains/AIX.h"
#include "ToolChains/AMDGPU.h"
+#include "ToolChains/AROS.h"
#include "ToolChains/AVR.h"
#include "ToolChains/Ananas.h"
#include "ToolChains/BareMetal.h"
@@ -5069,6 +5070,9 @@ const ToolChain &Driver::getToolChain(const ArgList &Args,
case llvm::Triple::Ananas:
TC = std::make_unique<toolchains::Ananas>(*this, Target, Args);
break;
+ case llvm::Triple::AROS:
+ TC = std::make_unique<toolchains::AROSToolChain>(*this, Target, Args);
+ break;
case llvm::Triple::CloudABI:
TC = std::make_unique<toolchains::CloudABI>(*this, Target, Args);
break;
diff --git a/clang/lib/Driver/ToolChains/AROS.cpp b/clang/lib/Driver/ToolChains/AROS.cpp
new file mode 100644
index 000000000000..0c9776be413e
--- /dev/null
+++ b/clang/lib/Driver/ToolChains/AROS.cpp
@@ -0,0 +1,326 @@
+//===--- AROS.cpp - AROS Tool Chain -------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "AROS.h"
+#include "InputInfo.h"
+#include "CommonArgs.h"
+#include "clang/Config/config.h"
+#include "clang/Driver/Compilation.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Driver/Options.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+using namespace clang::driver;
+using namespace clang::driver::tools;
+using namespace clang::driver::toolchains;
+using namespace clang;
+using namespace llvm::opt;
+
+
+void
+AROS::Assembler::ConstructJob(Compilation &C,
+ const JobAction &JA,
+ const InputInfo &Output,
+ const InputInfoList &Inputs,
+ const ArgList &Args,
+ const char *LinkingOutput) const {
+ claimNoWarnArgs(Args);
+ ArgStringList CmdArgs;
+
+ Args.AddAllArgValues(CmdArgs,
+ options::OPT_Wa_COMMA,
+ options::OPT_Xassembler);
+
+ CmdArgs.push_back("-o");
+ CmdArgs.push_back(Output.getFilename());
+
+ for (const auto &II : Inputs)
+ CmdArgs.push_back(II.getFilename());
+
+ const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+ C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
+}
+
+void
+AROS::Linker::ConstructJob(Compilation &C,
+ const JobAction &JA,
+ const InputInfo &Output,
+ const InputInfoList &Inputs,
+ const ArgList &Args,
+ const char *LinkingOutput) const {
+ const toolchains::AROSToolChain &AROSTC =
+ static_cast<const toolchains::AROSToolChain &>(getToolChain());
+ const char *Exec = Args.MakeArgString(AROSTC.GetLinkerPath());
+ const Driver &D = AROSTC.getDriver();
+ const std::string &SysRoot = D.SysRoot;
+ ArgStringList CmdArgs;
+
+ if (llvm::sys::path::filename(Exec) == "lld") {
+ CmdArgs.push_back("-flavor");
+ CmdArgs.push_back("gnu");
+ if (!D.SysRoot.empty())
+ CmdArgs.push_back(Args.MakeArgString("--sysroot=" + SysRoot));
+ }
+
+ // When building 32-bit code on AROS/pc64,
+ // we have to explicitly instruct ld in
+ // the base system to link 32-bit code.
+ if (AROSTC.getArch() == llvm::Triple::x86) {
+ CmdArgs.push_back("-m");
+ CmdArgs.push_back("elf_i386");
+ }
+
+ if (Output.isFilename()) {
+ CmdArgs.push_back("-o");
+ CmdArgs.push_back(Output.getFilename());
+ } else {
+ assert(Output.isNothing() && "Invalid output.");
+ }
+
+ AROSTC.addStartObjectFileArgs(Args, CmdArgs);
+
+ Args.AddAllArgs(CmdArgs,
+ {options::OPT_L,
+ options::OPT_T_Group,
+ options::OPT_e});
+
+ AddLinkerInputs(AROSTC, Inputs, Args, CmdArgs, JA);
+
+ if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
+ SmallString<128> LibPath(SysRoot);
+ llvm::sys::path::append(LibPath, "lib");
+ CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
+
+ if (D.CCCIsCXX()) {
+ AROSTC.AddCXXStdlibLibArgs(Args, CmdArgs);
+ CmdArgs.push_back("-lpthread");
+ }
+ CmdArgs.push_back("--start-group");
+ CmdArgs.push_back("-lmui");
+ CmdArgs.push_back("-larossupport");
+ CmdArgs.push_back("-lamiga");
+ if (!Args.hasArg(options::OPT_nostartfiles)) {
+ if (!Args.hasArg(options::OPT_static)) {
+ if (!Args.hasArg(options::OPT_no_stdc)) {
+ if (!Args.hasArg(options::OPT_no_posixc)) {
+ CmdArgs.push_back("-lposixc");
+ }
+
+ CmdArgs.push_back("-lstdcio");
+ CmdArgs.push_back("-lstdc");
+ }// OPT_no_stdc endif
+ } else {
+ if (!Args.hasArg(options::OPT_no_stdc)) {
+ CmdArgs.push_back("-lstdc.static");
+ }
+ }// OPT_static endif
+ }// OPT_nostartfiles endif
+ CmdArgs.push_back("-lcodesets");
+ CmdArgs.push_back("-lkeymap");
+ CmdArgs.push_back("-lexpansion");
+ CmdArgs.push_back("-lcommodities");
+ CmdArgs.push_back("-ldiskfont");
+ CmdArgs.push_back("-lasl");
+ CmdArgs.push_back("-lmuimaster");
+ CmdArgs.push_back("-ldatatypes");
+ CmdArgs.push_back("-lcybergraphics");
+ CmdArgs.push_back("-lworkbench");
+ CmdArgs.push_back("-licon");
+ CmdArgs.push_back("-lintuition");
+ CmdArgs.push_back("-lgadtools");
+ CmdArgs.push_back("-llayers");
+ CmdArgs.push_back("-laros");
+ CmdArgs.push_back("-lpartition");
+ CmdArgs.push_back("-liffparse");
+ CmdArgs.push_back("-lgraphics");
+ CmdArgs.push_back("-llocale");
+ CmdArgs.push_back("-ldos");
+ CmdArgs.push_back("-lutility");
+ CmdArgs.push_back("-loop");
+ if (!Args.hasArg(options::OPT_nosysbase)) {
+ CmdArgs.push_back("-lexec");
+ }
+ CmdArgs.push_back("-lautoinit");
+ CmdArgs.push_back("-llibinit");
+ if (Args.hasArg(options::OPT_nostartfiles)) {
+ if (!Args.hasArg(options::OPT_no_stdc)) {
+ CmdArgs.push_back("-lstdc.static");
+ }
+ }// 2nd OPT_nostartfiles endif
+ CmdArgs.push_back("--end-group");
+ }
+
+ C.addCommand(std::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
+}
+
+
+//------------------------------------------------------------------------------------------------------//
+
+
+AROSToolChain::AROSToolChain(const Driver &D,
+ const llvm::Triple &Triple,
+ const llvm::opt::ArgList &Args)
+ : Generic_ELF(D, Triple, Args) {
+ if (GetCXXStdlibType(Args) == ToolChain::CST_Libstdcxx) {
+
+ }
+
+ // FIXME:
+ // Now declared in AROS.h with the function getDefaultLinker() ???
+ // Is this the correct way to implement this ???
+ // This is an unused variable in clang 7 Driver. Delete this ???
+ // Use LLD by default.
+ // DefaultLinker = "collect-aros";
+
+
+}
+
+#if (0)
+bool AROSToolChain::IsUnwindTablesDefault() const {
+ // FIXME:
+
+ // all non-x86 targets need unwind tables, however,
+ // LLVM currently does not know how to emit them.
+
+ // FIXME:
+ // Is this the correct implementation of this function ???
+// bool AROSToolChain::IsUnwindTablesDefault(const ArgList &Args) const {
+ //// Unwind tables are not emitted if -fno-exceptions
+ //// is supplied (except when targeting x86_64).
+ //return getArch() == llvm::Triple::x86_64 ||
+ // (GetExceptionModel(Args) != llvm::ExceptionHandling::SjLj &&
+ // Args.hasFlag(options::OPT_fexceptions,
+ // options::OPT_fno_exceptions,
+ // true));
+
+ return getArch() == llvm::Triple::x86_64;
+}
+
+bool AROSToolChain::isPICDefault() const {
+ return getArch() == llvm::Triple::x86_64;
+}
+
+bool AROSToolChain::isPIEDefault() const {
+ return getArch() == llvm::Triple::x86_64;
+}
+
+bool AROSToolChain::isPICDefaultForced() const {
+ return getArch() == llvm::Triple::x86_64;
+}
+#endif
+
+void AROSToolChain::
+AddAROSSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ const Driver &D = getDriver();
+ const std::string &SysRoot = D.SysRoot;
+
+ if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
+ addSystemInclude(DriverArgs, CC1Args, SysRoot "/include");
+ if (!DriverArgs.hasArg(options::OPT_no_posixc)) {
+ SmallString<128> ResourceDir(SysRoot);
+ llvm::sys::path::append(ResourceDir, "include/aros/posixc");
+ addSystemInclude(DriverArgs, CC1Args, ResourceDir);
+ }// OPT_no_posixc endif
+ if (!DriverArgs.hasArg(options::OPT_no_stdc)) {
+ SmallString<128> ResourceDir(SysRoot);
+ llvm::sys::path::append(ResourceDir, "include/aros/stdc");
+ addSystemInclude(DriverArgs, CC1Args, ResourceDir);
+ }// OPT_no_stdc endif
+ }// OPT_nobuiltininc endif
+}
+
+void AROSToolChain::
+AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ if (DriverArgs.hasArg(options::OPT_nostdlibinc))
+ return;
+
+ AddAROSSystemIncludeArgs(DriverArgs, CC1Args);
+}
+
+void AROSToolChain::
+addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args,
+ Action::OffloadKind DeviceOffloadingKind) const {
+ CC1Args.push_back("-D__AROS__");
+ CC1Args.push_back("-D__AROS");
+ CC1Args.push_back("-DAROS");
+ CC1Args.push_back("-D__AMIGA__");
+ CC1Args.push_back("-D_AMIGA");
+ CC1Args.push_back("-DAMIGA");
+ CC1Args.push_back("-D__ELF__");
+ CC1Args.push_back("-Dsystem=posix");
+}
+
+
+void AROSToolChain::
+AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ if (DriverArgs.hasArg(options::OPT_nostdlibinc) ||
+ DriverArgs.hasArg(options::OPT_nostdincxx))
+ return;
+
+ switch (GetCXXStdlibType(DriverArgs)) {
+ case ToolChain::CST_Libcxx:
+ AddAROSSystemIncludeArgs(DriverArgs, CC1Args);
+ break;
+
+ case ToolChain::CST_Libstdcxx:
+ AddAROSSystemIncludeArgs(DriverArgs, CC1Args);
+ break;
+ }
+}
+
+void AROSToolChain::
+AddCXXStdlibLibArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const {
+ switch (GetCXXStdlibType(DriverArgs)) {
+ case ToolChain::CST_Libcxx:
+ CC1Args.push_back("-lc++");
+ break;
+ case ToolChain::CST_Libstdcxx:
+ CC1Args.push_back("-lstdc++");
+ break;
+ }
+}
+
+void AROSToolChain::
+addStartObjectFileArgs(const llvm::opt::ArgList &Args,
+ llvm::opt::ArgStringList &CmdArgs) const {
+ if (Args.hasArg(options::OPT_nostartfiles))
+ return;
+
+ const Driver &D = getDriver();
+ const std::string &SysRoot = D.SysRoot;
+ SmallString<128> LibPath(SysRoot);
+ llvm::sys::path::append(LibPath, "lib/");
+
+ // Derived from startfile spec.
+ CmdArgs.push_back(Args.MakeArgString(LibPath + "startup.o"));
+ if (Args.hasArg(options::OPT_detach)) {
+ CmdArgs.push_back(Args.MakeArgString(LibPath + "detach.o"));
+ }
+ if (Args.hasArg(options::OPT_nix)) {
+ CmdArgs.push_back(Args.MakeArgString(LibPath + "nixmain.o"));
+ }
+}
+
+
+Tool *AROSToolChain::buildAssembler() const {
+ return new tools::AROS::Assembler(*this);
+}
+
+Tool *AROSToolChain::buildLinker() const {
+ return new tools::AROS::Linker(*this);
+}
diff --git a/clang/lib/Driver/ToolChains/AROS.h b/clang/lib/Driver/ToolChains/AROS.h
new file mode 100644
index 000000000000..a7f825ba8b6a
--- /dev/null
+++ b/clang/lib/Driver/ToolChains/AROS.h
@@ -0,0 +1,98 @@
+//===--- AROS.h - AROS ToolChain Implementations ----------*- C -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AROS_H
+#define LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AROS_H
+
+#include "Gnu.h"
+#include "clang/Driver/Tool.h"
+#include "clang/Driver/ToolChain.h"
+
+namespace clang {
+namespace driver {
+namespace tools {
+
+/// AROS -- Directly call GNU Binutils assembler and linker
+namespace AROS {
+class LLVM_LIBRARY_VISIBILITY Assembler : public GnuTool {
+public:
+ Assembler(const ToolChain &TC)
+ : GnuTool("AROS::Assembler", "assembler", 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 Linker : public GnuTool {
+public:
+ Linker(const ToolChain &TC)
+ : GnuTool("AROS::Linker", "linker", 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 AROS
+} // end namespace tools
+
+namespace toolchains {
+// FIXME:
+// AROS - The base AROS tool chain. I changed it to => (Generic_ELF)
+// Should it be changed back to => Generic_GCC ???
+class LLVM_LIBRARY_VISIBILITY AROSToolChain : public Generic_ELF {
+public:
+ AROSToolChain(const Driver &D,
+ const llvm::Triple &Triple,
+ const llvm::opt::ArgList &Args);
+
+ void AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const override;
+
+ void addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args,
+ Action::OffloadKind DeviceOffloadKind) const override;
+
+ void AddClangCXXStdlibIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const override;
+
+ void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
+ llvm::opt::ArgStringList &CmdArgs) const override;
+
+ void addStartObjectFileArgs(const llvm::opt::ArgList &Args,
+ llvm::opt::ArgStringList &CmdArgs) const;
+ // FIXME:
+ // Is this the correct use of this function in this header?
+ // Moved from AROS.cpp as it was an unused variable "DefaultLinker=collect-aros"
+ // Should "ld.lld" be declare here ???
+ // Use LLD by default.? "ld.lld" ???
+ const char *getDefaultLinker() const override { return "collect-aros"; }
+
+private:
+ void AddAROSSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+ llvm::opt::ArgStringList &CC1Args) const;
+
+protected:
+ Tool *buildAssembler() const override;
+ Tool *buildLinker() const override;
+};
+
+
+} // end namespace toolchains
+} // end namespace driver
+} // end namespace clang
+
+#endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_AROS_H
diff --git a/clang/lib/Frontend/InitHeaderSearch.cpp b/clang/lib/Frontend/InitHeaderSearch.cpp
index bc31445d6d08..e98b57a857df 100644
--- a/clang/lib/Frontend/InitHeaderSearch.cpp
+++ b/clang/lib/Frontend/InitHeaderSearch.cpp
@@ -221,6 +221,11 @@ void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple,
if (HSOpts.UseStandardSystemIncludes) {
switch (os) {
+ case llvm::Triple::AROS:
+ // FIXME:
+ // Fill this in with your default include paths...
+ // AddPath("??/??/??/??", System, false);
+ // AddPath("/usr/include", System, false);
case llvm::Triple::CloudABI:
case llvm::Triple::FreeBSD:
case llvm::Triple::NetBSD:
@@ -333,6 +338,7 @@ void InitHeaderSearch::AddDefaultCIncludePaths(const llvm::Triple &triple,
}
switch (os) {
+ case llvm::Triple::AROS:
case llvm::Triple::CloudABI:
case llvm::Triple::RTEMS:
case llvm::Triple::NaCl:

44
tools/crosstools/llvm/llvm-10.0.1.src-aros.diff Normal file
View File

@ -0,0 +1,44 @@
diff --git a/include/llvm/ADT/Triple.h b/include/llvm/ADT/Triple.h
index a00b3b2495..062dbab6e1 100644
--- a/include/llvm/ADT/Triple.h
+++ b/include/llvm/ADT/Triple.h
@@ -159,6 +159,7 @@ public:
UnknownOS,
Ananas,
+ AROS,
CloudABI,
Darwin,
DragonFly,
@@ -450,6 +451,11 @@ public:
return isOSVersionLT(Minor + 4, Micro, 0);
}
+ /// Is this an AROS triple.
+ bool isAROS() const {
+ return getOS() == Triple::AROS;
+ }
+
/// isMacOSX - Is this a Mac OS X triple. For legacy reasons, we support both
/// "darwin" and "osx" as OS X triples.
bool isMacOSX() const {
diff --git a/lib/Support/Triple.cpp b/lib/Support/Triple.cpp
index da6b877a85..8c7f36c72b 100644
--- a/lib/Support/Triple.cpp
+++ b/lib/Support/Triple.cpp
@@ -186,6 +186,7 @@ StringRef Triple::getOSTypeName(OSType Kind) {
case AMDHSA: return "amdhsa";
case AMDPAL: return "amdpal";
case Ananas: return "ananas";
+ case AROS: return "aros";
case CNK: return "cnk";
case CUDA: return "cuda";
case CloudABI: return "cloudabi";
@@ -488,6 +489,7 @@ static Triple::VendorType parseVendor(StringRef VendorName) {
static Triple::OSType parseOS(StringRef OSName) {
return StringSwitch<Triple::OSType>(OSName)
.StartsWith("ananas", Triple::Ananas)
+ .StartsWith("aros", Triple::AROS)
.StartsWith("cloudabi", Triple::CloudABI)
.StartsWith("darwin", Triple::Darwin)
.StartsWith("dragonfly", Triple::DragonFly)

44
tools/crosstools/llvm/llvm-10.0.1rc1.src-aros.diff Normal file
View File

@ -0,0 +1,44 @@
diff --git a/include/llvm/ADT/Triple.h b/include/llvm/ADT/Triple.h
index a00b3b2495..062dbab6e1 100644
--- a/include/llvm/ADT/Triple.h
+++ b/include/llvm/ADT/Triple.h
@@ -159,6 +159,7 @@ public:
UnknownOS,
Ananas,
+ AROS,
CloudABI,
Darwin,
DragonFly,
@@ -450,6 +451,11 @@ public:
return isOSVersionLT(Minor + 4, Micro, 0);
}
+ /// Is this an AROS triple.
+ bool isAROS() const {
+ return getOS() == Triple::AROS;
+ }
+
/// isMacOSX - Is this a Mac OS X triple. For legacy reasons, we support both
/// "darwin" and "osx" as OS X triples.
bool isMacOSX() const {
diff --git a/lib/Support/Triple.cpp b/lib/Support/Triple.cpp
index da6b877a85..8c7f36c72b 100644
--- a/lib/Support/Triple.cpp
+++ b/lib/Support/Triple.cpp
@@ -186,6 +186,7 @@ StringRef Triple::getOSTypeName(OSType Kind) {
case AMDHSA: return "amdhsa";
case AMDPAL: return "amdpal";
case Ananas: return "ananas";
+ case AROS: return "aros";
case CNK: return "cnk";
case CUDA: return "cuda";
case CloudABI: return "cloudabi";
@@ -488,6 +489,7 @@ static Triple::VendorType parseVendor(StringRef VendorName) {
static Triple::OSType parseOS(StringRef OSName) {
return StringSwitch<Triple::OSType>(OSName)
.StartsWith("ananas", Triple::Ananas)
+ .StartsWith("aros", Triple::AROS)
.StartsWith("cloudabi", Triple::CloudABI)
.StartsWith("darwin", Triple::Darwin)
.StartsWith("dragonfly", Triple::DragonFly)

44
tools/crosstools/llvm/llvm-11.0.0.src-aros.diff Normal file
View File

@ -0,0 +1,44 @@
diff --git a/include/llvm/ADT/Triple.h b/include/llvm/ADT/Triple.h
index 6bad18f19244..78c8bd9a9316 100644
--- a/include/llvm/ADT/Triple.h
+++ b/include/llvm/ADT/Triple.h
@@ -161,6 +161,7 @@ public:
UnknownOS,
Ananas,
+ AROS,
CloudABI,
Darwin,
DragonFly,
@@ -448,6 +449,11 @@ public:
return getOS() == Triple::Darwin || getOS() == Triple::MacOSX;
}
+ /// Is this an AROS triple.
+ bool isAROS() const {
+ return getOS() == Triple::AROS;
+ }
+
/// Is this an iOS triple.
/// Note: This identifies tvOS as a variant of iOS. If that ever
/// changes, i.e., if the two operating systems diverge or their version
diff --git a/lib/Support/Triple.cpp b/lib/Support/Triple.cpp
index fec1985ccaca..70aeac1239ec 100644
--- a/lib/Support/Triple.cpp
+++ b/lib/Support/Triple.cpp
@@ -188,6 +188,7 @@ StringRef Triple::getOSTypeName(OSType Kind) {
case AMDPAL: return "amdpal";
case Ananas: return "ananas";
case CNK: return "cnk";
+ case AROS: return "aros";
case CUDA: return "cuda";
case CloudABI: return "cloudabi";
case Contiki: return "contiki";
@@ -489,6 +490,7 @@ static Triple::VendorType parseVendor(StringRef VendorName) {
static Triple::OSType parseOS(StringRef OSName) {
return StringSwitch<Triple::OSType>(OSName)
.StartsWith("ananas", Triple::Ananas)
+ .StartsWith("aros", Triple::AROS)
.StartsWith("cloudabi", Triple::CloudABI)
.StartsWith("darwin", Triple::Darwin)
.StartsWith("dragonfly", Triple::DragonFly)

44
tools/crosstools/llvm/llvm-11.0.1.src-aros.diff Normal file
View File

@ -0,0 +1,44 @@
diff --git a/llvm/include/llvm/ADT/Triple.h b/llvm/include/llvm/ADT/Triple.h
index 6bfdfe691c2e..1f7f0127c1fd 100644
--- a/llvm/include/llvm/ADT/Triple.h
+++ b/llvm/include/llvm/ADT/Triple.h
@@ -160,6 +160,7 @@ public:
UnknownOS,
Ananas,
+ AROS,
CloudABI,
Darwin,
DragonFly,
@@ -448,6 +449,11 @@ public:
return getOS() == Triple::Darwin || getOS() == Triple::MacOSX;
}
+ /// Is this an AROS triple.
+ bool isAROS() const {
+ return getOS() == Triple::AROS;
+ }
+
/// Is this an iOS triple.
/// Note: This identifies tvOS as a variant of iOS. If that ever
/// changes, i.e., if the two operating systems diverge or their version
diff --git a/llvm/lib/Support/Triple.cpp b/llvm/lib/Support/Triple.cpp
index b1b4c3e63481..e4d8611d09af 100644
--- a/llvm/lib/Support/Triple.cpp
+++ b/llvm/lib/Support/Triple.cpp
@@ -187,6 +187,7 @@ StringRef Triple::getOSTypeName(OSType Kind) {
case AMDHSA: return "amdhsa";
case AMDPAL: return "amdpal";
case Ananas: return "ananas";
+ case AROS: return "aros";
case CUDA: return "cuda";
case CloudABI: return "cloudabi";
case Contiki: return "contiki";
@@ -489,6 +490,7 @@ static Triple::VendorType parseVendor(StringRef VendorName) {
static Triple::OSType parseOS(StringRef OSName) {
return StringSwitch<Triple::OSType>(OSName)
.StartsWith("ananas", Triple::Ananas)
+ .StartsWith("aros", Triple::AROS)
.StartsWith("cloudabi", Triple::CloudABI)
.StartsWith("darwin", Triple::Darwin)
.StartsWith("dragonfly", Triple::DragonFly)

30
tools/crosstools/llvm/mmakefile.src
View File

@ -13,12 +13,14 @@ endif
USER_CXXFLAGS := -std=c++11
LLVM_REPOSITORY := http://llvm.org/releases/$(LLVM_VERSION)
LLVM_ARCHBASE := llvm-$(LLVM_VERSION).src
LLVMLLD_ARCHBASE := lld-$(LLVM_VERSION).src
CLANG_ARCHBASE := cfe-$(LLVM_VERSION).src
LIBCXX_ARCHBASE := libcxx-$(LLVM_VERSION).src
LIBCXXABI_ARCHBASE := libcxxabi-$(LLVM_VERSION).src
LLVM_REPOSITORY :=https://github.com/llvm/llvm-project/releases/download/llvmorg-$(LLVM_VERSION)$(LLVM_REPO)
LLVM_ARCHBASE :=llvm-$(LLVM_VERSION)$(LLVM_RELEASE).src
LLVMLLD_ARCHBASE :=lld-$(LLVM_VERSION)$(LLVM_RELEASE).src
CLANG_ARCHBASE :=$(CLANG_NAME)-$(LLVM_VERSION)$(LLVM_RELEASE).src
LIBCXX_ARCHBASE :=libcxx-$(LLVM_VERSION)$(LLVM_RELEASE).src
LIBCXXABI_ARCHBASE :=libcxxabi-$(LLVM_VERSION)$(LLVM_RELEASE).src
#LLVM_ALL_TARGETS := yes
@ -49,26 +51,14 @@ LLVM_CMAKEOPTIONS := \
-DLLVM_TARGETS_TO_BUILD=$(LLVM_TARGETS) \
-DLLVM_DEFAULT_TARGET_TRIPLE=$(AROS_TARGET_CPU)-unknown-aros \
-DLLVM_ENABLE_DOXYGEN=OFF \
-DLLDB_DISABLE_LIBEDIT=ON \
-DLLDB_DISABLE_CURSES=ON \
-DLLDB_DISABLE_PYTHON=ON \
-DLLVM_ENABLE_TERMINFO=OFF \
-DLLVM_BUILD_RUNTIME=OFF \
-DLLVM_ENABLE_ASSERTIONS=OFF \
-DLLVM_ENABLE_BINDINGS=OFF \
-DLLVM_INCLUDE_TESTS=OFF \
-DLLVM_INCLUDE_EXAMPLES=OFF \
-DLLVM_INCLUDE_BENCHMARKS=OFF \
-DLLVM_OPTIMIZED_TABLEGEN=ON \
-DLLVM_ENABLE_LTO=ON \
-DLLVM_INSTALL_TOOLCHAIN_ONLY=ON \
-DLLVM_ENABLE_PROJECTS="clang;libcxx;libcxxabi;lld" \
-DLIBCXX_ENABLE_SHARED=OFF \
-DLIBCXX_ENABLE_STATIC=ON \
-DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON \
-DLIBCXX_ENABLE_ASSERTIONS=OFF \
-DLIBCXX_INCLUDE_TESTS=OFF \
-DLIBCXX_INCLUDE_BENCHMARKS=OFF
-DLLVM_INCLUDE_BENCHMARKS=OFF
# TODO: Should be disabled for AROS "host"
LLVM_CMAKEOPTIONS += -DBUILD_SHARED_LIBS=ON