[RISCV] Passing small data limitation value to RISCV backend

[shiva0217]

Summary

Passing small data limitation to RISCVELFTargetObjectFile by module flag,
So the backend can set small data section threshold by the value.

[simoncook]

As this mllvm option only affects the creation of ELF objects, do we also need to add a similar option for the LTO case, as the -G value would have no effect otherwise?

[shiva0217]

In D57497#1378511, @simoncook wrote:

As this mllvm option only affects the creation of ELF objects, do we also need to add a similar option for the LTO case, as the -G value would have no effect otherwise?

Hi Simon, I think you're right, we may need a way to pass -G value for the LTO. One possible solution is adding passing code in AddGoldPlugin, but there's no other target specific code. I can't find other targets passing their cl::opt flags through the LTO. Any suggestions?

[apazos]

Hi Shiva, I think you need to check for and pass along the -G option to the linker (gnutools::Linker and RISCV::Linker) and will be available for LTO. Check Hexagon, it passes the threshold value to the assembler (via -gpsize) and linker (via -G).

[shiva0217]

1. Setting small data limitation to zero for PIC and RV64 with large code model.
2. Support passing small data limitation with LTO enabled.

[shiva0217]

In D57497#1382206, @apazos wrote:

Hi Shiva, I think you need to check for and pass along the -G option to the linker (gnutools::Linker and RISCV::Linker) and will be available for LTO. Check Hexagon, it passes the threshold value to the assembler (via -gpsize) and linker (via -G).

Hi Ana, thanks for the tips!
I follow Hexagon and implement the passing code in RISCV::Linker::ConstructJob.
Could you help me to check whether it could work properly?

[apazos]

Hi Shiva, I will check, but I think you need to also modify gnutools:Linker because riscv::Linker is called for baremetal. I think you need in both places.
The way I check is by invoking -flto -v from clang and look at the arguments passed to the compiler and linker

[apazos]

I don't see -plugin-opt=-riscv-ssection-threshold=.. being passed.
tools::gnutools::Linker::ConstructJob is being invoked with target riscv32-unknown-linux-gnu
It has to work for riscv32-unknown-linux-gnu and riscv32-unknown-elf

[shiva0217]

Support passing small data limitation for target riscv32-unknown-linux-gnu with LTO enabled.

[shiva0217]

In D57497#1382393, @apazos wrote:

I don't see -plugin-opt=-riscv-ssection-threshold=.. being passed.
tools::gnutools::Linker::ConstructJob is being invoked with target riscv32-unknown-linux-gnu
It has to work for riscv32-unknown-linux-gnu and riscv32-unknown-elf

Hi Ana, I've added the passing code in tools::gnutools::Linker::ConstructJob for non-baremetal target.
Thanks for pointing me out the missing part. :)

[efriedma]

How do we actually want this to work for LTO? Would it make sense to encode this on global variables somehow, to allow different thresholds for different source files?

[apazos]

So Eli is concerned we might end up with many globals in the small data section or not picking the best candidates if we pass -G to all files in LTO.
I don’t know if anyone has experimented with a heuristic to selectively pick which globals and of which size will be allowed to go into the small data section.
Simon, do you have any insight?
Shiva, maybe for now we don’t pass the flag to LTO. But I think you got the correct mechanism. The only other suggestion I have is to add a RISC-V specific function to avoid too much RISC-V specific code in gnutools::Linker::constructJob. You just check the triple and call something like toolchains::RISCVToolChain::AddGoldPluginAdditionalFlags.

[jrtc27]

Please update docs/ClangCommandLineReference.rst. Also, in my limited testing, GCC just seems to pass the -msmall-data-limit=... flag straight through to the linker through COLLECT_GCC_OPTIONS. Finally, please add tests for -msmall-data-limit=... instead of or as well as -G, since GCC only recognises the former on RISC-V.

[shiva0217]

1. Remove passing path for LTO because Eli raised the concern that whether it would appropriate to assign the same limitation for all files when LTO enabled.
2. Add -msmall-data-limitation= as James pointed out it's the main setting flag for RISCV GCC

[apazos]

If this is a target flag in GCC, shouldn't we make it a LLVM Target feature and pass it as -mattr, just like done for mrelax?

[shiva0217]

In D57497#1388350, @apazos wrote:

If this is a target flag in GCC, shouldn't we make it a LLVM Target feature and pass it as -mattr, just like done for mrelax?

Hi Ana,
It seems that most of the -mattr features only obtain on/off without assigning a value.
For -mfpu=vfp4, each fpu configuration will be declared as a feature (e.g. FeatureVFP4) and the configurations are limited,
but the threshold value could be any number.
Did you mean declare as a target feature in RISCV.td or I misunderstanding something?

[efriedma]

Did you mean declare as a target feature in RISCV.td or I misunderstanding something?

That's sort of the right idea, but I don't think it works in this context because we aren't trying to change the generated code for a function; we actually need to stick the global into a specific section. Maybe worth sending an email to llvmdev to discuss the right way to represent this in IR?

[shiva0217]

In D57497#1394137, @efriedma wrote:

Did you mean declare as a target feature in RISCV.td or I misunderstanding something?

That's sort of the right idea, but I don't think it works in this context because we aren't trying to change the generated code for a function; we actually need to stick the global into a specific section. Maybe worth sending an email to llvmdev to discuss the right way to represent this in IR?

Hi Eli,
I have sent the email to llvmdev http://lists.llvm.org/pipermail/llvm-dev/2019-February/130222.html. It seems that there're not much consensus on how to represent in IR. I incline to implement passing through -plugin-opt= as the first version. We could create an incremental patch when we have more consensus on IR approach. What do you think?

[shiva0217]

Passing small data limitation by module flag.

[apazos]

lib/Driver/ToolChains/Clang.cpp

1803 ↗

(On Diff #190595)

Might be simpler to just set it to 0, and if G is present in the command line, and the other flags are not present, then you change the value. Also, might be good to print a warning to let user know -G is ignored?

lib/Driver/ToolChains/RISCVToolchain.cpp

117 ↗

(On Diff #190595)

This change is not part of this patch.

[shiva0217]

Update patch to address Ana's comments.

1. Ignoring -G when -msmall-data-limit= in the command line and show the warning message
2. Removing LTO plugin invoking which should introduce in another patch

[apazos]

lib/Driver/ToolChains/Clang.cpp

1813 ↗

(On Diff #191640)

Why do you we need to set a default? It will cause the optimization to be on now, and I thought we want to first prioritize the globals we want to consider for the optimization.
I think you should check for msmall-data-limit flag occurring with G, fpic and mcmodel flags and print warning in all cases.

[shiva0217]

Add warning message for -msmall-data-limit with -fpic or RV64 with -mcmodel=large

[shiva0217]

lib/Driver/ToolChains/Clang.cpp

1813 ↗

(On Diff #191640)

Hi Ana,
It seems that RISC-V GCC will set 8 as default value even with -mno-relax.
Another issue is that the sorting scope will be a compile unit. So when linker link the .sdata from objects, it will get globals from object A with usage times from high to low and then the globals from object B with usage times from high to low which probably not we want. The sorting might make sense when the LTO enabled.
I have added the warning message, thanks for the suggestion.

[apazos]

Shiva, we forgot about this patch. Can you rebase it so we move on with merging.

[shiva0217]

In D57497#1913473, @apazos wrote:

Shiva, we forgot about this patch. Can you rebase it so we move on with merging.

Ok, I'll rebase the patch.

[shiva0217]

Rebase to the trunk

[lenary]

Two nits, then I'd be happy for this to land.

It would be useful if @jrtc27 would also re-review, as he has blocking comments (which I believe are now addressed).

clang/docs/ClangCommandLineReference.rst

3202

"(RISC-V only)" please

clang/lib/CodeGen/CodeGenModule.cpp

689

You should not be using ModFlagBehaviourFirstVal here - use Error if that is what you intend for conflicting values. The other possible option is Max but that could be confusing (I think we'd prefer Min, which doesn't yet exist)

[shiva0217]

Update patch to address @lenary's comments.

[evandro]

clang/docs/ClangCommandLineReference.rst

3202

s/arg/limit/
s/limitation/limit/

clang/include/clang/Basic/DiagnosticDriverKinds.td

403

Rather:

"ignoring '-G' with '-msmall-data-limit'"

406

Rather:

"ignoring '-msmall-data-limit=' with '-mcmodel=large' for PIC or RV64"

clang/include/clang/Driver/CC1Options.td

317

s/limitation/limit/

clang/include/clang/Driver/Options.td

2304

s/limitation/limit/

[shiva0217]

Update patch to address @evandro's comments.

[jrtc27]

I believe my previous comments have indeed been addressed.

clang/docs/ClangCommandLineReference.rst

3202

This seems like needless noise; it's already in the RISCV section, we don't need to say it's RISC-V only in the body too. Other architectures are inconsistent about this but I see it as a waste of time?

[shiva0217]

Update patch to address @jrtc27's comment.

[apazos]

Shiva, I see a warning always being printed:

'+small-data-limit=' is not a recognized feature for this target (ignoring feature)

This is because it is being passed down as a target feature.

Might be good to add a test case to make sure the SmallDataLimit module flag is created, no target feature is passed, and that no warnings are printed.

[apazos]

Shiva, I am not sure how the SDataLimit is being honored in LTO mode.
Where does getModuleMetadata get called?
If the SelectSectionForGlobal api is called without getModuleMetadata being called first, it will use the default 8 instead of honoring the SDataLimit.

[shiva0217]

In D57497#1917835, @apazos wrote:

Shiva, I see a warning always being printed:

'+small-data-limit=' is not a recognized feature for this target (ignoring feature)

This is because it is being passed down as a target feature.

Might be good to add a test case to make sure the SmallDataLimit module flag is created, no target feature is passed, and that no warnings are printed.

Hi Ana,
Thanks for catching this, I'll fix it and add testing lines for it.

In D57497#1918483, @apazos wrote:

Shiva, I am not sure how the SDataLimit is being honored in LTO mode.
Where does getModuleMetadata get called?
If the SelectSectionForGlobal api is called without getModuleMetadata being called first, it will use the default 8 instead of honoring the SDataLimit.

It seems that SDataLimit will be honored in LTO mode because getModuleMetadata will be called in AsmPrinter::doInitialization and SelectSectionForGlobal will be called from AsmPrinter::doFinalization->emitGlobalVariable->SectionForGLobal->SelectSecfionForGlobal.

[shiva0217]

Update the patch to address @apazos's comments.

[apazos]

Thanks Shiva, I res-ynced and rebuilt the patch. It is working fine.

I see there is a msmall-data-threshold flag used by Mips and Hexagon, and now we are adding a new flag msmall-data-limit. Should't we reuse the flag?

[shiva0217]

In D57497#1920097, @apazos wrote:

Thanks Shiva, I res-ynced and rebuilt the patch. It is working fine.

I see there is a msmall-data-threshold flag used by Mips and Hexagon, and now we are adding a new flag msmall-data-limit. Should't we reuse the flag?

Hi Ana,
Thanks for trying the patch. msmall-data-limit is also a RISCV GCC flag, so I would recommend using the same flag as GCC.

[lenary]

In D57497#1920870, @shiva0217 wrote:

In D57497#1920097, @apazos wrote:

Thanks Shiva, I res-ynced and rebuilt the patch. It is working fine.

I see there is a msmall-data-threshold flag used by Mips and Hexagon, and now we are adding a new flag msmall-data-limit. Should't we reuse the flag?

Hi Ana,
Thanks for trying the patch. msmall-data-limit is also a RISCV GCC flag, so I would recommend using the same flag as GCC.

How hard would it be to use the -msmall-data-threshold flag work if a -msmall-data-limit flag is not provided?

[shiva0217]

In D57497#1921497, @lenary wrote:

In D57497#1920870, @shiva0217 wrote:

In D57497#1920097, @apazos wrote:

Thanks Shiva, I res-ynced and rebuilt the patch. It is working fine.

I see there is a msmall-data-threshold flag used by Mips and Hexagon, and now we are adding a new flag msmall-data-limit. Should't we reuse the flag?

Hi Ana,
Thanks for trying the patch. msmall-data-limit is also a RISCV GCC flag, so I would recommend using the same flag as GCC.

How hard would it be to use the -msmall-data-threshold flag work if a -msmall-data-limit flag is not provided?

I think it won't be hard, users just need to find the same semantic flags when switching between LLVM and GCC. If we use the same flag for the same functionality, we could avoid the effort. Does it sound reasonable?

[lenary]

In D57497#1923615, @shiva0217 wrote:

In D57497#1921497, @lenary wrote:

How hard would it be to use the -msmall-data-threshold flag work if a -msmall-data-limit flag is not provided?

I think it won't be hard, users just need to find the same semantic flags when switching between LLVM and GCC. If we use the same flag for the same functionality, we could avoid the effort. Does it sound reasonable?

I'm not suggesting "don't support -msmall-data-limit=". I'm suggesting "use -msmall-data-threshold= if -msmall-data-limit= is not specified".

Actually, we can always add this support in later, it shouldn't block this patch. I'm happy for this patch to be merged - @jrtc27 is too, so let's wait for @apazos's final thoughts.

[apazos]

Shiva, how about making the flag small-data-limit alias of -msmall-data-threshold?

[shiva0217]

In D57497#1927881, @apazos wrote:

Shiva, how about making the flag small-data-limit alias of -msmall-data-threshold?

Hi @apazos,
I try to implement -small-data-limit alias of -small-data-threshold, it will trigger the assertion "Multi-level aliases are not supported." in Option constructor because -msmall-data-threshold alias to -G. So I implement -small-data-limit alias of -G, then we can get -msmall-data-limit= and -msmall-data-threshold= inputs by OPT_G in SetRISCVSmallDataLimit(). In a meanwhile, warning of "Ignore -G because -msmall-data-limit= has higher priority" will be removed and -G may override -msmall-data-limit if -G is the last flag. What do you think?

[shiva0217]

Update patch to address @apazos's comments.

[apazos]

Thanks Shiva, making it alias of -G makes sense, LGTM.

[MaskRay]

clang/lib/Driver/ToolChains/Clang.cpp

1970

There are multiple issues. With -fpic -fpic, this will give a warning when -msmall-data-limit=N is specified, which is undesired.

1978

-mcmodel=Large is rejected. We don't need to use equals_lower.

clang/test/CodeGen/riscv-sdata-module-flag.c

1

test/CodeGen tests usually use %clang_cc1, not %clang.

Many tests here test the driver behavior and should be placed into test/Driver.

clang/docs/ClangCommandLineReference.rst

 .. option:: -sycl-std=<arg>
 
 SYCL language standard to compile for.
 
 Target-dependent compilation options
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 .. option:: -G<size>, -G=<arg>, -msmall-data-threshold=<arg>
 
-Put objects of at most <size> bytes into small data section (MIPS / Hexagon)
+Put objects of at most <size> bytes into small data section (MIPS / Hexagon / RISCV)
 
 .. option:: -ffixed-x1
 
 Reserve the 1 register (AArch64/RISC-V only)
 
 .. option:: -ffixed-x10
 
 Reserve the 10 register (AArch64/RISC-V only)

 RISCV
 -----
 .. option:: -mrelax, -mno-relax
 
 Enable linker relaxation
 
 .. option:: -msave-restore, -mno-save-restore
 
 Enable using library calls for save and restore
 
+.. option:: -msmall-data-limit=<limit>
+
+Put global and static data smaller than the limit into a special section
+
 Long double flags
 -----------------
 Selects the long double implementation
 
 .. option:: -mlong-double-128
 
 Force long double to be 128 bits
 

clang/include/clang/Basic/CodeGenOptions.def

 /// Whether to use public LTO visibility for entities in std and stdext
 /// namespaces. This is enabled by clang-cl's /MT and /MTd flags.
 CODEGENOPT(LTOVisibilityPublicStd, 1, 0)
 
 /// The user specified number of registers to be used for integral arguments,
 /// or 0 if unspecified.
 VALUE_CODEGENOPT(NumRegisterParameters, 32, 0)
 
+/// The threshold to put data into small data section.
+VALUE_CODEGENOPT(SmallDataLimit, 32, 0)
+
 /// The lower bound for a buffer to be considered for stack protection.
 VALUE_CODEGENOPT(SSPBufferSize, 32, 0)
 
 /// The kind of generated debug info.
 ENUM_CODEGENOPT(DebugInfo, codegenoptions::DebugInfoKind, 3, codegenoptions::NoDebugInfo)
 
 /// Whether to generate macro debug info.
 CODEGENOPT(MacroDebugInfo, 1, 0)

clang/include/clang/Basic/DiagnosticDriverKinds.td

def warn_target_unsupported_compact_branches : Warning<
   " support it">, InGroup<UnsupportedCB>;
 def warn_target_unsupported_extension : Warning<
   "ignoring extension '%0' because the '%1' architecture does not support it">,
    InGroup<InvalidCommandLineArgument>;
 def warn_drv_unsupported_gpopt : Warning<
   "ignoring '-mgpopt' option as it cannot be used with %select{|the implicit"
   " usage of }0-mabicalls">,
   InGroup<UnsupportedGPOpt>;
+def warn_drv_unsupported_sdata : Warning<
+  "ignoring '-msmall-data-limit=' with -mcmodel=large for -fpic or RV64">,
+  InGroup<OptionIgnored>;
 def warn_drv_unsupported_longcalls : Warning<
   "ignoring '-mlong-calls' option as it is not currently supported with "
   "%select{|the implicit usage of }0-mabicalls">,
   InGroup<OptionIgnored>;
 def warn_drv_unsupported_pic_with_mabicalls : Warning<
   "ignoring '%0' option as it cannot be used with "
   "%select{implicit usage of|}1 -mabicalls and the N64 ABI">,
   InGroup<OptionIgnored>;
 def err_drv_unsupported_noabicalls_pic : Error<
   "position-independent code requires '-mabicalls'">;

clang/include/clang/Driver/CC1Options.td

 def mlimit_float_precision : Separate<["-"], "mlimit-float-precision">,
   HelpText<"Limit float precision to the given value">;
 def split_stacks : Flag<["-"], "split-stacks">,
   HelpText<"Try to use a split stack if possible.">;
 def mno_zero_initialized_in_bss : Flag<["-"], "mno-zero-initialized-in-bss">,
   HelpText<"Do not put zero initialized data in the BSS">;
 def mregparm : Separate<["-"], "mregparm">,
   HelpText<"Limit the number of registers available for integer arguments">;
+def msmall_data_limit : Separate<["-"], "msmall-data-limit">,
+  HelpText<"Put global and static data smaller than the limit into a special section">;
 def munwind_tables : Flag<["-"], "munwind-tables">,
   HelpText<"Generate unwinding tables for all functions">;
 def mconstructor_aliases : Flag<["-"], "mconstructor-aliases">,
   HelpText<"Emit complete constructors and destructors as aliases when possible">;
 def mlink_bitcode_file : Separate<["-"], "mlink-bitcode-file">,
   HelpText<"Link the given bitcode file before performing optimizations.">;
 def mlink_builtin_bitcode : Separate<["-"], "mlink-builtin-bitcode">,
   HelpText<"Link and internalize needed symbols from the given bitcode file "

clang/include/clang/Driver/Options.td

def mspeculative_load_hardening : Flag<["-"], "mspeculative-load-hardening">,
   Group<m_Group>, Flags<[CoreOption,CC1Option]>;
 def mno_speculative_load_hardening : Flag<["-"], "mno-speculative-load-hardening">,
   Group<m_Group>, Flags<[CoreOption]>;
 
 def mrelax : Flag<["-"], "mrelax">, Group<m_riscv_Features_Group>,
   HelpText<"Enable linker relaxation">;
 def mno_relax : Flag<["-"], "mno-relax">, Group<m_riscv_Features_Group>,
   HelpText<"Disable linker relaxation">;
+def msmall_data_limit_EQ : Joined<["-"], "msmall-data-limit=">, Group<m_Group>,
+  Alias<G>,
+  HelpText<"Put global and static data smaller than the limit into a special section">;
 def msave_restore : Flag<["-"], "msave-restore">, Group<m_riscv_Features_Group>,
   HelpText<"Enable using library calls for save and restore">;
 def mno_save_restore : Flag<["-"], "mno-save-restore">, Group<m_riscv_Features_Group>,
   HelpText<"Disable using library calls for save and restore">;
 def mcmodel_EQ_medlow : Flag<["-"], "mcmodel=medlow">, Group<m_riscv_Features_Group>,
   Flags<[CC1Option]>, Alias<mcmodel_EQ>, AliasArgs<["small"]>,
   HelpText<"Equivalent to -mcmodel=small, compatible with RISC-V gcc.">;
 def mcmodel_EQ_medany : Flag<["-"], "mcmodel=medany">, Group<m_riscv_Features_Group>,

clang/lib/CodeGen/CodeGenModule.h

private:
   void EmitVersionIdentMetadata();
 
   /// Emit the Clang commandline as llvm.commandline metadata.
   void EmitCommandLineMetadata();
 
   /// Emits target specific Metadata for global declarations.
   void EmitTargetMetadata();
 
+  /// Emit the module flag metadata used to pass options controlling the
+  /// the backend to LLVM.
+  void EmitBackendOptionsMetadata(const CodeGenOptions CodeGenOpts);
+
   /// Emits OpenCL specific Metadata e.g. OpenCL version.
   void EmitOpenCLMetadata();
 
   /// Emit the llvm.gcov metadata used to tell LLVM where to emit the .gcno and
   /// .gcda files in a way that persists in .bc files.
   void EmitCoverageFile();
 
   /// Emits the initializer for a uuidof string.

clang/lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::Release() {
 
   if (getCodeGenOpts().EmitVersionIdentMetadata)
     EmitVersionIdentMetadata();
 
   if (!getCodeGenOpts().RecordCommandLine.empty())
     EmitCommandLineMetadata();
 
   EmitTargetMetadata();
+
+  EmitBackendOptionsMetadata(getCodeGenOpts());
 }
 
 void CodeGenModule::EmitOpenCLMetadata() {
   // SPIR v2.0 s2.13 - The OpenCL version used by the module is stored in the
   // opencl.ocl.version named metadata node.
   // C++ is backwards compatible with OpenCL v2.0.
   // FIXME: We might need to add CXX version at some point too?
   auto Version = LangOpts.OpenCLCPlusPlus ? 200 : LangOpts.OpenCLVersion;
   llvm::Metadata *OCLVerElts[] = {
       llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
           Int32Ty, Version / 100)),
       llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
           Int32Ty, (Version % 100) / 10))};
   llvm::NamedMDNode *OCLVerMD =
       TheModule.getOrInsertNamedMetadata("opencl.ocl.version");
   llvm::LLVMContext &Ctx = TheModule.getContext();
   OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
 }
 
+void CodeGenModule::EmitBackendOptionsMetadata(
+    const CodeGenOptions CodeGenOpts) {
+  switch (getTriple().getArch()) {
+  default:
+    break;
+  case llvm::Triple::riscv32:
+  case llvm::Triple::riscv64:
+    getModule().addModuleFlag(llvm::Module::Error, "SmallDataLimit",
+                              CodeGenOpts.SmallDataLimit);
+    break;
+  }
+}
+
 void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
   // Make sure that this type is translated.
   Types.UpdateCompletedType(TD);
 }
 
 void CodeGenModule::RefreshTypeCacheForClass(const CXXRecordDecl *RD) {
   // Make sure that this type is translated.
   Types.RefreshTypeCacheForClass(RD);

clang/lib/Driver/ToolChains/Clang.cpp

void Clang::AddPPCTargetArgs(const ArgList &Args,
   }
 
   if (ABIName) {
     CmdArgs.push_back("-target-abi");
     CmdArgs.push_back(ABIName);
   }
 }
 
+static void SetRISCVSmallDataLimit(const ToolChain &TC, const ArgList &Args,
+                                   ArgStringList &CmdArgs) {
+  const Driver &D = TC.getDriver();
+  const llvm::Triple &Triple = TC.getTriple();
+  // Default small data limitation is eight.
+  const char *SmallDataLimit = "8";
+  // Get small data limitation.
+  if (Args.getLastArg(options::OPT_shared, options::OPT_fpic,
+                      options::OPT_fPIC)) {
+    // Not support linker relaxation for PIC.
+    SmallDataLimit = "0";
+    if (Args.hasArg(options::OPT_G)) {
+      D.Diag(diag::warn_drv_unsupported_sdata);
+    }
+  } else if (Args.getLastArgValue(options::OPT_mcmodel_EQ)
+                 .equals_lower("large") &&
+             (Triple.getArch() == llvm::Triple::riscv64)) {
+    // Not support linker relaxation for RV64 with large code model.
+    SmallDataLimit = "0";
+    if (Args.hasArg(options::OPT_G)) {
+      D.Diag(diag::warn_drv_unsupported_sdata);
+    }
+  } else if (Arg *A = Args.getLastArg(options::OPT_G)) {
+    SmallDataLimit = A->getValue();
+  }
+  // Forward the -msmall-data-limit= option.
+  CmdArgs.push_back("-msmall-data-limit");
+  CmdArgs.push_back(SmallDataLimit);
+}
+
 void Clang::AddRISCVTargetArgs(const ArgList &Args,
                                ArgStringList &CmdArgs) const {
   const llvm::Triple &Triple = getToolChain().getTriple();
   StringRef ABIName = riscv::getRISCVABI(Args, Triple);
 
   CmdArgs.push_back("-target-abi");
   CmdArgs.push_back(ABIName.data());
+
+  SetRISCVSmallDataLimit(getToolChain(), Args, CmdArgs);
 }
 
 void Clang::AddSparcTargetArgs(const ArgList &Args,
                                ArgStringList &CmdArgs) const {
   sparc::FloatABI FloatABI =
       sparc::getSparcFloatABI(getToolChain().getDriver(), Args);
 
   if (FloatABI == sparc::FloatABI::Soft) {

clang/lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   Opts.ReciprocalMath = Args.hasArg(OPT_freciprocal_math);
   Opts.NoTrappingMath = Args.hasArg(OPT_fno_trapping_math);
   Opts.StrictFloatCastOverflow =
       !Args.hasArg(OPT_fno_strict_float_cast_overflow);
 
   Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
   Opts.NumRegisterParameters = getLastArgIntValue(Args, OPT_mregparm, 0, Diags);
   Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
+  Opts.SmallDataLimit =
+      getLastArgIntValue(Args, OPT_msmall_data_limit, 0, Diags);
   Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
   Opts.NoWarn = Args.hasArg(OPT_massembler_no_warn);
   Opts.EnableSegmentedStacks = Args.hasArg(OPT_split_stacks);
   Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
   Opts.IncrementalLinkerCompatible =
       Args.hasArg(OPT_mincremental_linker_compatible);
   Opts.PIECopyRelocations =
       Args.hasArg(OPT_mpie_copy_relocations);

clang/test/CodeGen/riscv-sdata-module-flag.c

+// RUN: %clang -target riscv32-unknown-elf %s -S -emit-llvm -o - \
+// RUN:   | FileCheck %s -check-prefix=RV32-DEFAULT
+// RUN: %clang -target riscv32-unknown-elf %s -S -emit-llvm -G4 -o - \
+// RUN:   | FileCheck %s -check-prefix=RV32-G4
+// RUN: %clang -target riscv32-unknown-elf %s -S -emit-llvm -msmall-data-limit=0 -o - \
+// RUN:   | FileCheck %s -check-prefix=RV32-S0
+// RUN: %clang -target riscv32-unknown-elf %s -S -emit-llvm -msmall-data-limit=2 -G4 -o - \
+// RUN:   | FileCheck %s -check-prefix=RV32-S2G4
+// RUN: %clang -target riscv32-unknown-elf %s -S -emit-llvm -msmall-data-threshold=16 -o - \
+// RUN:   | FileCheck %s -check-prefix=RV32-T16
+// RUN: %clang -target riscv32-unknown-elf %s -S -emit-llvm -fpic -o - \
+// RUN:   | FileCheck %s -check-prefix=RV32-PIC
+
+// RUN: %clang -target riscv64-unknown-elf %s -S -emit-llvm -o - \
+// RUN:   | FileCheck %s -check-prefix=RV64-DEFAULT
+// RUN: %clang -target riscv64-unknown-elf %s -S -emit-llvm -G4 -o - \
+// RUN:   | FileCheck %s -check-prefix=RV64-G4
+// RUN: %clang -target riscv64-unknown-elf %s -S -emit-llvm -msmall-data-limit=0 -o - \
+// RUN:   | FileCheck %s -check-prefix=RV64-S0
+// RUN: %clang -target riscv64-unknown-elf %s -S -emit-llvm -msmall-data-limit=2 -G4 -o - \
+// RUN:   | FileCheck %s -check-prefix=RV64-S2G4
+// RUN: %clang -target riscv64-unknown-elf %s -S -emit-llvm -msmall-data-threshold=16 -o - \
+// RUN:   | FileCheck %s -check-prefix=RV64-T16
+// RUN: %clang -target riscv64-unknown-elf %s -S -emit-llvm -fpic -o - \
+// RUN:   | FileCheck %s -check-prefix=RV64-PIC
+// RUN: %clang -target riscv64-unknown-elf %s -S -emit-llvm -mcmodel=large -o - \
+// RUN:   | FileCheck %s -check-prefix=RV64-LARGE
+
+void test() {}
+
+// RV32-DEFAULT: !{i32 1, !"SmallDataLimit", i32 8}
+// RV32-G4:      !{i32 1, !"SmallDataLimit", i32 4}
+// RV32-S0:      !{i32 1, !"SmallDataLimit", i32 0}
+// RV32-S2G4:    !{i32 1, !"SmallDataLimit", i32 4}
+// RV32-T16:     !{i32 1, !"SmallDataLimit", i32 16}
+// RV32-PIC:     !{i32 1, !"SmallDataLimit", i32 0}
+
+// RV64-DEFAULT: !{i32 1, !"SmallDataLimit", i32 8}
+// RV64-G4:      !{i32 1, !"SmallDataLimit", i32 4}
+// RV64-S0:      !{i32 1, !"SmallDataLimit", i32 0}
+// RV64-S2G4:    !{i32 1, !"SmallDataLimit", i32 4}
+// RV64-T16:     !{i32 1, !"SmallDataLimit", i32 16}
+// RV64-PIC:     !{i32 1, !"SmallDataLimit", i32 0}
+// RV64-LARGE:   !{i32 1, !"SmallDataLimit", i32 0}
+
+// The value will be passed by module flag instead of target feature.
+// RV32-S0-NOT: +small-data-limit=
+// RV64-S0-NOT: +small-data-limit=

clang/test/Driver/riscv-sdata-warning.c

+// REQUIRES: riscv-registered-target
+// RUN: %clang -S -target riscv32-unknown-elf -fpic -msmall-data-limit=8 %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-PIC-SDATA %s
+// CHECK-PIC-SDATA: warning: ignoring '-msmall-data-limit=' with -mcmodel=large for -fpic or RV64
+
+// RUN: %clang -S -target riscv64-unknown-elf -mcmodel=large -msmall-data-limit=8 %s 2>&1 \
+// RUN:   | FileCheck -check-prefix=CHECK-RV64-LARGE-SDATA %s
+// CHECK-RV64-LARGE-SDATA: warning: ignoring '-msmall-data-limit=' with -mcmodel=large for -fpic or RV64