This is an archive of the discontinued LLVM Phabricator instance.

Differential D154991

[FPEnv][TableGen] Add strictfp attribute to constrained intrinsics by default.
ClosedPublic

Authored by kpn on Jul 11 2023, 10:58 AM.

Details

Reviewers
pengfei
chapuni
akshaykhadse
craig.topper
arsenm
Commits
rG91f886a40d3f: [FPEnv][TableGen] Add strictfp attribute to constrained intrinsics by default.
Summary

In D146869 @arsenm pointed out that the constrained intrinsics aren't getting the strictfp attribute by default. They should be, since they are required to have it anyway.

TableGen did not know about this attribute until now. This patch adds strictfp to TableGen, and it uses it on all of the constrained intrinsics.

Diff Detail

Event Timeline

kpn created this revision.Jul 11 2023, 10:58 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 11 2023, 10:58 AM
Herald added a subscriber: jdoerfert. · View Herald Transcript
kpn requested review of this revision.Jul 11 2023, 10:58 AM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptJul 11 2023, 10:58 AM
Herald added subscribers: llvm-commits, cfe-commits, wdng. · View Herald Transcript
arsenm added inline comments.Jul 11 2023, 11:05 AM
llvm/test/Feature/fp-intrinsics-attr.ll
1 ↗(On Diff #539193)

Should move to test/Assembler and round trip through llvm-as and llvm-dis like other similar tests

kpn updated this revision to Diff 539204.Jul 11 2023, 11:15 AM

Move test and change to round-tripping as requested.

arsenm accepted this revision.Jul 11 2023, 11:24 AM
arsenm added inline comments.
llvm/include/llvm/IR/Intrinsics.td
1102–1106

Eventually I think it would be better if we had some sort of fpenv access property, such that we'll know which set of target intrinsics need handling and which aspects of the fpenv

This revision is now accepted and ready to land.Jul 11 2023, 11:24 AM
Harbormaster completed remote builds in B244547: Diff 539204.Jul 11 2023, 4:21 PM
This revision was landed with ongoing or failed builds.Jul 12 2023, 6:56 AM
Closed by commit rG91f886a40d3f: [FPEnv][TableGen] Add strictfp attribute to constrained intrinsics by default. (authored by kpn). · Explain Why
This revision was automatically updated to reflect the committed changes.
kpn added a commit: rG91f886a40d3f: [FPEnv][TableGen] Add strictfp attribute to constrained intrinsics by default..
kpn mentioned this in rG95c2d01dfedc: [FPEnv][RISCV] Correct strictfp tests..Jul 20 2023, 7:18 AM
kpn mentioned this in rG76c22b18eafd: [FPEnv][AMDGPU] Correct strictfp tests..Jul 25 2023, 10:24 AM
kpn mentioned this in rGd6857060a3b7: [FPEnv][X86] Correct strictfp tests..Jul 26 2023, 6:07 AM
kpn mentioned this in rG7e0e8b7acee4: [FPEnv][PowerPC] Correct strictfp tests..Jul 26 2023, 6:13 AM
kpn mentioned this in rGf57fb82e0f90: [FPEnv][AArch64] Correct strictfp tests..
kpn mentioned this in rG33e25cdd4882: [FPEnv][X86] Correct strictfp tests..Jul 26 2023, 10:36 AM
kpn mentioned this in rG1e7c79d3627f: [FPEnv][InstCombine] Correct strictfp tests..Aug 2 2023, 10:03 AM
kpn mentioned this in rGd9b1036bc469: [FPEnv][InstSimplify] Correct strictfp tests..Aug 2 2023, 10:07 AM
kpn mentioned this in rGb58b7f7c6704: [FPEnv][LibCallsShrinkWrap] Correct strictfp tests..Aug 3 2023, 6:42 AM
kpn mentioned this in rGeb2558c5666c: Recommit [FPEnv][InstSimplify] Correct strictfp tests..Aug 3 2023, 6:45 AM

Revision Contents

PathSize
clang/
test/
CodeGenOpenCL/
2 lines
llvm/
include/
llvm/
IR/
6 lines
test/
Assembler/
318 lines
Verifier/
25 lines
utils/
TableGen/
3 lines
3 lines
8 lines

Diff 539540

clang/test/CodeGenOpenCL/cl20-device-side-enqueue-attributes.cl

Show First 20 Lines • Show All 165 Lines • ▼ Show 20 Lines
// SPIR32: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } // SPIR32: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
// SPIR32: attributes #[[ATTR2]] = { convergent noinline nounwind optnone "denormal-fp-math-f32"="preserve-sign,preserve-sign" "no-trapping-math"="true" "stack-protector-buffer-size"="8" } // SPIR32: attributes #[[ATTR2]] = { convergent noinline nounwind optnone "denormal-fp-math-f32"="preserve-sign,preserve-sign" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
// SPIR32: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } // SPIR32: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
// SPIR32: attributes #[[ATTR4]] = { convergent nounwind "denormal-fp-math-f32"="preserve-sign,preserve-sign" "no-trapping-math"="true" "stack-protector-buffer-size"="8" } // SPIR32: attributes #[[ATTR4]] = { convergent nounwind "denormal-fp-math-f32"="preserve-sign,preserve-sign" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
//. //.
// STRICTFP: attributes #[[ATTR0]] = { convergent noinline norecurse nounwind optnone strictfp "stack-protector-buffer-size"="8" "uniform-work-group-size"="false" } // STRICTFP: attributes #[[ATTR0]] = { convergent noinline norecurse nounwind optnone strictfp "stack-protector-buffer-size"="8" "uniform-work-group-size"="false" }
// STRICTFP: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } // STRICTFP: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
// STRICTFP: attributes #[[ATTR2]] = { convergent noinline nounwind optnone strictfp "stack-protector-buffer-size"="8" } // STRICTFP: attributes #[[ATTR2]] = { convergent noinline nounwind optnone strictfp "stack-protector-buffer-size"="8" }
// STRICTFP: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } // STRICTFP: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nosync nounwind strictfp willreturn memory(inaccessiblemem: readwrite) }
// STRICTFP: attributes #[[ATTR4]] = { convergent nounwind "stack-protector-buffer-size"="8" } // STRICTFP: attributes #[[ATTR4]] = { convergent nounwind "stack-protector-buffer-size"="8" }
// STRICTFP: attributes #[[ATTR5]] = { strictfp } // STRICTFP: attributes #[[ATTR5]] = { strictfp }
//. //.
// SPIR32: [[META0:![0-9]+]] = !{i32 1, !"wchar_size", i32 4} // SPIR32: [[META0:![0-9]+]] = !{i32 1, !"wchar_size", i32 4}
// SPIR32: [[META1:![0-9]+]] = !{i32 2, i32 0} // SPIR32: [[META1:![0-9]+]] = !{i32 2, i32 0}
// SPIR32: [[META2:![0-9]+]] = !{i32 1, i32 1, i32 0} // SPIR32: [[META2:![0-9]+]] = !{i32 1, i32 1, i32 0}
// SPIR32: [[META3:![0-9]+]] = !{!"none", !"none", !"none"} // SPIR32: [[META3:![0-9]+]] = !{!"none", !"none", !"none"}
// SPIR32: [[META4:![0-9]+]] = !{!"float*", !"float*", !"int"} // SPIR32: [[META4:![0-9]+]] = !{!"float*", !"float*", !"int"}
Show All 9 Lines

llvm/include/llvm/IR/Intrinsics.td

Show First 20 Lines • Show All 1,093 Lines • ▼ Show 20 Lines
def int_is_fpclass def int_is_fpclass
: DefaultAttrsIntrinsic<[LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>], : DefaultAttrsIntrinsic<[LLVMScalarOrSameVectorWidth<0, llvm_i1_ty>],
[llvm_anyfloat_ty, llvm_i32_ty], [llvm_anyfloat_ty, llvm_i32_ty],
[IntrNoMem, IntrSpeculatable, ImmArg<ArgIndex<1>>]>; [IntrNoMem, IntrSpeculatable, ImmArg<ArgIndex<1>>]>;
//===--------------- Constrained Floating Point Intrinsics ----------------===// //===--------------- Constrained Floating Point Intrinsics ----------------===//
// //
let IntrProperties = [IntrInaccessibleMemOnly, IntrWillReturn] in { /// IntrStrictFP - The intrinsic is allowed to be used in an alternate
/// floating point environment.
def IntrStrictFP : IntrinsicProperty;
let IntrProperties = [IntrInaccessibleMemOnly, IntrWillReturn, IntrStrictFP] in {
arsenmUnsubmitted
Not Done
ReplyInline Actions

Eventually I think it would be better if we had some sort of fpenv access property, such that we'll know which set of target intrinsics need handling and which aspects of the fpenv

arsenm: Eventually I think it would be better if we had some sort of fpenv access property, such that…
def int_experimental_constrained_fadd : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ], def int_experimental_constrained_fadd : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
[ LLVMMatchType<0>, [ LLVMMatchType<0>,
LLVMMatchType<0>, LLVMMatchType<0>,
llvm_metadata_ty, llvm_metadata_ty,
llvm_metadata_ty ]>; llvm_metadata_ty ]>;
def int_experimental_constrained_fsub : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ], def int_experimental_constrained_fsub : DefaultAttrsIntrinsic<[ llvm_anyfloat_ty ],
[ LLVMMatchType<0>, [ LLVMMatchType<0>,
LLVMMatchType<0>, LLVMMatchType<0>,
▲ Show 20 Lines • Show All 1,449 Lines • Show Last 20 Lines

llvm/test/Assembler/fp-intrinsics-attr.ll

  • This file was added.
; RUN: llvm-as < %s | llvm-dis | FileCheck %s
; Test to verify that constrained intrinsics all have the strictfp attribute.
; Ordering is from Intrinsics.td.
define void @func(double %a, double %b, double %c, i32 %i) strictfp {
; CHECK-LABEL: define void @func
; CHECK-SAME: (double [[A:%.*]], double [[B:%.*]], double [[C:%.*]], i32 [[I:%.*]]) #[[ATTR0:[0-9]+]] {
%add = call double @llvm.experimental.constrained.fadd.f64(
double %a, double %b,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%sub = call double @llvm.experimental.constrained.fsub.f64(
double %a, double %b,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%mul = call double @llvm.experimental.constrained.fmul.f64(
double %a, double %b,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%div = call double @llvm.experimental.constrained.fdiv.f64(
double %a, double %b,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%rem = call double @llvm.experimental.constrained.frem.f64(
double %a, double %b,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%fma = call double @llvm.experimental.constrained.fma.f64(
double %a, double %b, double %c,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%fmuladd = call double @llvm.experimental.constrained.fmuladd.f64(
double %a, double %b, double %c,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%si = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double %a,
metadata !"fpexcept.strict")
%ui = call i32 @llvm.experimental.constrained.fptoui.i32.f64(double %a,
metadata !"fpexcept.strict")
%sfp = call double @llvm.experimental.constrained.sitofp.f64.i32(i32 %i,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%ufp = call double @llvm.experimental.constrained.uitofp.f64.i32(i32 %i,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%fptrunc = call float @llvm.experimental.constrained.fptrunc.f32.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%ext = call double @llvm.experimental.constrained.fpext.f64.f32(
float %fptrunc,
metadata !"fpexcept.strict")
%sqrt = call double @llvm.experimental.constrained.sqrt.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%powi = call double @llvm.experimental.constrained.powi.f64(
double %a, i32 %i,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%sin = call double @llvm.experimental.constrained.sin.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%cos = call double @llvm.experimental.constrained.cos.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%pow = call double @llvm.experimental.constrained.pow.f64(
double %a, double %b,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%log = call double @llvm.experimental.constrained.log.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%log10 = call double @llvm.experimental.constrained.log10.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%log2 = call double @llvm.experimental.constrained.log2.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%exp = call double @llvm.experimental.constrained.exp.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%exp2 = call double @llvm.experimental.constrained.exp2.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%rint = call double @llvm.experimental.constrained.rint.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%neari = call double @llvm.experimental.constrained.nearbyint.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%x32 = call i32 @llvm.experimental.constrained.lrint.i32.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%x64 = call i64 @llvm.experimental.constrained.llrint.i64.f64(
double %a,
metadata !"round.dynamic",
metadata !"fpexcept.strict")
%maxnum = call double @llvm.experimental.constrained.maxnum.f64(
double %a, double %b,
metadata !"fpexcept.strict")
%minnum = call double @llvm.experimental.constrained.minnum.f64(
double %a, double %b,
metadata !"fpexcept.strict")
%maxmum = call double @llvm.experimental.constrained.maximum.f64(
double %a, double %b,
metadata !"fpexcept.strict")
%minmum = call double @llvm.experimental.constrained.minimum.f64(
double %a, double %b,
metadata !"fpexcept.strict")
%ceil = call double @llvm.experimental.constrained.ceil.f64(
double %a,
metadata !"fpexcept.strict")
%floor = call double @llvm.experimental.constrained.floor.f64(
double %a,
metadata !"fpexcept.strict")
%y32 = call i32 @llvm.experimental.constrained.lround.i32.f64(
double %a,
metadata !"fpexcept.strict")
%y64 = call i64 @llvm.experimental.constrained.llround.i64.f64(
double %a,
metadata !"fpexcept.strict")
%round = call double @llvm.experimental.constrained.round.f64(
double %a,
metadata !"fpexcept.strict")
%roundev = call double @llvm.experimental.constrained.roundeven.f64(
double %a,
metadata !"fpexcept.strict")
%trunc = call double @llvm.experimental.constrained.trunc.f64(
double %a,
metadata !"fpexcept.strict")
%q1 = call i1 @llvm.experimental.constrained.fcmp.f64(
double %a, double %b,
metadata !"oeq",
metadata !"fpexcept.strict")
%s1 = call i1 @llvm.experimental.constrained.fcmps.f64(
double %a, double %b,
metadata !"oeq",
metadata !"fpexcept.strict")
; CHECK: ret void
ret void
}
declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.fadd.f64({{.*}}) #[[ATTR1:[0-9]+]]
declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.fsub.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.fmul.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.fdiv.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.frem.f64(double, double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.frem.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.fma.f64(double, double, double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.fma.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.fmuladd.f64(double, double, double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.fmuladd.f64({{.*}}) #[[ATTR1]]
declare i32 @llvm.experimental.constrained.fptosi.i32.f64(double, metadata)
; CHECK: @llvm.experimental.constrained.fptosi.i32.f64({{.*}}) #[[ATTR1]]
declare i32 @llvm.experimental.constrained.fptoui.i32.f64(double, metadata)
; CHECK: @llvm.experimental.constrained.fptoui.i32.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.sitofp.f64.i32(i32, metadata, metadata)
; CHECK: @llvm.experimental.constrained.sitofp.f64.i32({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.uitofp.f64.i32(i32, metadata, metadata)
; CHECK: @llvm.experimental.constrained.uitofp.f64.i32({{.*}}) #[[ATTR1]]
declare float @llvm.experimental.constrained.fptrunc.f32.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.fptrunc.f32.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.fpext.f64.f32(float, metadata)
; CHECK: @llvm.experimental.constrained.fpext.f64.f32({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.sqrt.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.powi.f64(double, i32, metadata, metadata)
; CHECK: @llvm.experimental.constrained.powi.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.sin.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.sin.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.cos.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.cos.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.pow.f64(double, double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.pow.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.log.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.log.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.log10.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.log10.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.log2.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.log2.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.exp.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.exp.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.exp2.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.exp2.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.rint.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.nearbyint.f64({{.*}}) #[[ATTR1]]
declare i32 @llvm.experimental.constrained.lrint.i32.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.lrint.i32.f64({{.*}}) #[[ATTR1]]
declare i64 @llvm.experimental.constrained.llrint.i64.f64(double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.llrint.i64.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.maxnum.f64(double, double, metadata)
; CHECK: @llvm.experimental.constrained.maxnum.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.minnum.f64(double, double, metadata)
; CHECK: @llvm.experimental.constrained.minnum.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.maximum.f64(double, double, metadata)
; CHECK: @llvm.experimental.constrained.maximum.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.minimum.f64(double, double, metadata)
; CHECK: @llvm.experimental.constrained.minimum.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.ceil.f64(double, metadata)
; CHECK: @llvm.experimental.constrained.ceil.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.floor.f64(double, metadata)
; CHECK: @llvm.experimental.constrained.floor.f64({{.*}}) #[[ATTR1]]
declare i32 @llvm.experimental.constrained.lround.i32.f64(double, metadata)
; CHECK: @llvm.experimental.constrained.lround.i32.f64({{.*}}) #[[ATTR1]]
declare i64 @llvm.experimental.constrained.llround.i64.f64(double, metadata)
; CHECK: @llvm.experimental.constrained.llround.i64.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.round.f64(double, metadata)
; CHECK: @llvm.experimental.constrained.round.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.roundeven.f64(double, metadata)
; CHECK: @llvm.experimental.constrained.roundeven.f64({{.*}}) #[[ATTR1]]
declare double @llvm.experimental.constrained.trunc.f64(double, metadata)
; CHECK: @llvm.experimental.constrained.trunc.f64({{.*}}) #[[ATTR1]]
declare i1 @llvm.experimental.constrained.fcmp.f64(double, double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.fcmp.f64({{.*}}) #[[ATTR1]]
declare i1 @llvm.experimental.constrained.fcmps.f64(double, double, metadata, metadata)
; CHECK: @llvm.experimental.constrained.fcmps.f64({{.*}}) #[[ATTR1]]
; CHECK: attributes #[[ATTR0]] = {{{.*}} strictfp {{.*}}}
; CHECK: attributes #[[ATTR1]] = { {{.*}} strictfp {{.*}} }

llvm/test/Verifier/fp-intrinsics-pass.ll

; RUN: opt -passes=verify -S < %s 2>&1 | FileCheck %s ; RUN: opt -passes=verify -S < %s 2>&1 | FileCheck %s
declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata) #0 declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata) #0 declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)
; Test that the verifier accepts legal code, and that the correct attributes are ; Test that the verifier accepts legal code, and that the correct attributes are
; attached to the FP intrinsic. The attributes are checked at the bottom. ; attached to the FP intrinsic. The attributes are checked at the bottom.
; CHECK: declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata) #[[ATTR:[0-9]+]] ; CHECK: declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata) #[[ATTR:[0-9]+]]
; CHECK: declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata) #[[ATTR]] ; CHECK: declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata) #[[ATTR]]
; Note: FP exceptions aren't usually caught through normal unwind mechanisms, ; Note: FP exceptions aren't usually caught through normal unwind mechanisms,
; but we may want to revisit this for asynchronous exception handling. ; but we may want to revisit this for asynchronous exception handling.
define double @f1(double %a, double %b) #0 { define double @f1(double %a, double %b) strictfp {
; CHECK-LABEL: define double @f1 ; CHECK-LABEL: define double @f1
; CHECK-SAME: (double [[A:%.*]], double [[B:%.*]]) #[[ATTR1:[0-9]+]] { ; CHECK-SAME: (double [[A:%.*]], double [[B:%.*]]) #[[STRICTFP:[0-9]+]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[FADD:%.*]] = call double @llvm.experimental.constrained.fadd.f64(double [[A]], double [[B]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR1]] ; CHECK-NEXT: [[FADD:%.*]] = call double @llvm.experimental.constrained.fadd.f64(double [[A]], double [[B]], metadata !"round.dynamic", metadata !"fpexcept.strict")
; CHECK-NEXT: ret double [[FADD]] ; CHECK-NEXT: ret double [[FADD]]
entry: entry:
%fadd = call double @llvm.experimental.constrained.fadd.f64( %fadd = call double @llvm.experimental.constrained.fadd.f64(
double %a, double %b, double %a, double %b,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") #0 metadata !"fpexcept.strict")
ret double %fadd ret double %fadd
} }
define double @f1u(double %a) #0 { define double @f1u(double %a) strictfp {
; CHECK-LABEL: define double @f1u ; CHECK-LABEL: define double @f1u
; CHECK-SAME: (double [[A:%.*]]) #[[ATTR1]] { ; CHECK-SAME: (double [[A:%.*]]) #[[STRICTFP]] {
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[FSQRT:%.*]] = call double @llvm.experimental.constrained.sqrt.f64(double [[A]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR1]] ; CHECK-NEXT: [[FSQRT:%.*]] = call double @llvm.experimental.constrained.sqrt.f64(double [[A]], metadata !"round.dynamic", metadata !"fpexcept.strict")
; CHECK-NEXT: ret double [[FSQRT]] ; CHECK-NEXT: ret double [[FSQRT]]
; ;
entry: entry:
%fsqrt = call double @llvm.experimental.constrained.sqrt.f64( %fsqrt = call double @llvm.experimental.constrained.sqrt.f64(
double %a, double %a,
metadata !"round.dynamic", metadata !"round.dynamic",
metadata !"fpexcept.strict") #0 metadata !"fpexcept.strict")
ret double %fsqrt ret double %fsqrt
} }
attributes #0 = { strictfp } ; CHECK: attributes #[[ATTR]] = { nocallback nofree nosync nounwind strictfp willreturn memory(inaccessiblemem: readwrite) }
; TODO: Why is strictfp not in the below list? ; CHECK: attributes #[[STRICTFP]] = { strictfp }
; CHECK: attributes #[[ATTR]] = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) }

llvm/utils/TableGen/CodeGenIntrinsics.h

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Linesstruct CodeGenIntrinsic {
/// True if the intrinsic has side effects that aren't captured by any /// True if the intrinsic has side effects that aren't captured by any
/// of the other flags. /// of the other flags.
bool hasSideEffects; bool hasSideEffects;
// True if the intrinsic is marked as speculatable. // True if the intrinsic is marked as speculatable.
bool isSpeculatable; bool isSpeculatable;
// True if the intrinsic is marked as strictfp.
bool isStrictFP;
enum ArgAttrKind { enum ArgAttrKind {
NoCapture, NoCapture,
NoAlias, NoAlias,
NoUndef, NoUndef,
NonNull, NonNull,
Returned, Returned,
ReadOnly, ReadOnly,
WriteOnly, WriteOnly,
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/utils/TableGen/CodeGenIntrinsics.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 LinesCodeGenIntrinsic::CodeGenIntrinsic(Record *R,
isNoFree = false; isNoFree = false;
isWillReturn = false; isWillReturn = false;
isCold = false; isCold = false;
isNoDuplicate = false; isNoDuplicate = false;
isNoMerge = false; isNoMerge = false;
isConvergent = false; isConvergent = false;
isSpeculatable = false; isSpeculatable = false;
hasSideEffects = false; hasSideEffects = false;
isStrictFP = false;
if (DefName.size() <= 4 || DefName.substr(0, 4) != "int_") if (DefName.size() <= 4 || DefName.substr(0, 4) != "int_")
PrintFatalError(DefLoc, PrintFatalError(DefLoc,
"Intrinsic '" + DefName + "' does not start with 'int_'!"); "Intrinsic '" + DefName + "' does not start with 'int_'!");
EnumName = DefName.substr(4); EnumName = DefName.substr(4);
if (R->getValue( if (R->getValue(
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Linesvoid CodeGenIntrinsic::setProperty(Record *R) {
else if (R->getName() == "IntrWillReturn") else if (R->getName() == "IntrWillReturn")
isWillReturn = !isNoReturn; isWillReturn = !isNoReturn;
else if (R->getName() == "IntrCold") else if (R->getName() == "IntrCold")
isCold = true; isCold = true;
else if (R->getName() == "IntrSpeculatable") else if (R->getName() == "IntrSpeculatable")
isSpeculatable = true; isSpeculatable = true;
else if (R->getName() == "IntrHasSideEffects") else if (R->getName() == "IntrHasSideEffects")
hasSideEffects = true; hasSideEffects = true;
else if (R->getName() == "IntrStrictFP")
isStrictFP = true;
else if (R->isSubClassOf("NoCapture")) { else if (R->isSubClassOf("NoCapture")) {
unsigned ArgNo = R->getValueAsInt("ArgNo"); unsigned ArgNo = R->getValueAsInt("ArgNo");
addArgAttribute(ArgNo, NoCapture); addArgAttribute(ArgNo, NoCapture);
} else if (R->isSubClassOf("NoAlias")) { } else if (R->isSubClassOf("NoAlias")) {
unsigned ArgNo = R->getValueAsInt("ArgNo"); unsigned ArgNo = R->getValueAsInt("ArgNo");
addArgAttribute(ArgNo, NoAlias); addArgAttribute(ArgNo, NoAlias);
} else if (R->isSubClassOf("NoUndef")) { } else if (R->isSubClassOf("NoUndef")) {
unsigned ArgNo = R->getValueAsInt("ArgNo"); unsigned ArgNo = R->getValueAsInt("ArgNo");
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/utils/TableGen/IntrinsicEmitter.cpp

Show First 20 Lines • Show All 382 Lines • ▼ Show 20 Lines if (L->isConvergent != R->isConvergent)
return R->isConvergent; return R->isConvergent;
if (L->isSpeculatable != R->isSpeculatable) if (L->isSpeculatable != R->isSpeculatable)
return R->isSpeculatable; return R->isSpeculatable;
if (L->hasSideEffects != R->hasSideEffects) if (L->hasSideEffects != R->hasSideEffects)
return R->hasSideEffects; return R->hasSideEffects;
if (L->isStrictFP != R->isStrictFP)
return R->isStrictFP;
// Try to order by readonly/readnone attribute. // Try to order by readonly/readnone attribute.
uint32_t LK = L->ME.toIntValue(); uint32_t LK = L->ME.toIntValue();
uint32_t RK = R->ME.toIntValue(); uint32_t RK = R->ME.toIntValue();
if (LK != RK) return (LK > RK); if (LK != RK) return (LK > RK);
return std::nullopt; return std::nullopt;
} }
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines for (const CodeGenIntrinsic &Intrinsic : Ints) {
if (Intrinsic.isNoDuplicate) if (Intrinsic.isNoDuplicate)
OS << " Attribute::get(C, Attribute::NoDuplicate),\n"; OS << " Attribute::get(C, Attribute::NoDuplicate),\n";
if (Intrinsic.isNoMerge) if (Intrinsic.isNoMerge)
OS << " Attribute::get(C, Attribute::NoMerge),\n"; OS << " Attribute::get(C, Attribute::NoMerge),\n";
if (Intrinsic.isConvergent) if (Intrinsic.isConvergent)
OS << " Attribute::get(C, Attribute::Convergent),\n"; OS << " Attribute::get(C, Attribute::Convergent),\n";
if (Intrinsic.isSpeculatable) if (Intrinsic.isSpeculatable)
OS << " Attribute::get(C, Attribute::Speculatable),\n"; OS << " Attribute::get(C, Attribute::Speculatable),\n";
if (Intrinsic.isStrictFP)
OS << " Attribute::get(C, Attribute::StrictFP),\n";
MemoryEffects ME = Intrinsic.ME; MemoryEffects ME = Intrinsic.ME;
// TODO: IntrHasSideEffects should affect not only readnone intrinsics. // TODO: IntrHasSideEffects should affect not only readnone intrinsics.
if (ME.doesNotAccessMemory() && Intrinsic.hasSideEffects) if (ME.doesNotAccessMemory() && Intrinsic.hasSideEffects)
ME = MemoryEffects::unknown(); ME = MemoryEffects::unknown();
if (ME != MemoryEffects::unknown()) { if (ME != MemoryEffects::unknown()) {
OS << " Attribute::getWithMemoryEffects(C, " OS << " Attribute::getWithMemoryEffects(C, "
<< "MemoryEffects::createFromIntValue(" << ME.toIntValue() << ")),\n"; << "MemoryEffects::createFromIntValue(" << ME.toIntValue() << ")),\n";
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines for (auto UniqAttribute : UniqAttributes) {
} }
if (!Intrinsic.canThrow || if (!Intrinsic.canThrow ||
(Intrinsic.ME != MemoryEffects::unknown() && (Intrinsic.ME != MemoryEffects::unknown() &&
!Intrinsic.hasSideEffects) || !Intrinsic.hasSideEffects) ||
Intrinsic.isNoReturn || Intrinsic.isNoCallback || Intrinsic.isNoSync || Intrinsic.isNoReturn || Intrinsic.isNoCallback || Intrinsic.isNoSync ||
Intrinsic.isNoFree || Intrinsic.isWillReturn || Intrinsic.isCold || Intrinsic.isNoFree || Intrinsic.isWillReturn || Intrinsic.isCold ||
Intrinsic.isNoDuplicate || Intrinsic.isNoMerge || Intrinsic.isNoDuplicate || Intrinsic.isNoMerge ||
Intrinsic.isConvergent || Intrinsic.isSpeculatable) { Intrinsic.isConvergent || Intrinsic.isSpeculatable ||
Intrinsic.isStrictFP) {
unsigned ID = UniqFnAttributes.find(&Intrinsic)->second; unsigned ID = UniqFnAttributes.find(&Intrinsic)->second;
OS << " AS[" << numAttrs++ << "] = {AttributeList::FunctionIndex, " OS << " AS[" << numAttrs++ << "] = {AttributeList::FunctionIndex, "
<< "getIntrinsicFnAttributeSet(C, " << ID << ")};\n"; << "getIntrinsicFnAttributeSet(C, " << ID << ")};\n";
} }
if (numAttrs) { if (numAttrs) {
OS << " NumAttrs = " << numAttrs << ";\n"; OS << " NumAttrs = " << numAttrs << ";\n";
OS << " break;\n"; OS << " break;\n";
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines