Normalize usage of StrBoolAttr

[serge-sans-paille]

Summary

Priori to this patch, StrBoolAttr attributes had the strange property to be either unset, set to false or set to true. And the associated value was a string containing either "true" or "false". This is both cumbersome to use and inefficient.

This patch propose to no longer use the value filed, and just check the presence of the attribute, which was already an established practice in part of the LLVM codebase, see for instance https://reviews.llvm.org/D96400
As a side effect, when compiling sqlite3.c source code in -O0, this change makes the instruction count decrease from 6,157,211,048 to 6,155,407,798. Simpler and faster.

[jdoerfert]

I like this change.

[nikic]

Looks good conceptually. Only concern I have is that we used to emit some of these attributes with explicit ="false" (I think -- correct me if I'm wrong), in which case existing bitcode would now be interpreted as if the attribute was enabled, not disabled. I think we need some AutoUpgrade handling to drop the attribute from existing bitcode in that case.

[nikic]

clang/lib/CodeGen/CGCall.cpp

1819

Why did this one not change?

[serge-sans-paille]

In D99080#2642019, @nikic wrote:

Looks good conceptually. Only concern I have is that we used to emit some of these attributes with explicit ="false" (I think -- correct me if I'm wrong), in which case existing bitcode would now be interpreted as if the attribute was enabled, not disabled. I think we need some AutoUpgrade handling to drop the attribute from existing bitcode in that case.

OK, I never did this before but that definitively sounds important to me.

clang/lib/CodeGen/CGCall.cpp

1819

Because it's not listed as a`StrBoolAttr` but just a regular String Attribute

[serge-sans-paille]

Add AutoUpgrade path, plus some extra asserts

[nikic]

LGTM apart from the broken assert.

llvm/lib/IR/Attributes.cpp

1672

This needs a llvm/IR/Attributes.inc include to actually do anything. Also typo doens't.

[nikic]

On second thought, I think this needs a test for the AutoUpgrade part. In particular I suspect that the AutoUpgrade will not work if you actually enable that assertion you added, as that also goes through AttrBuilder.

[serge-sans-paille]

Fix missing include + add auto upgrade test

[serge-sans-paille]

Thanks @nikic for pointing me in the assert direction; i've been prting without much trouble all exisiting test to use the form proposed in this review, and I'm now in an interesting situation; What if the following code:

 define double @unsafe_fp_math_off(double %x) {
  %div = fdiv double %x, 2.0
  ret double %div
}

gets compiled without extra flag? There's no unsafe math flag anywhere, so it's indeed a div. If I add the attribute "unsafe-fp-math" I get a mul, and that's fine.

If I compiler this code with -enable-unsafe-fp-math from llc, it's equivalent to having the "unsafe-fp-math", and that's fine too. But then with current design, there's no way to *force* that function into safe mode, whatever the CLI passed to llc.

Stated otherwise, having three states for a str bool attribute indeed has one quality: the attribute can be in the *unset* state, where CLI argument can prevail.

[nikic]

In D99080#2647980, @serge-sans-paille wrote:

If I compiler this code with -enable-unsafe-fp-math from llc, it's equivalent to having the "unsafe-fp-math", and that's fine too. But then with current design, there's no way to *force* that function into safe mode, whatever the CLI passed to llc.

Stated otherwise, having three states for a str bool attribute indeed has one quality: the attribute can be in the *unset* state, where CLI argument can prevail.

My view on this is that all relevant information must be encoded in the IR (be it via FMF flags, attributes or module flags) for LTO reasons. opt/llc flags can only exist as a testing convenience, and it's okay if they force behavior without a way to opt-out. If you need to opt-out, don't pass the flag :)

[serge-sans-paille]

I kept the simplifcation of the API while not chagnign the representation int his alternative review: https://reviews.llvm.org/D99299 It doesn't have the performance gain of this patch, but the representation is unchanged which makes it easier to review. And it's backward compatible, so no need to auto-upgrade

[nikic]

Should this one be abandoned now?

[serge-sans-paille]

In D99080#2723694, @nikic wrote:

Should this one be abandoned now?

It depends. I'd like it to land, but that means changing the behavior of

--enable-no-infs-fp-math                                              - Enable FP math optimizations that assume no +-Infs
--enable-no-nans-fp-math                                              - Enable FP math optimizations that assume no NaNs
--enable-no-signed-zeros-fp-math                                      - Enable FP math optimizations that assume the sign of 0 is insignificant
--enable-no-trapping-fp-math                                          - Enable setting the FP exceptions build attribute not to use exceptions
--enable-unsafe-fp-math                                               - Enable optimizations that may decrease FP precision

from lli. Maybe I should post a small RFC on that topic ?

[nikic]

In D99080#2724930, @serge-sans-paille wrote:

In D99080#2723694, @nikic wrote:

Should this one be abandoned now?

It depends. I'd like it to land, but that means changing the behavior of

--enable-no-infs-fp-math                                              - Enable FP math optimizations that assume no +-Infs
--enable-no-nans-fp-math                                              - Enable FP math optimizations that assume no NaNs
--enable-no-signed-zeros-fp-math                                      - Enable FP math optimizations that assume the sign of 0 is insignificant
--enable-no-trapping-fp-math                                          - Enable setting the FP exceptions build attribute not to use exceptions
--enable-unsafe-fp-math                                               - Enable optimizations that may decrease FP precision

from lli. Maybe I should post a small RFC on that topic ?

It would be ideal to drop these llc flags completely, and adjust the tests that use them to use FMF flags. I don't think they serve any purpose apart from making bad tests simpler to write. @spatel Are there any nearer-term plans to drop support for global fast math attributes/flags?

[spatel]

In D99080#2756453, @nikic wrote:

In D99080#2724930, @serge-sans-paille wrote:

In D99080#2723694, @nikic wrote:

Should this one be abandoned now?

It depends. I'd like it to land, but that means changing the behavior of

--enable-no-infs-fp-math                                              - Enable FP math optimizations that assume no +-Infs
--enable-no-nans-fp-math                                              - Enable FP math optimizations that assume no NaNs
--enable-no-signed-zeros-fp-math                                      - Enable FP math optimizations that assume the sign of 0 is insignificant
--enable-no-trapping-fp-math                                          - Enable setting the FP exceptions build attribute not to use exceptions
--enable-unsafe-fp-math                                               - Enable optimizations that may decrease FP precision

from lli. Maybe I should post a small RFC on that topic ?

It would be ideal to drop these llc flags completely, and adjust the tests that use them to use FMF flags. I don't think they serve any purpose apart from making bad tests simpler to write.

Agree. IIUC, we can do that part now without waiting for the next question to be resolved...

@spatel Are there any nearer-term plans to drop support for global fast math attributes/flags?

We haven't made much progress lately. I think we need to propagate FMF on FP values more thoroughly -- function arguments, casts, and possibly memory ops (not sure how that reconciles with type-less memory) -- to guarantee that FMF is a complete replacement for the global flags in IR ( https://llvm.org/PR35607 ). But it's also possible that the backend is already good enough now that we can try it there (but it's a job that requires updating lots of codegen tests last time I checked).

[serge-sans-paille]

It would be ideal to drop these llc flags completely, and adjust the tests that use them to use FMF flags. I don't think they serve any purpose apart from making bad tests simpler to write.

Agree. IIUC, we can do that part now without waiting for the next question to be resolved...

I'm going that way then.

[serge-sans-paille]

This change introduces a behavior change: when an attribute is not set, it used to mean `use the default value''. It now means `attribute unset''.

[serge-sans-paille]

@nikic here is the follow-up you were looking for

[nikic]

This is going to be pretty impossible to review in the current form :) I think it would be best if you just directly commit all changes that just do "remove "foobar"="false" from tests. That's just NFC cleanup of unnecessary attributes, and should cut down the size of this diff by a lot.

[nikic]

This patch can probably be abandoned?

clang/lib/CodeGen/CGCall.cpp

case CodeGenOptions::FramePointerKind::NonLeaf:
       break;
     case CodeGenOptions::FramePointerKind::All:
       FpKind = "all";
       break;
     }
     FuncAttrs.addAttribute("frame-pointer", FpKind);
 
     if (CodeGenOpts.LessPreciseFPMAD)
-      FuncAttrs.addAttribute("less-precise-fpmad", "true");
+      FuncAttrs.addAttribute("less-precise-fpmad");
 
     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());
     }
 
     if (LangOpts.getFPExceptionMode() == LangOptions::FPE_Ignore)
-      FuncAttrs.addAttribute("no-trapping-math", "true");
+      FuncAttrs.addAttribute("no-trapping-math");
 
     // 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.
     if (LangOpts.NoHonorInfs)
-      FuncAttrs.addAttribute("no-infs-fp-math", "true");
+      FuncAttrs.addAttribute("no-infs-fp-math");
     if (LangOpts.NoHonorNaNs)
-      FuncAttrs.addAttribute("no-nans-fp-math", "true");
+      FuncAttrs.addAttribute("no-nans-fp-math");
     if (LangOpts.UnsafeFPMath)
-      FuncAttrs.addAttribute("unsafe-fp-math", "true");
+      FuncAttrs.addAttribute("unsafe-fp-math");
     if (CodeGenOpts.SoftFloat)
       FuncAttrs.addAttribute("use-soft-float", "true");
     FuncAttrs.addAttribute("stack-protector-buffer-size",
                            llvm::utostr(CodeGenOpts.SSPBufferSize));
     if (LangOpts.NoSignedZero)
-      FuncAttrs.addAttribute("no-signed-zeros-fp-math", "true");
+      FuncAttrs.addAttribute("no-signed-zeros-fp-math");
 
     // 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/lib/CodeGen/CodeGenFunction.cpp

void CodeGenFunction::CGFPOptionsRAII::ConstructorHelper(FPOptions FPFeatures) {
   assert((CGF.CurFuncDecl == nullptr || CGF.Builder.getIsFPConstrained() ||
           isa<CXXConstructorDecl>(CGF.CurFuncDecl) ||
           isa<CXXDestructorDecl>(CGF.CurFuncDecl) ||
           (NewExceptionBehavior == llvm::fp::ebIgnore &&
            NewRoundingBehavior == llvm::RoundingMode::NearestTiesToEven)) &&
          "FPConstrained should be enabled on entire function");
 
   auto mergeFnAttrValue = [&](StringRef Name, bool Value) {
-    auto OldValue =
-        CGF.CurFn->getFnAttribute(Name).getValueAsString() == "true";
+    auto OldValue = CGF.CurFn->hasFnAttribute(Name);
     auto NewValue = OldValue & Value;
-    if (OldValue != NewValue)
-      CGF.CurFn->addFnAttr(Name, llvm::toStringRef(NewValue));
+    if (OldValue && !NewValue)
+      CGF.CurFn->removeFnAttr(Name);
   };
   mergeFnAttrValue("no-infs-fp-math", FPFeatures.getNoHonorInfs());
   mergeFnAttrValue("no-nans-fp-math", FPFeatures.getNoHonorNaNs());
   mergeFnAttrValue("no-signed-zeros-fp-math", FPFeatures.getNoSignedZero());
   mergeFnAttrValue("unsafe-fp-math", FPFeatures.getAllowFPReassociate() &&
                                          FPFeatures.getAllowReciprocal() &&
                                          FPFeatures.getAllowApproxFunc() &&
                                          FPFeatures.getNoSignedZero());
#undef SANITIZER
   if (Count && Offset <= Count) {
     Fn->addFnAttr("patchable-function-entry", std::to_string(Count - Offset));
     if (Offset)
       Fn->addFnAttr("patchable-function-prefix", std::to_string(Offset));
   }
 
   // Add no-jump-tables value.
   if (CGM.getCodeGenOpts().NoUseJumpTables)
-    Fn->addFnAttr("no-jump-tables", "true");
+    Fn->addFnAttr("no-jump-tables");
 
   // Add no-inline-line-tables value.
   if (CGM.getCodeGenOpts().NoInlineLineTables)
     Fn->addFnAttr("no-inline-line-tables");
 
   // Add profile-sample-accurate value.
   if (CGM.getCodeGenOpts().ProfileSampleAccurate)
     Fn->addFnAttr("profile-sample-accurate");

llvm/include/llvm/CodeGen/TargetLowering.h

#include "llvm/IR/ConstrainedOps.def"
   /// Return true if the operation uses custom lowering, regardless of whether
   /// the type is legal or not.
   bool isOperationCustom(unsigned Op, EVT VT) const {
     return getOperationAction(Op, VT) == Custom;
   }
 
   /// Return true if lowering to a jump table is allowed.
   virtual bool areJTsAllowed(const Function *Fn) const {
-    if (Fn->getFnAttribute("no-jump-tables").getValueAsString() == "true")
+    if (Fn->hasFnAttribute("no-jump-tables"))
       return false;
 
     return isOperationLegalOrCustom(ISD::BR_JT, MVT::Other) ||
            isOperationLegalOrCustom(ISD::BRIND, MVT::Other);
   }
 
   /// Check whether the range [Low,High] fits in a machine word.
   bool rangeFitsInWord(const APInt &Low, const APInt &High,

llvm/lib/Analysis/IVDescriptors.cpp

 bool RecurrenceDescriptor::isReductionPHI(PHINode *Phi, Loop *TheLoop,
                                           RecurrenceDescriptor &RedDes,
                                           DemandedBits *DB, AssumptionCache *AC,
                                           DominatorTree *DT) {
 
   BasicBlock *Header = TheLoop->getHeader();
   Function &F = *Header->getParent();
   FastMathFlags FMF;
-  FMF.setNoNaNs(
-      F.getFnAttribute("no-nans-fp-math").getValueAsString() == "true");
-  FMF.setNoSignedZeros(
-      F.getFnAttribute("no-signed-zeros-fp-math").getValueAsString() == "true");
+  FMF.setNoNaNs(F.hasFnAttribute("no-nans-fp-math"));
+  FMF.setNoSignedZeros(F.hasFnAttribute("no-signed-zeros-fp-math"));
 
   if (AddReductionVar(Phi, RecurKind::Add, TheLoop, FMF, RedDes, DB, AC, DT)) {
     LLVM_DEBUG(dbgs() << "Found an ADD reduction PHI." << *Phi << "\n");
     return true;
   }
   if (AddReductionVar(Phi, RecurKind::Mul, TheLoop, FMF, RedDes, DB, AC, DT)) {
     LLVM_DEBUG(dbgs() << "Found a MUL reduction PHI." << *Phi << "\n");
     return true;

llvm/lib/IR/Attributes.cpp

void AttrBuilder::clear() {
   ByValType = nullptr;
   StructRetType = nullptr;
   ByRefType = nullptr;
   PreallocatedType = nullptr;
 }
 
 AttrBuilder &AttrBuilder::addAttribute(Attribute Attr) {
   if (Attr.isStringAttribute()) {
+
+#ifndef NDEBUG
+    // ensure StrBoolAttr are either set or unset, without any value set
+#define GET_ATTR_NAMES
+#define ATTRIBUTE_STRBOOL(ENUM_NAME, DISPLAY_NAME)                             \
+  if (Attr.getKindAsString() == #DISPLAY_NAME)                                 \
+    assert(Attr.getValueAsString().empty() && "StrBoolAttr doens't need "      \
+                                              "value");
+#endif
+
     addAttribute(Attr.getKindAsString(), Attr.getValueAsString());
     return *this;
   }
 
   Attribute::AttrKind Kind = Attr.getKindAsEnum();
   Attrs[Kind] = true;
 
   if (Kind == Attribute::Alignment)
static void set(Function &Fn,
     else
       Fn.removeFnAttr(Kind);
   }
 };
 
 struct StrBoolAttr {
   static bool isSet(const Function &Fn,
                     StringRef Kind) {
-    auto A = Fn.getFnAttribute(Kind);
-    return A.getValueAsString().equals("true");
+    return Fn.hasFnAttribute(Kind);
   }
 
   static void set(Function &Fn,
                   StringRef Kind, bool Val) {
-    Fn.addFnAttr(Kind, Val ? "true" : "false");
+    if (Val)
+      Fn.addFnAttr(Kind);
+    else
+      Fn.removeFnAttr(Kind);
   }
 };
 
 #define GET_ATTR_NAMES
 #define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME)                                \
   struct ENUM_NAME##Attr : EnumAttr {                                          \
     static enum Attribute::AttrKind getKind() {                                \
       return llvm::Attribute::ENUM_NAME;                                       \
     }                                                                          \
   };
 #define ATTRIBUTE_STRBOOL(ENUM_NAME, DISPLAY_NAME)                             \
   struct ENUM_NAME##Attr : StrBoolAttr {                                       \
     static StringRef getKind() { return #DISPLAY_NAME; }                       \
   };
 #include "llvm/IR/Attributes.inc"
 
 #define GET_ATTR_COMPAT_FUNC
 #include "llvm/IR/Attributes.inc"
 

llvm/lib/IR/AutoUpgrade.cpp

std::string llvm::UpgradeDataLayoutString(StringRef DL, StringRef TT) {
   Regex R("(e-m:[a-z](-p:32:32)?)(-[if]64:.*$)");
   if (!R.match(DL, &Groups))
     return std::string(DL);
 
   return (Groups[1] + AddrSpaces + Groups[3]).str();
 }
 
 void llvm::UpgradeAttributes(AttrBuilder &B) {
+  // StrBoolAttributes are either set with no value, or unset
+  SmallVector<StringRef> ToRemove;
+  for (auto &KV : B.td_attrs()) {
+#define GET_ATTR_NAMES
+#define ATTRIBUTE_STRBOOL(ENUM_NAME, DISPLAY_NAME)                             \
+  if (KV.first == #DISPLAY_NAME) {                                             \
+    if (KV.second == "false")                                                  \
+      ToRemove.push_back(KV.first);                                            \
+    else if (KV.second == "true")                                              \
+      KV.second = "";                                                          \
+  }
+#include "llvm/IR/Attributes.inc"
+  }
+  for (auto const &AttrName : ToRemove)
+    B.removeAttribute(AttrName);
+
   StringRef FramePointer;
   if (B.contains("no-frame-pointer-elim")) {
     // The value can be "true" or "false".
     for (const auto &I : B.td_attrs())
       if (I.first == "no-frame-pointer-elim")
         FramePointer = I.second == "true" ? "all" : "none";
     B.removeAttribute("no-frame-pointer-elim");
   }

llvm/lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

if (NewFDiv) {
     NewFDiv->takeName(&FDiv);
     FDiv.eraseFromParent();
   }
 
   return !!NewFDiv;
 }
 
 static bool hasUnsafeFPMath(const Function &F) {
-  Attribute Attr = F.getFnAttribute("unsafe-fp-math");
-  return Attr.getValueAsString() == "true";
+  return F.hasFnAttribute("unsafe-fp-math");
 }
 
 static std::pair<Value*, Value*> getMul64(IRBuilder<> &Builder,
                                           Value *LHS, Value *RHS) {
   Type *I32Ty = Builder.getInt32Ty();
   Type *I64Ty = Builder.getInt64Ty();
 
   Value *LHS_EXT64 = Builder.CreateZExt(LHS, I64Ty);

llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp

bool AMDGPULibCalls::parseFunctionName(const StringRef& FMangledName,
   return AMDGPULibFunc::parse(FMangledName, *FInfo);
 }
 
 bool AMDGPULibCalls::isUnsafeMath(const CallInst *CI) const {
   if (auto Op = dyn_cast<FPMathOperator>(CI))
     if (Op->isFast())
       return true;
   const Function *F = CI->getParent()->getParent();
-  Attribute Attr = F->getFnAttribute("unsafe-fp-math");
-  return Attr.getValueAsString() == "true";
+  return F->hasFnAttribute("unsafe-fp-math");
 }
 
 bool AMDGPULibCalls::useNativeFunc(const StringRef F) const {
   return AllNative || llvm::is_contained(UseNative, F);
 }
 
 void AMDGPULibCalls::initNativeFuncs() {
   AllNative = useNativeFunc("all") ||

llvm/lib/Target/ARM/ARMAsmPrinter.cpp

 // FIXME:
 // The following seem like one-off assembler flags, but they actually need
 // to appear in the .ARM.attributes section in ELF.
 // Instead of subclassing the MCELFStreamer, we do the work here.
 
  // Returns true if all functions have the same function attribute value.
  // It also returns true when the module has no functions.
 static bool checkFunctionsAttributeConsistency(const Module &M, StringRef Attr,
-                                               StringRef Value) {
-   return !any_of(M, [&](const Function &F) {
-       return F.getFnAttribute(Attr).getValueAsString() != Value;
-   });
+                                               bool Value) {
+  return all_of(
+      M, [&](const Function &F) { return F.hasFnAttribute(Attr) == Value; });
 }
 // Returns true if all functions have the same denormal mode.
 // It also returns true when the module has no functions.
 static bool checkDenormalAttributeConsistency(const Module &M,
                                               StringRef Attr,
                                               DenormalMode Value) {
   return !any_of(M, [&](const Function &F) {
     StringRef AttrVal = F.getFnAttribute(Attr).getValueAsString();
else {
     // to whether denormals are flushed to positive zero or to
     // whatever the sign of zero is (ARM v7AR ARM 2.7.5). Historically
     // LLVM has chosen to flush this to positive zero (most likely for
     // GCC compatibility), so that's the chosen value here (the
     // absence of its emission implies zero).
   }
 
   // Set FP exceptions and rounding
   if (checkFunctionsAttributeConsistency(*MMI->getModule(),
-                                         "no-trapping-math", "true") ||
+                                         "no-trapping-math") ||
       TM.Options.NoTrappingFPMath)
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_exceptions,
                       ARMBuildAttrs::Not_Allowed);
   else if (!TM.Options.UnsafeFPMath) {
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_exceptions, ARMBuildAttrs::Allowed);
 
     // If the user has permitted this code to choose the IEEE 754
     // rounding at run-time, emit the rounding attribute.

llvm/lib/Target/Hexagon/HexagonTargetMachine.cpp

std::string CPU =
       CPUAttr.isValid() ? CPUAttr.getValueAsString().str() : TargetCPU;
   std::string FS =
       FSAttr.isValid() ? FSAttr.getValueAsString().str() : TargetFS;
   // Append the preexisting target features last, so that +mattr overrides
   // the "unsafe-fp-math" function attribute.
   // Creating a separate target feature is not strictly necessary, it only
   // exists to make "unsafe-fp-math" force creating a new subtarget.
 
-  if (FnAttrs.hasFnAttribute("unsafe-fp-math") &&
-      F.getFnAttribute("unsafe-fp-math").getValueAsString() == "true")
+  if (FnAttrs.hasFnAttribute("unsafe-fp-math"))
     FS = FS.empty() ? "+unsafe-fp" : "+unsafe-fp," + FS;
 
   auto &I = SubtargetMap[CPU + FS];
   if (!I) {
     // This needs to be done before we create a new subtarget since any
     // creation will depend on the TM and the code generation flags on the
     // function that reside in TargetOptions.
     resetTargetOptions(F);

llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp

 
 bool NVPTXTargetLowering::allowUnsafeFPMath(MachineFunction &MF) const {
   // Honor TargetOptions flags that explicitly say unsafe math is okay.
   if (MF.getTarget().Options.UnsafeFPMath)
     return true;
 
   // Allow unsafe math if unsafe-fp-math attribute explicitly says so.
   const Function &F = MF.getFunction();
-  if (F.hasFnAttribute("unsafe-fp-math")) {
-    Attribute Attr = F.getFnAttribute("unsafe-fp-math");
-    StringRef Val = Attr.getValueAsString();
-    if (Val == "true")
-      return true;
-  }
-
-  return false;
+  return F.hasFnAttribute("unsafe-fp-math");
 }
 
 /// PerformADDCombineWithOperands - Try DAG combinations for an ADD with
 /// operands N0 and N1.  This is a helper for PerformADDCombine that is
 /// called with the default operands, and if that fails, with commuted
 /// operands.
 static SDValue PerformADDCombineWithOperands(SDNode *N, SDValue N0, SDValue N1,
                                            TargetLowering::DAGCombinerInfo &DCI,

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

static bool SwitchToLookupTable(SwitchInst *SI, IRBuilder<> &Builder,
                                 DomTreeUpdater *DTU, const DataLayout &DL,
                                 const TargetTransformInfo &TTI) {
   assert(SI->getNumCases() > 1 && "Degenerate switch?");
 
   BasicBlock *BB = SI->getParent();
   Function *Fn = BB->getParent();
   // Only build lookup table when we have a target that supports it or the
   // attribute is not set.
-  if (!TTI.shouldBuildLookupTables() ||
-      (Fn->getFnAttribute("no-jump-tables").getValueAsString() == "true"))
+  if (!TTI.shouldBuildLookupTables() || Fn->hasFnAttribute("no-jump-tables"))
     return false;
 
   // FIXME: If the switch is too sparse for a lookup table, perhaps we could
   // split off a dense part and build a lookup table for that.
 
   // FIXME: This creates arrays of GEPs to constant strings, which means each
   // GEP needs a runtime relocation in PIC code. We should just build one big
   // string and lookup indices into that.

llvm/test/CodeGen/X86/switch.ll

 ; NOOPT: decl
 ; NOOPT: subl $4
 ; NOOPT: ja
 ; NOOPT: movq .LJTI
 ; NOOPT: jmpq
 }
 
 ; Should never be lowered as a jump table because of the attribute
-define void @basic_nojumptable(i32 %x) "no-jump-tables"="true" {
+define void @basic_nojumptable(i32 %x) "no-jump-tables" {
 entry:
   switch i32 %x, label %return [
     i32 3, label %bb0
     i32 1, label %bb1
     i32 4, label %bb1
     i32 5, label %bb2
   ]
 bb0: tail call void @g(i32 0) br label %return
 bb1: tail call void @g(i32 1) br label %return
 bb2: tail call void @g(i32 1) br label %return
 return: ret void
 
 ; Lowered as a jump table, both with and without optimization.
 ; CHECK-LABEL: basic_nojumptable
 ; CHECK-NOT: jmpq *.LJTI
 }
 
 ; Should be lowered as a jump table because of the attribute
-define void @basic_nojumptable_false(i32 %x) "no-jump-tables"="false" {
+define void @basic_nojumptable_false(i32 %x) {
 entry:
   switch i32 %x, label %return [
     i32 3, label %bb0
     i32 1, label %bb1
     i32 4, label %bb1
     i32 5, label %bb2
   ]
 bb0: tail call void @g(i32 0) br label %return

llvm/test/Transforms/IROutliner/outlining-compatible-and-attribute-transfer.ll

entry:
   store float 4.0, float* %c, align 4
   %al = load float, float* %a
   %bl = load float, float* %b
   %cl = load float, float* %c
   %0 = fmul float %al, %bl
   ret void
 }
 
-attributes #0 = { "no-nans-fp-math"="true" "no-signed-zeros-fp-math"="true" "less-precise-fpmad"="true"
-"unsafe-fp-math"="true" "no-infs-fp-math"="true"}
+attributes #0 = { "no-nans-fp-math" "no-signed-zeros-fp-math" "less-precise-fpmad" "unsafe-fp-math" "no-infs-fp-math"}
 
 ; CHECK: define internal void @outlined_ir_func_0(float* [[ARG0:%.*]], float* [[ARG1:%.*]], float* [[ARG2:%.*]]) [[ATTR1:#[0-9]+]] {
 ; CHECK: entry_to_outline:
 ; CHECK-NEXT:    store float 2.000000e+00, float* [[ARG0]], align 4
 ; CHECK-NEXT:    store float 3.000000e+00, float* [[ARG1]], align 4
 ; CHECK-NEXT:    store float 4.000000e+00, float* [[ARG2]], align 4
 ; CHECK-NEXT:    [[AL:%.*]] = load float, float* [[ARG0]], align 4
 ; CHECK-NEXT:    [[BL:%.*]] = load float, float* [[ARG1]], align 4
 ; CHECK-NEXT:    [[CL:%.*]] = load float, float* [[ARG2]], align 4
 
 ; CHECK: define internal void @outlined_ir_func_1(i32* [[ARG0:%.*]], i32* [[ARG1:%.*]], i32* [[ARG2:%.*]]) [[ATTR:#[0-9]+]] {
 ; CHECK: entry_to_outline:
 ; CHECK-NEXT:    store i32 2, i32* [[ARG0]], align 4
 ; CHECK-NEXT:    store i32 3, i32* [[ARG1]], align 4
 ; CHECK-NEXT:    store i32 4, i32* [[ARG2]], align 4
 ; CHECK-NEXT:    [[AL:%.*]] = load i32, i32* [[ARG0]], align 4
 ; CHECK-NEXT:    [[BL:%.*]] = load i32, i32* [[ARG1]], align 4
 ; CHECK-NEXT:    [[CL:%.*]] = load i32, i32* [[ARG2]], align 4
 
 
-; CHECK: attributes [[ATTR1]] =   { minsize optsize "less-precise-fpmad"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "unsafe-fp-math"="false" }
-; CHECK: attributes [[ATTR]] = { minsize optsize "less-precise-fpmad"="true" "no-infs-fp-math"="true" "no-nans-fp-math"="true" "no-signed-zeros-fp-math"="true" "unsafe-fp-math"="true" }
+; CHECK: attributes [[ATTR1]] =   { minsize optsize }
+; CHECK: attributes [[ATTR]] = { minsize optsize "less-precise-fpmad" "no-infs-fp-math" "no-nans-fp-math" "no-signed-zeros-fp-math" "unsafe-fp-math" }

llvm/test/Transforms/Inline/attributes.ll

 define i32 @test_target_features1(i32 %i) "target-features"="+sse4.2" {
   %1 = call i32 @test_target_features_callee1(i32 %i)
   ret i32 %1
 ; CHECK-LABEL: @test_target_features1(
 ; CHECK-NEXT: @test_target_features_callee1
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @less-precise-fpmad_callee0(i32 %i) "less-precise-fpmad"="false" {
+define i32 @less-precise-fpmad_callee0(i32 %i) {
   ret i32 %i
-; CHECK: @less-precise-fpmad_callee0(i32 %i) [[FPMAD_FALSE:#[0-9]+]] {
+; CHECK: @less-precise-fpmad_callee0(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @less-precise-fpmad_callee1(i32 %i) "less-precise-fpmad"="true" {
+define i32 @less-precise-fpmad_callee1(i32 %i) "less-precise-fpmad" {
   ret i32 %i
 ; CHECK: @less-precise-fpmad_callee1(i32 %i) [[FPMAD_TRUE:#[0-9]+]] {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_less-precise-fpmad0(i32 %i) "less-precise-fpmad"="false" {
+define i32 @test_less-precise-fpmad0(i32 %i) {
   %1 = call i32 @less-precise-fpmad_callee0(i32 %i)
   ret i32 %1
-; CHECK: @test_less-precise-fpmad0(i32 %i) [[FPMAD_FALSE]] {
+; CHECK: @test_less-precise-fpmad0(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_less-precise-fpmad1(i32 %i) "less-precise-fpmad"="false" {
+define i32 @test_less-precise-fpmad1(i32 %i) {
   %1 = call i32 @less-precise-fpmad_callee1(i32 %i)
   ret i32 %1
-; CHECK: @test_less-precise-fpmad1(i32 %i) [[FPMAD_FALSE]] {
+; CHECK: @test_less-precise-fpmad1(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_less-precise-fpmad2(i32 %i) "less-precise-fpmad"="true" {
+define i32 @test_less-precise-fpmad2(i32 %i) "less-precise-fpmad" {
   %1 = call i32 @less-precise-fpmad_callee0(i32 %i)
   ret i32 %1
-; CHECK: @test_less-precise-fpmad2(i32 %i) [[FPMAD_FALSE]] {
+; CHECK: @test_less-precise-fpmad2(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_less-precise-fpmad3(i32 %i) "less-precise-fpmad"="true" {
+define i32 @test_less-precise-fpmad3(i32 %i) "less-precise-fpmad" {
   %1 = call i32 @less-precise-fpmad_callee1(i32 %i)
   ret i32 %1
 ; CHECK: @test_less-precise-fpmad3(i32 %i) [[FPMAD_TRUE]] {
 ; CHECK-NEXT: ret i32
 }
 
 define i32 @no-implicit-float_callee0(i32 %i) {
   ret i32 %i

 ; Check that no-jump-tables flag propagates from inlined callee to caller 
 
 define i32 @no-use-jump-tables_callee0(i32 %i) {
   ret i32 %i
 ; CHECK: @no-use-jump-tables_callee0(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @no-use-jump-tables_callee1(i32 %i) "no-jump-tables"="true" {
+define i32 @no-use-jump-tables_callee1(i32 %i) "no-jump-tables" {
   ret i32 %i
 ; CHECK: @no-use-jump-tables_callee1(i32 %i) [[NOUSEJUMPTABLES:#[0-9]+]] {
 ; CHECK-NEXT: ret i32
 }
 
 define i32 @test_no-use-jump-tables0(i32 %i) {
   %1 = call i32 @no-use-jump-tables_callee0(i32 %i)
   ret i32 %1
 ; CHECK: @test_no-use-jump-tables0(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
 define i32 @test_no-use-jump-tables1(i32 %i) {
   %1 = call i32 @no-use-jump-tables_callee1(i32 %i)
   ret i32 %1
 ; CHECK: @test_no-use-jump-tables1(i32 %i) [[NOUSEJUMPTABLES]] {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-use-jump-tables2(i32 %i) "no-jump-tables"="true" {
+define i32 @test_no-use-jump-tables2(i32 %i) "no-jump-tables" {
   %1 = call i32 @no-use-jump-tables_callee0(i32 %i)
   ret i32 %1
 ; CHECK: @test_no-use-jump-tables2(i32 %i) [[NOUSEJUMPTABLES]] {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-use-jump-tables3(i32 %i) "no-jump-tables"="true" {
+define i32 @test_no-use-jump-tables3(i32 %i) "no-jump-tables" {
   %1 = call i32 @no-use-jump-tables_callee1(i32 %i)
   ret i32 %1
 ; CHECK: @test_no-use-jump-tables3(i32 %i) [[NOUSEJUMPTABLES]] {
 ; CHECK-NEXT: ret i32
 }
 
 ; Callee with null_pointer_is_valid attribute should not be inlined
 ; into a caller without this attribute.

 ; attribute.
 define i32 @test_null-pointer-is-valid2(i32 %i) null_pointer_is_valid {
   %1 = call i32 @null-pointer-is-valid_callee2(i32 %i)
   ret i32 %1
 ; CHECK: @test_null-pointer-is-valid2(i32 %i) [[NULLPOINTERISVALID]] {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @no-infs-fp-math_callee0(i32 %i) "no-infs-fp-math"="false" {
+define i32 @no-infs-fp-math_callee0(i32 %i) {
   ret i32 %i
-; CHECK: @no-infs-fp-math_callee0(i32 %i) [[NO_INFS_FPMATH_FALSE:#[0-9]+]] {
+; CHECK: @no-infs-fp-math_callee0(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @no-infs-fp-math_callee1(i32 %i) "no-infs-fp-math"="true" {
+define i32 @no-infs-fp-math_callee1(i32 %i) "no-infs-fp-math" {
   ret i32 %i
 ; CHECK: @no-infs-fp-math_callee1(i32 %i) [[NO_INFS_FPMATH_TRUE:#[0-9]+]] {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-infs-fp-math0(i32 %i) "no-infs-fp-math"="false" {
+define i32 @test_no-infs-fp-math0(i32 %i) {
   %1 = call i32 @no-infs-fp-math_callee0(i32 %i)
   ret i32 %1
-; CHECK: @test_no-infs-fp-math0(i32 %i) [[NO_INFS_FPMATH_FALSE]] {
+; CHECK: @test_no-infs-fp-math0(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-infs-fp-math1(i32 %i) "no-infs-fp-math"="false" {
+define i32 @test_no-infs-fp-math1(i32 %i) {
   %1 = call i32 @no-infs-fp-math_callee1(i32 %i)
   ret i32 %1
-; CHECK: @test_no-infs-fp-math1(i32 %i) [[NO_INFS_FPMATH_FALSE]] {
+; CHECK: @test_no-infs-fp-math1(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-infs-fp-math2(i32 %i) "no-infs-fp-math"="true" {
+define i32 @test_no-infs-fp-math2(i32 %i) "no-infs-fp-math" {
   %1 = call i32 @no-infs-fp-math_callee0(i32 %i)
   ret i32 %1
-; CHECK: @test_no-infs-fp-math2(i32 %i) [[NO_INFS_FPMATH_FALSE]] {
+; CHECK: @test_no-infs-fp-math2(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-infs-fp-math3(i32 %i) "no-infs-fp-math"="true" {
+define i32 @test_no-infs-fp-math3(i32 %i) "no-infs-fp-math" {
   %1 = call i32 @no-infs-fp-math_callee1(i32 %i)
   ret i32 %1
 ; CHECK: @test_no-infs-fp-math3(i32 %i) [[NO_INFS_FPMATH_TRUE]] {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @no-nans-fp-math_callee0(i32 %i) "no-nans-fp-math"="false" {
+define i32 @no-nans-fp-math_callee0(i32 %i) {
   ret i32 %i
-; CHECK: @no-nans-fp-math_callee0(i32 %i) [[NO_NANS_FPMATH_FALSE:#[0-9]+]] {
+; CHECK: @no-nans-fp-math_callee0(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @no-nans-fp-math_callee1(i32 %i) "no-nans-fp-math"="true" {
+define i32 @no-nans-fp-math_callee1(i32 %i) "no-nans-fp-math" {
   ret i32 %i
 ; CHECK: @no-nans-fp-math_callee1(i32 %i) [[NO_NANS_FPMATH_TRUE:#[0-9]+]] {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-nans-fp-math0(i32 %i) "no-nans-fp-math"="false" {
+define i32 @test_no-nans-fp-math0(i32 %i) {
   %1 = call i32 @no-nans-fp-math_callee0(i32 %i)
   ret i32 %1
-; CHECK: @test_no-nans-fp-math0(i32 %i) [[NO_NANS_FPMATH_FALSE]] {
+; CHECK: @test_no-nans-fp-math0(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-nans-fp-math1(i32 %i) "no-nans-fp-math"="false" {
+define i32 @test_no-nans-fp-math1(i32 %i) {
   %1 = call i32 @no-nans-fp-math_callee1(i32 %i)
   ret i32 %1
-; CHECK: @test_no-nans-fp-math1(i32 %i) [[NO_NANS_FPMATH_FALSE]] {
+; CHECK: @test_no-nans-fp-math1(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-nans-fp-math2(i32 %i) "no-nans-fp-math"="true" {
+define i32 @test_no-nans-fp-math2(i32 %i) "no-nans-fp-math" {
   %1 = call i32 @no-nans-fp-math_callee0(i32 %i)
   ret i32 %1
-; CHECK: @test_no-nans-fp-math2(i32 %i) [[NO_NANS_FPMATH_FALSE]] {
+; CHECK: @test_no-nans-fp-math2(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-nans-fp-math3(i32 %i) "no-nans-fp-math"="true" {
+define i32 @test_no-nans-fp-math3(i32 %i) "no-nans-fp-math" {
   %1 = call i32 @no-nans-fp-math_callee1(i32 %i)
   ret i32 %1
 ; CHECK: @test_no-nans-fp-math3(i32 %i) [[NO_NANS_FPMATH_TRUE]] {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @no-signed-zeros-fp-math_callee0(i32 %i) "no-signed-zeros-fp-math"="false" {
+define i32 @no-signed-zeros-fp-math_callee0(i32 %i) {
   ret i32 %i
-; CHECK: @no-signed-zeros-fp-math_callee0(i32 %i) [[NO_SIGNED_ZEROS_FPMATH_FALSE:#[0-9]+]] {
+; CHECK: @no-signed-zeros-fp-math_callee0(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @no-signed-zeros-fp-math_callee1(i32 %i) "no-signed-zeros-fp-math"="true" {
+define i32 @no-signed-zeros-fp-math_callee1(i32 %i) "no-signed-zeros-fp-math" {
   ret i32 %i
 ; CHECK: @no-signed-zeros-fp-math_callee1(i32 %i) [[NO_SIGNED_ZEROS_FPMATH_TRUE:#[0-9]+]] {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-signed-zeros-fp-math0(i32 %i) "no-signed-zeros-fp-math"="false" {
+define i32 @test_no-signed-zeros-fp-math0(i32 %i) {
   %1 = call i32 @no-signed-zeros-fp-math_callee0(i32 %i)
   ret i32 %1
-; CHECK: @test_no-signed-zeros-fp-math0(i32 %i) [[NO_SIGNED_ZEROS_FPMATH_FALSE]] {
+; CHECK: @test_no-signed-zeros-fp-math0(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-signed-zeros-fp-math1(i32 %i) "no-signed-zeros-fp-math"="false" {
+define i32 @test_no-signed-zeros-fp-math1(i32 %i) {
   %1 = call i32 @no-signed-zeros-fp-math_callee1(i32 %i)
   ret i32 %1
-; CHECK: @test_no-signed-zeros-fp-math1(i32 %i) [[NO_SIGNED_ZEROS_FPMATH_FALSE]] {
+; CHECK: @test_no-signed-zeros-fp-math1(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-signed-zeros-fp-math2(i32 %i) "no-signed-zeros-fp-math"="true" {
+define i32 @test_no-signed-zeros-fp-math2(i32 %i) "no-signed-zeros-fp-math" {
   %1 = call i32 @no-signed-zeros-fp-math_callee0(i32 %i)
   ret i32 %1
-; CHECK: @test_no-signed-zeros-fp-math2(i32 %i) [[NO_SIGNED_ZEROS_FPMATH_FALSE]] {
+; CHECK: @test_no-signed-zeros-fp-math2(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_no-signed-zeros-fp-math3(i32 %i) "no-signed-zeros-fp-math"="true" {
+define i32 @test_no-signed-zeros-fp-math3(i32 %i) "no-signed-zeros-fp-math" {
   %1 = call i32 @no-signed-zeros-fp-math_callee1(i32 %i)
   ret i32 %1
 ; CHECK: @test_no-signed-zeros-fp-math3(i32 %i) [[NO_SIGNED_ZEROS_FPMATH_TRUE]] {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @unsafe-fp-math_callee0(i32 %i) "unsafe-fp-math"="false" {
+define i32 @unsafe-fp-math_callee0(i32 %i) {
   ret i32 %i
-; CHECK: @unsafe-fp-math_callee0(i32 %i) [[UNSAFE_FPMATH_FALSE:#[0-9]+]] {
+; CHECK: @unsafe-fp-math_callee0(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @unsafe-fp-math_callee1(i32 %i) "unsafe-fp-math"="true" {
+define i32 @unsafe-fp-math_callee1(i32 %i) "unsafe-fp-math" {
   ret i32 %i
 ; CHECK: @unsafe-fp-math_callee1(i32 %i) [[UNSAFE_FPMATH_TRUE:#[0-9]+]] {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_unsafe-fp-math0(i32 %i) "unsafe-fp-math"="false" {
+define i32 @test_unsafe-fp-math0(i32 %i) {
   %1 = call i32 @unsafe-fp-math_callee0(i32 %i)
   ret i32 %1
-; CHECK: @test_unsafe-fp-math0(i32 %i) [[UNSAFE_FPMATH_FALSE]] {
+; CHECK: @test_unsafe-fp-math0(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_unsafe-fp-math1(i32 %i) "unsafe-fp-math"="false" {
+define i32 @test_unsafe-fp-math1(i32 %i) {
   %1 = call i32 @unsafe-fp-math_callee1(i32 %i)
   ret i32 %1
-; CHECK: @test_unsafe-fp-math1(i32 %i) [[UNSAFE_FPMATH_FALSE]] {
+; CHECK: @test_unsafe-fp-math1(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_unsafe-fp-math2(i32 %i) "unsafe-fp-math"="true" {
+define i32 @test_unsafe-fp-math2(i32 %i) "unsafe-fp-math" {
   %1 = call i32 @unsafe-fp-math_callee0(i32 %i)
   ret i32 %1
-; CHECK: @test_unsafe-fp-math2(i32 %i) [[UNSAFE_FPMATH_FALSE]] {
+; CHECK: @test_unsafe-fp-math2(i32 %i) {
 ; CHECK-NEXT: ret i32
 }
 
-define i32 @test_unsafe-fp-math3(i32 %i) "unsafe-fp-math"="true" {
+define i32 @test_unsafe-fp-math3(i32 %i) "unsafe-fp-math" {
   %1 = call i32 @unsafe-fp-math_callee1(i32 %i)
   ret i32 %1
 ; CHECK: @test_unsafe-fp-math3(i32 %i) [[UNSAFE_FPMATH_TRUE]] {
 ; CHECK-NEXT: ret i32
 }
 
 ; CHECK: attributes [[SLH]] = { speculative_load_hardening }
-; CHECK: attributes [[FPMAD_FALSE]] = { "less-precise-fpmad"="false" }
-; CHECK: attributes [[FPMAD_TRUE]] = { "less-precise-fpmad"="true" }
+; CHECK: attributes [[FPMAD_TRUE]] = { "less-precise-fpmad" }
 ; CHECK: attributes [[NOIMPLICITFLOAT]] = { noimplicitfloat }
-; CHECK: attributes [[NOUSEJUMPTABLES]] = { "no-jump-tables"="true" }
+; CHECK: attributes [[NOUSEJUMPTABLES]] = { "no-jump-tables" }
 ; CHECK: attributes [[NULLPOINTERISVALID]] = { null_pointer_is_valid }
-; CHECK: attributes [[NO_INFS_FPMATH_FALSE]] = { "no-infs-fp-math"="false" }
-; CHECK: attributes [[NO_INFS_FPMATH_TRUE]] = { "no-infs-fp-math"="true" }
-; CHECK: attributes [[NO_NANS_FPMATH_FALSE]] = { "no-nans-fp-math"="false" }
-; CHECK: attributes [[NO_NANS_FPMATH_TRUE]] = { "no-nans-fp-math"="true" }
-; CHECK: attributes [[NO_SIGNED_ZEROS_FPMATH_FALSE]] = { "no-signed-zeros-fp-math"="false" }
-; CHECK: attributes [[NO_SIGNED_ZEROS_FPMATH_TRUE]] = { "no-signed-zeros-fp-math"="true" }
-; CHECK: attributes [[UNSAFE_FPMATH_FALSE]] = { "unsafe-fp-math"="false" }
-; CHECK: attributes [[UNSAFE_FPMATH_TRUE]] = { "unsafe-fp-math"="true" }
+; CHECK: attributes [[NO_INFS_FPMATH_TRUE]] = { "no-infs-fp-math" }
+; CHECK: attributes [[NO_NANS_FPMATH_TRUE]] = { "no-nans-fp-math" }
+; CHECK: attributes [[NO_SIGNED_ZEROS_FPMATH_TRUE]] = { "no-signed-zeros-fp-math" }
+; CHECK: attributes [[UNSAFE_FPMATH_TRUE]] = { "unsafe-fp-math" }