Reduce the number of attributes attached to each function

[serge-sans-paille]

Summary

This takes advantage of the implicit default behavior to reduce the number of
attributes, which in turns reduces compilation time. I've observed -3% in
instruction count when compiling sqlite3 amalgamation with -O0

[nikic]

LGTM

Possibly some of these should be converted to enum attributes...

clang/lib/CodeGen/CGCall.cpp

case CodeGenOptions::FramePointerKind::NonLeaf:
       FpKind = "non-leaf";
       break;
     case CodeGenOptions::FramePointerKind::All:
       FpKind = "all";
       break;
     }
     FuncAttrs.addAttribute("frame-pointer", FpKind);
 
-    FuncAttrs.addAttribute("less-precise-fpmad",
-                           llvm::toStringRef(CodeGenOpts.LessPreciseFPMAD));
+    if (CodeGenOpts.LessPreciseFPMAD)
+      FuncAttrs.addAttribute("less-precise-fpmad", "true");
 
     if (CodeGenOpts.NullPointerIsValid)
       FuncAttrs.addAttribute(llvm::Attribute::NullPointerIsValid);
 
     if (CodeGenOpts.FPDenormalMode != llvm::DenormalMode::getIEEE())
       FuncAttrs.addAttribute("denormal-fp-math",
                              CodeGenOpts.FPDenormalMode.str());
     if (CodeGenOpts.FP32DenormalMode != CodeGenOpts.FPDenormalMode) {
       FuncAttrs.addAttribute(
           "denormal-fp-math-f32",
           CodeGenOpts.FP32DenormalMode.str());
     }
 
-    FuncAttrs.addAttribute("no-trapping-math",
-                           llvm::toStringRef(LangOpts.getFPExceptionMode() ==
-                                             LangOptions::FPE_Ignore));
+    if (LangOpts.getFPExceptionMode() == LangOptions::FPE_Ignore)
+      FuncAttrs.addAttribute("no-trapping-math", "true");
 
     // Strict (compliant) code is the default, so only add this attribute to
     // indicate that we are trying to workaround a problem case.
     if (!CodeGenOpts.StrictFloatCastOverflow)
       FuncAttrs.addAttribute("strict-float-cast-overflow", "false");
 
     // TODO: Are these all needed?
     // unsafe/inf/nan/nsz are handled by instruction-level FastMathFlags.
-    FuncAttrs.addAttribute("no-infs-fp-math",
-                           llvm::toStringRef(LangOpts.NoHonorInfs));
-    FuncAttrs.addAttribute("no-nans-fp-math",
-                           llvm::toStringRef(LangOpts.NoHonorNaNs));
-    FuncAttrs.addAttribute("unsafe-fp-math",
-                           llvm::toStringRef(LangOpts.UnsafeFPMath));
-    FuncAttrs.addAttribute("use-soft-float",
-                           llvm::toStringRef(CodeGenOpts.SoftFloat));
+    if (LangOpts.NoHonorInfs)
+      FuncAttrs.addAttribute("no-infs-fp-math", "true");
+    if (LangOpts.NoHonorNaNs)
+      FuncAttrs.addAttribute("no-nans-fp-math", "true");
+    if (LangOpts.UnsafeFPMath)
+      FuncAttrs.addAttribute("unsafe-fp-math", "true");
+    if (CodeGenOpts.SoftFloat)
+      FuncAttrs.addAttribute("use-soft-float", "true");
     FuncAttrs.addAttribute("stack-protector-buffer-size",
                            llvm::utostr(CodeGenOpts.SSPBufferSize));
-    FuncAttrs.addAttribute("no-signed-zeros-fp-math",
-                           llvm::toStringRef(LangOpts.NoSignedZero));
+    if (LangOpts.NoSignedZero)
+      FuncAttrs.addAttribute("no-signed-zeros-fp-math", "true");
 
     // TODO: Reciprocal estimate codegen options should apply to instructions?
     const std::vector<std::string> &Recips = CodeGenOpts.Reciprocals;
     if (!Recips.empty())
       FuncAttrs.addAttribute("reciprocal-estimates",
                              llvm::join(Recips, ","));
 
     if (!CodeGenOpts.PreferVectorWidth.empty() &&

clang/test/CodeGen/attr-target-x87-softfp.c

 // RUN: %clang_cc1 -triple x86_64-linux-gnu -target-cpu x86-64 -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=HARD
 // RUN: %clang_cc1 -msoft-float -triple x86_64-linux-gnu -target-cpu x86-64 -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK -check-prefix=SOFT
 
 int __attribute__((target("x87"))) foo(int a) { return 4; }
 int __attribute__((target("no-x87"))) bar(int a) { return 4; }
 
 // CHECK: foo{{.*}} #0
 // CHECK: bar{{.*}} #1
 
 // CHECK: #0 = {{.*}}"target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87"
-// HARD: "use-soft-float"="false"
+// HARD-NOT: "use-soft-float"
 // SOFT: "use-soft-float"="true"
 
 // CHECK: #1 = {{.*}}"target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,-x87"
-// HARD: "use-soft-float"="false"
+// HARD-NOT: "use-soft-float"
 // SOFT: "use-soft-float"="true"

clang/test/CodeGenOpenCL/no-signed-zeros.cl

 // RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s -check-prefix=NORMAL
 // RUN: %clang_cc1 %s -emit-llvm -cl-no-signed-zeros -o - | FileCheck %s -check-prefix=NO-SIGNED-ZEROS
 
 float signedzeros(float a) {
   return a;
 }
 
 // CHECK: attributes
-// NORMAL: "no-signed-zeros-fp-math"="false"
+// NORMAL-NOT: "no-signed-zeros-fp-math"
 // NO-SIGNED-ZEROS: "no-signed-zeros-fp-math"="true"

clang/test/CodeGenOpenCL/relaxed-fpmath.cl

float spscalardiv(float a, float b) {
   // FINITE: fdiv nnan ninf float
   // UNSAFE: fdiv reassoc nsz arcp afn float
   // MAD: fdiv float
   // NOSIGNED: fdiv nsz float
   return a / b;
 }
 // CHECK: attributes
 
-// NORMAL: "less-precise-fpmad"="false"
-// NORMAL: "no-infs-fp-math"="false"
-// NORMAL: "no-nans-fp-math"="false"
-// NORMAL: "no-signed-zeros-fp-math"="false"
-// NORMAL: "unsafe-fp-math"="false"
+// NORMAL-NOT: "less-precise-fpmad"
+// NORMAL-NOT: "no-infs-fp-math"
+// NORMAL-NOT: "no-nans-fp-math"
+// NORMAL-NOT: "no-signed-zeros-fp-math"
+// NORMAL-NOT: "unsafe-fp-math"
 
 // FAST: "less-precise-fpmad"="true"
 // FAST: "no-infs-fp-math"="true"
 // FAST: "no-nans-fp-math"="true"
 // FAST: "no-signed-zeros-fp-math"="true"
 // FAST: "unsafe-fp-math"="true"
 
-// FINITE: "less-precise-fpmad"="false"
+// FINITE-NOT: "less-precise-fpmad"
 // FINITE: "no-infs-fp-math"="true"
 // FINITE: "no-nans-fp-math"="true"
-// FINITE: "no-signed-zeros-fp-math"="false"
-// FINITE: "unsafe-fp-math"="false"
+// FINITE-NOT: "no-signed-zeros-fp-math"
+// FINITE-NOT: "unsafe-fp-math"
 
 // UNSAFE: "less-precise-fpmad"="true"
-// UNSAFE: "no-infs-fp-math"="false"
-// UNSAFE: "no-nans-fp-math"="false"
+// UNSAFE-NOT: "no-infs-fp-math"
+// UNSAFE-NOT: "no-nans-fp-math"
 // UNSAFE: "no-signed-zeros-fp-math"="true"
 // UNSAFE: "unsafe-fp-math"="true"
 
 // MAD: "less-precise-fpmad"="true"
-// MAD: "no-infs-fp-math"="false"
-// MAD: "no-nans-fp-math"="false"
-// MAD: "no-signed-zeros-fp-math"="false"
-// MAD: "unsafe-fp-math"="false"
-
-// NOSIGNED: "less-precise-fpmad"="false"
-// NOSIGNED: "no-infs-fp-math"="false"
-// NOSIGNED: "no-nans-fp-math"="false"
+// MAD-NOT: "no-infs-fp-math"
+// MAD-NOT: "no-nans-fp-math"
+// MAD-NOT: "no-signed-zeros-fp-math"
+// MAD-NOT: "unsafe-fp-math"
+
+// NOSIGNED-NOT: "less-precise-fpmad"
+// NOSIGNED-NOT: "no-infs-fp-math"
+// NOSIGNED-NOT: "no-nans-fp-math"
 // NOSIGNED: "no-signed-zeros-fp-math"="true"
-// NOSIGNED: "unsafe-fp-math"="false"
+// NOSIGNED-NOT: "unsafe-fp-math"
 
 #else
 // Undefine this to avoid putting it in the PCH.
 #undef GEN_PCH
 #endif