[CodeGen] Add codegen of IR function attribute fine_grained_bitfields

[jmciver]

Summary

This change helps to prevents mixing fine grained and non fine grained bit-field
addressing schemes, which can result in incorrect poison state at
initialization. The IR function attribute fine_grained_bitfields is only added
when fine grained bitfield accesses are enable. The attribute is used by opt to
prevent inlining.

[aaron.ballman]

The changes look reasonable to me as far as they go, but I'm not confident I understand the LLVM bits this builds on top of well enough to accept with much authority. So giving my LG, but not accepting the review so other reviewers can weigh in.

[jmciver]

I am closing this ticket as we are working on alternative solutions to poison based load semantics.

Thanks to everyone for taking the time to discuss this patch and its limitations!

clang/lib/CodeGen/CGCall.cpp

if (AttrOnCallSite) {
     if (CodeGenOpts.Backchain)
       FuncAttrs.addAttribute("backchain");
     if (CodeGenOpts.EnableSegmentedStacks)
       FuncAttrs.addAttribute("split-stack");
 
     if (CodeGenOpts.SpeculativeLoadHardening)
       FuncAttrs.addAttribute(llvm::Attribute::SpeculativeLoadHardening);
 
+    if (getTypes().getCodeGenOpts().FineGrainedBitfieldAccesses)
+      FuncAttrs.addAttribute(llvm::Attribute::FineGrainedBitfields);
+
     // Add zero-call-used-regs attribute.
     switch (CodeGenOpts.getZeroCallUsedRegs()) {
     case llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Skip:
       FuncAttrs.removeAttribute("zero-call-used-regs");
       break;
     case llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::UsedGPRArg:
       FuncAttrs.addAttribute("zero-call-used-regs", "used-gpr-arg");
       break;

clang/lib/CodeGen/CodeGenFunction.cpp

#undef SANITIZER
   Builder.setDefaultConstrainedExcept(FPExceptionBehavior);
   if ((FD && (FD->UsesFPIntrin() || FD->hasAttr<StrictFPAttr>())) ||
       (!FD && (FPExceptionBehavior != llvm::fp::ebIgnore ||
                RM != llvm::RoundingMode::NearestTiesToEven))) {
     Builder.setIsFPConstrained(true);
     Fn->addFnAttr(llvm::Attribute::StrictFP);
   }
 
+  // The fine grained bit-fields attribute is used to determine IPO inlining
+  // compatibility.
+  if (getTypes().getCodeGenOpts().FineGrainedBitfieldAccesses)
+    Fn->addFnAttr(llvm::Attribute::FineGrainedBitfields);
+
   // If a custom alignment is used, force realigning to this alignment on
   // any main function which certainly will need it.
   if (FD && ((FD->isMain() || FD->isMSVCRTEntryPoint()) &&
              CGM.getCodeGenOpts().StackAlignment))
     Fn->addFnAttr("stackrealign");
 
   // "main" doesn't need to zero out call-used registers.
   if (FD && FD->isMain())

clang/test/CodeGen/fine-grained-bitfield-accesses.c

+// RUN: %clang -ffine-grained-bitfield-accesses -S -emit-llvm -o - %s | FileCheck %s
+// CHECK: define{{.*}} @g(){{.*}} #[[GATTR:[0-9]+]] {
+// CHECK: declare{{.*}} void @f(ptr noundef){{.*}} #[[FATTR:[0-9]+]]
+// CHECK: attributes #[[GATTR]] = {{.*}} fine_grained_bitfields {{.*}}
+// CHECK: attributes #[[FATTR]] = {{.*}} fine_grained_bitfields {{.*}}
+//
+// Verify that the clang fine-grained-bitfield-accesses option adds the IR
+// function attribute fine_grained_bitfields.
+struct X {
+  int a : 8;
+  int b : 24;
+};
+
+void f(struct X*);
+
+int g() {
+  struct X x;
+  x.a = 10;
+  f(&x);
+  return x.a;
+}