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: E->getArg(Arg: I));
32 Address CCPtr = CGF.EmitPointerWithAlignment(Addr: E->getArg(Arg: NumArgs));
33 Function *F = CGF.CGM.getIntrinsic(IID: IntrinsicID);
34 Value *Call = CGF.Builder.CreateCall(Callee: F, Args);
35 Value *CC = CGF.Builder.CreateExtractValue(Agg: Call, Idxs: 1);
36 CGF.Builder.CreateStore(Val: CC, Addr: CCPtr);
37 return CGF.Builder.CreateExtractValue(Agg: Call, Idxs: 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(BitSize: IntType->getScalarSizeInBits());
55 llvm::Value *ComparandPtr = CGF.EmitScalarExpr(E: E->getArg(Arg: 0));
56 llvm::Value *DestinationPtr = CGF.EmitScalarExpr(E: E->getArg(Arg: 1));
57
58 Address DestinationAddr = Address(DestinationPtr, IntType, Alignment);
59 Address ComparandAddr = Address(ComparandPtr, IntType, Alignment);
60
61 llvm::Value *Comparand = CGF.Builder.CreateLoad(Addr: ComparandAddr);
62 llvm::Value *Exchange;
63 if (HasAddr) {
64 llvm::Value *ExchangePtr = CGF.EmitScalarExpr(E: E->getArg(Arg: 2));
65 Address ExchangeAddr = Address(ExchangePtr, IntType, Alignment);
66 Exchange = CGF.Builder.CreateLoad(Addr: ExchangeAddr);
67 } else {
68 Exchange = CGF.EmitScalarExpr(E: E->getArg(Arg: 2));
69 }
70
71 Value *Result = CGF.Builder.CreateAtomicCmpXchg(
72 Addr: DestinationAddr, Cmp: Comparand, New: Exchange,
73 SuccessOrdering: llvm::AtomicOrdering::SequentiallyConsistent,
74 FailureOrdering: llvm::AtomicOrdering::SequentiallyConsistent);
75
76 // Store Destination in Comparand.
77 CGF.Builder.CreateStore(Val: CGF.Builder.CreateExtractValue(Agg: Result, Idxs: 0),
78 Addr: ComparandAddr);
79
80 // Extract boolean success flag, invert it and zext it to int.
81 llvm::Value *RetVal =
82 CGF.Builder.CreateNot(V: CGF.Builder.CreateExtractValue(Agg: Result, Idxs: 1));
83 return CGF.Builder.CreateZExt(V: RetVal, DestTy: CGF.ConvertType(T: 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: E->getArg(Arg: 0));
91 Value *Control = llvm::ConstantInt::get(Ty: Int32Ty, V: 0xff0c);
92 Function *F = CGM.getIntrinsic(IID: Intrinsic::s390_tbegin);
93 return Builder.CreateCall(Callee: F, Args: {TDB, Control});
94 }
95 case SystemZ::BI__builtin_tbegin_nofloat: {
96 Value *TDB = EmitScalarExpr(E: E->getArg(Arg: 0));
97 Value *Control = llvm::ConstantInt::get(Ty: Int32Ty, V: 0xff0c);
98 Function *F = CGM.getIntrinsic(IID: Intrinsic::s390_tbegin_nofloat);
99 return Builder.CreateCall(Callee: F, Args: {TDB, Control});
100 }
101 case SystemZ::BI__builtin_tbeginc: {
102 Value *TDB = llvm::ConstantPointerNull::get(T: Int8PtrTy);
103 Value *Control = llvm::ConstantInt::get(Ty: Int32Ty, V: 0xff08);
104 Function *F = CGM.getIntrinsic(IID: Intrinsic::s390_tbeginc);
105 return Builder.CreateCall(Callee: F, Args: {TDB, Control});
106 }
107 case SystemZ::BI__builtin_tabort: {
108 Value *Data = EmitScalarExpr(E: E->getArg(Arg: 0));
109 Function *F = CGM.getIntrinsic(IID: Intrinsic::s390_tabort);
110 return Builder.CreateCall(Callee: F, Args: Builder.CreateSExt(V: Data, DestTy: Int64Ty, Name: "tabort"));
111 }
112 case SystemZ::BI__builtin_non_tx_store: {
113 Value *Address = EmitScalarExpr(E: E->getArg(Arg: 0));
114 Value *Data = EmitScalarExpr(E: E->getArg(Arg: 1));
115 Function *F = CGM.getIntrinsic(IID: Intrinsic::s390_ntstg);
116 return Builder.CreateCall(Callee: F, Args: {Data, Address});
117 }
118 case SystemZ::BI__cs: {
119 return EmitAtomicCmpXchgForZOSIntrin(CGF&: *this, E, IntType: Int32Ty, HasAddr: false);
120 }
121 case SystemZ::BI__cs1: {
122 return EmitAtomicCmpXchgForZOSIntrin(CGF&: *this, E, IntType: Int32Ty, HasAddr: true);
123 }
124 case SystemZ::BI__csg:
125 case SystemZ::BI__cds1: {
126 return EmitAtomicCmpXchgForZOSIntrin(CGF&: *this, E, IntType: Int64Ty, HasAddr: true);
127 }
128 case SystemZ::BI__cdsg: {
129 llvm::Type *Int128Ty = llvm::IntegerType::get(C&: getLLVMContext(), NumBits: 128);
130 return EmitAtomicCmpXchgForZOSIntrin(CGF&: *this, E, IntType: Int128Ty, HasAddr: 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(T: E->getType());
144 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
145 Value *Undef = ConstantInt::get(Ty: Builder.getInt1Ty(), V: false);
146 Function *F = CGM.getIntrinsic(IID: Intrinsic::ctlz, Tys: ResultType);
147 return Builder.CreateCall(Callee: F, Args: {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(T: E->getType());
156 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
157 Value *Undef = ConstantInt::get(Ty: Builder.getInt1Ty(), V: false);
158 Function *F = CGM.getIntrinsic(IID: Intrinsic::cttz, Tys: ResultType);
159 return Builder.CreateCall(Callee: F, Args: {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(T: E->getType());
167 llvm::Value *Src = EmitScalarExpr(E: E->getArg(Arg: 0));
168 llvm::Value *Amt = EmitScalarExpr(E: E->getArg(Arg: 1));
169 // Splat scalar rotate amount to vector type.
170 unsigned NumElts = cast<llvm::FixedVectorType>(Val: ResultType)->getNumElements();
171 Amt = Builder.CreateIntCast(V: Amt, DestTy: ResultType->getScalarType(), isSigned: false);
172 Amt = Builder.CreateVectorSplat(NumElts, V: Amt);
173 Function *F = CGM.getIntrinsic(IID: Intrinsic::fshl, Tys: ResultType);
174 return Builder.CreateCall(Callee: F, Args: { 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(T: E->getType());
182 llvm::Value *Src = EmitScalarExpr(E: E->getArg(Arg: 0));
183 llvm::Value *Amt = EmitScalarExpr(E: E->getArg(Arg: 1));
184 Function *F = CGM.getIntrinsic(IID: Intrinsic::fshl, Tys: ResultType);
185 return Builder.CreateCall(Callee: F, Args: { Src, Src, Amt });
186 }
187
188 case SystemZ::BI__builtin_s390_vfsqsb:
189 case SystemZ::BI__builtin_s390_vfsqdb: {
190 llvm::Type *ResultType = ConvertType(T: E->getType());
191 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
192 if (Builder.getIsFPConstrained()) {
193 Function *F = CGM.getIntrinsic(IID: Intrinsic::experimental_constrained_sqrt, Tys: ResultType);
194 return Builder.CreateConstrainedFPCall(Callee: F, Args: { X });
195 } else {
196 Function *F = CGM.getIntrinsic(IID: Intrinsic::sqrt, Tys: ResultType);
197 return Builder.CreateCall(Callee: F, Args: X);
198 }
199 }
200 case SystemZ::BI__builtin_s390_vfmasb:
201 case SystemZ::BI__builtin_s390_vfmadb: {
202 llvm::Type *ResultType = ConvertType(T: E->getType());
203 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
204 Value *Y = EmitScalarExpr(E: E->getArg(Arg: 1));
205 Value *Z = EmitScalarExpr(E: E->getArg(Arg: 2));
206 if (Builder.getIsFPConstrained()) {
207 Function *F = CGM.getIntrinsic(IID: Intrinsic::experimental_constrained_fma, Tys: ResultType);
208 return Builder.CreateConstrainedFPCall(Callee: F, Args: {X, Y, Z});
209 } else {
210 Function *F = CGM.getIntrinsic(IID: Intrinsic::fma, Tys: ResultType);
211 return Builder.CreateCall(Callee: F, Args: {X, Y, Z});
212 }
213 }
214 case SystemZ::BI__builtin_s390_vfmssb:
215 case SystemZ::BI__builtin_s390_vfmsdb: {
216 llvm::Type *ResultType = ConvertType(T: E->getType());
217 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
218 Value *Y = EmitScalarExpr(E: E->getArg(Arg: 1));
219 Value *Z = EmitScalarExpr(E: E->getArg(Arg: 2));
220 if (Builder.getIsFPConstrained()) {
221 Function *F = CGM.getIntrinsic(IID: Intrinsic::experimental_constrained_fma, Tys: ResultType);
222 return Builder.CreateConstrainedFPCall(Callee: F, Args: {X, Y, Builder.CreateFNeg(V: Z, Name: "neg")});
223 } else {
224 Function *F = CGM.getIntrinsic(IID: Intrinsic::fma, Tys: ResultType);
225 return Builder.CreateCall(Callee: F, Args: {X, Y, Builder.CreateFNeg(V: Z, Name: "neg")});
226 }
227 }
228 case SystemZ::BI__builtin_s390_vfnmasb:
229 case SystemZ::BI__builtin_s390_vfnmadb: {
230 llvm::Type *ResultType = ConvertType(T: E->getType());
231 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
232 Value *Y = EmitScalarExpr(E: E->getArg(Arg: 1));
233 Value *Z = EmitScalarExpr(E: E->getArg(Arg: 2));
234 if (Builder.getIsFPConstrained()) {
235 Function *F = CGM.getIntrinsic(IID: Intrinsic::experimental_constrained_fma, Tys: ResultType);
236 return Builder.CreateFNeg(V: Builder.CreateConstrainedFPCall(Callee: F, Args: {X, Y, Z}), Name: "neg");
237 } else {
238 Function *F = CGM.getIntrinsic(IID: Intrinsic::fma, Tys: ResultType);
239 return Builder.CreateFNeg(V: Builder.CreateCall(Callee: F, Args: {X, Y, Z}), Name: "neg");
240 }
241 }
242 case SystemZ::BI__builtin_s390_vfnmssb:
243 case SystemZ::BI__builtin_s390_vfnmsdb: {
244 llvm::Type *ResultType = ConvertType(T: E->getType());
245 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
246 Value *Y = EmitScalarExpr(E: E->getArg(Arg: 1));
247 Value *Z = EmitScalarExpr(E: E->getArg(Arg: 2));
248 if (Builder.getIsFPConstrained()) {
249 Function *F = CGM.getIntrinsic(IID: Intrinsic::experimental_constrained_fma, Tys: ResultType);
250 Value *NegZ = Builder.CreateFNeg(V: Z, Name: "sub");
251 return Builder.CreateFNeg(V: Builder.CreateConstrainedFPCall(Callee: F, Args: {X, Y, NegZ}));
252 } else {
253 Function *F = CGM.getIntrinsic(IID: Intrinsic::fma, Tys: ResultType);
254 Value *NegZ = Builder.CreateFNeg(V: Z, Name: "neg");
255 return Builder.CreateFNeg(V: Builder.CreateCall(Callee: F, Args: {X, Y, NegZ}));
256 }
257 }
258 case SystemZ::BI__builtin_s390_vflpsb:
259 case SystemZ::BI__builtin_s390_vflpdb: {
260 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
261 return Builder.CreateFAbs(V: X);
262 }
263 case SystemZ::BI__builtin_s390_vflnsb:
264 case SystemZ::BI__builtin_s390_vflndb: {
265 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
266 return Builder.CreateFNeg(V: Builder.CreateFAbs(V: X), Name: "neg");
267 }
268 case SystemZ::BI__builtin_s390_vfisb:
269 case SystemZ::BI__builtin_s390_vfidb: {
270 llvm::Type *ResultType = ConvertType(T: E->getType());
271 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
272 // Constant-fold the M4 and M5 mask arguments.
273 llvm::APSInt M4 = *E->getArg(Arg: 1)->getIntegerConstantExpr(Ctx: getContext());
274 llvm::APSInt M5 = *E->getArg(Arg: 2)->getIntegerConstantExpr(Ctx: 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(IID: CI, Tys: ResultType);
309 return Builder.CreateConstrainedFPCall(Callee: F, Args: X);
310 } else {
311 Function *F = CGM.getIntrinsic(IID: ID, Tys: ResultType);
312 return Builder.CreateCall(Callee: F, Args: 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(IID: ID);
321 Value *M4Value = llvm::ConstantInt::get(Context&: getLLVMContext(), V: M4);
322 Value *M5Value = llvm::ConstantInt::get(Context&: getLLVMContext(), V: M5);
323 return Builder.CreateCall(Callee: F, Args: {X, M4Value, M5Value});
324 }
325 case SystemZ::BI__builtin_s390_vfmaxsb:
326 case SystemZ::BI__builtin_s390_vfmaxdb: {
327 llvm::Type *ResultType = ConvertType(T: E->getType());
328 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
329 Value *Y = EmitScalarExpr(E: E->getArg(Arg: 1));
330 // Constant-fold the M4 mask argument.
331 llvm::APSInt M4 = *E->getArg(Arg: 2)->getIntegerConstantExpr(Ctx: 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(IID: CI, Tys: ResultType);
344 return Builder.CreateConstrainedFPCall(Callee: F, Args: {X, Y});
345 } else {
346 Function *F = CGM.getIntrinsic(IID: ID, Tys: ResultType);
347 return Builder.CreateCall(Callee: F, Args: {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(IID: ID);
356 Value *M4Value = llvm::ConstantInt::get(Context&: getLLVMContext(), V: M4);
357 return Builder.CreateCall(Callee: F, Args: {X, Y, M4Value});
358 }
359 case SystemZ::BI__builtin_s390_vfminsb:
360 case SystemZ::BI__builtin_s390_vfmindb: {
361 llvm::Type *ResultType = ConvertType(T: E->getType());
362 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
363 Value *Y = EmitScalarExpr(E: E->getArg(Arg: 1));
364 // Constant-fold the M4 mask argument.
365 llvm::APSInt M4 = *E->getArg(Arg: 2)->getIntegerConstantExpr(Ctx: 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(IID: CI, Tys: ResultType);
378 return Builder.CreateConstrainedFPCall(Callee: F, Args: {X, Y});
379 } else {
380 Function *F = CGM.getIntrinsic(IID: ID, Tys: ResultType);
381 return Builder.CreateCall(Callee: F, Args: {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(IID: ID);
390 Value *M4Value = llvm::ConstantInt::get(Context&: getLLVMContext(), V: M4);
391 return Builder.CreateCall(Callee: F, Args: {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(T: E->getType());
399 Value *X = EmitScalarExpr(E: E->getArg(Arg: 0));
400 Function *F = CGM.getIntrinsic(IID: Intrinsic::bswap, Tys: ResultType);
401 return Builder.CreateCall(Callee: F, Args: 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}
496