Add foot target skeleton

clang/lib/Basic/CMakeLists.txt

@@ -103,6 +103,7 @@ add_clang_library(clangBasic
   Targets/BPF.cpp
   Targets/CSKY.cpp
   Targets/DirectX.cpp
+  Targets/Foot.cpp
   Targets/Hexagon.cpp
   Targets/Lanai.cpp
   Targets/LoongArch.cpp

clang/lib/Basic/Targets.cpp

@@ -21,6 +21,7 @@
 #include "Targets/BPF.h"
 #include "Targets/CSKY.h"
 #include "Targets/DirectX.h"
+#include "Targets/Foot.h"
 #include "Targets/Hexagon.h"
 #include "Targets/Lanai.h"
 #include "Targets/LoongArch.h"
@@ -122,6 +123,9 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple,
   case llvm::Triple::xcore:
     return std::make_unique<XCoreTargetInfo>(Triple, Opts);
 
+  case llvm::Triple::foot:
+    return std::make_unique<FootTargetInfo>(Triple, Opts);
+
   case llvm::Triple::hexagon:
     if (os == llvm::Triple::Linux &&
         Triple.getEnvironment() == llvm::Triple::Musl)

clang/lib/Basic/Targets/Foot.cpp

@@ -0,0 +1,57 @@
+#include "Foot.h"
+
+#include "clang/Basic/MacroBuilder.h"
+
+static const char* FootDataLayoutStr =
+  "e-"
+  "p:16:32-"
+  "n8:16:32-"
+  "i64:64:64-i32:32:32-i16:16:32-"
+  "f32:32:32-"
+  "v32:32:32";
+
+namespace clang {
+namespace targets {
+
+FootTargetInfo::FootTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
+    : TargetInfo(Triple) {
+  resetDataLayout(FootDataLayoutStr);
+}
+
+void FootTargetInfo::getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const
+{
+  Builder.defineMacro("__foot__");
+}
+
+SmallVector<Builtin::InfosShard> FootTargetInfo::getTargetBuiltins() const
+{
+  return {};
+}
+
+TargetInfo::BuiltinVaListKind FootTargetInfo::getBuiltinVaListKind() const
+{
+  return BuiltinVaListKind::VoidPtrBuiltinVaList;
+}
+
+bool FootTargetInfo::validateAsmConstraint(const char *&Name, ConstraintInfo &info) const
+{
+  return true;
+}
+
+std::string_view FootTargetInfo::getClobbers() const
+{
+  return "";
+}
+
+ArrayRef<const char *> FootTargetInfo::getGCCRegNames() const
+{
+  return {};
+}
+
+ArrayRef<TargetInfo::GCCRegAlias> FootTargetInfo::getGCCRegAliases() const
+{
+  return {};
+}
+
+} // namespace targets
+} // namespace clang

clang/lib/Basic/Targets/Foot.h

@@ -0,0 +1,27 @@
+#ifndef CLANG_LIB_BASIC_TARGETS_FOOT_FOOT_H
+#define CLANG_LIB_BASIC_TARGETS_FOOT_FOOT_H
+
+#include "clang/Basic/TargetInfo.h"
+
+namespace clang {
+namespace targets {
+
+class LLVM_LIBRARY_VISIBILITY FootTargetInfo : public TargetInfo
+{
+public:
+  FootTargetInfo(const llvm::Triple &Triple, const TargetOptions &);
+  void getTargetDefines(const LangOptions &Opts, MacroBuilder &Builder) const override;
+  SmallVector<Builtin::InfosShard> getTargetBuiltins() const override;
+  BuiltinVaListKind getBuiltinVaListKind() const override;
+  bool validateAsmConstraint(const char *&Name, ConstraintInfo &info) const override;
+  std::string_view getClobbers() const override;
+
+protected:
+  ArrayRef<const char *> getGCCRegNames() const override;
+  ArrayRef<GCCRegAlias> getGCCRegAliases() const override;
+};
+
+} // namespace targets
+} // namespace clang
+
+#endif // CLANG_LIB_BASIC_TARGETS_FOOT_FOOT_H

llvm/CMakeLists.txt

@@ -533,6 +533,7 @@ set(LLVM_ALL_TARGETS
   ARM
   AVR
   BPF
+  Foot
   Hexagon
   Lanai
   LoongArch

llvm/include/llvm/TargetParser/Triple.h

@@ -60,6 +60,7 @@ public:
     bpfeb,       // eBPF or extended BPF or 64-bit BPF (big endian)
     csky,        // CSKY: csky
     dxil,        // DXIL 32-bit DirectX bytecode
+    foot,        // foot: foot
     hexagon,     // Hexagon: hexagon
     loongarch32, // LoongArch (32-bit): loongarch32
     loongarch64, // LoongArch (64-bit): loongarch64

llvm/lib/Target/Foot/CMakeLists.txt

@@ -0,0 +1,17 @@
+add_llvm_component_group(Foot)
+
+add_llvm_target(FootCodeGen
+  FootTargetMachine.cpp
+
+  LINK_COMPONENTS
+  FootDesc
+  FootInfo
+  CodeGen
+  Support
+
+  ADD_TO_COMPONENT
+  Foot
+)
+
+add_subdirectory(MCTargetDesc)
+add_subdirectory(TargetInfo)

llvm/lib/Target/Foot/FootTargetInfo.h

@@ -0,0 +1,12 @@
+#ifndef LLVM_LIB_TARGET_FOOT_TARGETINFO_FOOTTARGETINFO_H
+#define LLVM_LIB_TARGET_FOOT_TARGETINFO_FOOTTARGETINFO_H
+
+namespace llvm {
+
+class Target;
+
+Target &getTheFootTarget();
+
+} // namespace llvm
+
+#endif // LLVM_LIB_TARGET_FOOT_TARGETINFO_FOOTTARGETINFO_H

llvm/lib/Target/Foot/FootTargetMachine.cpp

@@ -0,0 +1,32 @@
+#include "FootTargetMachine.h"
+#include "FootTargetInfo.h"
+#include "llvm/MC/TargetRegistry.h"
+using namespace llvm;
+
+static const char* FootDataLayoutStr =
+  "e-"
+  "p:16:32-"
+  "n8:16:32-"
+  "i64:64:64-i32:32:32-i16:16:32-"
+  "f32:32:32-"
+  "v32:32:32";
+
+namespace llvm {
+
+FootTargetMachine::FootTargetMachine(const Target &T, const Triple &TT,
+                                    StringRef CPU, StringRef FS,
+                                    const TargetOptions &Options,
+                                    std::optional<Reloc::Model> RM,
+                                    std::optional<CodeModel::Model> CM,
+                                    CodeGenOptLevel OL,
+                                    bool JIT)
+  : CodeGenTargetMachineImpl(T, FootDataLayoutStr, TT, CPU, FS, Options, RM ? *RM : Reloc::Static, CM ? *CM : CodeModel::Small, OL) {}
+
+FootTargetMachine::~FootTargetMachine() = default;
+
+} // namespace llvm
+
+extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeFootTarget()
+{
+  RegisterTargetMachine<FootTargetMachine> X(getTheFootTarget());
+}

llvm/lib/Target/Foot/FootTargetMachine.h

@@ -0,0 +1,22 @@
+#ifndef LLVM_LIB_TARGET_FOOT_FOOTTARGETMACHINE_H
+#define LLVM_LIB_TARGET_FOOT_FOOTTARGETMACHINE_H
+
+#include "llvm/CodeGen/CodeGenTargetMachineImpl.h"
+
+namespace llvm {
+
+class FootTargetMachine : public CodeGenTargetMachineImpl {
+public:
+  FootTargetMachine(const Target &T, const Triple &TT,
+                    StringRef CPU, StringRef FS,
+                    const TargetOptions &Options,
+                    std::optional<Reloc::Model> RM,
+                    std::optional<CodeModel::Model> CM,
+                    CodeGenOptLevel OL,
+                    bool JIT);
+  ~FootTargetMachine() override;
+};
+
+} // namespace llvm
+
+#endif // LLVM_LIB_TARGET_FOOT_FOOTTARGETMACHINE_H

llvm/lib/Target/Foot/MCTargetDesc/CMakeLists.txt

@@ -0,0 +1,9 @@
+add_llvm_component_library(LLVMFootDesc
+  FootTargetDesc.cpp
+
+  LINK_COMPONENTS
+  Support
+
+  ADD_TO_COMPONENT
+  Foot
+)

llvm/lib/Target/Foot/MCTargetDesc/FootTargetDesc.cpp

@@ -0,0 +1,5 @@
+#include "llvm/Support/Compiler.h"
+
+extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeFootTargetMC()
+{
+}

llvm/lib/Target/Foot/TargetInfo/CMakeLists.txt

@@ -0,0 +1,10 @@
+add_llvm_component_library(LLVMFootInfo
+  FootTargetInfo.cpp
+
+  LINK_COMPONENTS
+  Support
+  MC
+
+  ADD_TO_COMPONENT
+  Foot
+)

llvm/lib/Target/Foot/TargetInfo/FootTargetInfo.cpp

@@ -0,0 +1,16 @@
+#include "FootTargetInfo.h"
+#include "llvm/MC/TargetRegistry.h"
+using namespace llvm;
+
+extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeFootTargetInfo() {
+  RegisterTarget<Triple::foot, /*HasJIT=*/ false> X(
+    getTheFootTarget(), /*Name=*/"foot",
+    /*Desc=*/"Foot target",
+    /*BackendName=*/"Foot"
+  );
+}
+
+Target &llvm::getTheFootTarget() {
+  static Target TheFootTarget;
+  return TheFootTarget;
+}

llvm/lib/TargetParser/Triple.cpp

@@ -39,6 +39,7 @@ StringRef Triple::getArchTypeName(ArchType Kind) {
   case bpfel:          return "bpfel";
   case csky:           return "csky";
   case dxil:           return "dxil";
+  case foot:           return "foot";
   case hexagon:        return "hexagon";
   case hsail64:        return "hsail64";
   case hsail:          return "hsail";
@@ -198,6 +199,8 @@ StringRef Triple::getArchTypePrefix(ArchType Kind) {
   case mips64:
   case mips64el:    return "mips";
 
+  case foot:        return "foot";
+
   case hexagon:     return "hexagon";
 
   case amdgcn:      return "amdgcn";
@@ -464,6 +467,7 @@ Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
       .Case("riscv64", riscv64)
       .Case("riscv32be", riscv32be)
       .Case("riscv64be", riscv64be)
+      .Case("foot", foot)
       .Case("hexagon", hexagon)
       .Case("sparc", sparc)
       .Case("sparcel", sparcel)
@@ -611,6 +615,7 @@ static Triple::ArchType parseArch(StringRef ArchName) {
                 .Case("riscv64", Triple::riscv64)
                 .Case("riscv32be", Triple::riscv32be)
                 .Case("riscv64be", Triple::riscv64be)
+                .Case("foot", Triple::foot)
                 .Case("hexagon", Triple::hexagon)
                 .Cases("s390x", "systemz", Triple::systemz)
                 .Case("sparc", Triple::sparc)
@@ -940,6 +945,7 @@ static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
   case Triple::aarch64:
   case Triple::aarch64_32:
   case Triple::arm:
+  case Triple::foot:
   case Triple::thumb:
   case Triple::x86:
   case Triple::x86_64:
@@ -1681,6 +1687,7 @@ unsigned Triple::getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
     return 0;
 
   case llvm::Triple::avr:
+  case llvm::Triple::foot:
   case llvm::Triple::msp430:
     return 16;
 
@@ -1801,6 +1808,7 @@ Triple Triple::get32BitArchVariant() const {
   case Triple::armeb:
   case Triple::csky:
   case Triple::dxil:
+  case Triple::foot:
   case Triple::hexagon:
   case Triple::hsail:
   case Triple::kalimba:
@@ -1871,6 +1879,7 @@ Triple Triple::get64BitArchVariant() const {
   case Triple::avr:
   case Triple::csky:
   case Triple::dxil:
+  case Triple::foot:
   case Triple::hexagon:
   case Triple::kalimba:
   case Triple::lanai:
@@ -1958,6 +1967,7 @@ Triple Triple::getBigEndianArchVariant() const {
   case Triple::amdil:
   case Triple::avr:
   case Triple::dxil:
+  case Triple::foot:
   case Triple::hexagon:
   case Triple::hsail64:
   case Triple::hsail:
@@ -2071,6 +2081,7 @@ bool Triple::isLittleEndian() const {
   case Triple::bpfel:
   case Triple::csky:
   case Triple::dxil:
+  case Triple::foot:
   case Triple::hexagon:
   case Triple::hsail64:
   case Triple::hsail: