checking FP function attribute values and adding more build attribute tests

[SjoerdMeijer]

Summary

This renames the function for checking FP function attribute values and also adds more build attribute tests (which are in separate files because build attributes are set per file).

[jmolloy]

Looks reasonable to me.

lib/Target/ARM/ARMAsmPrinter.cpp

static ARMBuildAttrs::CPUArch getArchForCPU(StringRef CPU,
   else if (Subtarget->hasV5TOps())
     return ARMBuildAttrs::v5T;
   else if (Subtarget->hasV4TOps())
     return ARMBuildAttrs::v4T;
   else
     return ARMBuildAttrs::v4;
 }
 
-// Returns true if all functions have the same function attribute value
-static bool haveAllFunctionsAttribute(const Module &M, StringRef Attr,
+// Returns true if all functions have the same function attribute value.
+// It also returns true when there are no functions, or when
+// the particular function attribute is not set to a value.
+static bool checkFunctionsAttributeConsistency(const Module &M, StringRef Attr,
                                                StringRef Value) {
-  for (auto &F : M)
-    if (F.getFnAttribute(Attr).getValueAsString() != Value)
-      return false;
-
-  return true;
+  return !any_of(M, [&](const Function &F) {
+    return F.hasFnAttribute(Attr) &&
+           F.getFnAttribute(Attr).getValueAsString() != Value;
+  });
 }
 
-
 void ARMAsmPrinter::emitAttributes() {
   MCTargetStreamer &TS = *OutStreamer->getTargetStreamer();
   ARMTargetStreamer &ATS = static_cast<ARMTargetStreamer &>(TS);
 
   ATS.emitTextAttribute(ARMBuildAttrs::conformance, "2.09");
 
   ATS.switchVendor("aeabi");
 
if (isPositionIndependent()) {
     ATS.emitAttribute(ARMBuildAttrs::ABI_PCS_GOT_use,
                       ARMBuildAttrs::AddressGOT);
   } else {
     ATS.emitAttribute(ARMBuildAttrs::ABI_PCS_GOT_use,
                       ARMBuildAttrs::AddressDirect);
   }
 
   // Set FP Denormals.
-  if (haveAllFunctionsAttribute(*MMI->getModule(), "denormal-fp-math",
+  if (checkFunctionsAttributeConsistency(*MMI->getModule(),
+                                         "denormal-fp-math",
                                          "preserve-sign") ||
       TM.Options.FPDenormalMode == FPDenormal::PreserveSign)
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_denormal,
                       ARMBuildAttrs::PreserveFPSign);
-  else if (haveAllFunctionsAttribute(*MMI->getModule(), "denormal-fp-math",
+  else if (checkFunctionsAttributeConsistency(*MMI->getModule(),
+                                              "denormal-fp-math",
                                               "positive-zero") ||
            TM.Options.FPDenormalMode == FPDenormal::PositiveZero)
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_denormal,
                       ARMBuildAttrs::PositiveZero);
   else if (!TM.Options.UnsafeFPMath)
     ATS.emitAttribute(ARMBuildAttrs::ABI_FP_denormal,
                       ARMBuildAttrs::IEEEDenormals);
   else {
     if (!STI.hasVFP2()) {
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 (haveAllFunctionsAttribute(*MMI->getModule(), "no-trapping-math", "true") ||
+  if (checkFunctionsAttributeConsistency(*MMI->getModule(),
+                                         "no-trapping-math", "true") ||
       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.

test/CodeGen/ARM/build-attributes-fn-attr0.ll

+; Check FP options -fno-trapping-math and -fdenormal-fp-math. They are passed
+; as function attributes, which map on to build attributes ABI_FP_exceptions
+; ABI_FP_denormal. In the backend we therefore have a check to see if all
+; functions have consistent function attributes values. This check also returns
+; true when the compilation unit does not have any functions (i.e. the
+; attributes are consistent), which is what we check with this regression test.
+
+; RUN: llc < %s -mtriple=armv7-linux-gnueabi -mcpu=cortex-a15  | FileCheck %s --check-prefix=CHECK
+
+; CHECK:  .eabi_attribute 20, 2
+; CHECK:  .eabi_attribute 21, 0

test/CodeGen/ARM/build-attributes-fn-attr1.ll

+; Check FP options -fno-trapping-math and -fdenormal-fp-math. They are passed as
+; function attributes, which map on to build attributes ABI_FP_exceptions ABI_FP_denormal.
+; In the backend we have a check to see if all functions have consistent function
+; attributes values. This checks the "default" behaviour when these FP function
+; attributes are not set at all.
+
+; RUN: llc < %s -mtriple=armv7-linux-gnueabi -mcpu=cortex-a15  | FileCheck %s --check-prefix=CHECK
+
+; CHECK: .eabi_attribute 20, 2
+; CHECK: .eabi_attribute 21, 0
+
+
+define i32 @foo_no_fn_attr() local_unnamed_addr #0 {
+entry:
+  ret i32 42
+}
+
+attributes #0 = { minsize norecurse nounwind optsize readnone }

test/CodeGen/ARM/build-attributes-fn-attr2.ll

+; Check FP options -fno-trapping-math and -fdenormal-fp-math. They are passed
+; as function attributes, which map on to build attributes ABI_FP_exceptions
+; ABI_FP_denormal. In the backend we therefore have a check to see if all
+; functions have consistent function attributes values.
+; Here we just test correct output for specific values of no trapping math
+; and denormals.
+
+; RUN: llc < %s -mtriple=armv7-linux-gnueabi -mcpu=cortex-a15  | FileCheck %s --check-prefix=CHECK
+
+; CHECK: .eabi_attribute 20, 1
+; CHECK: .eabi_attribute 21, 1
+
+define i32 @foo() local_unnamed_addr #0 {
+entry:
+  ret i32 42
+}
+
+attributes #0 = { minsize norecurse nounwind optsize readnone "no-trapping-math"="false" "denormal-fp-math"="ieee"}

test/CodeGen/ARM/build-attributes-fn-attr3.ll

+; Check FP options -fno-trapping-math and -fdenormal-fp-math. They are passed
+; as function attributes, which map on to build attributes ABI_FP_exceptions
+; ABI_FP_denormal. In the backend we therefore have a check to see if all
+; functions have consistent function attributes values.
+; Here we check: no-trapping-math=true
+
+; RUN: llc < %s -mtriple=armv7-linux-gnueabi -mcpu=cortex-a15  | FileCheck %s --check-prefix=CHECK
+
+; CHECK: .eabi_attribute 20, 1
+; CHECK: .eabi_attribute 21, 0
+
+define i32 @foo() local_unnamed_addr #0 {
+entry:
+  ret i32 42
+}
+
+attributes #0 = { minsize norecurse nounwind optsize readnone "no-trapping-math"="true"}

test/CodeGen/ARM/build-attributes-fn-attr4.ll

+; Check FP options -fno-trapping-math and -fdenormal-fp-math. They are passed
+; as function attributes, which map on to build attributes ABI_FP_exceptions
+; ABI_FP_denormal. In the backend we therefore have a check to see if all
+; functions have consistent function attributes values.
+; Here we check: denormal-fp-math=positive-zero
+
+; RUN: llc < %s -mtriple=armv7-linux-gnueabi -mcpu=cortex-a15  | FileCheck %s --check-prefix=CHECK
+
+; CHECK: .eabi_attribute 20, 0
+; CHECK: .eabi_attribute 21, 0
+
+define i32 @foo1() local_unnamed_addr #0 {
+entry:
+  ret i32 42
+}
+
+define i32 @foo2() local_unnamed_addr #0 {
+entry:
+  ret i32 42
+}
+
+attributes #0 = { minsize norecurse nounwind optsize readnone "denormal-fp-math"="positive-zero"}

test/CodeGen/ARM/build-attributes-fn-attr5.ll

+; Check FP options -fno-trapping-math and -fdenormal-fp-math. They are passed
+; as function attributes, which map on to build attributes ABI_FP_exceptions
+; ABI_FP_denormal. In the backend we therefore have a check to see if all
+; functions have consistent function attributes values.
+; Here we check: denormal-fp-math=preserve-sign
+
+; RUN: llc < %s -mtriple=armv7-linux-gnueabi -mcpu=cortex-a15  | FileCheck %s --check-prefix=CHECK
+
+; CHECK: .eabi_attribute 20, 2
+; CHECK: .eabi_attribute 21, 0
+
+define i32 @foo1() local_unnamed_addr #0 {
+entry:
+  ret i32 42
+}
+
+define i32 @foo2() local_unnamed_addr #0 {
+entry:
+  ret i32 42
+}
+
+attributes #0 = { minsize norecurse nounwind optsize readnone "denormal-fp-math"="preserve-sign"}

test/CodeGen/ARM/build-attributes-fn-attr6.ll

+; Check FP options -fno-trapping-math and -fdenormal-fp-math. They are passed
+; as function attributes, which map on to build attributes ABI_FP_exceptions
+; ABI_FP_denormal. In the backend we therefore have a check to see if all
+; functions have consistent function attributes values. Here we check two
+; functions have inconsistent values, and that a default is returned. 
+
+; RUN: llc < %s -mtriple=armv7-linux-gnueabi -mcpu=cortex-a15  | FileCheck %s --check-prefix=CHECK
+
+; CHECK: .eabi_attribute 20, 0
+; CHECK: .eabi_attribute 21, 0
+
+define i32 @foo1() local_unnamed_addr #0 {
+entry:
+  ret i32 42
+}
+
+define i32 @foo2() local_unnamed_addr #1 {
+entry:
+  ret i32 42
+}
+
+attributes #0 = { minsize norecurse nounwind optsize readnone "denormal-fp-math"="preserve-sign"}
+attributes #0 = { minsize norecurse nounwind optsize readnone "denormal-fp-math"="positive-zero"}