[Clang] Add option to allow marking pass-by-value args as noalias.

[fhahn]

Summary

After the recent discussion on cfe-dev 'Can indirect class parameters be
noalias?' [1], it seems like using using noalias is problematic for
current C++, but should be allowed for C-only code.

This patch introduces a new option to let the user indicate that it is
safe to mark indirect class parameters as noalias. Note that this also
applies to external callers, e.g. it might not be safe to use this flag
for C functions that are called by C++ functions.

In targets that allocate indirect arguments in the called function, this
enables more agressive optimizations with respect to memory operations
and brings a ~1% - 2% codesize reduction for some programs.

I am not sure about the best name for the option and description. I
would appreciate any feedback.

[1] : http://lists.llvm.org/pipermail/cfe-dev/2020-July/066353.html

[rsmith]

clang/include/clang/Basic/LangOptions.def

371–374

Per the comment at the top of the file, the description should be a single noun phrase; we use this in diagnostics such as "AST file was built with %0 enabled but it is currently disabled". Something like "assumption that by-value parameters do not alias any other values" maybe?

clang/include/clang/Driver/Options.td

4292–4295

This should be in Group<f_Group>.

[fhahn]

Thanks for taking a look!

I adjusted the LangOpts description and added the flag to f_Group, as suggested.

[fhahn]

ping

[fhahn]

ping :)

[fhahn]

ping :)

[rjmccall]

Is it acceptable to leave this as a -cc1 option while we're pursuing this with the language committee? Do we have any intent to pursue this with the language committee?

clang/include/clang/Basic/LangOptions.def

372

This should be a code-gen option, I think. I can't really imagine how this would affect language processing.

clang/include/clang/Driver/Options.td

4292–4295

The "Note" clause seems to muddy more than it clarifies. Maybe "has no effect on non-trivially-copyable classes in C++"? Or add proper documentation somewhere instead of trying to jam this into the help text.

clang/lib/CodeGen/CGCall.cpp

2198

This definitely can't be added unconditionally to all types; you need to rule out non-trivial C++ class types, as well as types with ObjC weak references.

[fhahn]

Change to codegen option, adjust description for option, limit to trivially copyable types in C++, add corresponding test cases.

[fhahn]

clang/include/clang/Driver/Options.td

4292–4295

I've added the clarification, thanks!

clang/lib/CodeGen/CGCall.cpp

2198

Updated to rule out non trivially-copyable types.

I am not sure how to best handle types with weak references. I did not manage to find any helpers that traverse a whole type to check if it contains weak references.

I added clang/test/CodeGenObjC/pass-by-value-noalias.m and IIUC noalias should not be added for that case.

[fhahn]

Also restrict to types that are isNonTrivialToPrimitiveCopy, so we do not add noalias for problematic types, like ObjC structs with weak references.

[rjmccall]

clang/lib/CodeGen/CGCall.cpp

2198

The restriction should not be by triviality but by whether indirectness is forced semantically. That may currently only be available on RecordDecl (as RecordDecl::getArgPassingRestrictions), but you could definitely add an accessor to Type which checked for a RecordType and otherwise returned that there are no passing constraints. Tagging Akira, who worked on this.

[fhahn]

Update code to limit adding noalias to types with getArgPassingRestrictions() == RecordDecl::APK_CanPassInRegs. This rules out problematic types, like ones with non-trivial constructors or ObjC structs with weak pointers. Thanks @rjmccall

I also added the escape cases shared on cfe-dev by @rsmith

[fhahn]

clang/lib/CodeGen/CGCall.cpp

2198

Thanks John, that does indeed exactly what we need I think. I updated the code to use getAsRecordDecl here. I can also add a helper to Type if it is useful beyond here.

[fhahn]

Add check lines for escape examples. Note that for return-by-value we already add noalias to the pointer unconditionally.

[rjmccall]

Just a minor tweak and then LGTM.

clang/include/clang/Driver/Options.td

4292–4295

Oh, you need a space after the period.

[fhahn]

clang/include/clang/Driver/Options.td

4292–4295

Done, thanks!

clang/include/clang/Basic/LangOptions.def

 
 LANGOPT(FixedPoint, 1, 0, "fixed point types")
 LANGOPT(PaddingOnUnsignedFixedPoint, 1, 0,
         "unsigned fixed point types having one extra padding bit")
 
 LANGOPT(RegisterStaticDestructors, 1, 1, "Register C++ static destructors")
 
 LANGOPT(MatrixTypes, 1, 0, "Enable or disable the builtin matrix type")
+LANGOPT(PassByValueIsNoAlias, 1, 0, "assumption that by-value parameters do "
+                                    "not alias any other values")
 
 COMPATIBLE_VALUE_LANGOPT(MaxTokens, 32, 0, "Max number of tokens per TU or 0")
 
 ENUM_LANGOPT(SignReturnAddressScope, SignReturnAddressScopeKind, 2, SignReturnAddressScopeKind::None,
              "Scope of return address signing")
 ENUM_LANGOPT(SignReturnAddressKey, SignReturnAddressKeyKind, 1, SignReturnAddressKeyKind::AKey,
              "Key used for return address signing")
 LANGOPT(BranchTargetEnforcement, 1, 0, "Branch-target enforcement enabled")
 
 LANGOPT(SpeculativeLoadHardening, 1, 0, "Speculative load hardening enabled")

clang/include/clang/Driver/Options.td

def fwchar_type_EQ : Joined<["-"], "fwchar-type=">,
   HelpText<"Select underlying type for wchar_t">, Values<"char,short,int">;
 def fsigned_wchar : Flag<["-"], "fsigned-wchar">,
   HelpText<"Use a signed type for wchar_t">;
 def fno_signed_wchar : Flag<["-"], "fno-signed-wchar">,
   HelpText<"Use an unsigned type for wchar_t">;
 def fcompatibility_qualified_id_block_param_type_checking : Flag<["-"], "fcompatibility-qualified-id-block-type-checking">,
   HelpText<"Allow using blocks with parameters of more specific type than "
            "the type system guarantees when a parameter is qualified id">;
+def fpass_by_value_is_noalias: Flag<["-"], "fpass-by-value-is-noalias">,
+  HelpText<"Allows assuming by-value parameters do not alias any other value."
+           "Note that this may not hold for C++.">, Group<f_Group>;
 
 // FIXME: Remove these entirely once functionality/tests have been excised.
 def fobjc_gc_only : Flag<["-"], "fobjc-gc-only">, Group<f_Group>,
   HelpText<"Use GC exclusively for Objective-C related memory management">;
 def fobjc_gc : Flag<["-"], "fobjc-gc">, Group<f_Group>,
   HelpText<"Enable Objective-C garbage collection">;
 
 //===----------------------------------------------------------------------===//
 // Header Search Options

clang/lib/CodeGen/CGCall.cpp

for (CGFunctionInfo::const_arg_iterator I = FI.arg_begin(),
 
     case ABIArgInfo::Indirect: {
       if (AI.getInReg())
         Attrs.addAttribute(llvm::Attribute::InReg);
 
       if (AI.getIndirectByVal())
         Attrs.addByValAttr(getTypes().ConvertTypeForMem(ParamType));
 
+      if (getLangOpts().PassByValueIsNoAlias)
+        // When calling the function, the pointer passed in will be the only
+        // reference to the underlying object. Mark it accordingly.
+        Attrs.addAttribute(llvm::Attribute::NoAlias);
+
       // TODO: We could add the byref attribute if not byval, but it would
       // require updating many testcases.
 
       CharUnits Align = AI.getIndirectAlign();
 
       // In a byval argument, it is important that the required
       // alignment of the type is honored, as LLVM might be creating a
       // *new* stack object, and needs to know what alignment to give

clang/lib/Frontend/CompilerInvocation.cpp

if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
     }
   }
 
   Opts.CompleteMemberPointers = Args.hasArg(OPT_fcomplete_member_pointers);
   Opts.BuildingPCHWithObjectFile = Args.hasArg(OPT_building_pch_with_obj);
   Opts.PCHInstantiateTemplates = Args.hasArg(OPT_fpch_instantiate_templates);
 
   Opts.MatrixTypes = Args.hasArg(OPT_fenable_matrix);
+  Opts.PassByValueIsNoAlias = Args.hasArg(OPT_fpass_by_value_is_noalias);
 
   Opts.MaxTokens = getLastArgIntValue(Args, OPT_fmax_tokens_EQ, 0, Diags);
 
   if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
     StringRef SignScope = A->getValue();
 
     if (SignScope.equals_lower("none"))
       Opts.setSignReturnAddressScope(

clang/test/CodeGen/pass-by-value-noalias.c

+// RUN: %clang_cc1 -fpass-by-value-is-noalias -triple arm64-apple-iphoneos -emit-llvm -disable-llvm-optzns %s -o - 2>&1 | FileCheck --check-prefix=WITH_NOALIAS %s
+// RUN: %clang_cc1 -triple arm64-apple-iphoneos -emit-llvm -disable-llvm-optzns %s -o - 2>&1 | FileCheck --check-prefix=NO_NOALIAS %s
+
+// A struct large enough so it is not passed in registers on ARM64.
+struct Foo {
+  int a;
+  int b;
+  int c;
+  int d;
+  int e;
+  int f;
+};
+
+// WITH_NOALIAS: define void @take(%struct.Foo* noalias %arg)
+// NO_NOALIAS: define void @take(%struct.Foo* %arg)
+void take(struct Foo arg) {}