clang 24.0.0git
SystemZ.cpp
Go to the documentation of this file.
1//===------ SystemZ.cpp - Emit LLVM Code for builtins ---------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This contains code to emit Builtin calls as LLVM code.
10//
11//===----------------------------------------------------------------------===//
12
13#include "CGBuiltin.h"
14#include "CodeGenFunction.h"
15#include "clang/Basic/TargetBuiltins.h"
16#include "llvm/IR/IntrinsicsS390.h"
17
18using namespace clang;
19using namespace CodeGen;
20using namespace llvm;
21
22/// Handle a SystemZ function in which the final argument is a pointer
23/// to an int that receives the post-instruction CC value. At the LLVM level
24/// this is represented as a function that returns a {result, cc} pair.
25static Value *EmitSystemZIntrinsicWithCC(CodeGenFunction &CGF,
26 unsigned IntrinsicID,
27 const CallExpr *E) {
28 unsigned NumArgs = E->getNumArgs() - 1;
29 SmallVector<Value *, 8> Args(NumArgs);
30 for (unsigned I = 0; I < NumArgs; ++I)
31 Args[I] = CGF.EmitScalarExpr(E->getArg(I));
32 Address CCPtr = CGF.EmitPointerWithAlignment(E->getArg(NumArgs));
33 Function *F = CGF.CGM.getIntrinsic(IntrinsicID);
34 Value *Call = CGF.Builder.CreateCall(F, Args);
35 Value *CC = CGF.Builder.CreateExtractValue(Call, 1);
36 CGF.Builder.CreateStore(CC, CCPtr);
37 return CGF.Builder.CreateExtractValue(Call, 0);
38}
39
40/// For z/OS, the builtin __cs1 has the following signature:
41/// int __cs1(void * Comparand,
42/// void * Destination,
43/// void * Exchange);
44/// Whereas the llvm 'cmpxchg' instruction has the following syntax:
45/// compxchg *Destination, Comparand, Exchange.
46/// So we need to swap Comparand & Destination and dereference Comparand &
47/// Exchange when invoking CreateAtomicCmpXchg. For this reason we can not use
48/// the utility function MakeAtomicCmpXchgValue.
49static Value *EmitAtomicCmpXchgForZOSIntrin(CodeGenFunction &CGF,
50 const CallExpr *E,
51 llvm::Type *IntType, bool HasAddr) {
52
53 CharUnits Alignment =
54 CGF.getContext().toCharUnitsFromBits(IntType->getScalarSizeInBits());
55 llvm::Value *ComparandPtr = CGF.EmitScalarExpr(E->getArg(0));
56 llvm::Value *DestinationPtr = CGF.EmitScalarExpr(E->getArg(1));
57
58 Address DestinationAddr = Address(DestinationPtr, IntType, Alignment);
59 Address ComparandAddr = Address(ComparandPtr, IntType, Alignment);
60
61 llvm::Value *Comparand = CGF.Builder.CreateLoad(ComparandAddr);
62 llvm::Value *Exchange;
63 if (HasAddr) {
64 llvm::Value *ExchangePtr = CGF.EmitScalarExpr(E->getArg(2));
65 Address ExchangeAddr = Address(ExchangePtr, IntType, Alignment);
66 Exchange = CGF.Builder.CreateLoad(ExchangeAddr);
67 } else {
68 Exchange = CGF.EmitScalarExpr(E->getArg(2));
69 }
70
71 Value *Result = CGF.Builder.CreateAtomicCmpXchg(
72 DestinationAddr, Comparand, Exchange,
73 llvm::AtomicOrdering::SequentiallyConsistent,
74 llvm::AtomicOrdering::SequentiallyConsistent);
75
76 // Store Destination in Comparand.
77 CGF.Builder.CreateStore(CGF.Builder.CreateExtractValue(Result, 0),
78 ComparandAddr);
79
80 // Extract boolean success flag, invert it and zext it to int.
81 llvm::Value *RetVal =
82 CGF.Builder.CreateNot(CGF.Builder.CreateExtractValue(Result, 1));
83 return CGF.Builder.CreateZExt(RetVal, CGF.ConvertType(E->getType()));
84}
85
86Value *CodeGenFunction::EmitSystemZBuiltinExpr(unsigned BuiltinID,
87 const CallExpr *E) {
88 switch (BuiltinID) {
89 case SystemZ::BI__builtin_tbegin: {
90 Value *TDB = EmitScalarExpr(E->getArg(0));
91 Value *Control = llvm::ConstantInt::get(Int32Ty, 0xff0c);
92 Function *F = CGM.getIntrinsic(Intrinsic::s390_tbegin);
93 return Builder.CreateCall(F, {TDB, Control});
94 }
95 case SystemZ::BI__builtin_tbegin_nofloat: {
96 Value *TDB = EmitScalarExpr(E->getArg(0));
97 Value *Control = llvm::ConstantInt::get(Int32Ty, 0xff0c);
98 Function *F = CGM.getIntrinsic(Intrinsic::s390_tbegin_nofloat);
99 return Builder.CreateCall(F, {TDB, Control});
100 }
101 case SystemZ::BI__builtin_tbeginc: {
102 Value *TDB = llvm::ConstantPointerNull::get(Int8PtrTy);
103 Value *Control = llvm::ConstantInt::get(Int32Ty, 0xff08);
104 Function *F = CGM.getIntrinsic(Intrinsic::s390_tbeginc);
105 return Builder.CreateCall(F, {TDB, Control});
106 }
107 case SystemZ::BI__builtin_tabort: {
108 Value *Data = EmitScalarExpr(E->getArg(0));
109 Function *F = CGM.getIntrinsic(Intrinsic::s390_tabort);
110 return Builder.CreateCall(F, Builder.CreateSExt(Data, Int64Ty, "tabort"));
111 }
112 case SystemZ::BI__builtin_non_tx_store: {
113 Value *Address = EmitScalarExpr(E->getArg(0));
114 Value *Data = EmitScalarExpr(E->getArg(1));
115 Function *F = CGM.getIntrinsic(Intrinsic::s390_ntstg);
116 return Builder.CreateCall(F, {Data, Address});
117 }
118 case SystemZ::BI__cs: {
119 return EmitAtomicCmpXchgForZOSIntrin(*this, E, Int32Ty, false);
120 }
121 case SystemZ::BI__cs1: {
122 return EmitAtomicCmpXchgForZOSIntrin(*this, E, Int32Ty, true);
123 }
124 case SystemZ::BI__csg:
125 case SystemZ::BI__cds1: {
126 return EmitAtomicCmpXchgForZOSIntrin(*this, E, Int64Ty, true);
127 }
128 case SystemZ::BI__cdsg: {
129 llvm::Type *Int128Ty = llvm::IntegerType::get(getLLVMContext(), 128);
130 return EmitAtomicCmpXchgForZOSIntrin(*this, E, Int128Ty, true);
131 }
132
133 // Vector builtins. Note that most vector builtins are mapped automatically
134 // to target-specific LLVM intrinsics. The ones handled specially here can
135 // be represented via standard LLVM IR, which is preferable to enable common
136 // LLVM optimizations.
137
138 case SystemZ::BI__builtin_s390_vclzb:
139 case SystemZ::BI__builtin_s390_vclzh:
140 case SystemZ::BI__builtin_s390_vclzf:
141 case SystemZ::BI__builtin_s390_vclzg:
142 case SystemZ::BI__builtin_s390_vclzq: {
143 llvm::Type *ResultType = ConvertType(E->getType());
144 Value *X = EmitScalarExpr(E->getArg(0));
145 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
146 Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ResultType);
147 return Builder.CreateCall(F, {X, Undef});
148 }
149
150 case SystemZ::BI__builtin_s390_vctzb:
151 case SystemZ::BI__builtin_s390_vctzh:
152 case SystemZ::BI__builtin_s390_vctzf:
153 case SystemZ::BI__builtin_s390_vctzg:
154 case SystemZ::BI__builtin_s390_vctzq: {
155 llvm::Type *ResultType = ConvertType(E->getType());
156 Value *X = EmitScalarExpr(E->getArg(0));
157 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
158 Function *F = CGM.getIntrinsic(Intrinsic::cttz, ResultType);
159 return Builder.CreateCall(F, {X, Undef});
160 }
161
162 case SystemZ::BI__builtin_s390_verllb:
163 case SystemZ::BI__builtin_s390_verllh:
164 case SystemZ::BI__builtin_s390_verllf:
165 case SystemZ::BI__builtin_s390_verllg: {
166 llvm::Type *ResultType = ConvertType(E->getType());
167 llvm::Value *Src = EmitScalarExpr(E->getArg(0));
168 llvm::Value *Amt = EmitScalarExpr(E->getArg(1));
169 // Splat scalar rotate amount to vector type.
170 unsigned NumElts = cast<llvm::FixedVectorType>(ResultType)->getNumElements();
171 Amt = Builder.CreateIntCast(Amt, ResultType->getScalarType(), false);
172 Amt = Builder.CreateVectorSplat(NumElts, Amt);
173 Function *F = CGM.getIntrinsic(Intrinsic::fshl, ResultType);
174 return Builder.CreateCall(F, { Src, Src, Amt });
175 }
176
177 case SystemZ::BI__builtin_s390_verllvb:
178 case SystemZ::BI__builtin_s390_verllvh:
179 case SystemZ::BI__builtin_s390_verllvf:
180 case SystemZ::BI__builtin_s390_verllvg: {
181 llvm::Type *ResultType = ConvertType(E->getType());
182 llvm::Value *Src = EmitScalarExpr(E->getArg(0));
183 llvm::Value *Amt = EmitScalarExpr(E->getArg(1));
184 Function *F = CGM.getIntrinsic(Intrinsic::fshl, ResultType);
185 return Builder.CreateCall(F, { Src, Src, Amt });
186 }
187
188 case SystemZ::BI__builtin_s390_vfsqsb:
189 case SystemZ::BI__builtin_s390_vfsqdb: {
190 llvm::Type *ResultType = ConvertType(E->getType());
191 Value *X = EmitScalarExpr(E->getArg(0));
192 if (Builder.getIsFPConstrained()) {
193 Function *F = CGM.getIntrinsic(Intrinsic::experimental_constrained_sqrt, ResultType);
194 return Builder.CreateConstrainedFPCall(F, { X });
195 } else {
196 Function *F = CGM.getIntrinsic(Intrinsic::sqrt, ResultType);
197 return Builder.CreateCall(F, X);
198 }
199 }
200 case SystemZ::BI__builtin_s390_vfmasb:
201 case SystemZ::BI__builtin_s390_vfmadb: {
202 llvm::Type *ResultType = ConvertType(E->getType());
203 Value *X = EmitScalarExpr(E->getArg(0));
204 Value *Y = EmitScalarExpr(E->getArg(1));
205 Value *Z = EmitScalarExpr(E->getArg(2));
206 if (Builder.getIsFPConstrained()) {
207 Function *F = CGM.getIntrinsic(Intrinsic::experimental_constrained_fma, ResultType);
208 return Builder.CreateConstrainedFPCall(F, {X, Y, Z});
209 } else {
210 Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
211 return Builder.CreateCall(F, {X, Y, Z});
212 }
213 }
214 case SystemZ::BI__builtin_s390_vfmssb:
215 case SystemZ::BI__builtin_s390_vfmsdb: {
216 llvm::Type *ResultType = ConvertType(E->getType());
217 Value *X = EmitScalarExpr(E->getArg(0));
218 Value *Y = EmitScalarExpr(E->getArg(1));
219 Value *Z = EmitScalarExpr(E->getArg(2));
220 if (Builder.getIsFPConstrained()) {
221 Function *F = CGM.getIntrinsic(Intrinsic::experimental_constrained_fma, ResultType);
222 return Builder.CreateConstrainedFPCall(F, {X, Y, Builder.CreateFNeg(Z, "neg")});
223 } else {
224 Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
225 return Builder.CreateCall(F, {X, Y, Builder.CreateFNeg(Z, "neg")});
226 }
227 }
228 case SystemZ::BI__builtin_s390_vfnmasb:
229 case SystemZ::BI__builtin_s390_vfnmadb: {
230 llvm::Type *ResultType = ConvertType(E->getType());
231 Value *X = EmitScalarExpr(E->getArg(0));
232 Value *Y = EmitScalarExpr(E->getArg(1));
233 Value *Z = EmitScalarExpr(E->getArg(2));
234 if (Builder.getIsFPConstrained()) {
235 Function *F = CGM.getIntrinsic(Intrinsic::experimental_constrained_fma, ResultType);
236 return Builder.CreateFNeg(Builder.CreateConstrainedFPCall(F, {X, Y, Z}), "neg");
237 } else {
238 Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
239 return Builder.CreateFNeg(Builder.CreateCall(F, {X, Y, Z}), "neg");
240 }
241 }
242 case SystemZ::BI__builtin_s390_vfnmssb:
243 case SystemZ::BI__builtin_s390_vfnmsdb: {
244 llvm::Type *ResultType = ConvertType(E->getType());
245 Value *X = EmitScalarExpr(E->getArg(0));
246 Value *Y = EmitScalarExpr(E->getArg(1));
247 Value *Z = EmitScalarExpr(E->getArg(2));
248 if (Builder.getIsFPConstrained()) {
249 Function *F = CGM.getIntrinsic(Intrinsic::experimental_constrained_fma, ResultType);
250 Value *NegZ = Builder.CreateFNeg(Z, "sub");
251 return Builder.CreateFNeg(Builder.CreateConstrainedFPCall(F, {X, Y, NegZ}));
252 } else {
253 Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
254 Value *NegZ = Builder.CreateFNeg(Z, "neg");
255 return Builder.CreateFNeg(Builder.CreateCall(F, {X, Y, NegZ}));
256 }
257 }
258 case SystemZ::BI__builtin_s390_vflpsb:
259 case SystemZ::BI__builtin_s390_vflpdb: {
260 Value *X = EmitScalarExpr(E->getArg(0));
261 return Builder.CreateFAbs(X);
262 }
263 case SystemZ::BI__builtin_s390_vflnsb:
264 case SystemZ::BI__builtin_s390_vflndb: {
265 Value *X = EmitScalarExpr(E->getArg(0));
266 return Builder.CreateFNeg(Builder.CreateFAbs(X), "neg");
267 }
268 case SystemZ::BI__builtin_s390_vfisb:
269 case SystemZ::BI__builtin_s390_vfidb: {
270 llvm::Type *ResultType = ConvertType(E->getType());
271 Value *X = EmitScalarExpr(E->getArg(0));
272 // Constant-fold the M4 and M5 mask arguments.
273 llvm::APSInt M4 = *E->getArg(1)->getIntegerConstantExpr(getContext());
274 llvm::APSInt M5 = *E->getArg(2)->getIntegerConstantExpr(getContext());
275 // Check whether this instance can be represented via a LLVM standard
276 // intrinsic. We only support some combinations of M4 and M5.
277 Intrinsic::ID ID = Intrinsic::not_intrinsic;
278 Intrinsic::ID CI;
279 switch (M4.getZExtValue()) {
280 default: break;
281 case 0: // IEEE-inexact exception allowed
282 switch (M5.getZExtValue()) {
283 default: break;
284 case 0: ID = Intrinsic::rint;
285 CI = Intrinsic::experimental_constrained_rint; break;
286 }
287 break;
288 case 4: // IEEE-inexact exception suppressed
289 switch (M5.getZExtValue()) {
290 default: break;
291 case 0: ID = Intrinsic::nearbyint;
292 CI = Intrinsic::experimental_constrained_nearbyint; break;
293 case 1: ID = Intrinsic::round;
294 CI = Intrinsic::experimental_constrained_round; break;
295 case 4: ID = Intrinsic::roundeven;
296 CI = Intrinsic::experimental_constrained_roundeven; break;
297 case 5: ID = Intrinsic::trunc;
298 CI = Intrinsic::experimental_constrained_trunc; break;
299 case 6: ID = Intrinsic::ceil;
300 CI = Intrinsic::experimental_constrained_ceil; break;
301 case 7: ID = Intrinsic::floor;
302 CI = Intrinsic::experimental_constrained_floor; break;
303 }
304 break;
305 }
306 if (ID != Intrinsic::not_intrinsic) {
307 if (Builder.getIsFPConstrained()) {
308 Function *F = CGM.getIntrinsic(CI, ResultType);
309 return Builder.CreateConstrainedFPCall(F, X);
310 } else {
311 Function *F = CGM.getIntrinsic(ID, ResultType);
312 return Builder.CreateCall(F, X);
313 }
314 }
315 switch (BuiltinID) { // FIXME: constrained version?
316 case SystemZ::BI__builtin_s390_vfisb: ID = Intrinsic::s390_vfisb; break;
317 case SystemZ::BI__builtin_s390_vfidb: ID = Intrinsic::s390_vfidb; break;
318 default: llvm_unreachable("Unknown BuiltinID");
319 }
320 Function *F = CGM.getIntrinsic(ID);
321 Value *M4Value = llvm::ConstantInt::get(getLLVMContext(), M4);
322 Value *M5Value = llvm::ConstantInt::get(getLLVMContext(), M5);
323 return Builder.CreateCall(F, {X, M4Value, M5Value});
324 }
325 case SystemZ::BI__builtin_s390_vfmaxsb:
326 case SystemZ::BI__builtin_s390_vfmaxdb: {
327 llvm::Type *ResultType = ConvertType(E->getType());
328 Value *X = EmitScalarExpr(E->getArg(0));
329 Value *Y = EmitScalarExpr(E->getArg(1));
330 // Constant-fold the M4 mask argument.
331 llvm::APSInt M4 = *E->getArg(2)->getIntegerConstantExpr(getContext());
332 // Check whether this instance can be represented via a LLVM standard
333 // intrinsic. We only support some values of M4.
334 Intrinsic::ID ID = Intrinsic::not_intrinsic;
335 Intrinsic::ID CI;
336 switch (M4.getZExtValue()) {
337 default: break;
338 case 4: ID = Intrinsic::maxnum;
339 CI = Intrinsic::experimental_constrained_maxnum; break;
340 }
341 if (ID != Intrinsic::not_intrinsic) {
342 if (Builder.getIsFPConstrained()) {
343 Function *F = CGM.getIntrinsic(CI, ResultType);
344 return Builder.CreateConstrainedFPCall(F, {X, Y});
345 } else {
346 Function *F = CGM.getIntrinsic(ID, ResultType);
347 return Builder.CreateCall(F, {X, Y});
348 }
349 }
350 switch (BuiltinID) {
351 case SystemZ::BI__builtin_s390_vfmaxsb: ID = Intrinsic::s390_vfmaxsb; break;
352 case SystemZ::BI__builtin_s390_vfmaxdb: ID = Intrinsic::s390_vfmaxdb; break;
353 default: llvm_unreachable("Unknown BuiltinID");
354 }
355 Function *F = CGM.getIntrinsic(ID);
356 Value *M4Value = llvm::ConstantInt::get(getLLVMContext(), M4);
357 return Builder.CreateCall(F, {X, Y, M4Value});
358 }
359 case SystemZ::BI__builtin_s390_vfminsb:
360 case SystemZ::BI__builtin_s390_vfmindb: {
361 llvm::Type *ResultType = ConvertType(E->getType());
362 Value *X = EmitScalarExpr(E->getArg(0));
363 Value *Y = EmitScalarExpr(E->getArg(1));
364 // Constant-fold the M4 mask argument.
365 llvm::APSInt M4 = *E->getArg(2)->getIntegerConstantExpr(getContext());
366 // Check whether this instance can be represented via a LLVM standard
367 // intrinsic. We only support some values of M4.
368 Intrinsic::ID ID = Intrinsic::not_intrinsic;
369 Intrinsic::ID CI;
370 switch (M4.getZExtValue()) {
371 default: break;
372 case 4: ID = Intrinsic::minnum;
373 CI = Intrinsic::experimental_constrained_minnum; break;
374 }
375 if (ID != Intrinsic::not_intrinsic) {
376 if (Builder.getIsFPConstrained()) {
377 Function *F = CGM.getIntrinsic(CI, ResultType);
378 return Builder.CreateConstrainedFPCall(F, {X, Y});
379 } else {
380 Function *F = CGM.getIntrinsic(ID, ResultType);
381 return Builder.CreateCall(F, {X, Y});
382 }
383 }
384 switch (BuiltinID) {
385 case SystemZ::BI__builtin_s390_vfminsb: ID = Intrinsic::s390_vfminsb; break;
386 case SystemZ::BI__builtin_s390_vfmindb: ID = Intrinsic::s390_vfmindb; break;
387 default: llvm_unreachable("Unknown BuiltinID");
388 }
389 Function *F = CGM.getIntrinsic(ID);
390 Value *M4Value = llvm::ConstantInt::get(getLLVMContext(), M4);
391 return Builder.CreateCall(F, {X, Y, M4Value});
392 }
393
394 case SystemZ::BI__builtin_s390_vlbrh:
395 case SystemZ::BI__builtin_s390_vlbrf:
396 case SystemZ::BI__builtin_s390_vlbrg:
397 case SystemZ::BI__builtin_s390_vlbrq: {
398 llvm::Type *ResultType = ConvertType(E->getType());
399 Value *X = EmitScalarExpr(E->getArg(0));
400 Function *F = CGM.getIntrinsic(Intrinsic::bswap, ResultType);
401 return Builder.CreateCall(F, X);
402 }
403
404 // Vector intrinsics that output the post-instruction CC value.
405
406#define INTRINSIC_WITH_CC(NAME) \
407 case SystemZ::BI__builtin_##NAME: \
408 return EmitSystemZIntrinsicWithCC(*this, Intrinsic::NAME, E)
409
410 INTRINSIC_WITH_CC(s390_vpkshs);
411 INTRINSIC_WITH_CC(s390_vpksfs);
412 INTRINSIC_WITH_CC(s390_vpksgs);
413
414 INTRINSIC_WITH_CC(s390_vpklshs);
415 INTRINSIC_WITH_CC(s390_vpklsfs);
416 INTRINSIC_WITH_CC(s390_vpklsgs);
417
418 INTRINSIC_WITH_CC(s390_vceqbs);
419 INTRINSIC_WITH_CC(s390_vceqhs);
420 INTRINSIC_WITH_CC(s390_vceqfs);
421 INTRINSIC_WITH_CC(s390_vceqgs);
422 INTRINSIC_WITH_CC(s390_vceqqs);
423
424 INTRINSIC_WITH_CC(s390_vchbs);
425 INTRINSIC_WITH_CC(s390_vchhs);
426 INTRINSIC_WITH_CC(s390_vchfs);
427 INTRINSIC_WITH_CC(s390_vchgs);
428 INTRINSIC_WITH_CC(s390_vchqs);
429
430 INTRINSIC_WITH_CC(s390_vchlbs);
431 INTRINSIC_WITH_CC(s390_vchlhs);
432 INTRINSIC_WITH_CC(s390_vchlfs);
433 INTRINSIC_WITH_CC(s390_vchlgs);
434 INTRINSIC_WITH_CC(s390_vchlqs);
435
436 INTRINSIC_WITH_CC(s390_vfaebs);
437 INTRINSIC_WITH_CC(s390_vfaehs);
438 INTRINSIC_WITH_CC(s390_vfaefs);
439
440 INTRINSIC_WITH_CC(s390_vfaezbs);
441 INTRINSIC_WITH_CC(s390_vfaezhs);
442 INTRINSIC_WITH_CC(s390_vfaezfs);
443
444 INTRINSIC_WITH_CC(s390_vfeebs);
445 INTRINSIC_WITH_CC(s390_vfeehs);
446 INTRINSIC_WITH_CC(s390_vfeefs);
447
448 INTRINSIC_WITH_CC(s390_vfeezbs);
449 INTRINSIC_WITH_CC(s390_vfeezhs);
450 INTRINSIC_WITH_CC(s390_vfeezfs);
451
452 INTRINSIC_WITH_CC(s390_vfenebs);
453 INTRINSIC_WITH_CC(s390_vfenehs);
454 INTRINSIC_WITH_CC(s390_vfenefs);
455
456 INTRINSIC_WITH_CC(s390_vfenezbs);
457 INTRINSIC_WITH_CC(s390_vfenezhs);
458 INTRINSIC_WITH_CC(s390_vfenezfs);
459
460 INTRINSIC_WITH_CC(s390_vistrbs);
461 INTRINSIC_WITH_CC(s390_vistrhs);
462 INTRINSIC_WITH_CC(s390_vistrfs);
463
464 INTRINSIC_WITH_CC(s390_vstrcbs);
465 INTRINSIC_WITH_CC(s390_vstrchs);
466 INTRINSIC_WITH_CC(s390_vstrcfs);
467
468 INTRINSIC_WITH_CC(s390_vstrczbs);
469 INTRINSIC_WITH_CC(s390_vstrczhs);
470 INTRINSIC_WITH_CC(s390_vstrczfs);
471
472 INTRINSIC_WITH_CC(s390_vfcesbs);
473 INTRINSIC_WITH_CC(s390_vfcedbs);
474 INTRINSIC_WITH_CC(s390_vfchsbs);
475 INTRINSIC_WITH_CC(s390_vfchdbs);
476 INTRINSIC_WITH_CC(s390_vfchesbs);
477 INTRINSIC_WITH_CC(s390_vfchedbs);
478
479 INTRINSIC_WITH_CC(s390_vftcisb);
480 INTRINSIC_WITH_CC(s390_vftcidb);
481
482 INTRINSIC_WITH_CC(s390_vstrsb);
483 INTRINSIC_WITH_CC(s390_vstrsh);
484 INTRINSIC_WITH_CC(s390_vstrsf);
485
486 INTRINSIC_WITH_CC(s390_vstrszb);
487 INTRINSIC_WITH_CC(s390_vstrszh);
488 INTRINSIC_WITH_CC(s390_vstrszf);
489
490#undef INTRINSIC_WITH_CC
491
492 default:
493 return nullptr;
494 }
495}
EmitAtomicCmpXchgForZOSIntrin
static Value * EmitAtomicCmpXchgForZOSIntrin(CodeGenFunction &CGF, const CallExpr *E, llvm::Type *IntType, bool HasAddr)
For z/OS, the builtin __cs1 has the following signature: int __cs1(void * Comparand,...
Definition SystemZ.cpp:49
INTRINSIC_WITH_CC
#define INTRINSIC_WITH_CC(NAME)
EmitSystemZIntrinsicWithCC
static Value * EmitSystemZIntrinsicWithCC(CodeGenFunction &CGF, unsigned IntrinsicID, const CallExpr *E)
Handle a SystemZ function in which the final argument is a pointer to an int that receives the post-i...
Definition SystemZ.cpp:25
Result
Result
Implement __builtin_bit_cast and related operations.
Definition InterpBuiltinBitCast.cpp:38
X
#define X(type, name)
Definition Value.h:97
TargetBuiltins.h
Enumerates target-specific builtins in their own namespaces within namespace clang.
clang::ASTContext::toCharUnitsFromBits
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
Definition ASTContext.cpp:2687
clang::CallExpr
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition Expr.h:2949
clang::CallExpr::getArg
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition Expr.h:3153
clang::CallExpr::getNumArgs
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition Expr.h:3140
clang::CharUnits
CharUnits - This is an opaque type for sizes expressed in character units.
Definition CharUnits.h:38
clang::CodeGen::Address
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
Definition Address.h:128
clang::CodeGen::CGBuilderTy::CreateStore
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition CGBuilder.h:146
clang::CodeGen::CGBuilderTy::CreateAtomicCmpXchg
llvm::AtomicCmpXchgInst * CreateAtomicCmpXchg(Address Addr, llvm::Value *Cmp, llvm::Value *New, llvm::AtomicOrdering SuccessOrdering, llvm::AtomicOrdering FailureOrdering, llvm::SyncScope::ID SSID=llvm::SyncScope::System)
Definition CGBuilder.h:179
clang::CodeGen::CGBuilderTy::CreateLoad
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition CGBuilder.h:118
clang::CodeGen::CodeGenFunction
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Definition CodeGenFunction.h:258
clang::CodeGen::CodeGenFunction::ConvertType
llvm::Type * ConvertType(QualType T)
Definition CodeGenFunction.cpp:238
clang::CodeGen::CodeGenFunction::EmitSystemZBuiltinExpr
llvm::Value * EmitSystemZBuiltinExpr(unsigned BuiltinID, const CallExpr *E)
Definition SystemZ.cpp:86
clang::CodeGen::CodeGenFunction::EmitPointerWithAlignment
Address EmitPointerWithAlignment(const Expr *Addr, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
EmitPointerWithAlignment - Given an expression with a pointer type, emit the value and compute our be...
Definition CGExpr.cpp:1621
clang::CodeGen::CodeGenFunction::EmitScalarExpr
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type,...
Definition CGExprScalar.cpp:6193
clang::CodeGen::CodeGenFunction::getLLVMContext
llvm::LLVMContext & getLLVMContext()
Definition CodeGenFunction.h:2235
clang::CodeGen::CodeGenModule::getIntrinsic
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys={})
Definition CodeGenModule.cpp:7202
clang::Expr::getIntegerConstantExpr
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
Definition ExprConstant.cpp:22753
clang::Expr::getType
QualType getType() const
Definition Expr.h:144
clang
The JSON file list parser is used to communicate input to InstallAPI.
Definition CalledOnceCheck.h:17
clang::cast
U cast(CodeGen::Address addr)
Definition Address.h:327
llvm
Diagnostic wrappers for TextAPI types for error reporting.
Definition Dominators.h:30
Generated on for clang by doxygen 1.14.0