[Flang][Driver] Enable PIC in the frontend

[mnadeem]

Summary

This patch does the following:

• Consumes the PIC flags (fPIC/fPIE/fropi/frwpi etc) in flang-new. tools::ParsePICArgs() in ToolChains/CommonArgs.cpp is used for this.
• Adds FC1Option to "-mrelocation-model", "-pic-level", and "-pic-is-pie" command line options.
• Adds the above options to flang/Frontend/CodeGenOptions' data structure.
• Sets the relocation model in the target machine, and
• Sets module flags for the respective PIC/PIE type in LLVM IR.

I have tried my best to replicate how clang does things.

[awarzynski]

Many thanks for implementing this! I've only skimmed through so far, but mostly makes sense. Will take a closer look later.

Could you update the summary by adding more detail? What options are enabled and whether the semantics from Clang are preserved or not (they should unless there is a good reason not to)? It would help if you could list all of them. More comments inline.

clang/include/clang/Driver/Options.td

5954–5959

As per comments in Options.td, this is a "Code-gen Option" rather than a "Language Option". Could you move it back somewhere near the original comment?

I would also suggest using let (there's going to be more options like this):

let Flags = [CC1Option, CC1AsOption, FC1Option, NoDriverOption] {

def mrelocation_model : Separate<["-"], "mrelocation-model">,
  HelpText<"The relocation model to use">, Values<"static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic">,
  NormalizedValuesScope<"llvm::Reloc">,
  NormalizedValues<["Static", "PIC_", "ROPI", "RWPI", "ROPI_RWPI", "DynamicNoPIC"]>,
  MarshallingInfoEnum<CodeGenOpts<"RelocationModel">, "PIC_">;

} // let Flags = [CC1Option, CC1AsOption, FC1Option, NoDriverOption]

6320–6325

These are code-gen options to me. While originally located under "Language Options", I think that it would make more sense to move them near "CodeGen Options" instead (e.g. near mrelocation_model). @MaskRay any thoughts?

clang/lib/Driver/ToolChains/Flang.cpp

120

I would skip "Similar to clang" - this applies most of things here.

flang/test/Driver/pic-flags.f90

1

This comment is no longer valid

3

Why would you replace -### with -v? Same for other RUN lines.

[mnadeem]

flang/test/Driver/pic-flags.f90

3

I needed the command to run because I added check lines for the emitted LLVM IR, for example:

! CHECK-PIE-LEVEL1: !"PIC Level", i32 1}
! CHECK-PIE-LEVEL1: !"PIE Level", i32 1}

[awarzynski]

Left a few more comments and also added Diana as a reviewer. Would be good to get an extra pair of eyes on this :)

clang/include/clang/Driver/Options.td

6320–6325

Turns out that in Clang these options are indeed LangOptions. That's a bit confusing to me, but oh well.

clang/lib/Driver/ToolChains/Flang.cpp

120

Also, I'd move this whole block to a dedicated method.

flang/include/flang/Frontend/FrontendOptions.h

290–295

To me these are CodeGen options. Could you move this to https://github.com/llvm/llvm-project/blob/main/flang/include/flang/Frontend/CodeGenOptions.h?

flang/lib/Frontend/CompilerInvocation.cpp

151–162

Only -fpic and -fpie are tested/supported right? Please, could you trim this accordingly? Or, alternatively, expand the test.

flang/test/Driver/pic-flags.f90

3

Ah, of course! Thanks, I missed that earlier.

[MaskRay]

clang/include/clang/Driver/Options.td

6320–6325

clang/lib/Frontend/InitPreprocessor.cpp defines __PIC__.. IIUC the file does not know CodeGenOptions, so LangOptions isn't a bad choice.

[MaskRay]

flang/lib/Frontend/CompilerInvocation.cpp

151

Prefer == to equals

297

Use getLastArg when you need to do both hasArg and getLastArgValue.

flang/lib/Frontend/FrontendActions.cpp

532

expand auto

flang/test/Driver/driver-help.f90

131

wrong indentation?

[mnadeem]

• Moved mrelocation_model in Option.td to be near Codegen Options and put it in a let block.
• Moved all the options from FrontendOptions to CodeGenOptions
• Added ENUM_CODEGENOPT pragma in CodeGenOptions.def to handle the relocation model enum
• Transferred some code to a separate AddPicOptions() function
• Added more tests

[mnadeem]

flang/lib/Frontend/CompilerInvocation.cpp

151

Using llvm::StringSwitch now

151–162

Added more tests.

flang/lib/Frontend/FrontendActions.cpp

532

Changed the data type and logic.

[MaskRay]

flang/test/Driver/pic-flags.f90

59

I'd use ! CHECK-ROPI-NOT: "-pic

otherwise there is a risk that the pattern matches a temporary file named *-pic*.

[awarzynski]

Thanks for all the updates and for working on this! I'm not an expert in the semantics of -fpie/-fpic/-mrelocation-model, but this basically replicates the logic in Clang and I am not aware of any good reasons for Flang to diverge from that. This looks good to me.

I've left a few minor comments inline and would appreciate if you could address them before landing this. Thanks again for taking this on!

clang/include/clang/Driver/Options.td

5243

6320–6325

I think that we all agree that these options should remain somewhere withing the "Language Options" block, i.e. below:

//===----------------------------------------------------------------------===//
// Language Options
//===----------------------------------------------------------------------===//

As previously, you can use a let statement there:

let Flags = [CC1Option, FC1Option, NoDriverOption] in {
def pic_level : Separate<["-"], "pic-level">,
  HelpText<"Value for __PIC__">,
  MarshallingInfoInt<LangOpts<"PICLevel">>;
def pic_is_pie : Flag<["-"], "pic-is-pie">,
  HelpText<"File is for a position independent executable">,
  MarshallingInfoFlag<LangOpts<"PIE">>;

} // let Flags = [CC1Option, FC1Option, NoDriverOption]

flang/test/Driver/pic-flags.f90

1

[mnadeem]

clang/include/clang/Driver/Options.td

6320–6325

Sorry, missed that. Fixed now.

[clementval]

flang/test/Driver/pic-flags.f90

2–3

This test has been failing on my side for very long time. Just curious why we check for PIE-LEVEL-2 when no level is given. Where is the default given?

On my machine I have -mrelocation-model static for this run line.

[awarzynski]

flang/test/Driver/pic-flags.f90

2–3

This test has been failing on my side for very long time.

If this is failing for you then it should also fail on one of the Flang buildbots, right? Do you know what's different/special in your configuration?

Where is the default given?

You want to check:

• Flang::addPicOption (Flang.cpp)
• ParsePICArgs (CommonArgs.cpp)

[clementval]

flang/test/Driver/pic-flags.f90

2–3

If this is failing for you then it should also fail on one of the Flang buildbots, right? Do you know what's different/special in your configuration?

Well I probably have a config that is not in any buildbot.

In my configuration the PICLevel is 0 for flang-new -v -S -emit-llvm -o - /local/home/vclement/llvm-project/flang/test/Driver/pic-flags.f90 --target=aarch64-linux-gnu 2>&1

Which makes sense since no pic option is given. I'm wondering how it default to 2 on buildbot. I'll try to investigate.

clang/include/clang/Driver/Options.td

 let Flags = [CC1Option, CC1AsOption, NoDriverOption] in {
 
 def debug_info_kind_EQ : Joined<["-"], "debug-info-kind=">;
 def debug_info_macro : Flag<["-"], "debug-info-macro">,
   HelpText<"Emit macro debug information">,
   MarshallingInfoFlag<CodeGenOpts<"MacroDebugInfo">>;
 def default_function_attr : Separate<["-"], "default-function-attr">,
   HelpText<"Apply given attribute to all functions">,
   MarshallingInfoStringVector<CodeGenOpts<"DefaultFunctionAttrs">>;
 def dwarf_version_EQ : Joined<["-"], "dwarf-version=">,
   MarshallingInfoInt<CodeGenOpts<"DwarfVersion">>;
 def debugger_tuning_EQ : Joined<["-"], "debugger-tuning=">,
   Values<"gdb,lldb,sce,dbx">,
   NormalizedValuesScope<"llvm::DebuggerKind">, NormalizedValues<["GDB", "LLDB", "SCE", "DBX"]>,
   MarshallingInfoEnum<CodeGenOpts<"DebuggerTuning">, "Default">;
 def dwarf_debug_flags : Separate<["-"], "dwarf-debug-flags">,
   HelpText<"The string to embed in the Dwarf debug flags record.">,

 def mrelax_relocations : Flag<["--"], "mrelax-relocations">,
     HelpText<"Use relaxable elf relocations">,
     MarshallingInfoFlag<CodeGenOpts<"RelaxELFRelocations">>;
 def msave_temp_labels : Flag<["-"], "msave-temp-labels">,
   HelpText<"Save temporary labels in the symbol table. "
            "Note this may change .s semantics and shouldn't generally be used "
            "on compiler-generated code.">,
   MarshallingInfoFlag<CodeGenOpts<"SaveTempLabels">>;
-def mrelocation_model : Separate<["-"], "mrelocation-model">,
-  HelpText<"The relocation model to use">, Values<"static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic">,
-  NormalizedValuesScope<"llvm::Reloc">,
-  NormalizedValues<["Static", "PIC_", "ROPI", "RWPI", "ROPI_RWPI", "DynamicNoPIC"]>,
-  MarshallingInfoEnum<CodeGenOpts<"RelocationModel">, "PIC_">;
 def fno_math_builtin : Flag<["-"], "fno-math-builtin">,
   HelpText<"Disable implicit builtin knowledge of math functions">,
   MarshallingInfoFlag<LangOpts<"NoMathBuiltin">>;
 def fno_use_ctor_homing: Flag<["-"], "fno-use-ctor-homing">,
     HelpText<"Don't use constructor homing for debug info">;
 def fuse_ctor_homing: Flag<["-"], "fuse-ctor-homing">,
     HelpText<"Use constructor homing if we are using limited debug info already">;
 

 // Language Options
 //===----------------------------------------------------------------------===//
 
 def version : Flag<["-"], "version">,
   HelpText<"Print the compiler version">,
   Flags<[CC1Option, CC1AsOption, FC1Option, NoDriverOption]>,
   MarshallingInfoFlag<FrontendOpts<"ShowVersion">>;
 
+def mrelocation_model : Separate<["-"], "mrelocation-model">,
+  HelpText<"The relocation model to use">, Values<"static,pic,ropi,rwpi,ropi-rwpi,dynamic-no-pic">,
+  Flags<[CC1Option, CC1AsOption, FC1Option, NoDriverOption]>,
+  NormalizedValuesScope<"llvm::Reloc">,
+  NormalizedValues<["Static", "PIC_", "ROPI", "RWPI", "ROPI_RWPI", "DynamicNoPIC"]>,
+  MarshallingInfoEnum<CodeGenOpts<"RelocationModel">, "PIC_">;
+
 def main_file_name : Separate<["-"], "main-file-name">,
   HelpText<"Main file name to use for debug info and source if missing">,
   Flags<[CC1Option, CC1AsOption, NoDriverOption]>,
   MarshallingInfoString<CodeGenOpts<"MainFileName">>;
 def split_dwarf_output : Separate<["-"], "split-dwarf-output">,
   HelpText<"File name to use for split dwarf debug info output">,
   Flags<[CC1Option, CC1AsOption, NoDriverOption]>,
   MarshallingInfoString<CodeGenOpts<"SplitDwarfOutput">>;
def disable_objc_default_synthesize_properties : Flag<["-"], "disable-objc-default-synthesize-properties">,
   HelpText<"disable the default synthesis of Objective-C properties">,
   MarshallingInfoNegativeFlag<LangOpts<"ObjCDefaultSynthProperties">>;
 def fencode_extended_block_signature : Flag<["-"], "fencode-extended-block-signature">,
   HelpText<"enable extended encoding of block type signature">,
   MarshallingInfoFlag<LangOpts<"EncodeExtendedBlockSig">>;
 def function_alignment : Separate<["-"], "function-alignment">,
     HelpText<"default alignment for functions">,
     MarshallingInfoInt<LangOpts<"FunctionAlignment">>;
-def pic_level : Separate<["-"], "pic-level">,
-  HelpText<"Value for __PIC__">,
-  MarshallingInfoInt<LangOpts<"PICLevel">>;
-def pic_is_pie : Flag<["-"], "pic-is-pie">,
-  HelpText<"File is for a position independent executable">,
-  MarshallingInfoFlag<LangOpts<"PIE">>;
 def fhalf_no_semantic_interposition : Flag<["-"], "fhalf-no-semantic-interposition">,
   HelpText<"Like -fno-semantic-interposition but don't use local aliases">,
   MarshallingInfoFlag<LangOpts<"HalfNoSemanticInterposition">>;
 def fno_validate_pch : Flag<["-"], "fno-validate-pch">,
   HelpText<"Disable validation of precompiled headers">,
   MarshallingInfoFlag<PreprocessorOpts<"DisablePCHOrModuleValidation">, "DisableValidationForModuleKind::None">,
   Normalizer<"makeFlagToValueNormalizer(DisableValidationForModuleKind::All)">;
 def fallow_pcm_with_errors : Flag<["-"], "fallow-pcm-with-compiler-errors">,

 def load : Separate<["-"], "load">, MetaVarName<"<dsopath>">,
   HelpText<"Load the named plugin (dynamic shared object)">;
 def plugin : Separate<["-"], "plugin">, MetaVarName<"<name>">,
   HelpText<"Use the named plugin action instead of the default action (use \"help\" to list available options)">;
 defm debug_pass_manager : BoolOption<"f", "debug-pass-manager",
   CodeGenOpts<"DebugPassManager">, DefaultFalse,
   PosFlag<SetTrue, [], "Prints debug information for the new pass manager">,
   NegFlag<SetFalse, [], "Disables debug printing for the new pass manager">>;
+def pic_level : Separate<["-"], "pic-level">,
+  HelpText<"Value for __PIC__">,
+  MarshallingInfoInt<LangOpts<"PICLevel">>;
+def pic_is_pie : Flag<["-"], "pic-is-pie">,
+  HelpText<"File is for a position independent executable">,
+  MarshallingInfoFlag<LangOpts<"PIE">>;
 
 } // let Flags = [CC1Option, FC1Option, NoDriverOption]
 
 //===----------------------------------------------------------------------===//
 // cc1as-only Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1AsOption, NoDriverOption] in {

clang/lib/Driver/ToolChains/Clang.cpp

if (Value == "none") {
       }
     } else {
       D.Diag(diag::err_drv_unsupported_option_argument)
           << A->getOption().getName() << Value;
     }
   }
 }
 
-static const char *RelocationModelName(llvm::Reloc::Model Model) {
-  switch (Model) {
-  case llvm::Reloc::Static:
-    return "static";
-  case llvm::Reloc::PIC_:
-    return "pic";
-  case llvm::Reloc::DynamicNoPIC:
-    return "dynamic-no-pic";
-  case llvm::Reloc::ROPI:
-    return "ropi";
-  case llvm::Reloc::RWPI:
-    return "rwpi";
-  case llvm::Reloc::ROPI_RWPI:
-    return "ropi-rwpi";
-  }
-  llvm_unreachable("Unknown Reloc::Model kind");
-}
 static void handleAMDGPUCodeObjectVersionOptions(const Driver &D,
                                                  const ArgList &Args,
                                                  ArgStringList &CmdArgs,
                                                  bool IsCC1As = false) {
   // If no version was requested by the user, use the default value from the
   // back end. This is consistent with the value returned from
   // getAMDGPUCodeObjectVersion. This lets clang emit IR for amdgpu without
   // requiring the corresponding llvm to have the AMDGPU target enabled,

clang/lib/Driver/ToolChains/CommonArgs.h

 void SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T,
                     const JobAction &JA, const llvm::opt::ArgList &Args,
                     const InputInfo &Output, const char *OutFile);
 
 void addLTOOptions(const ToolChain &ToolChain, const llvm::opt::ArgList &Args,
                    llvm::opt::ArgStringList &CmdArgs, const InputInfo &Output,
                    const InputInfo &Input, bool IsThinLTO);
 
+const char *RelocationModelName(llvm::Reloc::Model Model);
+
 std::tuple<llvm::Reloc::Model, unsigned, bool>
 ParsePICArgs(const ToolChain &ToolChain, const llvm::opt::ArgList &Args);
 
 unsigned ParseFunctionAlignment(const ToolChain &TC,
                                 const llvm::opt::ArgList &Args);
 
 unsigned ParseDebugDefaultVersion(const ToolChain &TC,
                                   const llvm::opt::ArgList &Args);

clang/lib/Driver/ToolChains/CommonArgs.cpp

if (ProfileSampleUseArg &&
            options::OPT_fno_profile_sample_use) ||
        ProfileSampleUseArg->getOption().matches(options::OPT_fno_auto_profile)))
     return nullptr;
 
   return Args.getLastArg(options::OPT_fprofile_sample_use_EQ,
                          options::OPT_fauto_profile_EQ);
 }
 
+const char *tools::RelocationModelName(llvm::Reloc::Model Model) {
+  switch (Model) {
+  case llvm::Reloc::Static:
+    return "static";
+  case llvm::Reloc::PIC_:
+    return "pic";
+  case llvm::Reloc::DynamicNoPIC:
+    return "dynamic-no-pic";
+  case llvm::Reloc::ROPI:
+    return "ropi";
+  case llvm::Reloc::RWPI:
+    return "rwpi";
+  case llvm::Reloc::ROPI_RWPI:
+    return "ropi-rwpi";
+  }
+  llvm_unreachable("Unknown Reloc::Model kind");
+}
+
 /// Parses the various -fpic/-fPIC/-fpie/-fPIE arguments.  Then,
 /// smooshes them together with platform defaults, to decide whether
 /// this compile should be using PIC mode or not. Returns a tuple of
 /// (RelocationModel, PICLevel, IsPIE).
 std::tuple<llvm::Reloc::Model, unsigned, bool>
 tools::ParsePICArgs(const ToolChain &ToolChain, const ArgList &Args) {
   const llvm::Triple &EffectiveTriple = ToolChain.getEffectiveTriple();
   const llvm::Triple &Triple = ToolChain.getTriple();

clang/lib/Driver/ToolChains/Flang.cpp

void Flang::ConstructJob(Compilation &C, const JobAction &JA,
   // Color diagnostics are parsed by the driver directly from argv and later
   // re-parsed to construct this job; claim any possible color diagnostic here
   // to avoid warn_drv_unused_argument.
   Args.getLastArg(options::OPT_fcolor_diagnostics,
                   options::OPT_fno_color_diagnostics);
   if (D.getDiags().getDiagnosticOptions().ShowColors)
     CmdArgs.push_back("-fcolor-diagnostics");
 
+  // -fPIC/-fPIE and their variants. Similar to clang.
+  llvm::Reloc::Model RelocationModel;
+  unsigned PICLevel;
+  bool IsPIE;
+  std::tie(RelocationModel, PICLevel, IsPIE) = ParsePICArgs(TC, Args);
+
+  if (auto *RMName = RelocationModelName(RelocationModel)) {
+    CmdArgs.push_back("-mrelocation-model");
+    CmdArgs.push_back(RMName);
+  }
+  if (PICLevel > 0) {
+    CmdArgs.push_back("-pic-level");
+    CmdArgs.push_back(PICLevel == 1 ? "1" : "2");
+    if (IsPIE)
+      CmdArgs.push_back("-pic-is-pie");
+  }
+
   // Add other compile options
   AddOtherOptions(Args, CmdArgs);
 
   // Forward -Xflang arguments to -fc1
   Args.AddAllArgValues(CmdArgs, options::OPT_Xflang);
 
   // Forward -mllvm options to the LLVM option parser. In practice, this means
   // forwarding to `-fc1` as that's where the LLVM parser is run.

clang/lib/Driver/ToolChains/Linux.cpp

if (GCCInstallation.isValid()) {
     CC1Args.push_back("-isystem");
     CC1Args.push_back(DriverArgs.MakeArgString(
         GCCInstallation.getParentLibPath() + "/../" +
         GCCInstallation.getTriple().str() + "/include"));
   }
 }
 
 bool Linux::isPIEDefault(const llvm::opt::ArgList &Args) const {
-  // TODO: Remove the special treatment for Flang once its frontend driver can
-  // generate position independent code.
-  return !getDriver().IsFlangMode() &&
-         (CLANG_DEFAULT_PIE_ON_LINUX || getTriple().isAndroid() ||
-          getTriple().isMusl() || getSanitizerArgs(Args).requiresPIE());
+  return CLANG_DEFAULT_PIE_ON_LINUX || getTriple().isAndroid() ||
+         getTriple().isMusl() || getSanitizerArgs(Args).requiresPIE();
 }
 
 bool Linux::IsAArch64OutlineAtomicsDefault(const ArgList &Args) const {
   // Outline atomics for AArch64 are supported by compiler-rt
   // and libgcc since 9.3.1
   assert(getTriple().isAArch64() && "expected AArch64 target!");
   ToolChain::RuntimeLibType RtLib = GetRuntimeLibType(Args);
   if (RtLib == ToolChain::RLT_CompilerRT)

flang/include/flang/Frontend/FrontendOptions.h

 
 #ifndef FORTRAN_FRONTEND_FRONTENDOPTIONS_H
 #define FORTRAN_FRONTEND_FRONTENDOPTIONS_H
 
 #include "flang/Common/Fortran-features.h"
 #include "flang/Parser/characters.h"
 #include "flang/Parser/unparse.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/CodeGen.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cstdint>
 #include <string>
 
 namespace Fortran::frontend {
 
 enum ActionKind {
   /// -test-io mode
struct FrontendOptions {
   /// A list of arguments to forward to LLVM's option processing; this
   /// should only be used for debugging and experimental features.
   std::vector<std::string> llvmArgs;
 
   /// A list of arguments to forward to MLIR's option processing; this
   /// should only be used for debugging and experimental features.
   std::vector<std::string> mlirArgs;
 
+  /// Some targets need the pic levels. These are stored as
+  /// LLVM module flags.
+  llvm::Optional<llvm::PICLevel::Level> PICLevel;
+  llvm::Optional<llvm::PIELevel::Level> PIELevel;
+  /// For setting up the target machine.
+  llvm::Optional<llvm::Reloc::Model> RelocModel;
+
   // Return the appropriate input kind for a file extension. For example,
   /// "*.f" would return Language::Fortran.
   ///
   /// \return The input kind for the extension, or Language::Unknown if the
   /// extension is not recognized.
   static InputKind getInputKindForExtension(llvm::StringRef extension);
 };
 } // namespace Fortran::frontend
 
 #endif // FORTRAN_FRONTEND_FRONTENDOPTIONS_H

flang/lib/Frontend/CompilerInvocation.cpp

static void setUpFrontendBasedOnAction(FrontendOptions &opts) {
   if (opts.programAction == DebugDumpParsingLog)
     opts.instrumentedParse = true;
 
   if (opts.programAction == DebugDumpProvenance ||
       opts.programAction == Fortran::frontend::GetDefinition)
     opts.needProvenanceRangeToCharBlockMappings = true;
 }
 
+static llvm::Reloc::Model getRelocationFromName(llvm::StringRef model) {
+  if (model.equals("static"))
+    return llvm::Reloc::Static;
+  if (model.equals("pic"))
+    return llvm::Reloc::PIC_;
+  if (model.equals("dynamic-no-pic"))
+    return llvm::Reloc::DynamicNoPIC;
+  if (model.equals("ropi"))
+    return llvm::Reloc::ROPI;
+  if (model.equals("rwpi"))
+    return llvm::Reloc::RWPI;
+  if (model.equals("ropi-rwpi"))
+    return llvm::Reloc::ROPI_RWPI;
+  llvm_unreachable("Unknown relocation model.");
+}
+
 static bool parseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
                               clang::DiagnosticsEngine &diags) {
   unsigned numErrorsBefore = diags.getNumErrors();
 
   // By default the frontend driver creates a ParseSyntaxOnly action.
   opts.programAction = ParseSyntaxOnly;
 
   // Treat multiple action options as an invocation error. Note that `clang
if (llvm::opt::OptSpecifier(a->getOption().getID()) ==
         }
       }
       opts.getDefVals.line = optVals[0];
       opts.getDefVals.startColumn = optVals[1];
       opts.getDefVals.endColumn = optVals[2];
     }
   }
 
+  // Parse the PIC related -pic-level/-pic-is-pie/-mrelocation-model options.
+  if (int PICLevel = getLastArgIntValue(
+          args, clang::driver::options::OPT_pic_level, 0, diags)) {
+    opts.PICLevel = static_cast<llvm::PICLevel::Level>(PICLevel);
+    if (args.hasArg(clang::driver::options::OPT_pic_is_pie))
+      opts.PIELevel = static_cast<llvm::PIELevel::Level>(PICLevel);
+  }
+  if (args.hasArg(clang::driver::options::OPT_mrelocation_model)) {
+    llvm::StringRef model =
+        args.getLastArgValue(clang::driver::options::OPT_mrelocation_model);
+    opts.RelocModel = getRelocationFromName(model);
+  }
+
   // Parsing -load <dsopath> option and storing shared object path
   if (llvm::opt::Arg *a = args.getLastArg(clang::driver::options::OPT_load)) {
     opts.plugins.push_back(a->getValue());
   }
 
   // Parsing -plugin <name> option and storing plugin name and setting action
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_plugin)) {

flang/lib/Frontend/FrontendActions.cpp

if (!mlir::succeeded(pm.run(*mlirModule))) {
     ci.getDiagnostics().Report(diagID);
   }
 
   // Translate to LLVM IR
   llvm::Optional<llvm::StringRef> moduleName = mlirModule->getName();
   llvmModule = mlir::translateModuleToLLVMIR(
       *mlirModule, *llvmCtx, moduleName ? *moduleName : "FIRModule");
 
+  // Set PIC/PIE level LLVM module flags.
+  if (auto PICLevel = ci.getInvocation().getFrontendOpts().PICLevel)
+    llvmModule->setPICLevel(*PICLevel);
+  if (auto PIELevel = ci.getInvocation().getFrontendOpts().PIELevel)
+    llvmModule->setPIELevel(*PIELevel);
+
   if (!llvmModule) {
     unsigned diagID = ci.getDiagnostics().getCustomDiagID(
         clang::DiagnosticsEngine::Error, "failed to create the LLVM module");
     ci.getDiagnostics().Report(diagID);
     return;
   }
 }
 
const llvm::Target *theTarget =
       llvm::TargetRegistry::lookupTarget(theTriple, error);
   assert(theTarget && "Failed to create Target");
 
   // Create `TargetMachine`
   llvm::CodeGenOpt::Level OptLevel =
       getCGOptLevel(ci.getInvocation().getCodeGenOpts());
   tm.reset(theTarget->createTargetMachine(
       theTriple, /*CPU=*/"",
-      /*Features=*/"", llvm::TargetOptions(), /*Reloc::Model=*/llvm::None,
+      /*Features=*/"", llvm::TargetOptions(),
+      /*Reloc::Model=*/ci.getInvocation().getFrontendOpts().RelocModel,
       /*CodeModel::Model=*/llvm::None, OptLevel));
   assert(tm && "Failed to create TargetMachine");
 }
 
 static std::unique_ptr<llvm::raw_pwrite_stream>
 getOutputStream(CompilerInstance &ci, llvm::StringRef inFile,
                 BackendActionTy action) {
   switch (action) {

flang/test/Driver/driver-help.f90

 ! HELP-FC1-NEXT: -help                  Display available options
 ! HELP-FC1-NEXT: -init-only             Only execute frontend initialization
 ! HELP-FC1-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! HELP-FC1-NEXT: -load <dsopath>        Load the named plugin (dynamic shared object)
 ! HELP-FC1-NEXT: -mllvm <value>         Additional arguments to forward to LLVM's option processing
 ! HELP-FC1-NEXT: -mmlir <value>         Additional arguments to forward to MLIR's option processing
 ! HELP-FC1-NEXT: -module-dir <dir>      Put MODULE files in <dir>
 ! HELP-FC1-NEXT: -module-suffix <suffix> Use <suffix> as the suffix for module files (the default value is `.mod`)
+! HELP-FC1-NEXT:   -mrelocation-model <value>
+! HELP-FC1-NEXT:                           The relocation model to use
 ! HELP-FC1-NEXT: -nocpp                 Disable predefined and command line preprocessor macros
 ! HELP-FC1-NEXT: -o <file>              Write output to <file>
 ! HELP-FC1-NEXT: -pedantic              Warn on language extensions
+! HELP-FC1-NEXT: -pic-is-pie             File is for a position independent executable
+! HELP-FC1-NEXT: -pic-level <value>      Value for __PIC__
 ! HELP-FC1-NEXT: -plugin <name>         Use the named plugin action instead of the default action (use "help" to list available options)
 ! HELP-FC1-NEXT: -P                     Disable linemarker output in -E mode
 ! HELP-FC1-NEXT: -std=<value>           Language standard to compile for
 ! HELP-FC1-NEXT: -S                     Only run preprocess and compilation steps
 ! HELP-FC1-NEXT: -test-io               Run the InputOuputTest action. Use for development and testing only.
 ! HELP-FC1-NEXT: -triple <value>        Specify target triple (e.g. i686-apple-darwin9)
 ! HELP-FC1-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-FC1-NEXT: -version               Print the compiler version
 ! HELP-FC1-NEXT: -W<warning>            Enable the specified warning
 
 ! ERROR: error: unknown argument '-helps'; did you mean '-help'

flang/test/Driver/pic-flags.f90

 ! Verify that in contrast to Clang, Flang does not default to generating position independent executables/code
 
-! RUN: %flang -### %s --target=aarch64-linux-gnu 2>&1 | FileCheck %s --check-prefix=CHECK-NOPIE
-! RUN: %flang -### %s --target=aarch64-linux-gnu -fno-pie 2>&1 | FileCheck %s --check-prefix=CHECK-NOPIE
+! RUN: %flang -v -S -emit-llvm -o - %s --target=aarch64-linux-gnu -fno-pie 2>&1 | FileCheck %s --check-prefix=CHECK-NOPIE
 
-! RUN: %flang -### %s --target=aarch64-linux-gnu -fpie 2>&1 | FileCheck %s --check-prefix=CHECK-PIE
+! RUN: %flang -v -S -emit-llvm -o - %s --target=aarch64-linux-gnu 2>&1 | FileCheck %s --check-prefixes=CHECK-PIC,CHECK-PIE-LEVEL2
+! RUN: %flang -v -S -emit-llvm -o - %s --target=aarch64-linux-gnu -fpie 2>&1 | FileCheck %s --check-prefixes=CHECK-PIC,CHECK-PIE-LEVEL1
+! RUN: %flang -v -S -emit-llvm -o - %s --target=aarch64-linux-gnu -fPIE 2>&1 | FileCheck %s --check-prefixes=CHECK-PIC,CHECK-PIE-LEVEL2
+
+! RUN: %flang -v -S -emit-llvm -o - %s --target=aarch64-linux-gnu -fpic 2>&1 | FileCheck %s --check-prefixes=CHECK-PIC,CHECK-PIC-LEVEL1
+! RUN: %flang -v -S -emit-llvm -o - %s --target=aarch64-linux-gnu -fPIC 2>&1 | FileCheck %s --check-prefixes=CHECK-PIC,CHECK-PIC-LEVEL2
+
+! CHECK-NOPIE: -fc1
+! CHECK-NOPIE: -mrelocation-model static
+! CHECK-NOPIE-NOT: pic-level
+
+! CHECK-PIC: -fc1
+
+! CHECK-PIC-LEVEL1: -mrelocation-model pic -pic-level 1
+! CHECK-PIC-LEVEL1-NOT: -pic-is-pie
+! CHECK-PIC-LEVEL1-NOT: "PIE Level"
+! CHECK-PIC-LEVEL1: !"PIC Level", i32 1}
+! CHECK-PIC-LEVEL1-NOT: "PIE Level"
+
+! CHECK-PIC-LEVEL2: -mrelocation-model pic -pic-level 2
+! CHECK-PIC-LEVEL2-NOT: -pic-is-pie
+! CHECK-PIC-LEVEL1-NOT: "PIE Level"
+! CHECK-PIC-LEVEL2: !"PIC Level", i32 2}
+! CHECK-PIC-LEVEL1-NOT: "PIE Level"
+
+! CHECK-PIE-LEVEL1: -mrelocation-model pic -pic-level 1 -pic-is-pie
+! CHECK-PIE-LEVEL1: !"PIC Level", i32 1}
+! CHECK-PIE-LEVEL1: !"PIE Level", i32 1}
+! CHECK-PIE-LEVEL2: -mrelocation-model pic -pic-level 2 -pic-is-pie
+! CHECK-PIE-LEVEL2: !"PIC Level", i32 2}
+! CHECK-PIE-LEVEL2: !"PIE Level", i32 2}
 
-! CHECK-NOPIE: "-fc1"
-! CHECk-NOPIE-NOT: "-fpic"
-! CHECK-NOPIE: "{{.*}}ld"
-! CHECK-NOPIE-NOT: "-pie"
-
-! CHECK-PIE: "-fc1"
-!! TODO Once Flang supports `-fpie`, it //should// use -fpic when invoking `flang -fc1`. Update the following line once `-fpie` is
-! available.
-! CHECk-PIE-NOT: "-fpic"
-! CHECK-PIE: "{{.*}}ld"
-! CHECK-PIE-NOT: "-pie"