File: lower-mass-end-to-end.c

package info (click to toggle)
llvm-toolchain-15 1%3A15.0.6-4
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 1,554,644 kB
  • sloc: cpp: 5,922,452; ansic: 1,012,136; asm: 674,362; python: 191,568; objc: 73,855; f90: 42,327; lisp: 31,913; pascal: 11,973; javascript: 10,144; sh: 9,421; perl: 7,447; ml: 5,527; awk: 3,523; makefile: 2,520; xml: 885; cs: 573; fortran: 567
file content (148 lines) | stat: -rw-r--r-- 5,510 bytes parent folder | download | duplicates (13)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
// REQUIRES: powerpc-registered-target
// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -O3 -fapprox-func --target=powerpc64le-unknown-linux-gnu -S %s -o -| FileCheck %s -check-prefix=CHECK-MASS-AFN
// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -Ofast --target=powerpc64le-unknown-linux-gnu -S %s -o -| FileCheck %s -check-prefix=CHECK-MASS-FAST
// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -O3 -fapprox-func --target=powerpc-ibm-aix-xcoff -S %s -o -| FileCheck %s -check-prefix=CHECK-MASS-AFN
// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -Ofast --target=powerpc-ibm-aix-xcoff -S %s -o -| FileCheck %s -check-prefix=CHECK-MASS-FAST

// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass=false -O3 -fapprox-func --target=powerpc64le-unknown-linux-gnu -S %s -o -| FileCheck %s -check-prefix=CHECK-NO-MASS-AFN
// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass=false -Ofast --target=powerpc64le-unknown-linux-gnu -S %s -o -| FileCheck %s -check-prefix=CHECK-NO-MASS-FAST
// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass=false -O3 -fapprox-func --target=powerpc-ibm-aix-xcoff -S %s -o -| FileCheck %s -check-prefix=CHECK-NO-MASS-AFN
// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass=false -Ofast --target=powerpc-ibm-aix-xcoff -S %s -o -| FileCheck %s -check-prefix=CHECK-NO-MASS-FAST

// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -O3 -fno-approx-func --target=powerpc64le-unknown-linux-gnu -S %s -o -| FileCheck %s -check-prefix=CHECK-NO-MASS-AFN
// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -fno-fast-math --target=powerpc64le-unknown-linux-gnu -S %s -o -| FileCheck %s -check-prefix=CHECK-NO-MASS-FAST
// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -O3 -fno-approx-func --target=powerpc-ibm-aix-xcoff -S %s -o -| FileCheck %s -check-prefix=CHECK-NO-MASS-AFN
// RUN: %clang -mllvm -enable-ppc-gen-scalar-mass -fno-fast-math --target=powerpc-ibm-aix-xcoff -S %s -o -| FileCheck %s -check-prefix=CHECK-NO-MASS-FAST

extern double sin(double a);
extern double cos(double a);
extern double pow(double a, double b);
extern double log(double a);
extern double log10(double a);
extern double exp(double a);
extern float sinf(float a);
extern float cosf(float a);
extern float powf(float a, float b);
extern float logf(float a);
extern float log10f(float a);
extern float expf(float a);

double sin_f64(double a) {
// CHECK-LABEL: sin_f64
// CHECK-MASS-FAST: __xl_sin_finite
// CHECK-MASS-AFN: __xl_sin
// CHECK-NO-MASS-FAST-NOT: {{__xl_sin|__xl_sin_finite}}
// CHECK-NO-MASS-AFN-NOT: {{__xl_sin|__xl_sin_finite}}
// CHECK: blr
  return sin(a);
}

double cos_f64(double a) {
// CHECK-LABEL: cos_f64
// CHECK-MASS-FAST: __xl_cos_finite
// CHECK-MASS-AFN: __xl_cos
// CHECK-NO-MASS-FAST-NOT: {{__xl_cos|__xl_cos_finite}}
// CHECK-NO-MASS-AFN-NOT: {{__xl_cos|__xl_cos_finite}}
// CHECK: blr
  return cos(a);
}

double pow_f64(double a, double b) {
// CHECK-LABEL: pow_f64
// CHECK-MASS-FAST: __xl_pow_finite
// CHECK-MASS-AFN: __xl_pow
// CHECK-NO-MASS-FAST-NOT: {{__xl_pow|__xl_pow_finite}}
// CHECK-NO-MASS-AFN-NOT: {{__xl_pow|__xl_pow_finite}}
// CHECK: blr
  return pow(a, b);
}

double log_f64(double a) {
// CHECK-LABEL: log_f64
// CHECK-MASS-FAST: __xl_log_finite
// CHECK-MASS-AFN: __xl_log
// CHECK-NO-MASS-FAST-NOT: {{__xl_log|__xl_log_finite}}
// CHECK-NO-MASS-AFN-NOT: {{__xl_log|__xl_log_finite}}
// CHECK: blr
  return log(a);
}

double log10_f64(double a) {
// CHECK-LABEL: log10_f64
// CHECK-MASS-FAST: __xl_log10_finite
// CHECK-MASS-AFN: __xl_log10
// CHECK-NO-MASS-FAST-NOT: {{__xl_log10|__xl_log10_finite}}
// CHECK-NO-MASS-AFN-NOT: {{__xl_log10|__xl_log10_finite}}
// CHECK: blr
  return log10(a);
}

double exp_f64(double a) {
// CHECK-LABEL: exp_f64
// CHECK-MASS-FAST: __xl_exp_finite
// CHECK-MASS-AFN: __xl_exp
// CHECK-NO-MASS-FAST-NOT: {{__xl_exp|__xl_exp_finite}}
// CHECK-NO-MASS-AFN-NOT: {{__xl_exp|__xl_exp_finite}}
// CHECK: blr
  return exp(a);
}

float sin_f32(float a) {
// CHECK-LABEL: sin_f32
// CHECK-MASS-FAST: __xl_sinf_finite
// CHECK-MASS-AFN: __xl_sinf
// CHECK-NO-MASS-FAST-NOT: {{__xl_sinf|__xl_sinf_finite}}
// CHECK-NO-MASS-AFN-NOT: {{__xl_sinf|__xl_sinf_finite}}
// CHECK: blr
  return sinf(a);
}

float cos_f32(float a) {
// CHECK-LABEL: cos_f32
// CHECK-MASS-FAST: __xl_cosf_finite
// CHECK-MASS-AFN: __xl_cosf
// CHECK-NO-MASS-FAST-NOT: {{__xl_cosf|__xl_cosf_finite}}
// CHECK-NO-MASS-AFN-NOT: {{__xl_cosf|__xl_cosf_finite}}
// CHECK: blr
  return cosf(a);
}

float pow_f32(float a, float b) {
// CHECK-LABEL: pow_f32
// CHECK-MASS-FAST: __xl_powf_finite
// CHECK-MASS-AFN: __xl_powf
// CHECK-NO-MASS-FAST-NOT: {{__xl_pow|__xl_powf_finite}}
// CHECK-NO-MASS-AFN-NOT: {{__xl_pow|__xl_powf_finite}}
// CHECK: blr
  return powf(a, b);
}

float log_f32(float a) {
// CHECK-LABEL: log_f32
// CHECK-MASS-FAST: __xl_logf_finite
// CHECK-MASS-AFN: __xl_logf
// CHECK-NO-MASS-FAST-NOT: {{__xl_logf|__xl_logf_finite}}
// CHECK-NO-MASS-AFN-NOT: {{__xl_logf|__xl_logf_finite}}
// CHECK: blr
  return logf(a);
}

float log10_f32(float a) {
// CHECK-LABEL: log10_f32
// CHECK-MASS-FAST: __xl_log10f_finite
// CHECK-MASS-AFN: __xl_log10f
// CHECK-NO-MASS-FAST-NOT: {{__xl_log10f|__xl_log10f_finite}}
// CHECK-NO-MASS-AFN-NOT: {{__xl_log10f|__xl_log10f_finite}}
// CHECK: blr
  return log10f(a);
}

float exp_f32(float a) {
// CHECK-LABEL: exp_f32
// CHECK-MASS-FAST: __xl_expf_finite
// CHECK-MASS-AFN: __xl_expf
// CHECK-NO-MASS-FAST-NOT: {{__xl_expf|__xl_expf_finite}}
// CHECK-NO-MASS-AFN-NOT: {{__xl_expf|__xl_expf_finite}}
// CHECK: blr
  return expf(a);
}