Add RISC-V ePIC implementation

Author: luismarques

clang/include/clang/Basic/DiagnosticDriverKinds.td

@@ -503,7 +503,7 @@ def warn_slash_u_filename : Warning<"'/U%0' treated as the '/U' option">,
 def note_use_dashdash : Note<
   "use '--' to treat subsequent arguments as filenames">;
 
-def err_drv_ropi_rwpi_incompatible_with_pic : Error<
+def err_drv_epic_ropi_rwpi_incompatible_with_pic : Error<
   "embedded and GOT-based position independence are incompatible">;
 def err_drv_ropi_incompatible_with_cxx : Error<
   "ROPI is not compatible with c++">;

clang/include/clang/Basic/LangOptions.def

@@ -201,6 +201,7 @@ LANGOPT(EnableAIXExtendedAltivecABI  , 1, 0, "__EXTABI__  predefined macro")
 LANGOPT(EnableAIXQuadwordAtomicsABI  , 1, 0, "Use 16-byte atomic lock free semantics")
 COMPATIBLE_VALUE_LANGOPT(PICLevel    , 2, 0, "__PIC__ level")
 COMPATIBLE_VALUE_LANGOPT(PIE         , 1, 0, "is pie")
+LANGOPT(EPIC                         , 1, 0, "Position independence for embedded systems")
 LANGOPT(ROPI                         , 1, 0, "Read-only position independence")
 LANGOPT(RWPI                         , 1, 0, "Read-write position independence")
 COMPATIBLE_LANGOPT(GNUInline         , 1, 0, "GNU inline semantics")

clang/include/clang/Driver/Options.td

@@ -2746,6 +2746,10 @@ defm plt : BoolFOption<"plt",
   CodeGenOpts<"NoPLT">, DefaultFalse,
   NegFlag<SetTrue, [CC1Option], "Use GOT indirection instead of PLT to make external function calls (x86 only)">,
   PosFlag<SetFalse>>;
+defm epic : BoolFOption<"epic",
+  LangOpts<"EPIC">, DefaultFalse,
+  PosFlag<SetTrue, [CC1Option], "Generate position independent code for embedded systems (RISC-V only)">,
+  NegFlag<SetFalse>>;
 defm ropi : BoolFOption<"ropi",
   LangOpts<"ROPI">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Generate read-only position independent code (ARM only)">,
@@ -5376,9 +5380,9 @@ def migrator_no_finalize_removal : Flag<["-"], "no-finalize-removal">,
 let Flags = [CC1Option, CC1AsOption, FC1Option, NoDriverOption] in {
 
 def mrelocation_model : Separate<["-"], "mrelocation-model">,
-  HelpText<"The relocation model to use">, Values<"static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic">,
+  HelpText<"The relocation model to use">, Values<"static,pic,epic,ropi,rwpi,ropi-rwpi,dynamic-no-pic">,
   NormalizedValuesScope<"llvm::Reloc">,
-  NormalizedValues<["Static", "PIC_", "ROPI", "RWPI", "ROPI_RWPI", "DynamicNoPIC"]>,
+  NormalizedValues<["Static", "PIC_", "EPIC", "ROPI", "RWPI", "ROPI_RWPI", "DynamicNoPIC"]>,
   MarshallingInfoEnum<CodeGenOpts<"RelocationModel">, "PIC_">;
 
 } // let Flags = [CC1Option, CC1AsOption, FC1Option, NoDriverOption]

clang/lib/Driver/ToolChains/CommonArgs.cpp

@@ -1341,6 +1341,8 @@ const char *tools::RelocationModelName(llvm::Reloc::Model Model) {
     return "pic";
   case llvm::Reloc::DynamicNoPIC:
     return "dynamic-no-pic";
+  case llvm::Reloc::EPIC:
+    return "epic";
   case llvm::Reloc::ROPI:
     return "ropi";
   case llvm::Reloc::RWPI:
@@ -1498,38 +1500,48 @@ tools::ParsePICArgs(const ToolChain &ToolChain, const ArgList &Args) {
     return std::make_tuple(llvm::Reloc::DynamicNoPIC, PIC ? 2U : 0U, false);
   }
 
-  bool EmbeddedPISupported;
+  bool EPIC = false;
+  Arg* LastEPICArg = Args.getLastArg(options::OPT_fepic, options::OPT_fno_epic);
+  if (LastEPICArg && LastEPICArg->getOption().matches(options::OPT_fepic)) {
+    auto Arch = Triple.getArch();
+    if (Arch != llvm::Triple::riscv32 && Arch != llvm::Triple::riscv64)
+      ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
+          << LastEPICArg->getSpelling() << Triple.str();
+    EPIC = true;
+  }
+
+  bool RORWPISupported;
   switch (Triple.getArch()) {
     case llvm::Triple::arm:
     case llvm::Triple::armeb:
     case llvm::Triple::thumb:
     case llvm::Triple::thumbeb:
-      EmbeddedPISupported = true;
+      RORWPISupported = true;
       break;
     default:
-      EmbeddedPISupported = false;
+      RORWPISupported = false;
       break;
   }
 
   bool ROPI = false, RWPI = false;
   Arg* LastROPIArg = Args.getLastArg(options::OPT_fropi, options::OPT_fno_ropi);
   if (LastROPIArg && LastROPIArg->getOption().matches(options::OPT_fropi)) {
-    if (!EmbeddedPISupported)
+    if (!RORWPISupported)
       ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
           << LastROPIArg->getSpelling() << Triple.str();
     ROPI = true;
   }
   Arg *LastRWPIArg = Args.getLastArg(options::OPT_frwpi, options::OPT_fno_rwpi);
   if (LastRWPIArg && LastRWPIArg->getOption().matches(options::OPT_frwpi)) {
-    if (!EmbeddedPISupported)
+    if (!RORWPISupported)
       ToolChain.getDriver().Diag(diag::err_drv_unsupported_opt_for_target)
           << LastRWPIArg->getSpelling() << Triple.str();
     RWPI = true;
   }
 
   // ROPI and RWPI are not compatible with PIC or PIE.
   if ((ROPI || RWPI) && (PIC || PIE))
-    ToolChain.getDriver().Diag(diag::err_drv_ropi_rwpi_incompatible_with_pic);
+    ToolChain.getDriver().Diag(diag::err_drv_epic_ropi_rwpi_incompatible_with_pic);
 
   if (Triple.isMIPS()) {
     StringRef CPUName;
@@ -1552,7 +1564,9 @@ tools::ParsePICArgs(const ToolChain &ToolChain, const ArgList &Args) {
     return std::make_tuple(llvm::Reloc::PIC_, IsPICLevelTwo ? 2U : 1U, PIE);
 
   llvm::Reloc::Model RelocM = llvm::Reloc::Static;
-  if (ROPI && RWPI)
+  if (EPIC)
+    RelocM = llvm::Reloc::EPIC;
+  else if (ROPI && RWPI)
     RelocM = llvm::Reloc::ROPI_RWPI;
   else if (ROPI)
     RelocM = llvm::Reloc::ROPI;

clang/tools/driver/cc1as_main.cpp

@@ -436,20 +436,27 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
                 &MCOptions);
 
   bool PIC = false;
+  bool EPIC = false;
   if (Opts.RelocationModel == "static") {
     PIC = false;
   } else if (Opts.RelocationModel == "pic") {
     PIC = true;
+  } else if (Opts.RelocationModel == "epic") {
+    EPIC = true;
   } else {
-    assert(Opts.RelocationModel == "dynamic-no-pic" &&
+    assert((Opts.RelocationModel == "epic" ||
+            Opts.RelocationModel == "ropi" ||
+            Opts.RelocationModel == "rwpi" ||
+            Opts.RelocationModel == "ropi-rwpi" ||
+            Opts.RelocationModel == "dynamic-no-pic") &&
            "Invalid PIC model!");
     PIC = false;
   }
 
   // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
   // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
   std::unique_ptr<MCObjectFileInfo> MOFI(
-      TheTarget->createMCObjectFileInfo(Ctx, PIC));
+      TheTarget->createMCObjectFileInfo(Ctx, PIC, false, EPIC));
   if (Opts.DarwinTargetVariantTriple)
     MOFI->setDarwinTargetVariantTriple(*Opts.DarwinTargetVariantTriple);
   if (!Opts.DarwinTargetVariantSDKVersion.empty())

lld/ELF/Arch/RISCV.cpp

@@ -43,7 +43,9 @@ class RISCV final : public TargetInfo {
                      const uint8_t *loc) const override;
   void relocate(uint8_t *loc, const Relocation &rel,
                 uint64_t val) const override;
+  void relocateAlloc(InputSectionBase &sec, uint8_t *buf) const override;
   bool relaxOnce(int pass) const override;
+  void transformEPICRel(uint8_t *loc, Relocation &rel) const;
 };
 
 } // end anonymous namespace
@@ -251,6 +253,13 @@ RelType RISCV::getDynRel(RelType type) const {
                                      : static_cast<RelType>(R_RISCV_NONE);
 }
 
+static bool shouldMakePCRel(const Symbol &sym) {
+  OutputSection *section = sym.getOutputSection();
+  if (!section)
+    return false;
+  return (section->flags & SHF_WRITE) == 0;
+}
+
 RelExpr RISCV::getRelExpr(const RelType type, const Symbol &s,
                           const uint8_t *loc) const {
   switch (type) {
@@ -262,6 +271,9 @@ RelExpr RISCV::getRelExpr(const RelType type, const Symbol &s,
   case R_RISCV_LO12_I:
   case R_RISCV_LO12_S:
   case R_RISCV_RVC_LUI:
+  case R_RISCV_GPREL_HI20:
+  case R_RISCV_GPREL_LO12_I:
+  case R_RISCV_GPREL_LO12_S:
     return R_ABS;
   case R_RISCV_ADD8:
   case R_RISCV_ADD16:
@@ -305,6 +317,13 @@ RelExpr RISCV::getRelExpr(const RelType type, const Symbol &s,
   case R_RISCV_TPREL_ADD:
   case R_RISCV_RELAX:
     return config->relax ? R_RELAX_HINT : R_NONE;
+  case R_RISCV_GPREL_ADD:
+    return R_NONE;
+  case R_RISCV_EPIC_HI20:
+  case R_RISCV_EPIC_LO12_I:
+  case R_RISCV_EPIC_LO12_S:
+  case R_RISCV_EPIC_BASE_ADD:
+    return R_EPIC;
   default:
     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
           ") against symbol " + toString(s));
@@ -416,13 +435,15 @@ void RISCV::relocate(uint8_t *loc, const Relocation &rel, uint64_t val) const {
   case R_RISCV_TLS_GD_HI20:
   case R_RISCV_TLS_GOT_HI20:
   case R_RISCV_TPREL_HI20:
+  case R_RISCV_GPREL_HI20:
   case R_RISCV_HI20: {
     uint64_t hi = val + 0x800;
     checkInt(loc, SignExtend64(hi, bits) >> 12, 20, rel);
     write32le(loc, (read32le(loc) & 0xFFF) | (hi & 0xFFFFF000));
     return;
   }
 
+  case R_RISCV_GPREL_LO12_I:
   case R_RISCV_PCREL_LO12_I:
   case R_RISCV_TPREL_LO12_I:
   case R_RISCV_LO12_I: {
@@ -432,6 +453,7 @@ void RISCV::relocate(uint8_t *loc, const Relocation &rel, uint64_t val) const {
     return;
   }
 
+  case R_RISCV_GPREL_LO12_S:
   case R_RISCV_PCREL_LO12_S:
   case R_RISCV_TPREL_LO12_S:
   case R_RISCV_LO12_S: {
@@ -511,6 +533,32 @@ void RISCV::relocate(uint8_t *loc, const Relocation &rel, uint64_t val) const {
   }
 }
 
+void RISCV::relocateAlloc(InputSectionBase &sec, uint8_t *buf) const {
+  const unsigned bits = config->is64 ? 64 : 32;
+  uint64_t secAddr = sec.getOutputSection()->addr;
+  if (auto *s = dyn_cast<InputSection>(&sec))
+    secAddr += s->outSecOff;
+  for (Relocation &rel : sec.relocs()) {
+    if (rel.expr == R_EPIC) {
+      uint64_t offset = rel.offset;
+      uint8_t *bufLoc = buf + offset;
+      transformEPICRel(bufLoc, rel);
+      assert(rel.expr != R_EPIC);
+    }
+  }
+  for (const Relocation &rel : sec.relocs()) {
+    if (rel.expr == R_NONE)
+      continue;
+    uint8_t *loc = buf + rel.offset;
+    const uint64_t val = SignExtend64(
+        sec.getRelocTargetVA(sec.file, rel.type, rel.addend,
+                             secAddr + rel.offset, *rel.sym, rel.expr),
+        bits);
+    if (rel.expr != R_RELAX_HINT)
+      relocate(loc, rel, val);
+  }
+}
+
 namespace {
 struct SymbolAnchor {
   uint64_t offset;
@@ -1070,6 +1118,92 @@ void elf::mergeRISCVAttributesSections() {
                            mergeAttributesSection(sections));
 }
 
+// For R_RISCV_EPIC_LO12_{I,S}, the symbol actually points the corresponding
+// R_RISCV_EPIC_HI20 relocation, and the target VA is calculated using the
+// R_RISCV_EPIC_HI20's symbol.
+//
+// This function returns the R_RISCV_EPIC_HI20 relocation from
+// R_RISCV_EPIC_LO12's symbol and addend.
+static Relocation *getRISCVEPICHi20(const Symbol *sym, uint64_t addend) {
+  const Defined *d = cast<Defined>(sym);
+  if (!d->section) {
+    errorOrWarn("R_RISCV_EPIC_LO12_* relocation points to an absolute symbol: " +
+          sym->getName());
+    return nullptr;
+  }
+  InputSection *isec = cast<InputSection>(d->section);
+
+  if (addend != 0)
+    warn("non-zero addend in R_RISCV_EPIC_LO12_* relocation to " +
+         isec->getObjMsg(d->value) + " is ignored");
+
+  // Relocations are sorted by offset, so we can use std::equal_range to do
+  // binary search.
+  Relocation r;
+  r.offset = d->value;
+  auto range =
+      std::equal_range(isec->relocations.begin(), isec->relocations.end(), r,
+                       [](const Relocation &lhs, const Relocation &rhs) {
+                         return lhs.offset < rhs.offset;
+                       });
+
+  for (auto it = range.first; it != range.second; ++it)
+    // The R_RISCV_EPIC_HI20 relocation may have already been transformed into
+    // a R_RISCV_PCREL_HI20 or a R_RISCV_GPREL_HI20 relocation, so we also
+    // accept those.
+    if (it->type == R_RISCV_PCREL_HI20 || it->type == R_RISCV_GPREL_HI20 ||
+        it->type == R_RISCV_EPIC_HI20)
+      return &*it;
+
+  errorOrWarn("R_RISCV_EPIC_LO12_* relocation points to " +
+              isec->getObjMsg(d->value) +
+        " without an associated R_RISCV_EPIC_HI20_* relocation");
+  return nullptr;
+}
+
+void RISCV::transformEPICRel(uint8_t *loc, Relocation &rel) const {
+  switch (rel.type) {
+  case R_RISCV_EPIC_HI20:
+    if (shouldMakePCRel(*rel.sym)) {
+      *loc = *loc & 0xdf; // Rewrite LUI to AUIPC.
+      rel.type = R_RISCV_PCREL_HI20;
+    } else {
+      rel.type = R_RISCV_GPREL_HI20;
+    }
+    break;
+  case R_RISCV_EPIC_LO12_I: {
+    Relocation *hiRel = getRISCVEPICHi20(rel.sym, rel.addend);
+    if (shouldMakePCRel(*hiRel->sym))
+      rel.type = R_RISCV_PCREL_LO12_I;
+    else {
+      rel.type = R_RISCV_GPREL_LO12_I;
+      rel.sym = hiRel->sym;
+    }
+    break;
+  }
+  case R_RISCV_EPIC_LO12_S: {
+    Relocation *hiRel = getRISCVEPICHi20(rel.sym, rel.addend);
+    if (shouldMakePCRel(*hiRel->sym))
+      rel.type = R_RISCV_PCREL_LO12_S;
+    else {
+      rel.type = R_RISCV_GPREL_LO12_S;
+      rel.sym = hiRel->sym;
+    }
+    break;
+  }
+  case R_RISCV_EPIC_BASE_ADD:
+    if (shouldMakePCRel(*rel.sym)) {
+      if ((*loc & 0x7f) != 0b0110011) // not an uncompressed ADD.
+        error(getErrorLocation(loc) +
+              "R_RISCV_EPIC_BASE_ADD relocation against wrong instruction");
+      write32le(loc, itype(ADDI, 0, 0, 0)); // Rewrite ADD to NOP.
+    }
+    rel.type = R_RISCV_NONE;
+    break;
+  }
+  rel.expr = getRelExpr(rel.type, *rel.sym, loc);
+}
+
 TargetInfo *elf::getRISCVTargetInfo() {
   static RISCV target;
   return &target;

lld/ELF/Config.h

@@ -226,6 +226,7 @@ struct Config {
   bool ltoEmitAsm;
   bool ltoUniqueBasicBlockSectionNames;
   bool ltoWholeProgramVisibility;
+  bool ltoEpic;
   bool mergeArmExidx;
   bool mipsN32Abi = false;
   bool mmapOutputFile;

lld/ELF/Driver.cpp

@@ -1150,6 +1150,7 @@ static void readConfigs(opt::InputArgList &args) {
   config->ltoUniqueBasicBlockSectionNames =
       args.hasFlag(OPT_lto_unique_basic_block_section_names,
                    OPT_no_lto_unique_basic_block_section_names, false);
+  config->ltoEpic = args.hasArg(OPT_lto_epic);
   config->mapFile = args.getLastArgValue(OPT_Map);
   config->mipsGotSize = args::getInteger(args, OPT_mips_got_size, 0xfff0);
   config->mergeArmExidx =

lld/ELF/LTO.cpp

@@ -118,6 +118,8 @@ static lto::Config createConfig() {
     c.RelocModel = std::nullopt;
   else if (config->isPic)
     c.RelocModel = Reloc::PIC_;
+  else if (config->ltoEpic)
+    c.RelocModel = Reloc::EPIC;
   else
     c.RelocModel = Reloc::Static;
 

lld/ELF/Options.td

@@ -579,6 +579,10 @@ def lto_sample_profile: JJ<"lto-sample-profile=">,
 defm lto_whole_program_visibility: BB<"lto-whole-program-visibility",
   "Asserts that the LTO link has whole program visibility",
   "Asserts that the LTO link does not have whole program visibility">;
+def lto_pseudo_probe_for_profiling: F<"lto-pseudo-probe-for-profiling">,
+  HelpText<"Emit pseudo probes for sample profiling">;
+def lto_epic: FF<"lto-epic">,
+  HelpText<"Emit code suitable for the ePIC ABI during LTO">;
 def disable_verify: F<"disable-verify">;
 defm mllvm: Eq<"mllvm", "Additional arguments to forward to LLVM's option processing">;
 def opt_remarks_filename: Separate<["--"], "opt-remarks-filename">,

lld/ELF/Relocations.cpp

@@ -211,7 +211,6 @@ static bool isRelExpr(RelExpr expr) {
                R_RISCV_PC_INDIRECT, R_PPC64_RELAX_GOT_PC>(expr);
 }
 
-
 static RelExpr toPlt(RelExpr expr) {
   switch (expr) {
   case R_PPC64_CALL:
@@ -946,7 +945,7 @@ bool RelocationScanner::isStaticLinkTimeConstant(RelExpr e, RelType type,
             R_MIPS_GOTREL, R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_MIPS_GOT_GP_PC,
             R_AARCH64_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC, R_GOTPLTONLY_PC,
             R_PLT_PC, R_PLT_GOTPLT, R_PPC32_PLTREL, R_PPC64_CALL_PLT,
-            R_PPC64_RELAX_TOC, R_RISCV_ADD, R_AARCH64_GOT_PAGE>(e))
+            R_PPC64_RELAX_TOC, R_RISCV_ADD, R_AARCH64_GOT_PAGE, R_EPIC>(e))
     return true;
 
   // These never do, except if the entire file is position dependent or if