[ARM] Add diagnostics when initialization global variables with ropi/rwpi

[efriedma]

Summary

This patch adds diagnoses when initializing a global variable using the address of another global variable that uses ROPI/RWPI relocation model.

For example,
int a;
extern void foo();
int *x = &a; we cannot statically initialize x with -frwpi
void *y = &foo(); we can't statically initialize y with -fropi

[efriedma]

We really should be checking this much earlier.

IsGlobalLValue() in ExprConstant.cpp is the canonical place to answer the question "is the address of the given expression constant". Getting this right in semantic analysis means you don't have to chase down all the various places which generate global initializers. In addition to global variables, static local variables and compound literals can have static storage duration in C. And sometimes you can even run into trouble with globals which don't exist in the source code. One interesting example:

int a;
int g(const int**);
int f(void) {
  const int *x[] = {&a,&a,&a,&a,&a,&a,&a,&a};
  return g(x);
}

This is valid code whether or not we're in rwpi mode, but clang currently generates IR which won't link in rwpi mode. If semantic analysis concludes that &a isn't a constant, the correct code generation falls out naturally; otherwise, you have yet another place to add an explicit check in IR generation. And I won't even try to go into all the additional corner cases you can run into with C++ code.

As a bonus, you can generate nicer error messages in Sema.

[weimingz]

Hi Eli,
Thanks for the comments!
I though of implementation in Sema and I actually experimented a little bit. Then it seemed that the CodeGenOpts is only available in the CGM. Any ideas?

[efriedma]

If there isn't already a LangOptions flag which reflects this, it probably makes sense to add one.

[weimingz]

As Eli sugguested, it's better to check it in Sema. In order to access RelocationModel in Sema, we moved it from CodeGenOpts to LangOpts

[weimingz]

ping ?

include/clang/Basic/LangOptions.h

 #ifndef LLVM_CLANG_BASIC_LANGOPTIONS_H
 #define LLVM_CLANG_BASIC_LANGOPTIONS_H
 
 #include "clang/Basic/CommentOptions.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/Sanitizers.h"
 #include "clang/Basic/Visibility.h"
+#include "llvm/Support/CodeGen.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 
 /// Bitfields of LangOptions, split out from LangOptions in order to ensure that
 /// this large collection of bitfields is a trivial class type.
 class LangOptionsBase {

 #include "clang/Basic/LangOptions.def"
 };
 
 /// \brief Keeps track of the various options that can be
 /// enabled, which controls the dialect of C or C++ that is accepted.
 class LangOptions : public LangOptionsBase {
 public:
   typedef clang::Visibility Visibility;
-  
+  typedef llvm::Reloc::Model RelocModel;
   enum GCMode { NonGC, GCOnly, HybridGC };
   enum StackProtectorMode { SSPOff, SSPOn, SSPStrong, SSPReq };
   
   enum SignedOverflowBehaviorTy {
     SOB_Undefined,  // Default C standard behavior.
     SOB_Defined,    // -fwrapv
     SOB_Trapping    // -ftrapv
   };

include/clang/Basic/LangOptions.def

 LANGOPT(DefaultFPContract , 1, 0, "FP_CONTRACT")
 LANGOPT(NoBitFieldTypeAlign , 1, 0, "bit-field type alignment")
 LANGOPT(HexagonQdsp6Compat , 1, 0, "hexagon-qdsp6 backward compatibility")
 LANGOPT(ObjCAutoRefCount , 1, 0, "Objective-C automated reference counting")
 LANGOPT(ObjCWeakRuntime     , 1, 0, "__weak support in the ARC runtime")
 LANGOPT(ObjCWeak            , 1, 0, "Objective-C __weak in ARC and MRC files")
 LANGOPT(ObjCSubscriptingLegacyRuntime         , 1, 0, "Subscripting support in legacy ObjectiveC runtime")
 LANGOPT(FakeAddressSpaceMap , 1, 0, "OpenCL fake address space map")
+ENUM_LANGOPT(RelocationModel , RelocModel, 3, llvm::Reloc::PIC_, "Relocation model")
 ENUM_LANGOPT(AddressSpaceMapMangling , AddrSpaceMapMangling, 2, ASMM_Target, "OpenCL address space map mangling mode")
 LANGOPT(IncludeDefaultHeader, 1, 0, "Include default header file for OpenCL")
 BENIGN_LANGOPT(DelayedTemplateParsing , 1, 0, "delayed template parsing")
 LANGOPT(BlocksRuntimeOptional , 1, 0, "optional blocks runtime")
 
 ENUM_LANGOPT(GC, GCMode, 2, NonGC, "Objective-C Garbage Collection mode")
 ENUM_LANGOPT(ValueVisibilityMode, Visibility, 3, DefaultVisibility,
              "value symbol visibility")

include/clang/Frontend/CodeGenOptions.h

public:
   /// in situations where the input file name does not match the original input
   /// file, for example with -save-temps.
   std::string MainFileName;
 
   /// The name for the split debug info file that we'll break out. This is used
   /// in the backend for setting the name in the skeleton cu.
   std::string SplitDwarfFile;
 
-  /// The name of the relocation model to use.
-  std::string RelocationModel;
-
   /// The thread model to use
   std::string ThreadModel;
 
   /// If not an empty string, trap intrinsics are lowered to calls to this
   /// function instead of to trap instructions.
   std::string TrapFuncName;
 
   /// A list of command-line options to forward to the LLVM backend.

lib/AST/ExprConstant.cpp

 }
 
 /// Check that this reference or pointer core constant expression is a valid
 /// value for an address or reference constant expression. Return true if we
 /// can fold this expression, whether or not it's a constant expression.
 static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
                                           QualType Type, const LValue &LVal) {
   bool IsReferenceType = Type->isReferenceType();
-
   APValue::LValueBase Base = LVal.getLValueBase();
   const SubobjectDesignator &Designator = LVal.getLValueDesignator();
 
   // Check that the object is a global. Note that the fake 'this' object we
   // manufacture when checking potential constant expressions is conservatively
   // assumed to be global here.
   if (!IsGlobalLValue(Base)) {
     if (Info.getLangOpts().CPlusPlus11) {
       const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
       Info.FFDiag(Loc, diag::note_constexpr_non_global, 1)
         << IsReferenceType << !Designator.Entries.empty()
         << !!VD << VD;
       NoteLValueLocation(Info, Base);
     } else {
       Info.FFDiag(Loc);
     }
     // Don't allow references to temporaries to escape.
     return false;
   }
+
+  auto RM = Info.getLangOpts().getRelocationModel();
+  bool IsROPI = RM == llvm::Reloc::ROPI_RWPI || RM == llvm::Reloc::ROPI;
+  bool IsRWPI = RM == llvm::Reloc::ROPI_RWPI || RM == llvm::Reloc::RWPI;
+  if (Base && (IsROPI || IsRWPI)) {
+    if (const ValueDecl *D = Base.dyn_cast<const ValueDecl *>()) {
+      assert((isa<VarDecl>(D) || isa<FunctionDecl>(D)) &&
+             "unexpected ValueDecl type");
+      bool IsConstTyped = D->getType().isConstant(Info.Ctx);
+      if (isa<VarDecl>(D)) {
+        if ((IsRWPI && !IsConstTyped) || (IsROPI && IsConstTyped))
+          return false;
+      } else if (IsROPI) // Check ROPI with FunctionDecl.
+        return false;
+    }
+    // Check if Base is a read-only expr (e.g. StringLiteral) or compound
+    // literals that can be mutable or constant. Here only C related exprs are
+    // checked since C++ is disabled for ropi/rwpi.
+    if (const Expr *E = Base.dyn_cast<const Expr *>()) {
+      bool IsConstTyped = E->getType().isConstant(Info.Ctx);
+      switch (E->getStmtClass()) {
+      case Expr::CompoundLiteralExprClass:
+        if ((IsROPI && IsConstTyped) || (IsRWPI && !IsConstTyped))
+          return false;
+        break;
+      case Expr::StringLiteralClass:
+      case Expr::PredefinedExprClass:
+      case Expr::AddrLabelExprClass:
+        if (IsROPI)
+          return false;
+      default:
+        break;
+      }
+    }
+  }
+
   assert((Info.checkingPotentialConstantExpression() ||
           LVal.getLValueCallIndex() == 0) &&
          "have call index for global lvalue");
 
   if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) {
     if (const VarDecl *Var = dyn_cast<const VarDecl>(VD)) {
       // Check if this is a thread-local variable.
       if (Var->getTLSKind())

lib/CodeGen/BackendUtil.cpp

llvm::StringSwitch<unsigned>(CodeGenOpts.CodeModel)
       .Case("default", llvm::CodeModel::Default)
       .Default(~0u);
   assert(CodeModel != ~0u && "invalid code model!");
   llvm::CodeModel::Model CM = static_cast<llvm::CodeModel::Model>(CodeModel);
 
   std::string FeaturesStr =
       llvm::join(TargetOpts.Features.begin(), TargetOpts.Features.end(), ",");
 
-  // Keep this synced with the equivalent code in tools/driver/cc1as_main.cpp.
-  llvm::Optional<llvm::Reloc::Model> RM;
-  RM = llvm::StringSwitch<llvm::Reloc::Model>(CodeGenOpts.RelocationModel)
-           .Case("static", llvm::Reloc::Static)
-           .Case("pic", llvm::Reloc::PIC_)
-           .Case("ropi", llvm::Reloc::ROPI)
-           .Case("rwpi", llvm::Reloc::RWPI)
-           .Case("ropi-rwpi", llvm::Reloc::ROPI_RWPI)
-           .Case("dynamic-no-pic", llvm::Reloc::DynamicNoPIC);
-  assert(RM.hasValue() && "invalid PIC model!");
-
   CodeGenOpt::Level OptLevel;
   switch (CodeGenOpts.OptimizationLevel) {
   default:
     llvm_unreachable("Invalid optimization level!");
   case 0:
     OptLevel = CodeGenOpt::None;
     break;
   case 1:
void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
   for (const auto &Entry : HSOpts.UserEntries)
     if (!Entry.IsFramework &&
         (Entry.Group == frontend::IncludeDirGroup::Quoted ||
          Entry.Group == frontend::IncludeDirGroup::Angled ||
          Entry.Group == frontend::IncludeDirGroup::System))
       Options.MCOptions.IASSearchPaths.push_back(
           Entry.IgnoreSysRoot ? Entry.Path : HSOpts.Sysroot + Entry.Path);
 
-  TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr,
-                                          Options, RM, CM, OptLevel));
+  TM.reset(TheTarget->createTargetMachine(
+      Triple, TargetOpts.CPU, FeaturesStr, Options,
+      LangOpts.getRelocationModel(), CM, OptLevel));
 }
 
 bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
                                        BackendAction Action,
                                        raw_pwrite_stream &OS) {
   // Add LibraryInfo.
   llvm::Triple TargetTriple(TheModule->getTargetTriple());
   std::unique_ptr<TargetLibraryInfoImpl> TLII(

lib/Frontend/CodeGenOptions.cpp

 #include <string.h>
 
 namespace clang {
 
 CodeGenOptions::CodeGenOptions() {
 #define CODEGENOPT(Name, Bits, Default) Name = Default;
 #define ENUM_CODEGENOPT(Name, Type, Bits, Default) set##Name(Default);
 #include "clang/Frontend/CodeGenOptions.def"
-
-  RelocationModel = "pic";
   memcpy(CoverageVersion, "402*", 4);
 }
 
 bool CodeGenOptions::isNoBuiltinFunc(const char *Name) const {
   StringRef FuncName(Name);
   for (unsigned i = 0, e = NoBuiltinFuncs.size(); i != e; ++i)
     if (FuncName.equals(NoBuiltinFuncs[i]))
       return true;
   return false;
 }
 
 }  // end namespace clang

lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
   Opts.StrictEnums = Args.hasArg(OPT_fstrict_enums);
   Opts.StrictReturn = !Args.hasArg(OPT_fno_strict_return);
   Opts.StrictVTablePointers = Args.hasArg(OPT_fstrict_vtable_pointers);
   Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
                       Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
                       Args.hasArg(OPT_cl_fast_relaxed_math);
   Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
-  Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
   Opts.ThreadModel = Args.getLastArgValue(OPT_mthread_model, "posix");
   if (Opts.ThreadModel != "posix" && Opts.ThreadModel != "single")
     Diags.Report(diag::err_drv_invalid_value)
         << Args.getLastArg(OPT_mthread_model)->getAsString(Args)
         << Opts.ThreadModel;
   Opts.TrapFuncName = Args.getLastArgValue(OPT_ftrap_function_EQ);
   Opts.UseInitArray = Args.hasArg(OPT_fuse_init_array);
 
#include "clang/Frontend/LangStandards.def"
   Opts.EncodeExtendedBlockSig =
     Args.hasArg(OPT_fencode_extended_block_signature);
   Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
   Opts.PackStruct = getLastArgIntValue(Args, OPT_fpack_struct_EQ, 0, Diags);
   Opts.MaxTypeAlign = getLastArgIntValue(Args, OPT_fmax_type_align_EQ, 0, Diags);
   Opts.AlignDouble = Args.hasArg(OPT_malign_double);
   Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
   Opts.PIE = Args.hasArg(OPT_pic_is_pie);
+  // Keep this synced with the equivalent code in tools/driver/cc1as_main.cpp.
+  llvm::Reloc::Model RM;
+  RM = llvm::StringSwitch<llvm::Reloc::Model>(
+           Args.getLastArgValue(OPT_mrelocation_model, "pic"))
+           .Case("static", llvm::Reloc::Static)
+           .Case("pic", llvm::Reloc::PIC_)
+           .Case("ropi", llvm::Reloc::ROPI)
+           .Case("rwpi", llvm::Reloc::RWPI)
+           .Case("ropi-rwpi", llvm::Reloc::ROPI_RWPI)
+           .Case("dynamic-no-pic", llvm::Reloc::DynamicNoPIC)
+           .Default(llvm::Reloc::PIC_);
+  Opts.setRelocationModel(RM);
+
   Opts.Static = Args.hasArg(OPT_static_define);
   Opts.DumpRecordLayoutsSimple = Args.hasArg(OPT_fdump_record_layouts_simple);
   Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple
                         || Args.hasArg(OPT_fdump_record_layouts);
   Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
   Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
   Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
   Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);

test/CodeGen/arm-ropi-rwpi.c

+// REQUIRES: arm-registered-target
+
+// Below tests check if memcpy is not generated with ropi/rwpi for local var initialization.
+// RUN: %clang_cc1 -triple armv7 -S -emit-llvm -o - %s | FileCheck %s --check-prefix=DEFAULT
+// RUN: %clang_cc1 -triple armv7 -S -emit-llvm -mrelocation-model ropi  -o - %s | FileCheck %s --check-prefix=ROPI
+// RUN: %clang_cc1 -triple armv7 -S -emit-llvm -mrelocation-model rwpi  -o - %s | FileCheck %s --check-prefix=RWPI
+// RUN: %clang_cc1 -triple armv7 -S -emit-llvm -mrelocation-model ropi-rwpi  -o - %s | FileCheck %s --check-prefix=ROPI_RWPI
+
+extern int gv;
+extern const int c_gv;
+
+void test_local() {
+// DEFAULT-LABEL: @test_local
+// DEFAULT: call void @{{llvm.memcpy.*@test_local.x}}
+// DEFAULT: call void @{{llvm.memcpy.*@test_local.y}}
+
+// ROPI-LABEL: @test_local
+// ROPI: call void @{{llvm.memcpy.*@test_local.x}}
+// ROPI-NOT: call [e-mail]
+
+// RWPI-LABEL: @test_local
+// RWPI-NOT: call void@{{llvm.memcpy.*@test_local.x}}
+// RWPI: call void @{{llvm.memcpy.*@test_local.y}}
+
+// ROPI_RWPI-LABEL: @test_local
+// ROPI_RWPI-NOT: call void @llvm.memcpy
+
+  const int *x[] = {&gv, &gv, &gv}; // This is OK, no diagnostic.
+  func(x);
+  const int *y[] = {&c_gv, &c_gv, &c_gv}; // This is OK, no diagnostic.
+  func(y);
+}

test/Sema/ropi-rwpi.c

+// OK with local initialization, rwpi with const gv and ropi with non-const gv.
+// RUN: %clang_cc1 -triple armv7 -DDEFAULT -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple armv7 -DROPI -mrelocation-model ropi -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple armv7 -DRWPI -mrelocation-model rwpi -fsyntax-only -verify %s
+// RUN: %clang_cc1 -triple armv7 -DROPI -DRWPI -mrelocation-model ropi-rwpi -fsyntax-only -verify %s
+
+extern int func(const int* const []);
+
+extern int gv;
+extern const int c_gv;
+
+void *p1 = &func;
+const void *p2 = &c_gv;
+const int *p_compound_literal_c = &(const int){1};
+
+void ropi_test() {
+  static void *sp1 = &func;
+  static const void *sp2 = &c_gv;
+  static char(*x)[7] = &"abcdef";
+  static const void *x2 = &__func__;
+  static const int *const arr[2] = {&c_gv, &c_gv};
+  static void *addr = &&label1;
+label1:
+  return;
+}
+
+void *p3 = &gv;
+int *p_compound_literal = &(int){1};
+
+void rwpi_test() {
+  static void *sp1 = &gv;
+  static int *const arr[2] = {&gv, &gv};
+}
+
+unsigned test() {
+  unsigned a = (unsigned)&func;
+  unsigned b = (unsigned)&gv;
+  unsigned c = (unsigned)&c_gv;
+  return a + b + c;
+}
+
+#ifdef DEFAULT
+// expected-no-diagnostics
+#endif
+
+#if defined(ROPI)
+// expected-error@12 {{initializer element is not a compile-time constant}}
+// expected-error@13 {{initializer element is not a compile-time constant}}
+// expected-error@14 {{initializer element is not a compile-time constant}}
+
+// expected-error@17 {{initializer element is not a compile-time constant}}
+// expected-error@18 {{initializer element is not a compile-time constant}}
+// expected-error@19 {{initializer element is not a compile-time constant}}
+// expected-error@20 {{initializer element is not a compile-time constant}}
+// expected-error@21 {{initializer element is not a compile-time constant}}
+// expected-error@22 {{initializer element is not a compile-time constant}}
+#endif
+
+#if defined(RWPI)
+// expected-error@27 {{initializer element is not a compile-time constant}}
+// expected-error@28 {{initializer element is not a compile-time constant}}
+
+// expected-error@31 {{initializer element is not a compile-time constant}}
+// expected-error@32 {{initializer element is not a compile-time constant}}
+#endif