Bug Summary

File:clang/lib/CodeGen/CGExprScalar.cpp
Warning:line 2087, column 43
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name CGExprScalar.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/build-llvm -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D CLANG_ROUND_TRIP_CC1_ARGS=ON -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/include -I tools/clang/include -I include -I /build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/llvm/include -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-command-line-argument -Wno-unknown-warning-option -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/build-llvm -ferror-limit 19 -fvisibility-inlines-hidden -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-11-10-160236-22541-1 -x c++ /build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp

/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp

1//===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===//
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 Expr nodes with scalar LLVM types as LLVM code.
10//
11//===----------------------------------------------------------------------===//
12
13#include "CGCXXABI.h"
14#include "CGCleanup.h"
15#include "CGDebugInfo.h"
16#include "CGObjCRuntime.h"
17#include "CGOpenMPRuntime.h"
18#include "CodeGenFunction.h"
19#include "CodeGenModule.h"
20#include "ConstantEmitter.h"
21#include "TargetInfo.h"
22#include "clang/AST/ASTContext.h"
23#include "clang/AST/Attr.h"
24#include "clang/AST/DeclObjC.h"
25#include "clang/AST/Expr.h"
26#include "clang/AST/RecordLayout.h"
27#include "clang/AST/StmtVisitor.h"
28#include "clang/Basic/CodeGenOptions.h"
29#include "clang/Basic/TargetInfo.h"
30#include "llvm/ADT/APFixedPoint.h"
31#include "llvm/ADT/Optional.h"
32#include "llvm/IR/CFG.h"
33#include "llvm/IR/Constants.h"
34#include "llvm/IR/DataLayout.h"
35#include "llvm/IR/FixedPointBuilder.h"
36#include "llvm/IR/Function.h"
37#include "llvm/IR/GetElementPtrTypeIterator.h"
38#include "llvm/IR/GlobalVariable.h"
39#include "llvm/IR/Intrinsics.h"
40#include "llvm/IR/IntrinsicsPowerPC.h"
41#include "llvm/IR/MatrixBuilder.h"
42#include "llvm/IR/Module.h"
43#include <cstdarg>
44
45using namespace clang;
46using namespace CodeGen;
47using llvm::Value;
48
49//===----------------------------------------------------------------------===//
50// Scalar Expression Emitter
51//===----------------------------------------------------------------------===//
52
53namespace {
54
55/// Determine whether the given binary operation may overflow.
56/// Sets \p Result to the value of the operation for BO_Add, BO_Sub, BO_Mul,
57/// and signed BO_{Div,Rem}. For these opcodes, and for unsigned BO_{Div,Rem},
58/// the returned overflow check is precise. The returned value is 'true' for
59/// all other opcodes, to be conservative.
60bool mayHaveIntegerOverflow(llvm::ConstantInt *LHS, llvm::ConstantInt *RHS,
61 BinaryOperator::Opcode Opcode, bool Signed,
62 llvm::APInt &Result) {
63 // Assume overflow is possible, unless we can prove otherwise.
64 bool Overflow = true;
65 const auto &LHSAP = LHS->getValue();
66 const auto &RHSAP = RHS->getValue();
67 if (Opcode == BO_Add) {
68 if (Signed)
69 Result = LHSAP.sadd_ov(RHSAP, Overflow);
70 else
71 Result = LHSAP.uadd_ov(RHSAP, Overflow);
72 } else if (Opcode == BO_Sub) {
73 if (Signed)
74 Result = LHSAP.ssub_ov(RHSAP, Overflow);
75 else
76 Result = LHSAP.usub_ov(RHSAP, Overflow);
77 } else if (Opcode == BO_Mul) {
78 if (Signed)
79 Result = LHSAP.smul_ov(RHSAP, Overflow);
80 else
81 Result = LHSAP.umul_ov(RHSAP, Overflow);
82 } else if (Opcode == BO_Div || Opcode == BO_Rem) {
83 if (Signed && !RHS->isZero())
84 Result = LHSAP.sdiv_ov(RHSAP, Overflow);
85 else
86 return false;
87 }
88 return Overflow;
89}
90
91struct BinOpInfo {
92 Value *LHS;
93 Value *RHS;
94 QualType Ty; // Computation Type.
95 BinaryOperator::Opcode Opcode; // Opcode of BinOp to perform
96 FPOptions FPFeatures;
97 const Expr *E; // Entire expr, for error unsupported. May not be binop.
98
99 /// Check if the binop can result in integer overflow.
100 bool mayHaveIntegerOverflow() const {
101 // Without constant input, we can't rule out overflow.
102 auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS);
103 auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS);
104 if (!LHSCI || !RHSCI)
105 return true;
106
107 llvm::APInt Result;
108 return ::mayHaveIntegerOverflow(
109 LHSCI, RHSCI, Opcode, Ty->hasSignedIntegerRepresentation(), Result);
110 }
111
112 /// Check if the binop computes a division or a remainder.
113 bool isDivremOp() const {
114 return Opcode == BO_Div || Opcode == BO_Rem || Opcode == BO_DivAssign ||
115 Opcode == BO_RemAssign;
116 }
117
118 /// Check if the binop can result in an integer division by zero.
119 bool mayHaveIntegerDivisionByZero() const {
120 if (isDivremOp())
121 if (auto *CI = dyn_cast<llvm::ConstantInt>(RHS))
122 return CI->isZero();
123 return true;
124 }
125
126 /// Check if the binop can result in a float division by zero.
127 bool mayHaveFloatDivisionByZero() const {
128 if (isDivremOp())
129 if (auto *CFP = dyn_cast<llvm::ConstantFP>(RHS))
130 return CFP->isZero();
131 return true;
132 }
133
134 /// Check if at least one operand is a fixed point type. In such cases, this
135 /// operation did not follow usual arithmetic conversion and both operands
136 /// might not be of the same type.
137 bool isFixedPointOp() const {
138 // We cannot simply check the result type since comparison operations return
139 // an int.
140 if (const auto *BinOp = dyn_cast<BinaryOperator>(E)) {
141 QualType LHSType = BinOp->getLHS()->getType();
142 QualType RHSType = BinOp->getRHS()->getType();
143 return LHSType->isFixedPointType() || RHSType->isFixedPointType();
144 }
145 if (const auto *UnOp = dyn_cast<UnaryOperator>(E))
146 return UnOp->getSubExpr()->getType()->isFixedPointType();
147 return false;
148 }
149};
150
151static bool MustVisitNullValue(const Expr *E) {
152 // If a null pointer expression's type is the C++0x nullptr_t, then
153 // it's not necessarily a simple constant and it must be evaluated
154 // for its potential side effects.
155 return E->getType()->isNullPtrType();
156}
157
158/// If \p E is a widened promoted integer, get its base (unpromoted) type.
159static llvm::Optional<QualType> getUnwidenedIntegerType(const ASTContext &Ctx,
160 const Expr *E) {
161 const Expr *Base = E->IgnoreImpCasts();
162 if (E == Base)
163 return llvm::None;
164
165 QualType BaseTy = Base->getType();
166 if (!BaseTy->isPromotableIntegerType() ||
167 Ctx.getTypeSize(BaseTy) >= Ctx.getTypeSize(E->getType()))
168 return llvm::None;
169
170 return BaseTy;
171}
172
173/// Check if \p E is a widened promoted integer.
174static bool IsWidenedIntegerOp(const ASTContext &Ctx, const Expr *E) {
175 return getUnwidenedIntegerType(Ctx, E).hasValue();
176}
177
178/// Check if we can skip the overflow check for \p Op.
179static bool CanElideOverflowCheck(const ASTContext &Ctx, const BinOpInfo &Op) {
180 assert((isa<UnaryOperator>(Op.E) || isa<BinaryOperator>(Op.E)) &&(static_cast <bool> ((isa<UnaryOperator>(Op.E) ||
isa<BinaryOperator>(Op.E)) && "Expected a unary or binary operator"
) ? void (0) : __assert_fail ("(isa<UnaryOperator>(Op.E) || isa<BinaryOperator>(Op.E)) && \"Expected a unary or binary operator\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 181, __extension__ __PRETTY_FUNCTION__))
181 "Expected a unary or binary operator")(static_cast <bool> ((isa<UnaryOperator>(Op.E) ||
isa<BinaryOperator>(Op.E)) && "Expected a unary or binary operator"
) ? void (0) : __assert_fail ("(isa<UnaryOperator>(Op.E) || isa<BinaryOperator>(Op.E)) && \"Expected a unary or binary operator\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 181, __extension__ __PRETTY_FUNCTION__))
;
182
183 // If the binop has constant inputs and we can prove there is no overflow,
184 // we can elide the overflow check.
185 if (!Op.mayHaveIntegerOverflow())
186 return true;
187
188 // If a unary op has a widened operand, the op cannot overflow.
189 if (const auto *UO = dyn_cast<UnaryOperator>(Op.E))
190 return !UO->canOverflow();
191
192 // We usually don't need overflow checks for binops with widened operands.
193 // Multiplication with promoted unsigned operands is a special case.
194 const auto *BO = cast<BinaryOperator>(Op.E);
195 auto OptionalLHSTy = getUnwidenedIntegerType(Ctx, BO->getLHS());
196 if (!OptionalLHSTy)
197 return false;
198
199 auto OptionalRHSTy = getUnwidenedIntegerType(Ctx, BO->getRHS());
200 if (!OptionalRHSTy)
201 return false;
202
203 QualType LHSTy = *OptionalLHSTy;
204 QualType RHSTy = *OptionalRHSTy;
205
206 // This is the simple case: binops without unsigned multiplication, and with
207 // widened operands. No overflow check is needed here.
208 if ((Op.Opcode != BO_Mul && Op.Opcode != BO_MulAssign) ||
209 !LHSTy->isUnsignedIntegerType() || !RHSTy->isUnsignedIntegerType())
210 return true;
211
212 // For unsigned multiplication the overflow check can be elided if either one
213 // of the unpromoted types are less than half the size of the promoted type.
214 unsigned PromotedSize = Ctx.getTypeSize(Op.E->getType());
215 return (2 * Ctx.getTypeSize(LHSTy)) < PromotedSize ||
216 (2 * Ctx.getTypeSize(RHSTy)) < PromotedSize;
217}
218
219class ScalarExprEmitter
220 : public StmtVisitor<ScalarExprEmitter, Value*> {
221 CodeGenFunction &CGF;
222 CGBuilderTy &Builder;
223 bool IgnoreResultAssign;
224 llvm::LLVMContext &VMContext;
225public:
226
227 ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false)
228 : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
229 VMContext(cgf.getLLVMContext()) {
230 }
231
232 //===--------------------------------------------------------------------===//
233 // Utilities
234 //===--------------------------------------------------------------------===//
235
236 bool TestAndClearIgnoreResultAssign() {
237 bool I = IgnoreResultAssign;
238 IgnoreResultAssign = false;
239 return I;
240 }
241
242 llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); }
243 LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); }
244 LValue EmitCheckedLValue(const Expr *E, CodeGenFunction::TypeCheckKind TCK) {
245 return CGF.EmitCheckedLValue(E, TCK);
246 }
247
248 void EmitBinOpCheck(ArrayRef<std::pair<Value *, SanitizerMask>> Checks,
249 const BinOpInfo &Info);
250
251 Value *EmitLoadOfLValue(LValue LV, SourceLocation Loc) {
252 return CGF.EmitLoadOfLValue(LV, Loc).getScalarVal();
253 }
254
255 void EmitLValueAlignmentAssumption(const Expr *E, Value *V) {
256 const AlignValueAttr *AVAttr = nullptr;
257 if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
258 const ValueDecl *VD = DRE->getDecl();
259
260 if (VD->getType()->isReferenceType()) {
261 if (const auto *TTy =
262 dyn_cast<TypedefType>(VD->getType().getNonReferenceType()))
263 AVAttr = TTy->getDecl()->getAttr<AlignValueAttr>();
264 } else {
265 // Assumptions for function parameters are emitted at the start of the
266 // function, so there is no need to repeat that here,
267 // unless the alignment-assumption sanitizer is enabled,
268 // then we prefer the assumption over alignment attribute
269 // on IR function param.
270 if (isa<ParmVarDecl>(VD) && !CGF.SanOpts.has(SanitizerKind::Alignment))
271 return;
272
273 AVAttr = VD->getAttr<AlignValueAttr>();
274 }
275 }
276
277 if (!AVAttr)
278 if (const auto *TTy =
279 dyn_cast<TypedefType>(E->getType()))
280 AVAttr = TTy->getDecl()->getAttr<AlignValueAttr>();
281
282 if (!AVAttr)
283 return;
284
285 Value *AlignmentValue = CGF.EmitScalarExpr(AVAttr->getAlignment());
286 llvm::ConstantInt *AlignmentCI = cast<llvm::ConstantInt>(AlignmentValue);
287 CGF.emitAlignmentAssumption(V, E, AVAttr->getLocation(), AlignmentCI);
288 }
289
290 /// EmitLoadOfLValue - Given an expression with complex type that represents a
291 /// value l-value, this method emits the address of the l-value, then loads
292 /// and returns the result.
293 Value *EmitLoadOfLValue(const Expr *E) {
294 Value *V = EmitLoadOfLValue(EmitCheckedLValue(E, CodeGenFunction::TCK_Load),
295 E->getExprLoc());
296
297 EmitLValueAlignmentAssumption(E, V);
298 return V;
299 }
300
301 /// EmitConversionToBool - Convert the specified expression value to a
302 /// boolean (i1) truth value. This is equivalent to "Val != 0".
303 Value *EmitConversionToBool(Value *Src, QualType DstTy);
304
305 /// Emit a check that a conversion from a floating-point type does not
306 /// overflow.
307 void EmitFloatConversionCheck(Value *OrigSrc, QualType OrigSrcType,
308 Value *Src, QualType SrcType, QualType DstType,
309 llvm::Type *DstTy, SourceLocation Loc);
310
311 /// Known implicit conversion check kinds.
312 /// Keep in sync with the enum of the same name in ubsan_handlers.h
313 enum ImplicitConversionCheckKind : unsigned char {
314 ICCK_IntegerTruncation = 0, // Legacy, was only used by clang 7.
315 ICCK_UnsignedIntegerTruncation = 1,
316 ICCK_SignedIntegerTruncation = 2,
317 ICCK_IntegerSignChange = 3,
318 ICCK_SignedIntegerTruncationOrSignChange = 4,
319 };
320
321 /// Emit a check that an [implicit] truncation of an integer does not
322 /// discard any bits. It is not UB, so we use the value after truncation.
323 void EmitIntegerTruncationCheck(Value *Src, QualType SrcType, Value *Dst,
324 QualType DstType, SourceLocation Loc);
325
326 /// Emit a check that an [implicit] conversion of an integer does not change
327 /// the sign of the value. It is not UB, so we use the value after conversion.
328 /// NOTE: Src and Dst may be the exact same value! (point to the same thing)
329 void EmitIntegerSignChangeCheck(Value *Src, QualType SrcType, Value *Dst,
330 QualType DstType, SourceLocation Loc);
331
332 /// Emit a conversion from the specified type to the specified destination
333 /// type, both of which are LLVM scalar types.
334 struct ScalarConversionOpts {
335 bool TreatBooleanAsSigned;
336 bool EmitImplicitIntegerTruncationChecks;
337 bool EmitImplicitIntegerSignChangeChecks;
338
339 ScalarConversionOpts()
340 : TreatBooleanAsSigned(false),
341 EmitImplicitIntegerTruncationChecks(false),
342 EmitImplicitIntegerSignChangeChecks(false) {}
343
344 ScalarConversionOpts(clang::SanitizerSet SanOpts)
345 : TreatBooleanAsSigned(false),
346 EmitImplicitIntegerTruncationChecks(
347 SanOpts.hasOneOf(SanitizerKind::ImplicitIntegerTruncation)),
348 EmitImplicitIntegerSignChangeChecks(
349 SanOpts.has(SanitizerKind::ImplicitIntegerSignChange)) {}
350 };
351 Value *EmitScalarCast(Value *Src, QualType SrcType, QualType DstType,
352 llvm::Type *SrcTy, llvm::Type *DstTy,
353 ScalarConversionOpts Opts);
354 Value *
355 EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy,
356 SourceLocation Loc,
357 ScalarConversionOpts Opts = ScalarConversionOpts());
358
359 /// Convert between either a fixed point and other fixed point or fixed point
360 /// and an integer.
361 Value *EmitFixedPointConversion(Value *Src, QualType SrcTy, QualType DstTy,
362 SourceLocation Loc);
363
364 /// Emit a conversion from the specified complex type to the specified
365 /// destination type, where the destination type is an LLVM scalar type.
366 Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src,
367 QualType SrcTy, QualType DstTy,
368 SourceLocation Loc);
369
370 /// EmitNullValue - Emit a value that corresponds to null for the given type.
371 Value *EmitNullValue(QualType Ty);
372
373 /// EmitFloatToBoolConversion - Perform an FP to boolean conversion.
374 Value *EmitFloatToBoolConversion(Value *V) {
375 // Compare against 0.0 for fp scalars.
376 llvm::Value *Zero = llvm::Constant::getNullValue(V->getType());
377 return Builder.CreateFCmpUNE(V, Zero, "tobool");
378 }
379
380 /// EmitPointerToBoolConversion - Perform a pointer to boolean conversion.
381 Value *EmitPointerToBoolConversion(Value *V, QualType QT) {
382 Value *Zero = CGF.CGM.getNullPointer(cast<llvm::PointerType>(V->getType()), QT);
383
384 return Builder.CreateICmpNE(V, Zero, "tobool");
385 }
386
387 Value *EmitIntToBoolConversion(Value *V) {
388 // Because of the type rules of C, we often end up computing a
389 // logical value, then zero extending it to int, then wanting it
390 // as a logical value again. Optimize this common case.
391 if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(V)) {
392 if (ZI->getOperand(0)->getType() == Builder.getInt1Ty()) {
393 Value *Result = ZI->getOperand(0);
394 // If there aren't any more uses, zap the instruction to save space.
395 // Note that there can be more uses, for example if this
396 // is the result of an assignment.
397 if (ZI->use_empty())
398 ZI->eraseFromParent();
399 return Result;
400 }
401 }
402
403 return Builder.CreateIsNotNull(V, "tobool");
404 }
405
406 //===--------------------------------------------------------------------===//
407 // Visitor Methods
408 //===--------------------------------------------------------------------===//
409
410 Value *Visit(Expr *E) {
411 ApplyDebugLocation DL(CGF, E);
412 return StmtVisitor<ScalarExprEmitter, Value*>::Visit(E);
413 }
414
415 Value *VisitStmt(Stmt *S) {
416 S->dump(llvm::errs(), CGF.getContext());
417 llvm_unreachable("Stmt can't have complex result type!")::llvm::llvm_unreachable_internal("Stmt can't have complex result type!"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 417)
;
418 }
419 Value *VisitExpr(Expr *S);
420
421 Value *VisitConstantExpr(ConstantExpr *E) {
422 // A constant expression of type 'void' generates no code and produces no
423 // value.
424 if (E->getType()->isVoidType())
425 return nullptr;
426
427 if (Value *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E)) {
428 if (E->isGLValue())
429 return CGF.Builder.CreateLoad(Address(
430 Result, CGF.getContext().getTypeAlignInChars(E->getType())));
431 return Result;
432 }
433 return Visit(E->getSubExpr());
434 }
435 Value *VisitParenExpr(ParenExpr *PE) {
436 return Visit(PE->getSubExpr());
437 }
438 Value *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
439 return Visit(E->getReplacement());
440 }
441 Value *VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
442 return Visit(GE->getResultExpr());
443 }
444 Value *VisitCoawaitExpr(CoawaitExpr *S) {
445 return CGF.EmitCoawaitExpr(*S).getScalarVal();
446 }
447 Value *VisitCoyieldExpr(CoyieldExpr *S) {
448 return CGF.EmitCoyieldExpr(*S).getScalarVal();
449 }
450 Value *VisitUnaryCoawait(const UnaryOperator *E) {
451 return Visit(E->getSubExpr());
452 }
453
454 // Leaves.
455 Value *VisitIntegerLiteral(const IntegerLiteral *E) {
456 return Builder.getInt(E->getValue());
457 }
458 Value *VisitFixedPointLiteral(const FixedPointLiteral *E) {
459 return Builder.getInt(E->getValue());
460 }
461 Value *VisitFloatingLiteral(const FloatingLiteral *E) {
462 return llvm::ConstantFP::get(VMContext, E->getValue());
463 }
464 Value *VisitCharacterLiteral(const CharacterLiteral *E) {
465 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
466 }
467 Value *VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
468 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
469 }
470 Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
471 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
472 }
473 Value *VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
474 return EmitNullValue(E->getType());
475 }
476 Value *VisitGNUNullExpr(const GNUNullExpr *E) {
477 return EmitNullValue(E->getType());
478 }
479 Value *VisitOffsetOfExpr(OffsetOfExpr *E);
480 Value *VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
481 Value *VisitAddrLabelExpr(const AddrLabelExpr *E) {
482 llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel());
483 return Builder.CreateBitCast(V, ConvertType(E->getType()));
484 }
485
486 Value *VisitSizeOfPackExpr(SizeOfPackExpr *E) {
487 return llvm::ConstantInt::get(ConvertType(E->getType()),E->getPackLength());
488 }
489
490 Value *VisitPseudoObjectExpr(PseudoObjectExpr *E) {
491 return CGF.EmitPseudoObjectRValue(E).getScalarVal();
492 }
493
494 Value *VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E);
495
496 Value *VisitOpaqueValueExpr(OpaqueValueExpr *E) {
497 if (E->isGLValue())
498 return EmitLoadOfLValue(CGF.getOrCreateOpaqueLValueMapping(E),
499 E->getExprLoc());
500
501 // Otherwise, assume the mapping is the scalar directly.
502 return CGF.getOrCreateOpaqueRValueMapping(E).getScalarVal();
503 }
504
505 // l-values.
506 Value *VisitDeclRefExpr(DeclRefExpr *E) {
507 if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E))
508 return CGF.emitScalarConstant(Constant, E);
509 return EmitLoadOfLValue(E);
510 }
511
512 Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
513 return CGF.EmitObjCSelectorExpr(E);
514 }
515 Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
516 return CGF.EmitObjCProtocolExpr(E);
517 }
518 Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
519 return EmitLoadOfLValue(E);
520 }
521 Value *VisitObjCMessageExpr(ObjCMessageExpr *E) {
522 if (E->getMethodDecl() &&
523 E->getMethodDecl()->getReturnType()->isReferenceType())
524 return EmitLoadOfLValue(E);
525 return CGF.EmitObjCMessageExpr(E).getScalarVal();
526 }
527
528 Value *VisitObjCIsaExpr(ObjCIsaExpr *E) {
529 LValue LV = CGF.EmitObjCIsaExpr(E);
530 Value *V = CGF.EmitLoadOfLValue(LV, E->getExprLoc()).getScalarVal();
531 return V;
532 }
533
534 Value *VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
535 VersionTuple Version = E->getVersion();
536
537 // If we're checking for a platform older than our minimum deployment
538 // target, we can fold the check away.
539 if (Version <= CGF.CGM.getTarget().getPlatformMinVersion())
540 return llvm::ConstantInt::get(Builder.getInt1Ty(), 1);
541
542 return CGF.EmitBuiltinAvailable(Version);
543 }
544
545 Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
546 Value *VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E);
547 Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E);
548 Value *VisitConvertVectorExpr(ConvertVectorExpr *E);
549 Value *VisitMemberExpr(MemberExpr *E);
550 Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); }
551 Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
552 // Strictly speaking, we shouldn't be calling EmitLoadOfLValue, which
553 // transitively calls EmitCompoundLiteralLValue, here in C++ since compound
554 // literals aren't l-values in C++. We do so simply because that's the
555 // cleanest way to handle compound literals in C++.
556 // See the discussion here: https://reviews.llvm.org/D64464
557 return EmitLoadOfLValue(E);
558 }
559
560 Value *VisitInitListExpr(InitListExpr *E);
561
562 Value *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
563 assert(CGF.getArrayInitIndex() &&(static_cast <bool> (CGF.getArrayInitIndex() &&
"ArrayInitIndexExpr not inside an ArrayInitLoopExpr?") ? void
(0) : __assert_fail ("CGF.getArrayInitIndex() && \"ArrayInitIndexExpr not inside an ArrayInitLoopExpr?\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 564, __extension__ __PRETTY_FUNCTION__))
564 "ArrayInitIndexExpr not inside an ArrayInitLoopExpr?")(static_cast <bool> (CGF.getArrayInitIndex() &&
"ArrayInitIndexExpr not inside an ArrayInitLoopExpr?") ? void
(0) : __assert_fail ("CGF.getArrayInitIndex() && \"ArrayInitIndexExpr not inside an ArrayInitLoopExpr?\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 564, __extension__ __PRETTY_FUNCTION__))
;
565 return CGF.getArrayInitIndex();
566 }
567
568 Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
569 return EmitNullValue(E->getType());
570 }
571 Value *VisitExplicitCastExpr(ExplicitCastExpr *E) {
572 CGF.CGM.EmitExplicitCastExprType(E, &CGF);
573 return VisitCastExpr(E);
574 }
575 Value *VisitCastExpr(CastExpr *E);
576
577 Value *VisitCallExpr(const CallExpr *E) {
578 if (E->getCallReturnType(CGF.getContext())->isReferenceType())
579 return EmitLoadOfLValue(E);
580
581 Value *V = CGF.EmitCallExpr(E).getScalarVal();
582
583 EmitLValueAlignmentAssumption(E, V);
584 return V;
585 }
586
587 Value *VisitStmtExpr(const StmtExpr *E);
588
589 // Unary Operators.
590 Value *VisitUnaryPostDec(const UnaryOperator *E) {
591 LValue LV = EmitLValue(E->getSubExpr());
592 return EmitScalarPrePostIncDec(E, LV, false, false);
593 }
594 Value *VisitUnaryPostInc(const UnaryOperator *E) {
595 LValue LV = EmitLValue(E->getSubExpr());
596 return EmitScalarPrePostIncDec(E, LV, true, false);
597 }
598 Value *VisitUnaryPreDec(const UnaryOperator *E) {
599 LValue LV = EmitLValue(E->getSubExpr());
600 return EmitScalarPrePostIncDec(E, LV, false, true);
601 }
602 Value *VisitUnaryPreInc(const UnaryOperator *E) {
603 LValue LV = EmitLValue(E->getSubExpr());
604 return EmitScalarPrePostIncDec(E, LV, true, true);
605 }
606
607 llvm::Value *EmitIncDecConsiderOverflowBehavior(const UnaryOperator *E,
608 llvm::Value *InVal,
609 bool IsInc);
610
611 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
612 bool isInc, bool isPre);
613
614
615 Value *VisitUnaryAddrOf(const UnaryOperator *E) {
616 if (isa<MemberPointerType>(E->getType())) // never sugared
617 return CGF.CGM.getMemberPointerConstant(E);
618
619 return EmitLValue(E->getSubExpr()).getPointer(CGF);
620 }
621 Value *VisitUnaryDeref(const UnaryOperator *E) {
622 if (E->getType()->isVoidType())
623 return Visit(E->getSubExpr()); // the actual value should be unused
624 return EmitLoadOfLValue(E);
625 }
626 Value *VisitUnaryPlus(const UnaryOperator *E) {
627 // This differs from gcc, though, most likely due to a bug in gcc.
628 TestAndClearIgnoreResultAssign();
629 return Visit(E->getSubExpr());
630 }
631 Value *VisitUnaryMinus (const UnaryOperator *E);
632 Value *VisitUnaryNot (const UnaryOperator *E);
633 Value *VisitUnaryLNot (const UnaryOperator *E);
634 Value *VisitUnaryReal (const UnaryOperator *E);
635 Value *VisitUnaryImag (const UnaryOperator *E);
636 Value *VisitUnaryExtension(const UnaryOperator *E) {
637 return Visit(E->getSubExpr());
638 }
639
640 // C++
641 Value *VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E) {
642 return EmitLoadOfLValue(E);
643 }
644 Value *VisitSourceLocExpr(SourceLocExpr *SLE) {
645 auto &Ctx = CGF.getContext();
646 APValue Evaluated =
647 SLE->EvaluateInContext(Ctx, CGF.CurSourceLocExprScope.getDefaultExpr());
648 return ConstantEmitter(CGF).emitAbstract(SLE->getLocation(), Evaluated,
649 SLE->getType());
650 }
651
652 Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
653 CodeGenFunction::CXXDefaultArgExprScope Scope(CGF, DAE);
654 return Visit(DAE->getExpr());
655 }
656 Value *VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
657 CodeGenFunction::CXXDefaultInitExprScope Scope(CGF, DIE);
658 return Visit(DIE->getExpr());
659 }
660 Value *VisitCXXThisExpr(CXXThisExpr *TE) {
661 return CGF.LoadCXXThis();
662 }
663
664 Value *VisitExprWithCleanups(ExprWithCleanups *E);
665 Value *VisitCXXNewExpr(const CXXNewExpr *E) {
666 return CGF.EmitCXXNewExpr(E);
667 }
668 Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) {
669 CGF.EmitCXXDeleteExpr(E);
670 return nullptr;
671 }
672
673 Value *VisitTypeTraitExpr(const TypeTraitExpr *E) {
674 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
675 }
676
677 Value *VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E) {
678 return Builder.getInt1(E->isSatisfied());
679 }
680
681 Value *VisitRequiresExpr(const RequiresExpr *E) {
682 return Builder.getInt1(E->isSatisfied());
683 }
684
685 Value *VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
686 return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue());
687 }
688
689 Value *VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
690 return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue());
691 }
692
693 Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) {
694 // C++ [expr.pseudo]p1:
695 // The result shall only be used as the operand for the function call
696 // operator (), and the result of such a call has type void. The only
697 // effect is the evaluation of the postfix-expression before the dot or
698 // arrow.
699 CGF.EmitScalarExpr(E->getBase());
700 return nullptr;
701 }
702
703 Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) {
704 return EmitNullValue(E->getType());
705 }
706
707 Value *VisitCXXThrowExpr(const CXXThrowExpr *E) {
708 CGF.EmitCXXThrowExpr(E);
709 return nullptr;
710 }
711
712 Value *VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
713 return Builder.getInt1(E->getValue());
714 }
715
716 // Binary Operators.
717 Value *EmitMul(const BinOpInfo &Ops) {
718 if (Ops.Ty->isSignedIntegerOrEnumerationType()) {
719 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
720 case LangOptions::SOB_Defined:
721 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
722 case LangOptions::SOB_Undefined:
723 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
724 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
725 LLVM_FALLTHROUGH[[gnu::fallthrough]];
726 case LangOptions::SOB_Trapping:
727 if (CanElideOverflowCheck(CGF.getContext(), Ops))
728 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
729 return EmitOverflowCheckedBinOp(Ops);
730 }
731 }
732
733 if (Ops.Ty->isConstantMatrixType()) {
734 llvm::MatrixBuilder<CGBuilderTy> MB(Builder);
735 // We need to check the types of the operands of the operator to get the
736 // correct matrix dimensions.
737 auto *BO = cast<BinaryOperator>(Ops.E);
738 auto *LHSMatTy = dyn_cast<ConstantMatrixType>(
739 BO->getLHS()->getType().getCanonicalType());
740 auto *RHSMatTy = dyn_cast<ConstantMatrixType>(
741 BO->getRHS()->getType().getCanonicalType());
742 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Ops.FPFeatures);
743 if (LHSMatTy && RHSMatTy)
744 return MB.CreateMatrixMultiply(Ops.LHS, Ops.RHS, LHSMatTy->getNumRows(),
745 LHSMatTy->getNumColumns(),
746 RHSMatTy->getNumColumns());
747 return MB.CreateScalarMultiply(Ops.LHS, Ops.RHS);
748 }
749
750 if (Ops.Ty->isUnsignedIntegerType() &&
751 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
752 !CanElideOverflowCheck(CGF.getContext(), Ops))
753 return EmitOverflowCheckedBinOp(Ops);
754
755 if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
756 // Preserve the old values
757 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Ops.FPFeatures);
758 return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul");
759 }
760 if (Ops.isFixedPointOp())
761 return EmitFixedPointBinOp(Ops);
762 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
763 }
764 /// Create a binary op that checks for overflow.
765 /// Currently only supports +, - and *.
766 Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops);
767
768 // Check for undefined division and modulus behaviors.
769 void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops,
770 llvm::Value *Zero,bool isDiv);
771 // Common helper for getting how wide LHS of shift is.
772 static Value *GetWidthMinusOneValue(Value* LHS,Value* RHS);
773
774 // Used for shifting constraints for OpenCL, do mask for powers of 2, URem for
775 // non powers of two.
776 Value *ConstrainShiftValue(Value *LHS, Value *RHS, const Twine &Name);
777
778 Value *EmitDiv(const BinOpInfo &Ops);
779 Value *EmitRem(const BinOpInfo &Ops);
780 Value *EmitAdd(const BinOpInfo &Ops);
781 Value *EmitSub(const BinOpInfo &Ops);
782 Value *EmitShl(const BinOpInfo &Ops);
783 Value *EmitShr(const BinOpInfo &Ops);
784 Value *EmitAnd(const BinOpInfo &Ops) {
785 return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and");
786 }
787 Value *EmitXor(const BinOpInfo &Ops) {
788 return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor");
789 }
790 Value *EmitOr (const BinOpInfo &Ops) {
791 return Builder.CreateOr(Ops.LHS, Ops.RHS, "or");
792 }
793
794 // Helper functions for fixed point binary operations.
795 Value *EmitFixedPointBinOp(const BinOpInfo &Ops);
796
797 BinOpInfo EmitBinOps(const BinaryOperator *E);
798 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
799 Value *(ScalarExprEmitter::*F)(const BinOpInfo &),
800 Value *&Result);
801
802 Value *EmitCompoundAssign(const CompoundAssignOperator *E,
803 Value *(ScalarExprEmitter::*F)(const BinOpInfo &));
804
805 // Binary operators and binary compound assignment operators.
806#define HANDLEBINOP(OP) \
807 Value *VisitBin ## OP(const BinaryOperator *E) { \
808 return Emit ## OP(EmitBinOps(E)); \
809 } \
810 Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \
811 return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \
812 }
813 HANDLEBINOP(Mul)
814 HANDLEBINOP(Div)
815 HANDLEBINOP(Rem)
816 HANDLEBINOP(Add)
817 HANDLEBINOP(Sub)
818 HANDLEBINOP(Shl)
819 HANDLEBINOP(Shr)
820 HANDLEBINOP(And)
821 HANDLEBINOP(Xor)
822 HANDLEBINOP(Or)
823#undef HANDLEBINOP
824
825 // Comparisons.
826 Value *EmitCompare(const BinaryOperator *E, llvm::CmpInst::Predicate UICmpOpc,
827 llvm::CmpInst::Predicate SICmpOpc,
828 llvm::CmpInst::Predicate FCmpOpc, bool IsSignaling);
829#define VISITCOMP(CODE, UI, SI, FP, SIG) \
830 Value *VisitBin##CODE(const BinaryOperator *E) { \
831 return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \
832 llvm::FCmpInst::FP, SIG); }
833 VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT, true)
834 VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT, true)
835 VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE, true)
836 VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE, true)
837 VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ, false)
838 VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE, false)
839#undef VISITCOMP
840
841 Value *VisitBinAssign (const BinaryOperator *E);
842
843 Value *VisitBinLAnd (const BinaryOperator *E);
844 Value *VisitBinLOr (const BinaryOperator *E);
845 Value *VisitBinComma (const BinaryOperator *E);
846
847 Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); }
848 Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); }
849
850 Value *VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) {
851 return Visit(E->getSemanticForm());
852 }
853
854 // Other Operators.
855 Value *VisitBlockExpr(const BlockExpr *BE);
856 Value *VisitAbstractConditionalOperator(const AbstractConditionalOperator *);
857 Value *VisitChooseExpr(ChooseExpr *CE);
858 Value *VisitVAArgExpr(VAArgExpr *VE);
859 Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) {
860 return CGF.EmitObjCStringLiteral(E);
861 }
862 Value *VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
863 return CGF.EmitObjCBoxedExpr(E);
864 }
865 Value *VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
866 return CGF.EmitObjCArrayLiteral(E);
867 }
868 Value *VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
869 return CGF.EmitObjCDictionaryLiteral(E);
870 }
871 Value *VisitAsTypeExpr(AsTypeExpr *CE);
872 Value *VisitAtomicExpr(AtomicExpr *AE);
873};
874} // end anonymous namespace.
875
876//===----------------------------------------------------------------------===//
877// Utilities
878//===----------------------------------------------------------------------===//
879
880/// EmitConversionToBool - Convert the specified expression value to a
881/// boolean (i1) truth value. This is equivalent to "Val != 0".
882Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
883 assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs")(static_cast <bool> (SrcType.isCanonical() && "EmitScalarConversion strips typedefs"
) ? void (0) : __assert_fail ("SrcType.isCanonical() && \"EmitScalarConversion strips typedefs\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 883, __extension__ __PRETTY_FUNCTION__))
;
884
885 if (SrcType->isRealFloatingType())
886 return EmitFloatToBoolConversion(Src);
887
888 if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(SrcType))
889 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT);
890
891 assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) &&(static_cast <bool> ((SrcType->isIntegerType() || isa
<llvm::PointerType>(Src->getType())) && "Unknown scalar type to convert"
) ? void (0) : __assert_fail ("(SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && \"Unknown scalar type to convert\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 892, __extension__ __PRETTY_FUNCTION__))
892 "Unknown scalar type to convert")(static_cast <bool> ((SrcType->isIntegerType() || isa
<llvm::PointerType>(Src->getType())) && "Unknown scalar type to convert"
) ? void (0) : __assert_fail ("(SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && \"Unknown scalar type to convert\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 892, __extension__ __PRETTY_FUNCTION__))
;
893
894 if (isa<llvm::IntegerType>(Src->getType()))
895 return EmitIntToBoolConversion(Src);
896
897 assert(isa<llvm::PointerType>(Src->getType()))(static_cast <bool> (isa<llvm::PointerType>(Src->
getType())) ? void (0) : __assert_fail ("isa<llvm::PointerType>(Src->getType())"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 897, __extension__ __PRETTY_FUNCTION__))
;
898 return EmitPointerToBoolConversion(Src, SrcType);
899}
900
901void ScalarExprEmitter::EmitFloatConversionCheck(
902 Value *OrigSrc, QualType OrigSrcType, Value *Src, QualType SrcType,
903 QualType DstType, llvm::Type *DstTy, SourceLocation Loc) {
904 assert(SrcType->isFloatingType() && "not a conversion from floating point")(static_cast <bool> (SrcType->isFloatingType() &&
"not a conversion from floating point") ? void (0) : __assert_fail
("SrcType->isFloatingType() && \"not a conversion from floating point\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 904, __extension__ __PRETTY_FUNCTION__))
;
905 if (!isa<llvm::IntegerType>(DstTy))
906 return;
907
908 CodeGenFunction::SanitizerScope SanScope(&CGF);
909 using llvm::APFloat;
910 using llvm::APSInt;
911
912 llvm::Value *Check = nullptr;
913 const llvm::fltSemantics &SrcSema =
914 CGF.getContext().getFloatTypeSemantics(OrigSrcType);
915
916 // Floating-point to integer. This has undefined behavior if the source is
917 // +-Inf, NaN, or doesn't fit into the destination type (after truncation
918 // to an integer).
919 unsigned Width = CGF.getContext().getIntWidth(DstType);
920 bool Unsigned = DstType->isUnsignedIntegerOrEnumerationType();
921
922 APSInt Min = APSInt::getMinValue(Width, Unsigned);
923 APFloat MinSrc(SrcSema, APFloat::uninitialized);
924 if (MinSrc.convertFromAPInt(Min, !Unsigned, APFloat::rmTowardZero) &
925 APFloat::opOverflow)
926 // Don't need an overflow check for lower bound. Just check for
927 // -Inf/NaN.
928 MinSrc = APFloat::getInf(SrcSema, true);
929 else
930 // Find the largest value which is too small to represent (before
931 // truncation toward zero).
932 MinSrc.subtract(APFloat(SrcSema, 1), APFloat::rmTowardNegative);
933
934 APSInt Max = APSInt::getMaxValue(Width, Unsigned);
935 APFloat MaxSrc(SrcSema, APFloat::uninitialized);
936 if (MaxSrc.convertFromAPInt(Max, !Unsigned, APFloat::rmTowardZero) &
937 APFloat::opOverflow)
938 // Don't need an overflow check for upper bound. Just check for
939 // +Inf/NaN.
940 MaxSrc = APFloat::getInf(SrcSema, false);
941 else
942 // Find the smallest value which is too large to represent (before
943 // truncation toward zero).
944 MaxSrc.add(APFloat(SrcSema, 1), APFloat::rmTowardPositive);
945
946 // If we're converting from __half, convert the range to float to match
947 // the type of src.
948 if (OrigSrcType->isHalfType()) {
949 const llvm::fltSemantics &Sema =
950 CGF.getContext().getFloatTypeSemantics(SrcType);
951 bool IsInexact;
952 MinSrc.convert(Sema, APFloat::rmTowardZero, &IsInexact);
953 MaxSrc.convert(Sema, APFloat::rmTowardZero, &IsInexact);
954 }
955
956 llvm::Value *GE =
957 Builder.CreateFCmpOGT(Src, llvm::ConstantFP::get(VMContext, MinSrc));
958 llvm::Value *LE =
959 Builder.CreateFCmpOLT(Src, llvm::ConstantFP::get(VMContext, MaxSrc));
960 Check = Builder.CreateAnd(GE, LE);
961
962 llvm::Constant *StaticArgs[] = {CGF.EmitCheckSourceLocation(Loc),
963 CGF.EmitCheckTypeDescriptor(OrigSrcType),
964 CGF.EmitCheckTypeDescriptor(DstType)};
965 CGF.EmitCheck(std::make_pair(Check, SanitizerKind::FloatCastOverflow),
966 SanitizerHandler::FloatCastOverflow, StaticArgs, OrigSrc);
967}
968
969// Should be called within CodeGenFunction::SanitizerScope RAII scope.
970// Returns 'i1 false' when the truncation Src -> Dst was lossy.
971static std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
972 std::pair<llvm::Value *, SanitizerMask>>
973EmitIntegerTruncationCheckHelper(Value *Src, QualType SrcType, Value *Dst,
974 QualType DstType, CGBuilderTy &Builder) {
975 llvm::Type *SrcTy = Src->getType();
976 llvm::Type *DstTy = Dst->getType();
977 (void)DstTy; // Only used in assert()
978
979 // This should be truncation of integral types.
980 assert(Src != Dst)(static_cast <bool> (Src != Dst) ? void (0) : __assert_fail
("Src != Dst", "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 980, __extension__ __PRETTY_FUNCTION__))
;
981 assert(SrcTy->getScalarSizeInBits() > Dst->getType()->getScalarSizeInBits())(static_cast <bool> (SrcTy->getScalarSizeInBits() >
Dst->getType()->getScalarSizeInBits()) ? void (0) : __assert_fail
("SrcTy->getScalarSizeInBits() > Dst->getType()->getScalarSizeInBits()"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 981, __extension__ __PRETTY_FUNCTION__))
;
982 assert(isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) &&(static_cast <bool> (isa<llvm::IntegerType>(SrcTy
) && isa<llvm::IntegerType>(DstTy) && "non-integer llvm type"
) ? void (0) : __assert_fail ("isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) && \"non-integer llvm type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 983, __extension__ __PRETTY_FUNCTION__))
983 "non-integer llvm type")(static_cast <bool> (isa<llvm::IntegerType>(SrcTy
) && isa<llvm::IntegerType>(DstTy) && "non-integer llvm type"
) ? void (0) : __assert_fail ("isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) && \"non-integer llvm type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 983, __extension__ __PRETTY_FUNCTION__))
;
984
985 bool SrcSigned = SrcType->isSignedIntegerOrEnumerationType();
986 bool DstSigned = DstType->isSignedIntegerOrEnumerationType();
987
988 // If both (src and dst) types are unsigned, then it's an unsigned truncation.
989 // Else, it is a signed truncation.
990 ScalarExprEmitter::ImplicitConversionCheckKind Kind;
991 SanitizerMask Mask;
992 if (!SrcSigned && !DstSigned) {
993 Kind = ScalarExprEmitter::ICCK_UnsignedIntegerTruncation;
994 Mask = SanitizerKind::ImplicitUnsignedIntegerTruncation;
995 } else {
996 Kind = ScalarExprEmitter::ICCK_SignedIntegerTruncation;
997 Mask = SanitizerKind::ImplicitSignedIntegerTruncation;
998 }
999
1000 llvm::Value *Check = nullptr;
1001 // 1. Extend the truncated value back to the same width as the Src.
1002 Check = Builder.CreateIntCast(Dst, SrcTy, DstSigned, "anyext");
1003 // 2. Equality-compare with the original source value
1004 Check = Builder.CreateICmpEQ(Check, Src, "truncheck");
1005 // If the comparison result is 'i1 false', then the truncation was lossy.
1006 return std::make_pair(Kind, std::make_pair(Check, Mask));
1007}
1008
1009static bool PromotionIsPotentiallyEligibleForImplicitIntegerConversionCheck(
1010 QualType SrcType, QualType DstType) {
1011 return SrcType->isIntegerType() && DstType->isIntegerType();
1012}
1013
1014void ScalarExprEmitter::EmitIntegerTruncationCheck(Value *Src, QualType SrcType,
1015 Value *Dst, QualType DstType,
1016 SourceLocation Loc) {
1017 if (!CGF.SanOpts.hasOneOf(SanitizerKind::ImplicitIntegerTruncation))
1018 return;
1019
1020 // We only care about int->int conversions here.
1021 // We ignore conversions to/from pointer and/or bool.
1022 if (!PromotionIsPotentiallyEligibleForImplicitIntegerConversionCheck(SrcType,
1023 DstType))
1024 return;
1025
1026 unsigned SrcBits = Src->getType()->getScalarSizeInBits();
1027 unsigned DstBits = Dst->getType()->getScalarSizeInBits();
1028 // This must be truncation. Else we do not care.
1029 if (SrcBits <= DstBits)
1030 return;
1031
1032 assert(!DstType->isBooleanType() && "we should not get here with booleans.")(static_cast <bool> (!DstType->isBooleanType() &&
"we should not get here with booleans.") ? void (0) : __assert_fail
("!DstType->isBooleanType() && \"we should not get here with booleans.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1032, __extension__ __PRETTY_FUNCTION__))
;
1033
1034 // If the integer sign change sanitizer is enabled,
1035 // and we are truncating from larger unsigned type to smaller signed type,
1036 // let that next sanitizer deal with it.
1037 bool SrcSigned = SrcType->isSignedIntegerOrEnumerationType();
1038 bool DstSigned = DstType->isSignedIntegerOrEnumerationType();
1039 if (CGF.SanOpts.has(SanitizerKind::ImplicitIntegerSignChange) &&
1040 (!SrcSigned && DstSigned))
1041 return;
1042
1043 CodeGenFunction::SanitizerScope SanScope(&CGF);
1044
1045 std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
1046 std::pair<llvm::Value *, SanitizerMask>>
1047 Check =
1048 EmitIntegerTruncationCheckHelper(Src, SrcType, Dst, DstType, Builder);
1049 // If the comparison result is 'i1 false', then the truncation was lossy.
1050
1051 // Do we care about this type of truncation?
1052 if (!CGF.SanOpts.has(Check.second.second))
1053 return;
1054
1055 llvm::Constant *StaticArgs[] = {
1056 CGF.EmitCheckSourceLocation(Loc), CGF.EmitCheckTypeDescriptor(SrcType),
1057 CGF.EmitCheckTypeDescriptor(DstType),
1058 llvm::ConstantInt::get(Builder.getInt8Ty(), Check.first)};
1059 CGF.EmitCheck(Check.second, SanitizerHandler::ImplicitConversion, StaticArgs,
1060 {Src, Dst});
1061}
1062
1063// Should be called within CodeGenFunction::SanitizerScope RAII scope.
1064// Returns 'i1 false' when the conversion Src -> Dst changed the sign.
1065static std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
1066 std::pair<llvm::Value *, SanitizerMask>>
1067EmitIntegerSignChangeCheckHelper(Value *Src, QualType SrcType, Value *Dst,
1068 QualType DstType, CGBuilderTy &Builder) {
1069 llvm::Type *SrcTy = Src->getType();
1070 llvm::Type *DstTy = Dst->getType();
1071
1072 assert(isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) &&(static_cast <bool> (isa<llvm::IntegerType>(SrcTy
) && isa<llvm::IntegerType>(DstTy) && "non-integer llvm type"
) ? void (0) : __assert_fail ("isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) && \"non-integer llvm type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1073, __extension__ __PRETTY_FUNCTION__))
1073 "non-integer llvm type")(static_cast <bool> (isa<llvm::IntegerType>(SrcTy
) && isa<llvm::IntegerType>(DstTy) && "non-integer llvm type"
) ? void (0) : __assert_fail ("isa<llvm::IntegerType>(SrcTy) && isa<llvm::IntegerType>(DstTy) && \"non-integer llvm type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1073, __extension__ __PRETTY_FUNCTION__))
;
1074
1075 bool SrcSigned = SrcType->isSignedIntegerOrEnumerationType();
1076 bool DstSigned = DstType->isSignedIntegerOrEnumerationType();
1077 (void)SrcSigned; // Only used in assert()
1078 (void)DstSigned; // Only used in assert()
1079 unsigned SrcBits = SrcTy->getScalarSizeInBits();
1080 unsigned DstBits = DstTy->getScalarSizeInBits();
1081 (void)SrcBits; // Only used in assert()
1082 (void)DstBits; // Only used in assert()
1083
1084 assert(((SrcBits != DstBits) || (SrcSigned != DstSigned)) &&(static_cast <bool> (((SrcBits != DstBits) || (SrcSigned
!= DstSigned)) && "either the widths should be different, or the signednesses."
) ? void (0) : __assert_fail ("((SrcBits != DstBits) || (SrcSigned != DstSigned)) && \"either the widths should be different, or the signednesses.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1085, __extension__ __PRETTY_FUNCTION__))
1085 "either the widths should be different, or the signednesses.")(static_cast <bool> (((SrcBits != DstBits) || (SrcSigned
!= DstSigned)) && "either the widths should be different, or the signednesses."
) ? void (0) : __assert_fail ("((SrcBits != DstBits) || (SrcSigned != DstSigned)) && \"either the widths should be different, or the signednesses.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1085, __extension__ __PRETTY_FUNCTION__))
;
1086
1087 // NOTE: zero value is considered to be non-negative.
1088 auto EmitIsNegativeTest = [&Builder](Value *V, QualType VType,
1089 const char *Name) -> Value * {
1090 // Is this value a signed type?
1091 bool VSigned = VType->isSignedIntegerOrEnumerationType();
1092 llvm::Type *VTy = V->getType();
1093 if (!VSigned) {
1094 // If the value is unsigned, then it is never negative.
1095 // FIXME: can we encounter non-scalar VTy here?
1096 return llvm::ConstantInt::getFalse(VTy->getContext());
1097 }
1098 // Get the zero of the same type with which we will be comparing.
1099 llvm::Constant *Zero = llvm::ConstantInt::get(VTy, 0);
1100 // %V.isnegative = icmp slt %V, 0
1101 // I.e is %V *strictly* less than zero, does it have negative value?
1102 return Builder.CreateICmp(llvm::ICmpInst::ICMP_SLT, V, Zero,
1103 llvm::Twine(Name) + "." + V->getName() +
1104 ".negativitycheck");
1105 };
1106
1107 // 1. Was the old Value negative?
1108 llvm::Value *SrcIsNegative = EmitIsNegativeTest(Src, SrcType, "src");
1109 // 2. Is the new Value negative?
1110 llvm::Value *DstIsNegative = EmitIsNegativeTest(Dst, DstType, "dst");
1111 // 3. Now, was the 'negativity status' preserved during the conversion?
1112 // NOTE: conversion from negative to zero is considered to change the sign.
1113 // (We want to get 'false' when the conversion changed the sign)
1114 // So we should just equality-compare the negativity statuses.
1115 llvm::Value *Check = nullptr;
1116 Check = Builder.CreateICmpEQ(SrcIsNegative, DstIsNegative, "signchangecheck");
1117 // If the comparison result is 'false', then the conversion changed the sign.
1118 return std::make_pair(
1119 ScalarExprEmitter::ICCK_IntegerSignChange,
1120 std::make_pair(Check, SanitizerKind::ImplicitIntegerSignChange));
1121}
1122
1123void ScalarExprEmitter::EmitIntegerSignChangeCheck(Value *Src, QualType SrcType,
1124 Value *Dst, QualType DstType,
1125 SourceLocation Loc) {
1126 if (!CGF.SanOpts.has(SanitizerKind::ImplicitIntegerSignChange))
1127 return;
1128
1129 llvm::Type *SrcTy = Src->getType();
1130 llvm::Type *DstTy = Dst->getType();
1131
1132 // We only care about int->int conversions here.
1133 // We ignore conversions to/from pointer and/or bool.
1134 if (!PromotionIsPotentiallyEligibleForImplicitIntegerConversionCheck(SrcType,
1135 DstType))
1136 return;
1137
1138 bool SrcSigned = SrcType->isSignedIntegerOrEnumerationType();
1139 bool DstSigned = DstType->isSignedIntegerOrEnumerationType();
1140 unsigned SrcBits = SrcTy->getScalarSizeInBits();
1141 unsigned DstBits = DstTy->getScalarSizeInBits();
1142
1143 // Now, we do not need to emit the check in *all* of the cases.
1144 // We can avoid emitting it in some obvious cases where it would have been
1145 // dropped by the opt passes (instcombine) always anyways.
1146 // If it's a cast between effectively the same type, no check.
1147 // NOTE: this is *not* equivalent to checking the canonical types.
1148 if (SrcSigned == DstSigned && SrcBits == DstBits)
1149 return;
1150 // At least one of the values needs to have signed type.
1151 // If both are unsigned, then obviously, neither of them can be negative.
1152 if (!SrcSigned && !DstSigned)
1153 return;
1154 // If the conversion is to *larger* *signed* type, then no check is needed.
1155 // Because either sign-extension happens (so the sign will remain),
1156 // or zero-extension will happen (the sign bit will be zero.)
1157 if ((DstBits > SrcBits) && DstSigned)
1158 return;
1159 if (CGF.SanOpts.has(SanitizerKind::ImplicitSignedIntegerTruncation) &&
1160 (SrcBits > DstBits) && SrcSigned) {
1161 // If the signed integer truncation sanitizer is enabled,
1162 // and this is a truncation from signed type, then no check is needed.
1163 // Because here sign change check is interchangeable with truncation check.
1164 return;
1165 }
1166 // That's it. We can't rule out any more cases with the data we have.
1167
1168 CodeGenFunction::SanitizerScope SanScope(&CGF);
1169
1170 std::pair<ScalarExprEmitter::ImplicitConversionCheckKind,
1171 std::pair<llvm::Value *, SanitizerMask>>
1172 Check;
1173
1174 // Each of these checks needs to return 'false' when an issue was detected.
1175 ImplicitConversionCheckKind CheckKind;
1176 llvm::SmallVector<std::pair<llvm::Value *, SanitizerMask>, 2> Checks;
1177 // So we can 'and' all the checks together, and still get 'false',
1178 // if at least one of the checks detected an issue.
1179
1180 Check = EmitIntegerSignChangeCheckHelper(Src, SrcType, Dst, DstType, Builder);
1181 CheckKind = Check.first;
1182 Checks.emplace_back(Check.second);
1183
1184 if (CGF.SanOpts.has(SanitizerKind::ImplicitSignedIntegerTruncation) &&
1185 (SrcBits > DstBits) && !SrcSigned && DstSigned) {
1186 // If the signed integer truncation sanitizer was enabled,
1187 // and we are truncating from larger unsigned type to smaller signed type,
1188 // let's handle the case we skipped in that check.
1189 Check =
1190 EmitIntegerTruncationCheckHelper(Src, SrcType, Dst, DstType, Builder);
1191 CheckKind = ICCK_SignedIntegerTruncationOrSignChange;
1192 Checks.emplace_back(Check.second);
1193 // If the comparison result is 'i1 false', then the truncation was lossy.
1194 }
1195
1196 llvm::Constant *StaticArgs[] = {
1197 CGF.EmitCheckSourceLocation(Loc), CGF.EmitCheckTypeDescriptor(SrcType),
1198 CGF.EmitCheckTypeDescriptor(DstType),
1199 llvm::ConstantInt::get(Builder.getInt8Ty(), CheckKind)};
1200 // EmitCheck() will 'and' all the checks together.
1201 CGF.EmitCheck(Checks, SanitizerHandler::ImplicitConversion, StaticArgs,
1202 {Src, Dst});
1203}
1204
1205Value *ScalarExprEmitter::EmitScalarCast(Value *Src, QualType SrcType,
1206 QualType DstType, llvm::Type *SrcTy,
1207 llvm::Type *DstTy,
1208 ScalarConversionOpts Opts) {
1209 // The Element types determine the type of cast to perform.
1210 llvm::Type *SrcElementTy;
1211 llvm::Type *DstElementTy;
1212 QualType SrcElementType;
1213 QualType DstElementType;
1214 if (SrcType->isMatrixType() && DstType->isMatrixType()) {
1215 SrcElementTy = cast<llvm::VectorType>(SrcTy)->getElementType();
1216 DstElementTy = cast<llvm::VectorType>(DstTy)->getElementType();
1217 SrcElementType = SrcType->castAs<MatrixType>()->getElementType();
1218 DstElementType = DstType->castAs<MatrixType>()->getElementType();
1219 } else {
1220 assert(!SrcType->isMatrixType() && !DstType->isMatrixType() &&(static_cast <bool> (!SrcType->isMatrixType() &&
!DstType->isMatrixType() && "cannot cast between matrix and non-matrix types"
) ? void (0) : __assert_fail ("!SrcType->isMatrixType() && !DstType->isMatrixType() && \"cannot cast between matrix and non-matrix types\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1221, __extension__ __PRETTY_FUNCTION__))
1221 "cannot cast between matrix and non-matrix types")(static_cast <bool> (!SrcType->isMatrixType() &&
!DstType->isMatrixType() && "cannot cast between matrix and non-matrix types"
) ? void (0) : __assert_fail ("!SrcType->isMatrixType() && !DstType->isMatrixType() && \"cannot cast between matrix and non-matrix types\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1221, __extension__ __PRETTY_FUNCTION__))
;
1222 SrcElementTy = SrcTy;
1223 DstElementTy = DstTy;
1224 SrcElementType = SrcType;
1225 DstElementType = DstType;
1226 }
1227
1228 if (isa<llvm::IntegerType>(SrcElementTy)) {
1229 bool InputSigned = SrcElementType->isSignedIntegerOrEnumerationType();
1230 if (SrcElementType->isBooleanType() && Opts.TreatBooleanAsSigned) {
1231 InputSigned = true;
1232 }
1233
1234 if (isa<llvm::IntegerType>(DstElementTy))
1235 return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
1236 if (InputSigned)
1237 return Builder.CreateSIToFP(Src, DstTy, "conv");
1238 return Builder.CreateUIToFP(Src, DstTy, "conv");
1239 }
1240
1241 if (isa<llvm::IntegerType>(DstElementTy)) {
1242 assert(SrcElementTy->isFloatingPointTy() && "Unknown real conversion")(static_cast <bool> (SrcElementTy->isFloatingPointTy
() && "Unknown real conversion") ? void (0) : __assert_fail
("SrcElementTy->isFloatingPointTy() && \"Unknown real conversion\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1242, __extension__ __PRETTY_FUNCTION__))
;
1243 if (DstElementType->isSignedIntegerOrEnumerationType())
1244 return Builder.CreateFPToSI(Src, DstTy, "conv");
1245 return Builder.CreateFPToUI(Src, DstTy, "conv");
1246 }
1247
1248 if (DstElementTy->getTypeID() < SrcElementTy->getTypeID())
1249 return Builder.CreateFPTrunc(Src, DstTy, "conv");
1250 return Builder.CreateFPExt(Src, DstTy, "conv");
1251}
1252
1253/// Emit a conversion from the specified type to the specified destination type,
1254/// both of which are LLVM scalar types.
1255Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
1256 QualType DstType,
1257 SourceLocation Loc,
1258 ScalarConversionOpts Opts) {
1259 // All conversions involving fixed point types should be handled by the
1260 // EmitFixedPoint family functions. This is done to prevent bloating up this
1261 // function more, and although fixed point numbers are represented by
1262 // integers, we do not want to follow any logic that assumes they should be
1263 // treated as integers.
1264 // TODO(leonardchan): When necessary, add another if statement checking for
1265 // conversions to fixed point types from other types.
1266 if (SrcType->isFixedPointType()) {
1267 if (DstType->isBooleanType())
1268 // It is important that we check this before checking if the dest type is
1269 // an integer because booleans are technically integer types.
1270 // We do not need to check the padding bit on unsigned types if unsigned
1271 // padding is enabled because overflow into this bit is undefined
1272 // behavior.
1273 return Builder.CreateIsNotNull(Src, "tobool");
1274 if (DstType->isFixedPointType() || DstType->isIntegerType() ||
1275 DstType->isRealFloatingType())
1276 return EmitFixedPointConversion(Src, SrcType, DstType, Loc);
1277
1278 llvm_unreachable(::llvm::llvm_unreachable_internal("Unhandled scalar conversion from a fixed point type to another type."
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1279)
1279 "Unhandled scalar conversion from a fixed point type to another type.")::llvm::llvm_unreachable_internal("Unhandled scalar conversion from a fixed point type to another type."
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1279)
;
1280 } else if (DstType->isFixedPointType()) {
1281 if (SrcType->isIntegerType() || SrcType->isRealFloatingType())
1282 // This also includes converting booleans and enums to fixed point types.
1283 return EmitFixedPointConversion(Src, SrcType, DstType, Loc);
1284
1285 llvm_unreachable(::llvm::llvm_unreachable_internal("Unhandled scalar conversion to a fixed point type from another type."
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1286)
1286 "Unhandled scalar conversion to a fixed point type from another type.")::llvm::llvm_unreachable_internal("Unhandled scalar conversion to a fixed point type from another type."
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1286)
;
1287 }
1288
1289 QualType NoncanonicalSrcType = SrcType;
1290 QualType NoncanonicalDstType = DstType;
1291
1292 SrcType = CGF.getContext().getCanonicalType(SrcType);
1293 DstType = CGF.getContext().getCanonicalType(DstType);
1294 if (SrcType == DstType) return Src;
1295
1296 if (DstType->isVoidType()) return nullptr;
1297
1298 llvm::Value *OrigSrc = Src;
1299 QualType OrigSrcType = SrcType;
1300 llvm::Type *SrcTy = Src->getType();
1301
1302 // Handle conversions to bool first, they are special: comparisons against 0.
1303 if (DstType->isBooleanType())
1304 return EmitConversionToBool(Src, SrcType);
1305
1306 llvm::Type *DstTy = ConvertType(DstType);
1307
1308 // Cast from half through float if half isn't a native type.
1309 if (SrcType->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
1310 // Cast to FP using the intrinsic if the half type itself isn't supported.
1311 if (DstTy->isFloatingPointTy()) {
1312 if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics())
1313 return Builder.CreateCall(
1314 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16, DstTy),
1315 Src);
1316 } else {
1317 // Cast to other types through float, using either the intrinsic or FPExt,
1318 // depending on whether the half type itself is supported
1319 // (as opposed to operations on half, available with NativeHalfType).
1320 if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics()) {
1321 Src = Builder.CreateCall(
1322 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16,
1323 CGF.CGM.FloatTy),
1324 Src);
1325 } else {
1326 Src = Builder.CreateFPExt(Src, CGF.CGM.FloatTy, "conv");
1327 }
1328 SrcType = CGF.getContext().FloatTy;
1329 SrcTy = CGF.FloatTy;
1330 }
1331 }
1332
1333 // Ignore conversions like int -> uint.
1334 if (SrcTy == DstTy) {
1335 if (Opts.EmitImplicitIntegerSignChangeChecks)
1336 EmitIntegerSignChangeCheck(Src, NoncanonicalSrcType, Src,
1337 NoncanonicalDstType, Loc);
1338
1339 return Src;
1340 }
1341
1342 // Handle pointer conversions next: pointers can only be converted to/from
1343 // other pointers and integers. Check for pointer types in terms of LLVM, as
1344 // some native types (like Obj-C id) may map to a pointer type.
1345 if (auto DstPT = dyn_cast<llvm::PointerType>(DstTy)) {
1346 // The source value may be an integer, or a pointer.
1347 if (isa<llvm::PointerType>(SrcTy))
1348 return Builder.CreateBitCast(Src, DstTy, "conv");
1349
1350 assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?")(static_cast <bool> (SrcType->isIntegerType() &&
"Not ptr->ptr or int->ptr conversion?") ? void (0) : __assert_fail
("SrcType->isIntegerType() && \"Not ptr->ptr or int->ptr conversion?\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1350, __extension__ __PRETTY_FUNCTION__))
;
1351 // First, convert to the correct width so that we control the kind of
1352 // extension.
1353 llvm::Type *MiddleTy = CGF.CGM.getDataLayout().getIntPtrType(DstPT);
1354 bool InputSigned = SrcType->isSignedIntegerOrEnumerationType();
1355 llvm::Value* IntResult =
1356 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
1357 // Then, cast to pointer.
1358 return Builder.CreateIntToPtr(IntResult, DstTy, "conv");
1359 }
1360
1361 if (isa<llvm::PointerType>(SrcTy)) {
1362 // Must be an ptr to int cast.
1363 assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?")(static_cast <bool> (isa<llvm::IntegerType>(DstTy
) && "not ptr->int?") ? void (0) : __assert_fail (
"isa<llvm::IntegerType>(DstTy) && \"not ptr->int?\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1363, __extension__ __PRETTY_FUNCTION__))
;
1364 return Builder.CreatePtrToInt(Src, DstTy, "conv");
1365 }
1366
1367 // A scalar can be splatted to an extended vector of the same element type
1368 if (DstType->isExtVectorType() && !SrcType->isVectorType()) {
1369 // Sema should add casts to make sure that the source expression's type is
1370 // the same as the vector's element type (sans qualifiers)
1371 assert(DstType->castAs<ExtVectorType>()->getElementType().getTypePtr() ==(static_cast <bool> (DstType->castAs<ExtVectorType
>()->getElementType().getTypePtr() == SrcType.getTypePtr
() && "Splatted expr doesn't match with vector element type?"
) ? void (0) : __assert_fail ("DstType->castAs<ExtVectorType>()->getElementType().getTypePtr() == SrcType.getTypePtr() && \"Splatted expr doesn't match with vector element type?\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1373, __extension__ __PRETTY_FUNCTION__))
1372 SrcType.getTypePtr() &&(static_cast <bool> (DstType->castAs<ExtVectorType
>()->getElementType().getTypePtr() == SrcType.getTypePtr
() && "Splatted expr doesn't match with vector element type?"
) ? void (0) : __assert_fail ("DstType->castAs<ExtVectorType>()->getElementType().getTypePtr() == SrcType.getTypePtr() && \"Splatted expr doesn't match with vector element type?\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1373, __extension__ __PRETTY_FUNCTION__))
1373 "Splatted expr doesn't match with vector element type?")(static_cast <bool> (DstType->castAs<ExtVectorType
>()->getElementType().getTypePtr() == SrcType.getTypePtr
() && "Splatted expr doesn't match with vector element type?"
) ? void (0) : __assert_fail ("DstType->castAs<ExtVectorType>()->getElementType().getTypePtr() == SrcType.getTypePtr() && \"Splatted expr doesn't match with vector element type?\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1373, __extension__ __PRETTY_FUNCTION__))
;
1374
1375 // Splat the element across to all elements
1376 unsigned NumElements = cast<llvm::FixedVectorType>(DstTy)->getNumElements();
1377 return Builder.CreateVectorSplat(NumElements, Src, "splat");
1378 }
1379
1380 if (SrcType->isMatrixType() && DstType->isMatrixType())
1381 return EmitScalarCast(Src, SrcType, DstType, SrcTy, DstTy, Opts);
1382
1383 if (isa<llvm::VectorType>(SrcTy) || isa<llvm::VectorType>(DstTy)) {
1384 // Allow bitcast from vector to integer/fp of the same size.
1385 unsigned SrcSize = SrcTy->getPrimitiveSizeInBits();
1386 unsigned DstSize = DstTy->getPrimitiveSizeInBits();
1387 if (SrcSize == DstSize)
1388 return Builder.CreateBitCast(Src, DstTy, "conv");
1389
1390 // Conversions between vectors of different sizes are not allowed except
1391 // when vectors of half are involved. Operations on storage-only half
1392 // vectors require promoting half vector operands to float vectors and
1393 // truncating the result, which is either an int or float vector, to a
1394 // short or half vector.
1395
1396 // Source and destination are both expected to be vectors.
1397 llvm::Type *SrcElementTy = cast<llvm::VectorType>(SrcTy)->getElementType();
1398 llvm::Type *DstElementTy = cast<llvm::VectorType>(DstTy)->getElementType();
1399 (void)DstElementTy;
1400
1401 assert(((SrcElementTy->isIntegerTy() &&(static_cast <bool> (((SrcElementTy->isIntegerTy() &&
DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy
() && DstElementTy->isFloatingPointTy())) &&
"unexpected conversion between a floating-point vector and an "
"integer vector") ? void (0) : __assert_fail ("((SrcElementTy->isIntegerTy() && DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy() && DstElementTy->isFloatingPointTy())) && \"unexpected conversion between a floating-point vector and an \" \"integer vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1406, __extension__ __PRETTY_FUNCTION__))
1402 DstElementTy->isIntegerTy()) ||(static_cast <bool> (((SrcElementTy->isIntegerTy() &&
DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy
() && DstElementTy->isFloatingPointTy())) &&
"unexpected conversion between a floating-point vector and an "
"integer vector") ? void (0) : __assert_fail ("((SrcElementTy->isIntegerTy() && DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy() && DstElementTy->isFloatingPointTy())) && \"unexpected conversion between a floating-point vector and an \" \"integer vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1406, __extension__ __PRETTY_FUNCTION__))
1403 (SrcElementTy->isFloatingPointTy() &&(static_cast <bool> (((SrcElementTy->isIntegerTy() &&
DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy
() && DstElementTy->isFloatingPointTy())) &&
"unexpected conversion between a floating-point vector and an "
"integer vector") ? void (0) : __assert_fail ("((SrcElementTy->isIntegerTy() && DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy() && DstElementTy->isFloatingPointTy())) && \"unexpected conversion between a floating-point vector and an \" \"integer vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1406, __extension__ __PRETTY_FUNCTION__))
1404 DstElementTy->isFloatingPointTy())) &&(static_cast <bool> (((SrcElementTy->isIntegerTy() &&
DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy
() && DstElementTy->isFloatingPointTy())) &&
"unexpected conversion between a floating-point vector and an "
"integer vector") ? void (0) : __assert_fail ("((SrcElementTy->isIntegerTy() && DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy() && DstElementTy->isFloatingPointTy())) && \"unexpected conversion between a floating-point vector and an \" \"integer vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1406, __extension__ __PRETTY_FUNCTION__))
1405 "unexpected conversion between a floating-point vector and an "(static_cast <bool> (((SrcElementTy->isIntegerTy() &&
DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy
() && DstElementTy->isFloatingPointTy())) &&
"unexpected conversion between a floating-point vector and an "
"integer vector") ? void (0) : __assert_fail ("((SrcElementTy->isIntegerTy() && DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy() && DstElementTy->isFloatingPointTy())) && \"unexpected conversion between a floating-point vector and an \" \"integer vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1406, __extension__ __PRETTY_FUNCTION__))
1406 "integer vector")(static_cast <bool> (((SrcElementTy->isIntegerTy() &&
DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy
() && DstElementTy->isFloatingPointTy())) &&
"unexpected conversion between a floating-point vector and an "
"integer vector") ? void (0) : __assert_fail ("((SrcElementTy->isIntegerTy() && DstElementTy->isIntegerTy()) || (SrcElementTy->isFloatingPointTy() && DstElementTy->isFloatingPointTy())) && \"unexpected conversion between a floating-point vector and an \" \"integer vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1406, __extension__ __PRETTY_FUNCTION__))
;
1407
1408 // Truncate an i32 vector to an i16 vector.
1409 if (SrcElementTy->isIntegerTy())
1410 return Builder.CreateIntCast(Src, DstTy, false, "conv");
1411
1412 // Truncate a float vector to a half vector.
1413 if (SrcSize > DstSize)
1414 return Builder.CreateFPTrunc(Src, DstTy, "conv");
1415
1416 // Promote a half vector to a float vector.
1417 return Builder.CreateFPExt(Src, DstTy, "conv");
1418 }
1419
1420 // Finally, we have the arithmetic types: real int/float.
1421 Value *Res = nullptr;
1422 llvm::Type *ResTy = DstTy;
1423
1424 // An overflowing conversion has undefined behavior if either the source type
1425 // or the destination type is a floating-point type. However, we consider the
1426 // range of representable values for all floating-point types to be
1427 // [-inf,+inf], so no overflow can ever happen when the destination type is a
1428 // floating-point type.
1429 if (CGF.SanOpts.has(SanitizerKind::FloatCastOverflow) &&
1430 OrigSrcType->isFloatingType())
1431 EmitFloatConversionCheck(OrigSrc, OrigSrcType, Src, SrcType, DstType, DstTy,
1432 Loc);
1433
1434 // Cast to half through float if half isn't a native type.
1435 if (DstType->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
1436 // Make sure we cast in a single step if from another FP type.
1437 if (SrcTy->isFloatingPointTy()) {
1438 // Use the intrinsic if the half type itself isn't supported
1439 // (as opposed to operations on half, available with NativeHalfType).
1440 if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics())
1441 return Builder.CreateCall(
1442 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, SrcTy), Src);
1443 // If the half type is supported, just use an fptrunc.
1444 return Builder.CreateFPTrunc(Src, DstTy);
1445 }
1446 DstTy = CGF.FloatTy;
1447 }
1448
1449 Res = EmitScalarCast(Src, SrcType, DstType, SrcTy, DstTy, Opts);
1450
1451 if (DstTy != ResTy) {
1452 if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics()) {
1453 assert(ResTy->isIntegerTy(16) && "Only half FP requires extra conversion")(static_cast <bool> (ResTy->isIntegerTy(16) &&
"Only half FP requires extra conversion") ? void (0) : __assert_fail
("ResTy->isIntegerTy(16) && \"Only half FP requires extra conversion\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1453, __extension__ __PRETTY_FUNCTION__))
;
1454 Res = Builder.CreateCall(
1455 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16, CGF.CGM.FloatTy),
1456 Res);
1457 } else {
1458 Res = Builder.CreateFPTrunc(Res, ResTy, "conv");
1459 }
1460 }
1461
1462 if (Opts.EmitImplicitIntegerTruncationChecks)
1463 EmitIntegerTruncationCheck(Src, NoncanonicalSrcType, Res,
1464 NoncanonicalDstType, Loc);
1465
1466 if (Opts.EmitImplicitIntegerSignChangeChecks)
1467 EmitIntegerSignChangeCheck(Src, NoncanonicalSrcType, Res,
1468 NoncanonicalDstType, Loc);
1469
1470 return Res;
1471}
1472
1473Value *ScalarExprEmitter::EmitFixedPointConversion(Value *Src, QualType SrcTy,
1474 QualType DstTy,
1475 SourceLocation Loc) {
1476 llvm::FixedPointBuilder<CGBuilderTy> FPBuilder(Builder);
1477 llvm::Value *Result;
1478 if (SrcTy->isRealFloatingType())
1479 Result = FPBuilder.CreateFloatingToFixed(Src,
1480 CGF.getContext().getFixedPointSemantics(DstTy));
1481 else if (DstTy->isRealFloatingType())
1482 Result = FPBuilder.CreateFixedToFloating(Src,
1483 CGF.getContext().getFixedPointSemantics(SrcTy),
1484 ConvertType(DstTy));
1485 else {
1486 auto SrcFPSema = CGF.getContext().getFixedPointSemantics(SrcTy);
1487 auto DstFPSema = CGF.getContext().getFixedPointSemantics(DstTy);
1488
1489 if (DstTy->isIntegerType())
1490 Result = FPBuilder.CreateFixedToInteger(Src, SrcFPSema,
1491 DstFPSema.getWidth(),
1492 DstFPSema.isSigned());
1493 else if (SrcTy->isIntegerType())
1494 Result = FPBuilder.CreateIntegerToFixed(Src, SrcFPSema.isSigned(),
1495 DstFPSema);
1496 else
1497 Result = FPBuilder.CreateFixedToFixed(Src, SrcFPSema, DstFPSema);
1498 }
1499 return Result;
1500}
1501
1502/// Emit a conversion from the specified complex type to the specified
1503/// destination type, where the destination type is an LLVM scalar type.
1504Value *ScalarExprEmitter::EmitComplexToScalarConversion(
1505 CodeGenFunction::ComplexPairTy Src, QualType SrcTy, QualType DstTy,
1506 SourceLocation Loc) {
1507 // Get the source element type.
1508 SrcTy = SrcTy->castAs<ComplexType>()->getElementType();
1509
1510 // Handle conversions to bool first, they are special: comparisons against 0.
1511 if (DstTy->isBooleanType()) {
1512 // Complex != 0 -> (Real != 0) | (Imag != 0)
1513 Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy, Loc);
1514 Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy, Loc);
1515 return Builder.CreateOr(Src.first, Src.second, "tobool");
1516 }
1517
1518 // C99 6.3.1.7p2: "When a value of complex type is converted to a real type,
1519 // the imaginary part of the complex value is discarded and the value of the
1520 // real part is converted according to the conversion rules for the
1521 // corresponding real type.
1522 return EmitScalarConversion(Src.first, SrcTy, DstTy, Loc);
1523}
1524
1525Value *ScalarExprEmitter::EmitNullValue(QualType Ty) {
1526 return CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(Ty), Ty);
1527}
1528
1529/// Emit a sanitization check for the given "binary" operation (which
1530/// might actually be a unary increment which has been lowered to a binary
1531/// operation). The check passes if all values in \p Checks (which are \c i1),
1532/// are \c true.
1533void ScalarExprEmitter::EmitBinOpCheck(
1534 ArrayRef<std::pair<Value *, SanitizerMask>> Checks, const BinOpInfo &Info) {
1535 assert(CGF.IsSanitizerScope)(static_cast <bool> (CGF.IsSanitizerScope) ? void (0) :
__assert_fail ("CGF.IsSanitizerScope", "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1535, __extension__ __PRETTY_FUNCTION__))
;
1536 SanitizerHandler Check;
1537 SmallVector<llvm::Constant *, 4> StaticData;
1538 SmallVector<llvm::Value *, 2> DynamicData;
1539
1540 BinaryOperatorKind Opcode = Info.Opcode;
1541 if (BinaryOperator::isCompoundAssignmentOp(Opcode))
1542 Opcode = BinaryOperator::getOpForCompoundAssignment(Opcode);
1543
1544 StaticData.push_back(CGF.EmitCheckSourceLocation(Info.E->getExprLoc()));
1545 const UnaryOperator *UO = dyn_cast<UnaryOperator>(Info.E);
1546 if (UO && UO->getOpcode() == UO_Minus) {
1547 Check = SanitizerHandler::NegateOverflow;
1548 StaticData.push_back(CGF.EmitCheckTypeDescriptor(UO->getType()));
1549 DynamicData.push_back(Info.RHS);
1550 } else {
1551 if (BinaryOperator::isShiftOp(Opcode)) {
1552 // Shift LHS negative or too large, or RHS out of bounds.
1553 Check = SanitizerHandler::ShiftOutOfBounds;
1554 const BinaryOperator *BO = cast<BinaryOperator>(Info.E);
1555 StaticData.push_back(
1556 CGF.EmitCheckTypeDescriptor(BO->getLHS()->getType()));
1557 StaticData.push_back(
1558 CGF.EmitCheckTypeDescriptor(BO->getRHS()->getType()));
1559 } else if (Opcode == BO_Div || Opcode == BO_Rem) {
1560 // Divide or modulo by zero, or signed overflow (eg INT_MAX / -1).
1561 Check = SanitizerHandler::DivremOverflow;
1562 StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
1563 } else {
1564 // Arithmetic overflow (+, -, *).
1565 switch (Opcode) {
1566 case BO_Add: Check = SanitizerHandler::AddOverflow; break;
1567 case BO_Sub: Check = SanitizerHandler::SubOverflow; break;
1568 case BO_Mul: Check = SanitizerHandler::MulOverflow; break;
1569 default: llvm_unreachable("unexpected opcode for bin op check")::llvm::llvm_unreachable_internal("unexpected opcode for bin op check"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1569)
;
1570 }
1571 StaticData.push_back(CGF.EmitCheckTypeDescriptor(Info.Ty));
1572 }
1573 DynamicData.push_back(Info.LHS);
1574 DynamicData.push_back(Info.RHS);
1575 }
1576
1577 CGF.EmitCheck(Checks, Check, StaticData, DynamicData);
1578}
1579
1580//===----------------------------------------------------------------------===//
1581// Visitor Methods
1582//===----------------------------------------------------------------------===//
1583
1584Value *ScalarExprEmitter::VisitExpr(Expr *E) {
1585 CGF.ErrorUnsupported(E, "scalar expression");
1586 if (E->getType()->isVoidType())
1587 return nullptr;
1588 return llvm::UndefValue::get(CGF.ConvertType(E->getType()));
1589}
1590
1591Value *
1592ScalarExprEmitter::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
1593 ASTContext &Context = CGF.getContext();
1594 llvm::Optional<LangAS> GlobalAS =
1595 Context.getTargetInfo().getConstantAddressSpace();
1596 llvm::Constant *GlobalConstStr = Builder.CreateGlobalStringPtr(
1597 E->ComputeName(Context), "__usn_str",
1598 static_cast<unsigned>(GlobalAS.getValueOr(LangAS::Default)));
1599
1600 unsigned ExprAS = Context.getTargetAddressSpace(E->getType());
1601
1602 if (GlobalConstStr->getType()->getPointerAddressSpace() == ExprAS)
1603 return GlobalConstStr;
1604
1605 llvm::Type *EltTy = GlobalConstStr->getType()->getPointerElementType();
1606 llvm::PointerType *NewPtrTy = llvm::PointerType::get(EltTy, ExprAS);
1607 return Builder.CreateAddrSpaceCast(GlobalConstStr, NewPtrTy, "usn_addr_cast");
1608}
1609
1610Value *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1611 // Vector Mask Case
1612 if (E->getNumSubExprs() == 2) {
1613 Value *LHS = CGF.EmitScalarExpr(E->getExpr(0));
1614 Value *RHS = CGF.EmitScalarExpr(E->getExpr(1));
1615 Value *Mask;
1616
1617 auto *LTy = cast<llvm::FixedVectorType>(LHS->getType());
1618 unsigned LHSElts = LTy->getNumElements();
1619
1620 Mask = RHS;
1621
1622 auto *MTy = cast<llvm::FixedVectorType>(Mask->getType());
1623
1624 // Mask off the high bits of each shuffle index.
1625 Value *MaskBits =
1626 llvm::ConstantInt::get(MTy, llvm::NextPowerOf2(LHSElts - 1) - 1);
1627 Mask = Builder.CreateAnd(Mask, MaskBits, "mask");
1628
1629 // newv = undef
1630 // mask = mask & maskbits
1631 // for each elt
1632 // n = extract mask i
1633 // x = extract val n
1634 // newv = insert newv, x, i
1635 auto *RTy = llvm::FixedVectorType::get(LTy->getElementType(),
1636 MTy->getNumElements());
1637 Value* NewV = llvm::UndefValue::get(RTy);
1638 for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) {
1639 Value *IIndx = llvm::ConstantInt::get(CGF.SizeTy, i);
1640 Value *Indx = Builder.CreateExtractElement(Mask, IIndx, "shuf_idx");
1641
1642 Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt");
1643 NewV = Builder.CreateInsertElement(NewV, VExt, IIndx, "shuf_ins");
1644 }
1645 return NewV;
1646 }
1647
1648 Value* V1 = CGF.EmitScalarExpr(E->getExpr(0));
1649 Value* V2 = CGF.EmitScalarExpr(E->getExpr(1));
1650
1651 SmallVector<int, 32> Indices;
1652 for (unsigned i = 2; i < E->getNumSubExprs(); ++i) {
1653 llvm::APSInt Idx = E->getShuffleMaskIdx(CGF.getContext(), i-2);
1654 // Check for -1 and output it as undef in the IR.
1655 if (Idx.isSigned() && Idx.isAllOnes())
1656 Indices.push_back(-1);
1657 else
1658 Indices.push_back(Idx.getZExtValue());
1659 }
1660
1661 return Builder.CreateShuffleVector(V1, V2, Indices, "shuffle");
1662}
1663
1664Value *ScalarExprEmitter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1665 QualType SrcType = E->getSrcExpr()->getType(),
1666 DstType = E->getType();
1667
1668 Value *Src = CGF.EmitScalarExpr(E->getSrcExpr());
1669
1670 SrcType = CGF.getContext().getCanonicalType(SrcType);
1671 DstType = CGF.getContext().getCanonicalType(DstType);
1672 if (SrcType == DstType) return Src;
1673
1674 assert(SrcType->isVectorType() &&(static_cast <bool> (SrcType->isVectorType() &&
"ConvertVector source type must be a vector") ? void (0) : __assert_fail
("SrcType->isVectorType() && \"ConvertVector source type must be a vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1675, __extension__ __PRETTY_FUNCTION__))
1675 "ConvertVector source type must be a vector")(static_cast <bool> (SrcType->isVectorType() &&
"ConvertVector source type must be a vector") ? void (0) : __assert_fail
("SrcType->isVectorType() && \"ConvertVector source type must be a vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1675, __extension__ __PRETTY_FUNCTION__))
;
1676 assert(DstType->isVectorType() &&(static_cast <bool> (DstType->isVectorType() &&
"ConvertVector destination type must be a vector") ? void (0
) : __assert_fail ("DstType->isVectorType() && \"ConvertVector destination type must be a vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1677, __extension__ __PRETTY_FUNCTION__))
1677 "ConvertVector destination type must be a vector")(static_cast <bool> (DstType->isVectorType() &&
"ConvertVector destination type must be a vector") ? void (0
) : __assert_fail ("DstType->isVectorType() && \"ConvertVector destination type must be a vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1677, __extension__ __PRETTY_FUNCTION__))
;
1678
1679 llvm::Type *SrcTy = Src->getType();
1680 llvm::Type *DstTy = ConvertType(DstType);
1681
1682 // Ignore conversions like int -> uint.
1683 if (SrcTy == DstTy)
1684 return Src;
1685
1686 QualType SrcEltType = SrcType->castAs<VectorType>()->getElementType(),
1687 DstEltType = DstType->castAs<VectorType>()->getElementType();
1688
1689 assert(SrcTy->isVectorTy() &&(static_cast <bool> (SrcTy->isVectorTy() && "ConvertVector source IR type must be a vector"
) ? void (0) : __assert_fail ("SrcTy->isVectorTy() && \"ConvertVector source IR type must be a vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1690, __extension__ __PRETTY_FUNCTION__))
1690 "ConvertVector source IR type must be a vector")(static_cast <bool> (SrcTy->isVectorTy() && "ConvertVector source IR type must be a vector"
) ? void (0) : __assert_fail ("SrcTy->isVectorTy() && \"ConvertVector source IR type must be a vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1690, __extension__ __PRETTY_FUNCTION__))
;
1691 assert(DstTy->isVectorTy() &&(static_cast <bool> (DstTy->isVectorTy() && "ConvertVector destination IR type must be a vector"
) ? void (0) : __assert_fail ("DstTy->isVectorTy() && \"ConvertVector destination IR type must be a vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1692, __extension__ __PRETTY_FUNCTION__))
1692 "ConvertVector destination IR type must be a vector")(static_cast <bool> (DstTy->isVectorTy() && "ConvertVector destination IR type must be a vector"
) ? void (0) : __assert_fail ("DstTy->isVectorTy() && \"ConvertVector destination IR type must be a vector\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1692, __extension__ __PRETTY_FUNCTION__))
;
1693
1694 llvm::Type *SrcEltTy = cast<llvm::VectorType>(SrcTy)->getElementType(),
1695 *DstEltTy = cast<llvm::VectorType>(DstTy)->getElementType();
1696
1697 if (DstEltType->isBooleanType()) {
1698 assert((SrcEltTy->isFloatingPointTy() ||(static_cast <bool> ((SrcEltTy->isFloatingPointTy() ||
isa<llvm::IntegerType>(SrcEltTy)) && "Unknown boolean conversion"
) ? void (0) : __assert_fail ("(SrcEltTy->isFloatingPointTy() || isa<llvm::IntegerType>(SrcEltTy)) && \"Unknown boolean conversion\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1699, __extension__ __PRETTY_FUNCTION__))
1699 isa<llvm::IntegerType>(SrcEltTy)) && "Unknown boolean conversion")(static_cast <bool> ((SrcEltTy->isFloatingPointTy() ||
isa<llvm::IntegerType>(SrcEltTy)) && "Unknown boolean conversion"
) ? void (0) : __assert_fail ("(SrcEltTy->isFloatingPointTy() || isa<llvm::IntegerType>(SrcEltTy)) && \"Unknown boolean conversion\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1699, __extension__ __PRETTY_FUNCTION__))
;
1700
1701 llvm::Value *Zero = llvm::Constant::getNullValue(SrcTy);
1702 if (SrcEltTy->isFloatingPointTy()) {
1703 return Builder.CreateFCmpUNE(Src, Zero, "tobool");
1704 } else {
1705 return Builder.CreateICmpNE(Src, Zero, "tobool");
1706 }
1707 }
1708
1709 // We have the arithmetic types: real int/float.
1710 Value *Res = nullptr;
1711
1712 if (isa<llvm::IntegerType>(SrcEltTy)) {
1713 bool InputSigned = SrcEltType->isSignedIntegerOrEnumerationType();
1714 if (isa<llvm::IntegerType>(DstEltTy))
1715 Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
1716 else if (InputSigned)
1717 Res = Builder.CreateSIToFP(Src, DstTy, "conv");
1718 else
1719 Res = Builder.CreateUIToFP(Src, DstTy, "conv");
1720 } else if (isa<llvm::IntegerType>(DstEltTy)) {
1721 assert(SrcEltTy->isFloatingPointTy() && "Unknown real conversion")(static_cast <bool> (SrcEltTy->isFloatingPointTy() &&
"Unknown real conversion") ? void (0) : __assert_fail ("SrcEltTy->isFloatingPointTy() && \"Unknown real conversion\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1721, __extension__ __PRETTY_FUNCTION__))
;
1722 if (DstEltType->isSignedIntegerOrEnumerationType())
1723 Res = Builder.CreateFPToSI(Src, DstTy, "conv");
1724 else
1725 Res = Builder.CreateFPToUI(Src, DstTy, "conv");
1726 } else {
1727 assert(SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy() &&(static_cast <bool> (SrcEltTy->isFloatingPointTy() &&
DstEltTy->isFloatingPointTy() && "Unknown real conversion"
) ? void (0) : __assert_fail ("SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy() && \"Unknown real conversion\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1728, __extension__ __PRETTY_FUNCTION__))
1728 "Unknown real conversion")(static_cast <bool> (SrcEltTy->isFloatingPointTy() &&
DstEltTy->isFloatingPointTy() && "Unknown real conversion"
) ? void (0) : __assert_fail ("SrcEltTy->isFloatingPointTy() && DstEltTy->isFloatingPointTy() && \"Unknown real conversion\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1728, __extension__ __PRETTY_FUNCTION__))
;
1729 if (DstEltTy->getTypeID() < SrcEltTy->getTypeID())
1730 Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
1731 else
1732 Res = Builder.CreateFPExt(Src, DstTy, "conv");
1733 }
1734
1735 return Res;
1736}
1737
1738Value *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) {
1739 if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E)) {
1740 CGF.EmitIgnoredExpr(E->getBase());
1741 return CGF.emitScalarConstant(Constant, E);
1742 } else {
1743 Expr::EvalResult Result;
1744 if (E->EvaluateAsInt(Result, CGF.getContext(), Expr::SE_AllowSideEffects)) {
1745 llvm::APSInt Value = Result.Val.getInt();
1746 CGF.EmitIgnoredExpr(E->getBase());
1747 return Builder.getInt(Value);
1748 }
1749 }
1750
1751 return EmitLoadOfLValue(E);
1752}
1753
1754Value *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
1755 TestAndClearIgnoreResultAssign();
1756
1757 // Emit subscript expressions in rvalue context's. For most cases, this just
1758 // loads the lvalue formed by the subscript expr. However, we have to be
1759 // careful, because the base of a vector subscript is occasionally an rvalue,
1760 // so we can't get it as an lvalue.
1761 if (!E->getBase()->getType()->isVectorType())
1762 return EmitLoadOfLValue(E);
1763
1764 // Handle the vector case. The base must be a vector, the index must be an
1765 // integer value.
1766 Value *Base = Visit(E->getBase());
1767 Value *Idx = Visit(E->getIdx());
1768 QualType IdxTy = E->getIdx()->getType();
1769
1770 if (CGF.SanOpts.has(SanitizerKind::ArrayBounds))
1771 CGF.EmitBoundsCheck(E, E->getBase(), Idx, IdxTy, /*Accessed*/true);
1772
1773 return Builder.CreateExtractElement(Base, Idx, "vecext");
1774}
1775
1776Value *ScalarExprEmitter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
1777 TestAndClearIgnoreResultAssign();
1778
1779 // Handle the vector case. The base must be a vector, the index must be an
1780 // integer value.
1781 Value *RowIdx = Visit(E->getRowIdx());
1782 Value *ColumnIdx = Visit(E->getColumnIdx());
1783
1784 const auto *MatrixTy = E->getBase()->getType()->castAs<ConstantMatrixType>();
1785 unsigned NumRows = MatrixTy->getNumRows();
1786 llvm::MatrixBuilder<CGBuilderTy> MB(Builder);
1787 Value *Idx = MB.CreateIndex(RowIdx, ColumnIdx, NumRows);
1788 if (CGF.CGM.getCodeGenOpts().OptimizationLevel > 0)
1789 MB.CreateIndexAssumption(Idx, MatrixTy->getNumElementsFlattened());
1790
1791 Value *Matrix = Visit(E->getBase());
1792
1793 // TODO: Should we emit bounds checks with SanitizerKind::ArrayBounds?
1794 return Builder.CreateExtractElement(Matrix, Idx, "matrixext");
1795}
1796
1797static int getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx,
1798 unsigned Off) {
1799 int MV = SVI->getMaskValue(Idx);
1800 if (MV == -1)
1801 return -1;
1802 return Off + MV;
1803}
1804
1805static int getAsInt32(llvm::ConstantInt *C, llvm::Type *I32Ty) {
1806 assert(llvm::ConstantInt::isValueValidForType(I32Ty, C->getZExtValue()) &&(static_cast <bool> (llvm::ConstantInt::isValueValidForType
(I32Ty, C->getZExtValue()) && "Index operand too large for shufflevector mask!"
) ? void (0) : __assert_fail ("llvm::ConstantInt::isValueValidForType(I32Ty, C->getZExtValue()) && \"Index operand too large for shufflevector mask!\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1807, __extension__ __PRETTY_FUNCTION__))
1807 "Index operand too large for shufflevector mask!")(static_cast <bool> (llvm::ConstantInt::isValueValidForType
(I32Ty, C->getZExtValue()) && "Index operand too large for shufflevector mask!"
) ? void (0) : __assert_fail ("llvm::ConstantInt::isValueValidForType(I32Ty, C->getZExtValue()) && \"Index operand too large for shufflevector mask!\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1807, __extension__ __PRETTY_FUNCTION__))
;
1808 return C->getZExtValue();
1809}
1810
1811Value *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) {
1812 bool Ignore = TestAndClearIgnoreResultAssign();
1813 (void)Ignore;
1814 assert (Ignore == false && "init list ignored")(static_cast <bool> (Ignore == false && "init list ignored"
) ? void (0) : __assert_fail ("Ignore == false && \"init list ignored\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 1814, __extension__ __PRETTY_FUNCTION__))
;
1815 unsigned NumInitElements = E->getNumInits();
1816
1817 if (E->hadArrayRangeDesignator())
1818 CGF.ErrorUnsupported(E, "GNU array range designator extension");
1819
1820 llvm::VectorType *VType =
1821 dyn_cast<llvm::VectorType>(ConvertType(E->getType()));
1822
1823 if (!VType) {
1824 if (NumInitElements == 0) {
1825 // C++11 value-initialization for the scalar.
1826 return EmitNullValue(E->getType());
1827 }
1828 // We have a scalar in braces. Just use the first element.
1829 return Visit(E->getInit(0));
1830 }
1831
1832 unsigned ResElts = cast<llvm::FixedVectorType>(VType)->getNumElements();
1833
1834 // Loop over initializers collecting the Value for each, and remembering
1835 // whether the source was swizzle (ExtVectorElementExpr). This will allow
1836 // us to fold the shuffle for the swizzle into the shuffle for the vector
1837 // initializer, since LLVM optimizers generally do not want to touch
1838 // shuffles.
1839 unsigned CurIdx = 0;
1840 bool VIsUndefShuffle = false;
1841 llvm::Value *V = llvm::UndefValue::get(VType);
1842 for (unsigned i = 0; i != NumInitElements; ++i) {
1843 Expr *IE = E->getInit(i);
1844 Value *Init = Visit(IE);
1845 SmallVector<int, 16> Args;
1846
1847 llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType());
1848
1849 // Handle scalar elements. If the scalar initializer is actually one
1850 // element of a different vector of the same width, use shuffle instead of
1851 // extract+insert.
1852 if (!VVT) {
1853 if (isa<ExtVectorElementExpr>(IE)) {
1854 llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init);
1855
1856 if (cast<llvm::FixedVectorType>(EI->getVectorOperandType())
1857 ->getNumElements() == ResElts) {
1858 llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand());
1859 Value *LHS = nullptr, *RHS = nullptr;
1860 if (CurIdx == 0) {
1861 // insert into undef -> shuffle (src, undef)
1862 // shufflemask must use an i32
1863 Args.push_back(getAsInt32(C, CGF.Int32Ty));
1864 Args.resize(ResElts, -1);
1865
1866 LHS = EI->getVectorOperand();
1867 RHS = V;
1868 VIsUndefShuffle = true;
1869 } else if (VIsUndefShuffle) {
1870 // insert into undefshuffle && size match -> shuffle (v, src)
1871 llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V);
1872 for (unsigned j = 0; j != CurIdx; ++j)
1873 Args.push_back(getMaskElt(SVV, j, 0));
1874 Args.push_back(ResElts + C->getZExtValue());
1875 Args.resize(ResElts, -1);
1876
1877 LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0);
1878 RHS = EI->getVectorOperand();
1879 VIsUndefShuffle = false;
1880 }
1881 if (!Args.empty()) {
1882 V = Builder.CreateShuffleVector(LHS, RHS, Args);
1883 ++CurIdx;
1884 continue;
1885 }
1886 }
1887 }
1888 V = Builder.CreateInsertElement(V, Init, Builder.getInt32(CurIdx),
1889 "vecinit");
1890 VIsUndefShuffle = false;
1891 ++CurIdx;
1892 continue;
1893 }
1894
1895 unsigned InitElts = cast<llvm::FixedVectorType>(VVT)->getNumElements();
1896
1897 // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's
1898 // input is the same width as the vector being constructed, generate an
1899 // optimized shuffle of the swizzle input into the result.
1900 unsigned Offset = (CurIdx == 0) ? 0 : ResElts;
1901 if (isa<ExtVectorElementExpr>(IE)) {
1902 llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init);
1903 Value *SVOp = SVI->getOperand(0);
1904 auto *OpTy = cast<llvm::FixedVectorType>(SVOp->getType());
1905
1906 if (OpTy->getNumElements() == ResElts) {
1907 for (unsigned j = 0; j != CurIdx; ++j) {
1908 // If the current vector initializer is a shuffle with undef, merge
1909 // this shuffle directly into it.
1910 if (VIsUndefShuffle) {
1911 Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0));
1912 } else {
1913 Args.push_back(j);
1914 }
1915 }
1916 for (unsigned j = 0, je = InitElts; j != je; ++j)
1917 Args.push_back(getMaskElt(SVI, j, Offset));
1918 Args.resize(ResElts, -1);
1919
1920 if (VIsUndefShuffle)
1921 V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0);
1922
1923 Init = SVOp;
1924 }
1925 }
1926
1927 // Extend init to result vector length, and then shuffle its contribution
1928 // to the vector initializer into V.
1929 if (Args.empty()) {
1930 for (unsigned j = 0; j != InitElts; ++j)
1931 Args.push_back(j);
1932 Args.resize(ResElts, -1);
1933 Init = Builder.CreateShuffleVector(Init, Args, "vext");
1934
1935 Args.clear();
1936 for (unsigned j = 0; j != CurIdx; ++j)
1937 Args.push_back(j);
1938 for (unsigned j = 0; j != InitElts; ++j)
1939 Args.push_back(j + Offset);
1940 Args.resize(ResElts, -1);
1941 }
1942
1943 // If V is undef, make sure it ends up on the RHS of the shuffle to aid
1944 // merging subsequent shuffles into this one.
1945 if (CurIdx == 0)
1946 std::swap(V, Init);
1947 V = Builder.CreateShuffleVector(V, Init, Args, "vecinit");
1948 VIsUndefShuffle = isa<llvm::UndefValue>(Init);
1949 CurIdx += InitElts;
1950 }
1951
1952 // FIXME: evaluate codegen vs. shuffling against constant null vector.
1953 // Emit remaining default initializers.
1954 llvm::Type *EltTy = VType->getElementType();
1955
1956 // Emit remaining default initializers
1957 for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) {
1958 Value *Idx = Builder.getInt32(CurIdx);
1959 llvm::Value *Init = llvm::Constant::getNullValue(EltTy);
1960 V = Builder.CreateInsertElement(V, Init, Idx, "vecinit");
1961 }
1962 return V;
1963}
1964
1965bool CodeGenFunction::ShouldNullCheckClassCastValue(const CastExpr *CE) {
1966 const Expr *E = CE->getSubExpr();
1967
1968 if (CE->getCastKind() == CK_UncheckedDerivedToBase)
1969 return false;
1970
1971 if (isa<CXXThisExpr>(E->IgnoreParens())) {
1972 // We always assume that 'this' is never null.
1973 return false;
1974 }
1975
1976 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) {
1977 // And that glvalue casts are never null.
1978 if (ICE->isGLValue())
1979 return false;
1980 }
1981
1982 return true;
1983}
1984
1985// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts
1986// have to handle a more broad range of conversions than explicit casts, as they
1987// handle things like function to ptr-to-function decay etc.
1988Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
1989 Expr *E = CE->getSubExpr();
1990 QualType DestTy = CE->getType();
1991 CastKind Kind = CE->getCastKind();
1992
1993 // These cases are generally not written to ignore the result of
1994 // evaluating their sub-expressions, so we clear this now.
1995 bool Ignored = TestAndClearIgnoreResultAssign();
1996
1997 // Since almost all cast kinds apply to scalars, this switch doesn't have
1998 // a default case, so the compiler will warn on a missing case. The cases
1999 // are in the same order as in the CastKind enum.
2000 switch (Kind) {
1
Control jumps to 'case CK_CPointerToObjCPointerCast:' at line 2022
2001 case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!")::llvm::llvm_unreachable_internal("dependent cast kind in IR gen!"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2001)
;
2002 case CK_BuiltinFnToFnPtr:
2003 llvm_unreachable("builtin functions are handled elsewhere")::llvm::llvm_unreachable_internal("builtin functions are handled elsewhere"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2003)
;
2004
2005 case CK_LValueBitCast:
2006 case CK_ObjCObjectLValueCast: {
2007 Address Addr = EmitLValue(E).getAddress(CGF);
2008 Addr = Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(DestTy));
2009 LValue LV = CGF.MakeAddrLValue(Addr, DestTy);
2010 return EmitLoadOfLValue(LV, CE->getExprLoc());
2011 }
2012
2013 case CK_LValueToRValueBitCast: {
2014 LValue SourceLVal = CGF.EmitLValue(E);
2015 Address Addr = Builder.CreateElementBitCast(SourceLVal.getAddress(CGF),
2016 CGF.ConvertTypeForMem(DestTy));
2017 LValue DestLV = CGF.MakeAddrLValue(Addr, DestTy);
2018 DestLV.setTBAAInfo(TBAAAccessInfo::getMayAliasInfo());
2019 return EmitLoadOfLValue(DestLV, CE->getExprLoc());
2020 }
2021
2022 case CK_CPointerToObjCPointerCast:
2023 case CK_BlockPointerToObjCPointerCast:
2024 case CK_AnyPointerToBlockPointerCast:
2025 case CK_BitCast: {
2026 Value *Src = Visit(const_cast<Expr*>(E));
2027 llvm::Type *SrcTy = Src->getType();
2028 llvm::Type *DstTy = ConvertType(DestTy);
2029 if (SrcTy->isPtrOrPtrVectorTy() && DstTy->isPtrOrPtrVectorTy() &&
2
Calling 'Type::isPtrOrPtrVectorTy'
8
Returning from 'Type::isPtrOrPtrVectorTy'
2030 SrcTy->getPointerAddressSpace() != DstTy->getPointerAddressSpace()) {
2031 llvm_unreachable("wrong cast for pointers in different address spaces"::llvm::llvm_unreachable_internal("wrong cast for pointers in different address spaces"
"(must be an address space cast)!", "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2032)
2032 "(must be an address space cast)!")::llvm::llvm_unreachable_internal("wrong cast for pointers in different address spaces"
"(must be an address space cast)!", "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2032)
;
2033 }
2034
2035 if (CGF.SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
9
Assuming the condition is false
10
Taking false branch
2036 if (auto PT = DestTy->getAs<PointerType>())
2037 CGF.EmitVTablePtrCheckForCast(PT->getPointeeType(), Src,
2038 /*MayBeNull=*/true,
2039 CodeGenFunction::CFITCK_UnrelatedCast,
2040 CE->getBeginLoc());
2041 }
2042
2043 if (CGF.CGM.getCodeGenOpts().StrictVTablePointers) {
11
Assuming field 'StrictVTablePointers' is 0
12
Taking false branch
2044 const QualType SrcType = E->getType();
2045
2046 if (SrcType.mayBeNotDynamicClass() && DestTy.mayBeDynamicClass()) {
2047 // Casting to pointer that could carry dynamic information (provided by
2048 // invariant.group) requires launder.
2049 Src = Builder.CreateLaunderInvariantGroup(Src);
2050 } else if (SrcType.mayBeDynamicClass() && DestTy.mayBeNotDynamicClass()) {
2051 // Casting to pointer that does not carry dynamic information (provided
2052 // by invariant.group) requires stripping it. Note that we don't do it
2053 // if the source could not be dynamic type and destination could be
2054 // dynamic because dynamic information is already laundered. It is
2055 // because launder(strip(src)) == launder(src), so there is no need to
2056 // add extra strip before launder.
2057 Src = Builder.CreateStripInvariantGroup(Src);
2058 }
2059 }
2060
2061 // Update heapallocsite metadata when there is an explicit pointer cast.
2062 if (auto *CI
13.1
'CI' is null
13.1
'CI' is null
= dyn_cast<llvm::CallBase>(Src)) {
13
Assuming 'Src' is not a 'CallBase'
14
Taking false branch
2063 if (CI->getMetadata("heapallocsite") && isa<ExplicitCastExpr>(CE)) {
2064 QualType PointeeType = DestTy->getPointeeType();
2065 if (!PointeeType.isNull())
2066 CGF.getDebugInfo()->addHeapAllocSiteMetadata(CI, PointeeType,
2067 CE->getExprLoc());
2068 }
2069 }
2070
2071 // If Src is a fixed vector and Dst is a scalable vector, and both have the
2072 // same element type, use the llvm.experimental.vector.insert intrinsic to
2073 // perform the bitcast.
2074 if (const auto *FixedSrc
15.1
'FixedSrc' is non-null
15.1
'FixedSrc' is non-null
= dyn_cast<llvm::FixedVectorType>(SrcTy)) {
15
Assuming 'SrcTy' is a 'FixedVectorType'
16
Taking true branch
2075 if (const auto *ScalableDst
17.1
'ScalableDst' is non-null
17.1
'ScalableDst' is non-null
= dyn_cast<llvm::ScalableVectorType>(DstTy)) {
17
Assuming 'DstTy' is a 'ScalableVectorType'
18
Taking true branch
2076 // If we are casting a fixed i8 vector to a scalable 16 x i1 predicate
2077 // vector, use a vector insert and bitcast the result.
2078 bool NeedsBitCast = false;
2079 auto PredType = llvm::ScalableVectorType::get(Builder.getInt1Ty(), 16);
2080 llvm::Type *OrigType = DstTy;
2081 if (ScalableDst == PredType &&
19
Assuming 'ScalableDst' is equal to 'PredType'
21
Taking true branch
2082 FixedSrc->getElementType() == Builder.getInt8Ty()) {
20
Assuming the condition is true
2083 DstTy = llvm::ScalableVectorType::get(Builder.getInt8Ty(), 2);
2084 ScalableDst = dyn_cast<llvm::ScalableVectorType>(DstTy);
22
Assuming 'DstTy' is not a 'ScalableVectorType'
23
Null pointer value stored to 'ScalableDst'
2085 NeedsBitCast = true;
2086 }
2087 if (FixedSrc->getElementType() == ScalableDst->getElementType()) {
24
Called C++ object pointer is null
2088 llvm::Value *UndefVec = llvm::UndefValue::get(DstTy);
2089 llvm::Value *Zero = llvm::Constant::getNullValue(CGF.CGM.Int64Ty);
2090 llvm::Value *Result = Builder.CreateInsertVector(
2091 DstTy, UndefVec, Src, Zero, "castScalableSve");
2092 if (NeedsBitCast)
2093 Result = Builder.CreateBitCast(Result, OrigType);
2094 return Result;
2095 }
2096 }
2097 }
2098
2099 // If Src is a scalable vector and Dst is a fixed vector, and both have the
2100 // same element type, use the llvm.experimental.vector.extract intrinsic to
2101 // perform the bitcast.
2102 if (const auto *ScalableSrc = dyn_cast<llvm::ScalableVectorType>(SrcTy)) {
2103 if (const auto *FixedDst = dyn_cast<llvm::FixedVectorType>(DstTy)) {
2104 // If we are casting a scalable 16 x i1 predicate vector to a fixed i8
2105 // vector, bitcast the source and use a vector extract.
2106 auto PredType = llvm::ScalableVectorType::get(Builder.getInt1Ty(), 16);
2107 if (ScalableSrc == PredType &&
2108 FixedDst->getElementType() == Builder.getInt8Ty()) {
2109 SrcTy = llvm::ScalableVectorType::get(Builder.getInt8Ty(), 2);
2110 ScalableSrc = dyn_cast<llvm::ScalableVectorType>(SrcTy);
2111 Src = Builder.CreateBitCast(Src, SrcTy);
2112 }
2113 if (ScalableSrc->getElementType() == FixedDst->getElementType()) {
2114 llvm::Value *Zero = llvm::Constant::getNullValue(CGF.CGM.Int64Ty);
2115 return Builder.CreateExtractVector(DstTy, Src, Zero, "castFixedSve");
2116 }
2117 }
2118 }
2119
2120 // Perform VLAT <-> VLST bitcast through memory.
2121 // TODO: since the llvm.experimental.vector.{insert,extract} intrinsics
2122 // require the element types of the vectors to be the same, we
2123 // need to keep this around for bitcasts between VLAT <-> VLST where
2124 // the element types of the vectors are not the same, until we figure
2125 // out a better way of doing these casts.
2126 if ((isa<llvm::FixedVectorType>(SrcTy) &&
2127 isa<llvm::ScalableVectorType>(DstTy)) ||
2128 (isa<llvm::ScalableVectorType>(SrcTy) &&
2129 isa<llvm::FixedVectorType>(DstTy))) {
2130 Address Addr = CGF.CreateDefaultAlignTempAlloca(SrcTy, "saved-value");
2131 LValue LV = CGF.MakeAddrLValue(Addr, E->getType());
2132 CGF.EmitStoreOfScalar(Src, LV);
2133 Addr = Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(DestTy),
2134 "castFixedSve");
2135 LValue DestLV = CGF.MakeAddrLValue(Addr, DestTy);
2136 DestLV.setTBAAInfo(TBAAAccessInfo::getMayAliasInfo());
2137 return EmitLoadOfLValue(DestLV, CE->getExprLoc());
2138 }
2139
2140 return Builder.CreateBitCast(Src, DstTy);
2141 }
2142 case CK_AddressSpaceConversion: {
2143 Expr::EvalResult Result;
2144 if (E->EvaluateAsRValue(Result, CGF.getContext()) &&
2145 Result.Val.isNullPointer()) {
2146 // If E has side effect, it is emitted even if its final result is a
2147 // null pointer. In that case, a DCE pass should be able to
2148 // eliminate the useless instructions emitted during translating E.
2149 if (Result.HasSideEffects)
2150 Visit(E);
2151 return CGF.CGM.getNullPointer(cast<llvm::PointerType>(
2152 ConvertType(DestTy)), DestTy);
2153 }
2154 // Since target may map different address spaces in AST to the same address
2155 // space, an address space conversion may end up as a bitcast.
2156 return CGF.CGM.getTargetCodeGenInfo().performAddrSpaceCast(
2157 CGF, Visit(E), E->getType()->getPointeeType().getAddressSpace(),
2158 DestTy->getPointeeType().getAddressSpace(), ConvertType(DestTy));
2159 }
2160 case CK_AtomicToNonAtomic:
2161 case CK_NonAtomicToAtomic:
2162 case CK_UserDefinedConversion:
2163 return Visit(const_cast<Expr*>(E));
2164
2165 case CK_NoOp: {
2166 llvm::Value *V = Visit(const_cast<Expr *>(E));
2167 if (V) {
2168 // CK_NoOp can model a pointer qualification conversion, which can remove
2169 // an array bound and change the IR type.
2170 // FIXME: Once pointee types are removed from IR, remove this.
2171 llvm::Type *T = ConvertType(DestTy);
2172 if (T != V->getType())
2173 V = Builder.CreateBitCast(V, T);
2174 }
2175 return V;
2176 }
2177
2178 case CK_BaseToDerived: {
2179 const CXXRecordDecl *DerivedClassDecl = DestTy->getPointeeCXXRecordDecl();
2180 assert(DerivedClassDecl && "BaseToDerived arg isn't a C++ object pointer!")(static_cast <bool> (DerivedClassDecl && "BaseToDerived arg isn't a C++ object pointer!"
) ? void (0) : __assert_fail ("DerivedClassDecl && \"BaseToDerived arg isn't a C++ object pointer!\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2180, __extension__ __PRETTY_FUNCTION__))
;
2181
2182 Address Base = CGF.EmitPointerWithAlignment(E);
2183 Address Derived =
2184 CGF.GetAddressOfDerivedClass(Base, DerivedClassDecl,
2185 CE->path_begin(), CE->path_end(),
2186 CGF.ShouldNullCheckClassCastValue(CE));
2187
2188 // C++11 [expr.static.cast]p11: Behavior is undefined if a downcast is
2189 // performed and the object is not of the derived type.
2190 if (CGF.sanitizePerformTypeCheck())
2191 CGF.EmitTypeCheck(CodeGenFunction::TCK_DowncastPointer, CE->getExprLoc(),
2192 Derived.getPointer(), DestTy->getPointeeType());
2193
2194 if (CGF.SanOpts.has(SanitizerKind::CFIDerivedCast))
2195 CGF.EmitVTablePtrCheckForCast(
2196 DestTy->getPointeeType(), Derived.getPointer(),
2197 /*MayBeNull=*/true, CodeGenFunction::CFITCK_DerivedCast,
2198 CE->getBeginLoc());
2199
2200 return Derived.getPointer();
2201 }
2202 case CK_UncheckedDerivedToBase:
2203 case CK_DerivedToBase: {
2204 // The EmitPointerWithAlignment path does this fine; just discard
2205 // the alignment.
2206 return CGF.EmitPointerWithAlignment(CE).getPointer();
2207 }
2208
2209 case CK_Dynamic: {
2210 Address V = CGF.EmitPointerWithAlignment(E);
2211 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE);
2212 return CGF.EmitDynamicCast(V, DCE);
2213 }
2214
2215 case CK_ArrayToPointerDecay:
2216 return CGF.EmitArrayToPointerDecay(E).getPointer();
2217 case CK_FunctionToPointerDecay:
2218 return EmitLValue(E).getPointer(CGF);
2219
2220 case CK_NullToPointer:
2221 if (MustVisitNullValue(E))
2222 CGF.EmitIgnoredExpr(E);
2223
2224 return CGF.CGM.getNullPointer(cast<llvm::PointerType>(ConvertType(DestTy)),
2225 DestTy);
2226
2227 case CK_NullToMemberPointer: {
2228 if (MustVisitNullValue(E))
2229 CGF.EmitIgnoredExpr(E);
2230
2231 const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>();
2232 return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT);
2233 }
2234
2235 case CK_ReinterpretMemberPointer:
2236 case CK_BaseToDerivedMemberPointer:
2237 case CK_DerivedToBaseMemberPointer: {
2238 Value *Src = Visit(E);
2239
2240 // Note that the AST doesn't distinguish between checked and
2241 // unchecked member pointer conversions, so we always have to
2242 // implement checked conversions here. This is inefficient when
2243 // actual control flow may be required in order to perform the
2244 // check, which it is for data member pointers (but not member
2245 // function pointers on Itanium and ARM).
2246 return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src);
2247 }
2248
2249 case CK_ARCProduceObject:
2250 return CGF.EmitARCRetainScalarExpr(E);
2251 case CK_ARCConsumeObject:
2252 return CGF.EmitObjCConsumeObject(E->getType(), Visit(E));
2253 case CK_ARCReclaimReturnedObject:
2254 return CGF.EmitARCReclaimReturnedObject(E, /*allowUnsafe*/ Ignored);
2255 case CK_ARCExtendBlockObject:
2256 return CGF.EmitARCExtendBlockObject(E);
2257
2258 case CK_CopyAndAutoreleaseBlockObject:
2259 return CGF.EmitBlockCopyAndAutorelease(Visit(E), E->getType());
2260
2261 case CK_FloatingRealToComplex:
2262 case CK_FloatingComplexCast:
2263 case CK_IntegralRealToComplex:
2264 case CK_IntegralComplexCast:
2265 case CK_IntegralComplexToFloatingComplex:
2266 case CK_FloatingComplexToIntegralComplex:
2267 case CK_ConstructorConversion:
2268 case CK_ToUnion:
2269 llvm_unreachable("scalar cast to non-scalar value")::llvm::llvm_unreachable_internal("scalar cast to non-scalar value"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2269)
;
2270
2271 case CK_LValueToRValue:
2272 assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy))(static_cast <bool> (CGF.getContext().hasSameUnqualifiedType
(E->getType(), DestTy)) ? void (0) : __assert_fail ("CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy)"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2272, __extension__ __PRETTY_FUNCTION__))
;
2273 assert(E->isGLValue() && "lvalue-to-rvalue applied to r-value!")(static_cast <bool> (E->isGLValue() && "lvalue-to-rvalue applied to r-value!"
) ? void (0) : __assert_fail ("E->isGLValue() && \"lvalue-to-rvalue applied to r-value!\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2273, __extension__ __PRETTY_FUNCTION__))
;
2274 return Visit(const_cast<Expr*>(E));
2275
2276 case CK_IntegralToPointer: {
2277 Value *Src = Visit(const_cast<Expr*>(E));
2278
2279 // First, convert to the correct width so that we control the kind of
2280 // extension.
2281 auto DestLLVMTy = ConvertType(DestTy);
2282 llvm::Type *MiddleTy = CGF.CGM.getDataLayout().getIntPtrType(DestLLVMTy);
2283 bool InputSigned = E->getType()->isSignedIntegerOrEnumerationType();
2284 llvm::Value* IntResult =
2285 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
2286
2287 auto *IntToPtr = Builder.CreateIntToPtr(IntResult, DestLLVMTy);
2288
2289 if (CGF.CGM.getCodeGenOpts().StrictVTablePointers) {
2290 // Going from integer to pointer that could be dynamic requires reloading
2291 // dynamic information from invariant.group.
2292 if (DestTy.mayBeDynamicClass())
2293 IntToPtr = Builder.CreateLaunderInvariantGroup(IntToPtr);
2294 }
2295 return IntToPtr;
2296 }
2297 case CK_PointerToIntegral: {
2298 assert(!DestTy->isBooleanType() && "bool should use PointerToBool")(static_cast <bool> (!DestTy->isBooleanType() &&
"bool should use PointerToBool") ? void (0) : __assert_fail (
"!DestTy->isBooleanType() && \"bool should use PointerToBool\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2298, __extension__ __PRETTY_FUNCTION__))
;
2299 auto *PtrExpr = Visit(E);
2300
2301 if (CGF.CGM.getCodeGenOpts().StrictVTablePointers) {
2302 const QualType SrcType = E->getType();
2303
2304 // Casting to integer requires stripping dynamic information as it does
2305 // not carries it.
2306 if (SrcType.mayBeDynamicClass())
2307 PtrExpr = Builder.CreateStripInvariantGroup(PtrExpr);
2308 }
2309
2310 return Builder.CreatePtrToInt(PtrExpr, ConvertType(DestTy));
2311 }
2312 case CK_ToVoid: {
2313 CGF.EmitIgnoredExpr(E);
2314 return nullptr;
2315 }
2316 case CK_MatrixCast: {
2317 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2318 CE->getExprLoc());
2319 }
2320 case CK_VectorSplat: {
2321 llvm::Type *DstTy = ConvertType(DestTy);
2322 Value *Elt = Visit(const_cast<Expr*>(E));
2323 // Splat the element across to all elements
2324 unsigned NumElements = cast<llvm::FixedVectorType>(DstTy)->getNumElements();
2325 return Builder.CreateVectorSplat(NumElements, Elt, "splat");
2326 }
2327
2328 case CK_FixedPointCast:
2329 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2330 CE->getExprLoc());
2331
2332 case CK_FixedPointToBoolean:
2333 assert(E->getType()->isFixedPointType() &&(static_cast <bool> (E->getType()->isFixedPointType
() && "Expected src type to be fixed point type") ? void
(0) : __assert_fail ("E->getType()->isFixedPointType() && \"Expected src type to be fixed point type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2334, __extension__ __PRETTY_FUNCTION__))
2334 "Expected src type to be fixed point type")(static_cast <bool> (E->getType()->isFixedPointType
() && "Expected src type to be fixed point type") ? void
(0) : __assert_fail ("E->getType()->isFixedPointType() && \"Expected src type to be fixed point type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2334, __extension__ __PRETTY_FUNCTION__))
;
2335 assert(DestTy->isBooleanType() && "Expected dest type to be boolean type")(static_cast <bool> (DestTy->isBooleanType() &&
"Expected dest type to be boolean type") ? void (0) : __assert_fail
("DestTy->isBooleanType() && \"Expected dest type to be boolean type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2335, __extension__ __PRETTY_FUNCTION__))
;
2336 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2337 CE->getExprLoc());
2338
2339 case CK_FixedPointToIntegral:
2340 assert(E->getType()->isFixedPointType() &&(static_cast <bool> (E->getType()->isFixedPointType
() && "Expected src type to be fixed point type") ? void
(0) : __assert_fail ("E->getType()->isFixedPointType() && \"Expected src type to be fixed point type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2341, __extension__ __PRETTY_FUNCTION__))
2341 "Expected src type to be fixed point type")(static_cast <bool> (E->getType()->isFixedPointType
() && "Expected src type to be fixed point type") ? void
(0) : __assert_fail ("E->getType()->isFixedPointType() && \"Expected src type to be fixed point type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2341, __extension__ __PRETTY_FUNCTION__))
;
2342 assert(DestTy->isIntegerType() && "Expected dest type to be an integer")(static_cast <bool> (DestTy->isIntegerType() &&
"Expected dest type to be an integer") ? void (0) : __assert_fail
("DestTy->isIntegerType() && \"Expected dest type to be an integer\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2342, __extension__ __PRETTY_FUNCTION__))
;
2343 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2344 CE->getExprLoc());
2345
2346 case CK_IntegralToFixedPoint:
2347 assert(E->getType()->isIntegerType() &&(static_cast <bool> (E->getType()->isIntegerType(
) && "Expected src type to be an integer") ? void (0)
: __assert_fail ("E->getType()->isIntegerType() && \"Expected src type to be an integer\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2348, __extension__ __PRETTY_FUNCTION__))
2348 "Expected src type to be an integer")(static_cast <bool> (E->getType()->isIntegerType(
) && "Expected src type to be an integer") ? void (0)
: __assert_fail ("E->getType()->isIntegerType() && \"Expected src type to be an integer\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2348, __extension__ __PRETTY_FUNCTION__))
;
2349 assert(DestTy->isFixedPointType() &&(static_cast <bool> (DestTy->isFixedPointType() &&
"Expected dest type to be fixed point type") ? void (0) : __assert_fail
("DestTy->isFixedPointType() && \"Expected dest type to be fixed point type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2350, __extension__ __PRETTY_FUNCTION__))
2350 "Expected dest type to be fixed point type")(static_cast <bool> (DestTy->isFixedPointType() &&
"Expected dest type to be fixed point type") ? void (0) : __assert_fail
("DestTy->isFixedPointType() && \"Expected dest type to be fixed point type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2350, __extension__ __PRETTY_FUNCTION__))
;
2351 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2352 CE->getExprLoc());
2353
2354 case CK_IntegralCast: {
2355 ScalarConversionOpts Opts;
2356 if (auto *ICE = dyn_cast<ImplicitCastExpr>(CE)) {
2357 if (!ICE->isPartOfExplicitCast())
2358 Opts = ScalarConversionOpts(CGF.SanOpts);
2359 }
2360 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2361 CE->getExprLoc(), Opts);
2362 }
2363 case CK_IntegralToFloating:
2364 case CK_FloatingToIntegral:
2365 case CK_FloatingCast:
2366 case CK_FixedPointToFloating:
2367 case CK_FloatingToFixedPoint: {
2368 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, CE);
2369 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2370 CE->getExprLoc());
2371 }
2372 case CK_BooleanToSignedIntegral: {
2373 ScalarConversionOpts Opts;
2374 Opts.TreatBooleanAsSigned = true;
2375 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2376 CE->getExprLoc(), Opts);
2377 }
2378 case CK_IntegralToBoolean:
2379 return EmitIntToBoolConversion(Visit(E));
2380 case CK_PointerToBoolean:
2381 return EmitPointerToBoolConversion(Visit(E), E->getType());
2382 case CK_FloatingToBoolean: {
2383 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, CE);
2384 return EmitFloatToBoolConversion(Visit(E));
2385 }
2386 case CK_MemberPointerToBoolean: {
2387 llvm::Value *MemPtr = Visit(E);
2388 const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>();
2389 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT);
2390 }
2391
2392 case CK_FloatingComplexToReal:
2393 case CK_IntegralComplexToReal:
2394 return CGF.EmitComplexExpr(E, false, true).first;
2395
2396 case CK_FloatingComplexToBoolean:
2397 case CK_IntegralComplexToBoolean: {
2398 CodeGenFunction::ComplexPairTy V = CGF.EmitComplexExpr(E);
2399
2400 // TODO: kill this function off, inline appropriate case here
2401 return EmitComplexToScalarConversion(V, E->getType(), DestTy,
2402 CE->getExprLoc());
2403 }
2404
2405 case CK_ZeroToOCLOpaqueType: {
2406 assert((DestTy->isEventT() || DestTy->isQueueT() ||(static_cast <bool> ((DestTy->isEventT() || DestTy->
isQueueT() || DestTy->isOCLIntelSubgroupAVCType()) &&
"CK_ZeroToOCLEvent cast on non-event type") ? void (0) : __assert_fail
("(DestTy->isEventT() || DestTy->isQueueT() || DestTy->isOCLIntelSubgroupAVCType()) && \"CK_ZeroToOCLEvent cast on non-event type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2408, __extension__ __PRETTY_FUNCTION__))
2407 DestTy->isOCLIntelSubgroupAVCType()) &&(static_cast <bool> ((DestTy->isEventT() || DestTy->
isQueueT() || DestTy->isOCLIntelSubgroupAVCType()) &&
"CK_ZeroToOCLEvent cast on non-event type") ? void (0) : __assert_fail
("(DestTy->isEventT() || DestTy->isQueueT() || DestTy->isOCLIntelSubgroupAVCType()) && \"CK_ZeroToOCLEvent cast on non-event type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2408, __extension__ __PRETTY_FUNCTION__))
2408 "CK_ZeroToOCLEvent cast on non-event type")(static_cast <bool> ((DestTy->isEventT() || DestTy->
isQueueT() || DestTy->isOCLIntelSubgroupAVCType()) &&
"CK_ZeroToOCLEvent cast on non-event type") ? void (0) : __assert_fail
("(DestTy->isEventT() || DestTy->isQueueT() || DestTy->isOCLIntelSubgroupAVCType()) && \"CK_ZeroToOCLEvent cast on non-event type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2408, __extension__ __PRETTY_FUNCTION__))
;
2409 return llvm::Constant::getNullValue(ConvertType(DestTy));
2410 }
2411
2412 case CK_IntToOCLSampler:
2413 return CGF.CGM.createOpenCLIntToSamplerConversion(E, CGF);
2414
2415 } // end of switch
2416
2417 llvm_unreachable("unknown scalar cast")::llvm::llvm_unreachable_internal("unknown scalar cast", "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2417)
;
2418}
2419
2420Value *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) {
2421 CodeGenFunction::StmtExprEvaluation eval(CGF);
2422 Address RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(),
2423 !E->getType()->isVoidType());
2424 if (!RetAlloca.isValid())
2425 return nullptr;
2426 return CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(RetAlloca, E->getType()),
2427 E->getExprLoc());
2428}
2429
2430Value *ScalarExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
2431 CodeGenFunction::RunCleanupsScope Scope(CGF);
2432 Value *V = Visit(E->getSubExpr());
2433 // Defend against dominance problems caused by jumps out of expression
2434 // evaluation through the shared cleanup block.
2435 Scope.ForceCleanup({&V});
2436 return V;
2437}
2438
2439//===----------------------------------------------------------------------===//
2440// Unary Operators
2441//===----------------------------------------------------------------------===//
2442
2443static BinOpInfo createBinOpInfoFromIncDec(const UnaryOperator *E,
2444 llvm::Value *InVal, bool IsInc,
2445 FPOptions FPFeatures) {
2446 BinOpInfo BinOp;
2447 BinOp.LHS = InVal;
2448 BinOp.RHS = llvm::ConstantInt::get(InVal->getType(), 1, false);
2449 BinOp.Ty = E->getType();
2450 BinOp.Opcode = IsInc ? BO_Add : BO_Sub;
2451 BinOp.FPFeatures = FPFeatures;
2452 BinOp.E = E;
2453 return BinOp;
2454}
2455
2456llvm::Value *ScalarExprEmitter::EmitIncDecConsiderOverflowBehavior(
2457 const UnaryOperator *E, llvm::Value *InVal, bool IsInc) {
2458 llvm::Value *Amount =
2459 llvm::ConstantInt::get(InVal->getType(), IsInc ? 1 : -1, true);
2460 StringRef Name = IsInc ? "inc" : "dec";
2461 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
2462 case LangOptions::SOB_Defined:
2463 return Builder.CreateAdd(InVal, Amount, Name);
2464 case LangOptions::SOB_Undefined:
2465 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
2466 return Builder.CreateNSWAdd(InVal, Amount, Name);
2467 LLVM_FALLTHROUGH[[gnu::fallthrough]];
2468 case LangOptions::SOB_Trapping:
2469 if (!E->canOverflow())
2470 return Builder.CreateNSWAdd(InVal, Amount, Name);
2471 return EmitOverflowCheckedBinOp(createBinOpInfoFromIncDec(
2472 E, InVal, IsInc, E->getFPFeaturesInEffect(CGF.getLangOpts())));
2473 }
2474 llvm_unreachable("Unknown SignedOverflowBehaviorTy")::llvm::llvm_unreachable_internal("Unknown SignedOverflowBehaviorTy"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2474)
;
2475}
2476
2477namespace {
2478/// Handles check and update for lastprivate conditional variables.
2479class OMPLastprivateConditionalUpdateRAII {
2480private:
2481 CodeGenFunction &CGF;
2482 const UnaryOperator *E;
2483
2484public:
2485 OMPLastprivateConditionalUpdateRAII(CodeGenFunction &CGF,
2486 const UnaryOperator *E)
2487 : CGF(CGF), E(E) {}
2488 ~OMPLastprivateConditionalUpdateRAII() {
2489 if (CGF.getLangOpts().OpenMP)
2490 CGF.CGM.getOpenMPRuntime().checkAndEmitLastprivateConditional(
2491 CGF, E->getSubExpr());
2492 }
2493};
2494} // namespace
2495
2496llvm::Value *
2497ScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
2498 bool isInc, bool isPre) {
2499 OMPLastprivateConditionalUpdateRAII OMPRegion(CGF, E);
2500 QualType type = E->getSubExpr()->getType();
2501 llvm::PHINode *atomicPHI = nullptr;
2502 llvm::Value *value;
2503 llvm::Value *input;
2504
2505 int amount = (isInc ? 1 : -1);
2506 bool isSubtraction = !isInc;
2507
2508 if (const AtomicType *atomicTy = type->getAs<AtomicType>()) {
2509 type = atomicTy->getValueType();
2510 if (isInc && type->isBooleanType()) {
2511 llvm::Value *True = CGF.EmitToMemory(Builder.getTrue(), type);
2512 if (isPre) {
2513 Builder.CreateStore(True, LV.getAddress(CGF), LV.isVolatileQualified())
2514 ->setAtomic(llvm::AtomicOrdering::SequentiallyConsistent);
2515 return Builder.getTrue();
2516 }
2517 // For atomic bool increment, we just store true and return it for
2518 // preincrement, do an atomic swap with true for postincrement
2519 return Builder.CreateAtomicRMW(
2520 llvm::AtomicRMWInst::Xchg, LV.getPointer(CGF), True,
2521 llvm::AtomicOrdering::SequentiallyConsistent);
2522 }
2523 // Special case for atomic increment / decrement on integers, emit
2524 // atomicrmw instructions. We skip this if we want to be doing overflow
2525 // checking, and fall into the slow path with the atomic cmpxchg loop.
2526 if (!type->isBooleanType() && type->isIntegerType() &&
2527 !(type->isUnsignedIntegerType() &&
2528 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) &&
2529 CGF.getLangOpts().getSignedOverflowBehavior() !=
2530 LangOptions::SOB_Trapping) {
2531 llvm::AtomicRMWInst::BinOp aop = isInc ? llvm::AtomicRMWInst::Add :
2532 llvm::AtomicRMWInst::Sub;
2533 llvm::Instruction::BinaryOps op = isInc ? llvm::Instruction::Add :
2534 llvm::Instruction::Sub;
2535 llvm::Value *amt = CGF.EmitToMemory(
2536 llvm::ConstantInt::get(ConvertType(type), 1, true), type);
2537 llvm::Value *old =
2538 Builder.CreateAtomicRMW(aop, LV.getPointer(CGF), amt,
2539 llvm::AtomicOrdering::SequentiallyConsistent);
2540 return isPre ? Builder.CreateBinOp(op, old, amt) : old;
2541 }
2542 value = EmitLoadOfLValue(LV, E->getExprLoc());
2543 input = value;
2544 // For every other atomic operation, we need to emit a load-op-cmpxchg loop
2545 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
2546 llvm::BasicBlock *opBB = CGF.createBasicBlock("atomic_op", CGF.CurFn);
2547 value = CGF.EmitToMemory(value, type);
2548 Builder.CreateBr(opBB);
2549 Builder.SetInsertPoint(opBB);
2550 atomicPHI = Builder.CreatePHI(value->getType(), 2);
2551 atomicPHI->addIncoming(value, startBB);
2552 value = atomicPHI;
2553 } else {
2554 value = EmitLoadOfLValue(LV, E->getExprLoc());
2555 input = value;
2556 }
2557
2558 // Special case of integer increment that we have to check first: bool++.
2559 // Due to promotion rules, we get:
2560 // bool++ -> bool = bool + 1
2561 // -> bool = (int)bool + 1
2562 // -> bool = ((int)bool + 1 != 0)
2563 // An interesting aspect of this is that increment is always true.
2564 // Decrement does not have this property.
2565 if (isInc && type->isBooleanType()) {
2566 value = Builder.getTrue();
2567
2568 // Most common case by far: integer increment.
2569 } else if (type->isIntegerType()) {
2570 QualType promotedType;
2571 bool canPerformLossyDemotionCheck = false;
2572 if (type->isPromotableIntegerType()) {
2573 promotedType = CGF.getContext().getPromotedIntegerType(type);
2574 assert(promotedType != type && "Shouldn't promote to the same type.")(static_cast <bool> (promotedType != type && "Shouldn't promote to the same type."
) ? void (0) : __assert_fail ("promotedType != type && \"Shouldn't promote to the same type.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2574, __extension__ __PRETTY_FUNCTION__))
;
2575 canPerformLossyDemotionCheck = true;
2576 canPerformLossyDemotionCheck &=
2577 CGF.getContext().getCanonicalType(type) !=
2578 CGF.getContext().getCanonicalType(promotedType);
2579 canPerformLossyDemotionCheck &=
2580 PromotionIsPotentiallyEligibleForImplicitIntegerConversionCheck(
2581 type, promotedType);
2582 assert((!canPerformLossyDemotionCheck ||(static_cast <bool> ((!canPerformLossyDemotionCheck || type
->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType
() || ConvertType(type)->getScalarSizeInBits() == ConvertType
(promotedType)->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
"underlying canonical type, at least one of the types (either "
"base or promoted) will be signed, or the bitwidths will match."
) ? void (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2589, __extension__ __PRETTY_FUNCTION__))
2583 type->isSignedIntegerOrEnumerationType() ||(static_cast <bool> ((!canPerformLossyDemotionCheck || type
->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType
() || ConvertType(type)->getScalarSizeInBits() == ConvertType
(promotedType)->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
"underlying canonical type, at least one of the types (either "
"base or promoted) will be signed, or the bitwidths will match."
) ? void (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2589, __extension__ __PRETTY_FUNCTION__))
2584 promotedType->isSignedIntegerOrEnumerationType() ||(static_cast <bool> ((!canPerformLossyDemotionCheck || type
->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType
() || ConvertType(type)->getScalarSizeInBits() == ConvertType
(promotedType)->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
"underlying canonical type, at least one of the types (either "
"base or promoted) will be signed, or the bitwidths will match."
) ? void (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2589, __extension__ __PRETTY_FUNCTION__))
2585 ConvertType(type)->getScalarSizeInBits() ==(static_cast <bool> ((!canPerformLossyDemotionCheck || type
->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType
() || ConvertType(type)->getScalarSizeInBits() == ConvertType
(promotedType)->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
"underlying canonical type, at least one of the types (either "
"base or promoted) will be signed, or the bitwidths will match."
) ? void (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2589, __extension__ __PRETTY_FUNCTION__))
2586 ConvertType(promotedType)->getScalarSizeInBits()) &&(static_cast <bool> ((!canPerformLossyDemotionCheck || type
->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType
() || ConvertType(type)->getScalarSizeInBits() == ConvertType
(promotedType)->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
"underlying canonical type, at least one of the types (either "
"base or promoted) will be signed, or the bitwidths will match."
) ? void (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2589, __extension__ __PRETTY_FUNCTION__))
2587 "The following check expects that if we do promotion to different "(static_cast <bool> ((!canPerformLossyDemotionCheck || type
->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType
() || ConvertType(type)->getScalarSizeInBits() == ConvertType
(promotedType)->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
"underlying canonical type, at least one of the types (either "
"base or promoted) will be signed, or the bitwidths will match."
) ? void (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2589, __extension__ __PRETTY_FUNCTION__))
2588 "underlying canonical type, at least one of the types (either "(static_cast <bool> ((!canPerformLossyDemotionCheck || type
->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType
() || ConvertType(type)->getScalarSizeInBits() == ConvertType
(promotedType)->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
"underlying canonical type, at least one of the types (either "
"base or promoted) will be signed, or the bitwidths will match."
) ? void (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2589, __extension__ __PRETTY_FUNCTION__))
2589 "base or promoted) will be signed, or the bitwidths will match.")(static_cast <bool> ((!canPerformLossyDemotionCheck || type
->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType
() || ConvertType(type)->getScalarSizeInBits() == ConvertType
(promotedType)->getScalarSizeInBits()) && "The following check expects that if we do promotion to different "
"underlying canonical type, at least one of the types (either "
"base or promoted) will be signed, or the bitwidths will match."
) ? void (0) : __assert_fail ("(!canPerformLossyDemotionCheck || type->isSignedIntegerOrEnumerationType() || promotedType->isSignedIntegerOrEnumerationType() || ConvertType(type)->getScalarSizeInBits() == ConvertType(promotedType)->getScalarSizeInBits()) && \"The following check expects that if we do promotion to different \" \"underlying canonical type, at least one of the types (either \" \"base or promoted) will be signed, or the bitwidths will match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2589, __extension__ __PRETTY_FUNCTION__))
;
2590 }
2591 if (CGF.SanOpts.hasOneOf(
2592 SanitizerKind::ImplicitIntegerArithmeticValueChange) &&
2593 canPerformLossyDemotionCheck) {
2594 // While `x += 1` (for `x` with width less than int) is modeled as
2595 // promotion+arithmetics+demotion, and we can catch lossy demotion with
2596 // ease; inc/dec with width less than int can't overflow because of
2597 // promotion rules, so we omit promotion+demotion, which means that we can
2598 // not catch lossy "demotion". Because we still want to catch these cases
2599 // when the sanitizer is enabled, we perform the promotion, then perform
2600 // the increment/decrement in the wider type, and finally
2601 // perform the demotion. This will catch lossy demotions.
2602
2603 value = EmitScalarConversion(value, type, promotedType, E->getExprLoc());
2604 Value *amt = llvm::ConstantInt::get(value->getType(), amount, true);
2605 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
2606 // Do pass non-default ScalarConversionOpts so that sanitizer check is
2607 // emitted.
2608 value = EmitScalarConversion(value, promotedType, type, E->getExprLoc(),
2609 ScalarConversionOpts(CGF.SanOpts));
2610
2611 // Note that signed integer inc/dec with width less than int can't
2612 // overflow because of promotion rules; we're just eliding a few steps
2613 // here.
2614 } else if (E->canOverflow() && type->isSignedIntegerOrEnumerationType()) {
2615 value = EmitIncDecConsiderOverflowBehavior(E, value, isInc);
2616 } else if (E->canOverflow() && type->isUnsignedIntegerType() &&
2617 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) {
2618 value = EmitOverflowCheckedBinOp(createBinOpInfoFromIncDec(
2619 E, value, isInc, E->getFPFeaturesInEffect(CGF.getLangOpts())));
2620 } else {
2621 llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount, true);
2622 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
2623 }
2624
2625 // Next most common: pointer increment.
2626 } else if (const PointerType *ptr = type->getAs<PointerType>()) {
2627 QualType type = ptr->getPointeeType();
2628
2629 // VLA types don't have constant size.
2630 if (const VariableArrayType *vla
2631 = CGF.getContext().getAsVariableArrayType(type)) {
2632 llvm::Value *numElts = CGF.getVLASize(vla).NumElts;
2633 if (!isInc) numElts = Builder.CreateNSWNeg(numElts, "vla.negsize");
2634 if (CGF.getLangOpts().isSignedOverflowDefined())
2635 value = Builder.CreateGEP(value->getType()->getPointerElementType(),
2636 value, numElts, "vla.inc");
2637 else
2638 value = CGF.EmitCheckedInBoundsGEP(
2639 value, numElts, /*SignedIndices=*/false, isSubtraction,
2640 E->getExprLoc(), "vla.inc");
2641
2642 // Arithmetic on function pointers (!) is just +-1.
2643 } else if (type->isFunctionType()) {
2644 llvm::Value *amt = Builder.getInt32(amount);
2645
2646 value = CGF.EmitCastToVoidPtr(value);
2647 if (CGF.getLangOpts().isSignedOverflowDefined())
2648 value = Builder.CreateGEP(CGF.Int8Ty, value, amt, "incdec.funcptr");
2649 else
2650 value = CGF.EmitCheckedInBoundsGEP(value, amt, /*SignedIndices=*/false,
2651 isSubtraction, E->getExprLoc(),
2652 "incdec.funcptr");
2653 value = Builder.CreateBitCast(value, input->getType());
2654
2655 // For everything else, we can just do a simple increment.
2656 } else {
2657 llvm::Value *amt = Builder.getInt32(amount);
2658 if (CGF.getLangOpts().isSignedOverflowDefined())
2659 value = Builder.CreateGEP(value->getType()->getPointerElementType(),
2660 value, amt, "incdec.ptr");
2661 else
2662 value = CGF.EmitCheckedInBoundsGEP(value, amt, /*SignedIndices=*/false,
2663 isSubtraction, E->getExprLoc(),
2664 "incdec.ptr");
2665 }
2666
2667 // Vector increment/decrement.
2668 } else if (type->isVectorType()) {
2669 if (type->hasIntegerRepresentation()) {
2670 llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount);
2671
2672 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
2673 } else {
2674 value = Builder.CreateFAdd(
2675 value,
2676 llvm::ConstantFP::get(value->getType(), amount),
2677 isInc ? "inc" : "dec");
2678 }
2679
2680 // Floating point.
2681 } else if (type->isRealFloatingType()) {
2682 // Add the inc/dec to the real part.
2683 llvm::Value *amt;
2684 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);
2685
2686 if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
2687 // Another special case: half FP increment should be done via float
2688 if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics()) {
2689 value = Builder.CreateCall(
2690 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16,
2691 CGF.CGM.FloatTy),
2692 input, "incdec.conv");
2693 } else {
2694 value = Builder.CreateFPExt(input, CGF.CGM.FloatTy, "incdec.conv");
2695 }
2696 }
2697
2698 if (value->getType()->isFloatTy())
2699 amt = llvm::ConstantFP::get(VMContext,
2700 llvm::APFloat(static_cast<float>(amount)));
2701 else if (value->getType()->isDoubleTy())
2702 amt = llvm::ConstantFP::get(VMContext,
2703 llvm::APFloat(static_cast<double>(amount)));
2704 else {
2705 // Remaining types are Half, LongDouble, __ibm128 or __float128. Convert
2706 // from float.
2707 llvm::APFloat F(static_cast<float>(amount));
2708 bool ignored;
2709 const llvm::fltSemantics *FS;
2710 // Don't use getFloatTypeSemantics because Half isn't
2711 // necessarily represented using the "half" LLVM type.
2712 if (value->getType()->isFP128Ty())
2713 FS = &CGF.getTarget().getFloat128Format();
2714 else if (value->getType()->isHalfTy())
2715 FS = &CGF.getTarget().getHalfFormat();
2716 else if (value->getType()->isPPC_FP128Ty())
2717 FS = &CGF.getTarget().getIbm128Format();
2718 else
2719 FS = &CGF.getTarget().getLongDoubleFormat();
2720 F.convert(*FS, llvm::APFloat::rmTowardZero, &ignored);
2721 amt = llvm::ConstantFP::get(VMContext, F);
2722 }
2723 value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec");
2724
2725 if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {
2726 if (CGF.getContext().getTargetInfo().useFP16ConversionIntrinsics()) {
2727 value = Builder.CreateCall(
2728 CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16,
2729 CGF.CGM.FloatTy),
2730 value, "incdec.conv");
2731 } else {
2732 value = Builder.CreateFPTrunc(value, input->getType(), "incdec.conv");
2733 }
2734 }
2735
2736 // Fixed-point types.
2737 } else if (type->isFixedPointType()) {
2738 // Fixed-point types are tricky. In some cases, it isn't possible to
2739 // represent a 1 or a -1 in the type at all. Piggyback off of
2740 // EmitFixedPointBinOp to avoid having to reimplement saturation.
2741 BinOpInfo Info;
2742 Info.E = E;
2743 Info.Ty = E->getType();
2744 Info.Opcode = isInc ? BO_Add : BO_Sub;
2745 Info.LHS = value;
2746 Info.RHS = llvm::ConstantInt::get(value->getType(), 1, false);
2747 // If the type is signed, it's better to represent this as +(-1) or -(-1),
2748 // since -1 is guaranteed to be representable.
2749 if (type->isSignedFixedPointType()) {
2750 Info.Opcode = isInc ? BO_Sub : BO_Add;
2751 Info.RHS = Builder.CreateNeg(Info.RHS);
2752 }
2753 // Now, convert from our invented integer literal to the type of the unary
2754 // op. This will upscale and saturate if necessary. This value can become
2755 // undef in some cases.
2756 llvm::FixedPointBuilder<CGBuilderTy> FPBuilder(Builder);
2757 auto DstSema = CGF.getContext().getFixedPointSemantics(Info.Ty);
2758 Info.RHS = FPBuilder.CreateIntegerToFixed(Info.RHS, true, DstSema);
2759 value = EmitFixedPointBinOp(Info);
2760
2761 // Objective-C pointer types.
2762 } else {
2763 const ObjCObjectPointerType *OPT = type->castAs<ObjCObjectPointerType>();
2764 value = CGF.EmitCastToVoidPtr(value);
2765
2766 CharUnits size = CGF.getContext().getTypeSizeInChars(OPT->getObjectType());
2767 if (!isInc) size = -size;
2768 llvm::Value *sizeValue =
2769 llvm::ConstantInt::get(CGF.SizeTy, size.getQuantity());
2770
2771 if (CGF.getLangOpts().isSignedOverflowDefined())
2772 value = Builder.CreateGEP(CGF.Int8Ty, value, sizeValue, "incdec.objptr");
2773 else
2774 value = CGF.EmitCheckedInBoundsGEP(value, sizeValue,
2775 /*SignedIndices=*/false, isSubtraction,
2776 E->getExprLoc(), "incdec.objptr");
2777 value = Builder.CreateBitCast(value, input->getType());
2778 }
2779
2780 if (atomicPHI) {
2781 llvm::BasicBlock *curBlock = Builder.GetInsertBlock();
2782 llvm::BasicBlock *contBB = CGF.createBasicBlock("atomic_cont", CGF.CurFn);
2783 auto Pair = CGF.EmitAtomicCompareExchange(
2784 LV, RValue::get(atomicPHI), RValue::get(value), E->getExprLoc());
2785 llvm::Value *old = CGF.EmitToMemory(Pair.first.getScalarVal(), type);
2786 llvm::Value *success = Pair.second;
2787 atomicPHI->addIncoming(old, curBlock);
2788 Builder.CreateCondBr(success, contBB, atomicPHI->getParent());
2789 Builder.SetInsertPoint(contBB);
2790 return isPre ? value : input;
2791 }
2792
2793 // Store the updated result through the lvalue.
2794 if (LV.isBitField())
2795 CGF.EmitStoreThroughBitfieldLValue(RValue::get(value), LV, &value);
2796 else
2797 CGF.EmitStoreThroughLValue(RValue::get(value), LV);
2798
2799 // If this is a postinc, return the value read from memory, otherwise use the
2800 // updated value.
2801 return isPre ? value : input;
2802}
2803
2804
2805
2806Value *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
2807 TestAndClearIgnoreResultAssign();
2808 Value *Op = Visit(E->getSubExpr());
2809
2810 // Generate a unary FNeg for FP ops.
2811 if (Op->getType()->isFPOrFPVectorTy())
2812 return Builder.CreateFNeg(Op, "fneg");
2813
2814 // Emit unary minus with EmitSub so we handle overflow cases etc.
2815 BinOpInfo BinOp;
2816 BinOp.RHS = Op;
2817 BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType());
2818 BinOp.Ty = E->getType();
2819 BinOp.Opcode = BO_Sub;
2820 BinOp.FPFeatures = E->getFPFeaturesInEffect(CGF.getLangOpts());
2821 BinOp.E = E;
2822 return EmitSub(BinOp);
2823}
2824
2825Value *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
2826 TestAndClearIgnoreResultAssign();
2827 Value *Op = Visit(E->getSubExpr());
2828 return Builder.CreateNot(Op, "neg");
2829}
2830
2831Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) {
2832 // Perform vector logical not on comparison with zero vector.
2833 if (E->getType()->isVectorType() &&
2834 E->getType()->castAs<VectorType>()->getVectorKind() ==
2835 VectorType::GenericVector) {
2836 Value *Oper = Visit(E->getSubExpr());
2837 Value *Zero = llvm::Constant::getNullValue(Oper->getType());
2838 Value *Result;
2839 if (Oper->getType()->isFPOrFPVectorTy()) {
2840 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(
2841 CGF, E->getFPFeaturesInEffect(CGF.getLangOpts()));
2842 Result = Builder.CreateFCmp(llvm::CmpInst::FCMP_OEQ, Oper, Zero, "cmp");
2843 } else
2844 Result = Builder.CreateICmp(llvm::CmpInst::ICMP_EQ, Oper, Zero, "cmp");
2845 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
2846 }
2847
2848 // Compare operand to zero.
2849 Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr());
2850
2851 // Invert value.
2852 // TODO: Could dynamically modify easy computations here. For example, if
2853 // the operand is an icmp ne, turn into icmp eq.
2854 BoolVal = Builder.CreateNot(BoolVal, "lnot");
2855
2856 // ZExt result to the expr type.
2857 return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext");
2858}
2859
2860Value *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) {
2861 // Try folding the offsetof to a constant.
2862 Expr::EvalResult EVResult;
2863 if (E->EvaluateAsInt(EVResult, CGF.getContext())) {
2864 llvm::APSInt Value = EVResult.Val.getInt();
2865 return Builder.getInt(Value);
2866 }
2867
2868 // Loop over the components of the offsetof to compute the value.
2869 unsigned n = E->getNumComponents();
2870 llvm::Type* ResultType = ConvertType(E->getType());
2871 llvm::Value* Result = llvm::Constant::getNullValue(ResultType);
2872 QualType CurrentType = E->getTypeSourceInfo()->getType();
2873 for (unsigned i = 0; i != n; ++i) {
2874 OffsetOfNode ON = E->getComponent(i);
2875 llvm::Value *Offset = nullptr;
2876 switch (ON.getKind()) {
2877 case OffsetOfNode::Array: {
2878 // Compute the index
2879 Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex());
2880 llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr);
2881 bool IdxSigned = IdxExpr->getType()->isSignedIntegerOrEnumerationType();
2882 Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv");
2883
2884 // Save the element type
2885 CurrentType =
2886 CGF.getContext().getAsArrayType(CurrentType)->getElementType();
2887
2888 // Compute the element size
2889 llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType,
2890 CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity());
2891
2892 // Multiply out to compute the result
2893 Offset = Builder.CreateMul(Idx, ElemSize);
2894 break;
2895 }
2896
2897 case OffsetOfNode::Field: {
2898 FieldDecl *MemberDecl = ON.getField();
2899 RecordDecl *RD = CurrentType->castAs<RecordType>()->getDecl();
2900 const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD);
2901
2902 // Compute the index of the field in its parent.
2903 unsigned i = 0;
2904 // FIXME: It would be nice if we didn't have to loop here!
2905 for (RecordDecl::field_iterator Field = RD->field_begin(),
2906 FieldEnd = RD->field_end();
2907 Field != FieldEnd; ++Field, ++i) {
2908 if (*Field == MemberDecl)
2909 break;
2910 }
2911 assert(i < RL.getFieldCount() && "offsetof field in wrong type")(static_cast <bool> (i < RL.getFieldCount() &&
"offsetof field in wrong type") ? void (0) : __assert_fail (
"i < RL.getFieldCount() && \"offsetof field in wrong type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2911, __extension__ __PRETTY_FUNCTION__))
;
2912
2913 // Compute the offset to the field
2914 int64_t OffsetInt = RL.getFieldOffset(i) /
2915 CGF.getContext().getCharWidth();
2916 Offset = llvm::ConstantInt::get(ResultType, OffsetInt);
2917
2918 // Save the element type.
2919 CurrentType = MemberDecl->getType();
2920 break;
2921 }
2922
2923 case OffsetOfNode::Identifier:
2924 llvm_unreachable("dependent __builtin_offsetof")::llvm::llvm_unreachable_internal("dependent __builtin_offsetof"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 2924)
;
2925
2926 case OffsetOfNode::Base: {
2927 if (ON.getBase()->isVirtual()) {
2928 CGF.ErrorUnsupported(E, "virtual base in offsetof");
2929 continue;
2930 }
2931
2932 RecordDecl *RD = CurrentType->castAs<RecordType>()->getDecl();
2933 const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD);
2934
2935 // Save the element type.
2936 CurrentType = ON.getBase()->getType();
2937
2938 // Compute the offset to the base.
2939 const RecordType *BaseRT = CurrentType->getAs<RecordType>();
2940 CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl());
2941 CharUnits OffsetInt = RL.getBaseClassOffset(BaseRD);
2942 Offset = llvm::ConstantInt::get(ResultType, OffsetInt.getQuantity());
2943 break;
2944 }
2945 }
2946 Result = Builder.CreateAdd(Result, Offset);
2947 }
2948 return Result;
2949}
2950
2951/// VisitUnaryExprOrTypeTraitExpr - Return the size or alignment of the type of
2952/// argument of the sizeof expression as an integer.
2953Value *
2954ScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr(
2955 const UnaryExprOrTypeTraitExpr *E) {
2956 QualType TypeToSize = E->getTypeOfArgument();
2957 if (E->getKind() == UETT_SizeOf) {
2958 if (const VariableArrayType *VAT =
2959 CGF.getContext().getAsVariableArrayType(TypeToSize)) {
2960 if (E->isArgumentType()) {
2961 // sizeof(type) - make sure to emit the VLA size.
2962 CGF.EmitVariablyModifiedType(TypeToSize);
2963 } else {
2964 // C99 6.5.3.4p2: If the argument is an expression of type
2965 // VLA, it is evaluated.
2966 CGF.EmitIgnoredExpr(E->getArgumentExpr());
2967 }
2968
2969 auto VlaSize = CGF.getVLASize(VAT);
2970 llvm::Value *size = VlaSize.NumElts;
2971
2972 // Scale the number of non-VLA elements by the non-VLA element size.
2973 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(VlaSize.Type);
2974 if (!eltSize.isOne())
2975 size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), size);
2976
2977 return size;
2978 }
2979 } else if (E->getKind() == UETT_OpenMPRequiredSimdAlign) {
2980 auto Alignment =
2981 CGF.getContext()
2982 .toCharUnitsFromBits(CGF.getContext().getOpenMPDefaultSimdAlign(
2983 E->getTypeOfArgument()->getPointeeType()))
2984 .getQuantity();
2985 return llvm::ConstantInt::get(CGF.SizeTy, Alignment);
2986 }
2987
2988 // If this isn't sizeof(vla), the result must be constant; use the constant
2989 // folding logic so we don't have to duplicate it here.
2990 return Builder.getInt(E->EvaluateKnownConstInt(CGF.getContext()));
2991}
2992
2993Value *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) {
2994 Expr *Op = E->getSubExpr();
2995 if (Op->getType()->isAnyComplexType()) {
2996 // If it's an l-value, load through the appropriate subobject l-value.
2997 // Note that we have to ask E because Op might be an l-value that
2998 // this won't work for, e.g. an Obj-C property.
2999 if (E->isGLValue())
3000 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E),
3001 E->getExprLoc()).getScalarVal();
3002
3003 // Otherwise, calculate and project.
3004 return CGF.EmitComplexExpr(Op, false, true).first;
3005 }
3006
3007 return Visit(Op);
3008}
3009
3010Value *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) {
3011 Expr *Op = E->getSubExpr();
3012 if (Op->getType()->isAnyComplexType()) {
3013 // If it's an l-value, load through the appropriate subobject l-value.
3014 // Note that we have to ask E because Op might be an l-value that
3015 // this won't work for, e.g. an Obj-C property.
3016 if (Op->isGLValue())
3017 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E),
3018 E->getExprLoc()).getScalarVal();
3019
3020 // Otherwise, calculate and project.
3021 return CGF.EmitComplexExpr(Op, true, false).second;
3022 }
3023
3024 // __imag on a scalar returns zero. Emit the subexpr to ensure side
3025 // effects are evaluated, but not the actual value.
3026 if (Op->isGLValue())
3027 CGF.EmitLValue(Op);
3028 else
3029 CGF.EmitScalarExpr(Op, true);
3030 return llvm::Constant::getNullValue(ConvertType(E->getType()));
3031}
3032
3033//===----------------------------------------------------------------------===//
3034// Binary Operators
3035//===----------------------------------------------------------------------===//
3036
3037BinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) {
3038 TestAndClearIgnoreResultAssign();
3039 BinOpInfo Result;
3040 Result.LHS = Visit(E->getLHS());
3041 Result.RHS = Visit(E->getRHS());
3042 Result.Ty = E->getType();
3043 Result.Opcode = E->getOpcode();
3044 Result.FPFeatures = E->getFPFeaturesInEffect(CGF.getLangOpts());
3045 Result.E = E;
3046 return Result;
3047}
3048
3049LValue ScalarExprEmitter::EmitCompoundAssignLValue(
3050 const CompoundAssignOperator *E,
3051 Value *(ScalarExprEmitter::*Func)(const BinOpInfo &),
3052 Value *&Result) {
3053 QualType LHSTy = E->getLHS()->getType();
3054 BinOpInfo OpInfo;
3055
3056 if (E->getComputationResultType()->isAnyComplexType())
3057 return CGF.EmitScalarCompoundAssignWithComplex(E, Result);
3058
3059 // Emit the RHS first. __block variables need to have the rhs evaluated
3060 // first, plus this should improve codegen a little.
3061 OpInfo.RHS = Visit(E->getRHS());
3062 OpInfo.Ty = E->getComputationResultType();
3063 OpInfo.Opcode = E->getOpcode();
3064 OpInfo.FPFeatures = E->getFPFeaturesInEffect(CGF.getLangOpts());
3065 OpInfo.E = E;
3066 // Load/convert the LHS.
3067 LValue LHSLV = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
3068
3069 llvm::PHINode *atomicPHI = nullptr;
3070 if (const AtomicType *atomicTy = LHSTy->getAs<AtomicType>()) {
3071 QualType type = atomicTy->getValueType();
3072 if (!type->isBooleanType() && type->isIntegerType() &&
3073 !(type->isUnsignedIntegerType() &&
3074 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow)) &&
3075 CGF.getLangOpts().getSignedOverflowBehavior() !=
3076 LangOptions::SOB_Trapping) {
3077 llvm::AtomicRMWInst::BinOp AtomicOp = llvm::AtomicRMWInst::BAD_BINOP;
3078 llvm::Instruction::BinaryOps Op;
3079 switch (OpInfo.Opcode) {
3080 // We don't have atomicrmw operands for *, %, /, <<, >>
3081 case BO_MulAssign: case BO_DivAssign:
3082 case BO_RemAssign:
3083 case BO_ShlAssign:
3084 case BO_ShrAssign:
3085 break;
3086 case BO_AddAssign:
3087 AtomicOp = llvm::AtomicRMWInst::Add;
3088 Op = llvm::Instruction::Add;
3089 break;
3090 case BO_SubAssign:
3091 AtomicOp = llvm::AtomicRMWInst::Sub;
3092 Op = llvm::Instruction::Sub;
3093 break;
3094 case BO_AndAssign:
3095 AtomicOp = llvm::AtomicRMWInst::And;
3096 Op = llvm::Instruction::And;
3097 break;
3098 case BO_XorAssign:
3099 AtomicOp = llvm::AtomicRMWInst::Xor;
3100 Op = llvm::Instruction::Xor;
3101 break;
3102 case BO_OrAssign:
3103 AtomicOp = llvm::AtomicRMWInst::Or;
3104 Op = llvm::Instruction::Or;
3105 break;
3106 default:
3107 llvm_unreachable("Invalid compound assignment type")::llvm::llvm_unreachable_internal("Invalid compound assignment type"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3107)
;
3108 }
3109 if (AtomicOp != llvm::AtomicRMWInst::BAD_BINOP) {
3110 llvm::Value *Amt = CGF.EmitToMemory(
3111 EmitScalarConversion(OpInfo.RHS, E->getRHS()->getType(), LHSTy,
3112 E->getExprLoc()),
3113 LHSTy);
3114 Value *OldVal = Builder.CreateAtomicRMW(
3115 AtomicOp, LHSLV.getPointer(CGF), Amt,
3116 llvm::AtomicOrdering::SequentiallyConsistent);
3117
3118 // Since operation is atomic, the result type is guaranteed to be the
3119 // same as the input in LLVM terms.
3120 Result = Builder.CreateBinOp(Op, OldVal, Amt);
3121 return LHSLV;
3122 }
3123 }
3124 // FIXME: For floating point types, we should be saving and restoring the
3125 // floating point environment in the loop.
3126 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
3127 llvm::BasicBlock *opBB = CGF.createBasicBlock("atomic_op", CGF.CurFn);
3128 OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->getExprLoc());
3129 OpInfo.LHS = CGF.EmitToMemory(OpInfo.LHS, type);
3130 Builder.CreateBr(opBB);
3131 Builder.SetInsertPoint(opBB);
3132 atomicPHI = Builder.CreatePHI(OpInfo.LHS->getType(), 2);
3133 atomicPHI->addIncoming(OpInfo.LHS, startBB);
3134 OpInfo.LHS = atomicPHI;
3135 }
3136 else
3137 OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->getExprLoc());
3138
3139 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, OpInfo.FPFeatures);
3140 SourceLocation Loc = E->getExprLoc();
3141 OpInfo.LHS =
3142 EmitScalarConversion(OpInfo.LHS, LHSTy, E->getComputationLHSType(), Loc);
3143
3144 // Expand the binary operator.
3145 Result = (this->*Func)(OpInfo);
3146
3147 // Convert the result back to the LHS type,
3148 // potentially with Implicit Conversion sanitizer check.
3149 Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy,
3150 Loc, ScalarConversionOpts(CGF.SanOpts));
3151
3152 if (atomicPHI) {
3153 llvm::BasicBlock *curBlock = Builder.GetInsertBlock();
3154 llvm::BasicBlock *contBB = CGF.createBasicBlock("atomic_cont", CGF.CurFn);
3155 auto Pair = CGF.EmitAtomicCompareExchange(
3156 LHSLV, RValue::get(atomicPHI), RValue::get(Result), E->getExprLoc());
3157 llvm::Value *old = CGF.EmitToMemory(Pair.first.getScalarVal(), LHSTy);
3158 llvm::Value *success = Pair.second;
3159 atomicPHI->addIncoming(old, curBlock);
3160 Builder.CreateCondBr(success, contBB, atomicPHI->getParent());
3161 Builder.SetInsertPoint(contBB);
3162 return LHSLV;
3163 }
3164
3165 // Store the result value into the LHS lvalue. Bit-fields are handled
3166 // specially because the result is altered by the store, i.e., [C99 6.5.16p1]
3167 // 'An assignment expression has the value of the left operand after the
3168 // assignment...'.
3169 if (LHSLV.isBitField())
3170 CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, &Result);
3171 else
3172 CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV);
3173
3174 if (CGF.getLangOpts().OpenMP)
3175 CGF.CGM.getOpenMPRuntime().checkAndEmitLastprivateConditional(CGF,
3176 E->getLHS());
3177 return LHSLV;
3178}
3179
3180Value *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E,
3181 Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) {
3182 bool Ignore = TestAndClearIgnoreResultAssign();
3183 Value *RHS = nullptr;
3184 LValue LHS = EmitCompoundAssignLValue(E, Func, RHS);
3185
3186 // If the result is clearly ignored, return now.
3187 if (Ignore)
3188 return nullptr;
3189
3190 // The result of an assignment in C is the assigned r-value.
3191 if (!CGF.getLangOpts().CPlusPlus)
3192 return RHS;
3193
3194 // If the lvalue is non-volatile, return the computed value of the assignment.
3195 if (!LHS.isVolatileQualified())
3196 return RHS;
3197
3198 // Otherwise, reload the value.
3199 return EmitLoadOfLValue(LHS, E->getExprLoc());
3200}
3201
3202void ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck(
3203 const BinOpInfo &Ops, llvm::Value *Zero, bool isDiv) {
3204 SmallVector<std::pair<llvm::Value *, SanitizerMask>, 2> Checks;
3205
3206 if (CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero)) {
3207 Checks.push_back(std::make_pair(Builder.CreateICmpNE(Ops.RHS, Zero),
3208 SanitizerKind::IntegerDivideByZero));
3209 }
3210
3211 const auto *BO = cast<BinaryOperator>(Ops.E);
3212 if (CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow) &&
3213 Ops.Ty->hasSignedIntegerRepresentation() &&
3214 !IsWidenedIntegerOp(CGF.getContext(), BO->getLHS()) &&
3215 Ops.mayHaveIntegerOverflow()) {
3216 llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType());
3217
3218 llvm::Value *IntMin =
3219 Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
3220 llvm::Value *NegOne = llvm::Constant::getAllOnesValue(Ty);
3221
3222 llvm::Value *LHSCmp = Builder.CreateICmpNE(Ops.LHS, IntMin);
3223 llvm::Value *RHSCmp = Builder.CreateICmpNE(Ops.RHS, NegOne);
3224 llvm::Value *NotOverflow = Builder.CreateOr(LHSCmp, RHSCmp, "or");
3225 Checks.push_back(
3226 std::make_pair(NotOverflow, SanitizerKind::SignedIntegerOverflow));
3227 }
3228
3229 if (Checks.size() > 0)
3230 EmitBinOpCheck(Checks, Ops);
3231}
3232
3233Value *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) {
3234 {
3235 CodeGenFunction::SanitizerScope SanScope(&CGF);
3236 if ((CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero) ||
3237 CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) &&
3238 Ops.Ty->isIntegerType() &&
3239 (Ops.mayHaveIntegerDivisionByZero() || Ops.mayHaveIntegerOverflow())) {
3240 llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
3241 EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, true);
3242 } else if (CGF.SanOpts.has(SanitizerKind::FloatDivideByZero) &&
3243 Ops.Ty->isRealFloatingType() &&
3244 Ops.mayHaveFloatDivisionByZero()) {
3245 llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
3246 llvm::Value *NonZero = Builder.CreateFCmpUNE(Ops.RHS, Zero);
3247 EmitBinOpCheck(std::make_pair(NonZero, SanitizerKind::FloatDivideByZero),
3248 Ops);
3249 }
3250 }
3251
3252 if (Ops.Ty->isConstantMatrixType()) {
3253 llvm::MatrixBuilder<CGBuilderTy> MB(Builder);
3254 // We need to check the types of the operands of the operator to get the
3255 // correct matrix dimensions.
3256 auto *BO = cast<BinaryOperator>(Ops.E);
3257 (void)BO;
3258 assert((static_cast <bool> (isa<ConstantMatrixType>(BO->
getLHS()->getType().getCanonicalType()) && "first operand must be a matrix"
) ? void (0) : __assert_fail ("isa<ConstantMatrixType>(BO->getLHS()->getType().getCanonicalType()) && \"first operand must be a matrix\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3260, __extension__ __PRETTY_FUNCTION__))
3259 isa<ConstantMatrixType>(BO->getLHS()->getType().getCanonicalType()) &&(static_cast <bool> (isa<ConstantMatrixType>(BO->
getLHS()->getType().getCanonicalType()) && "first operand must be a matrix"
) ? void (0) : __assert_fail ("isa<ConstantMatrixType>(BO->getLHS()->getType().getCanonicalType()) && \"first operand must be a matrix\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3260, __extension__ __PRETTY_FUNCTION__))
3260 "first operand must be a matrix")(static_cast <bool> (isa<ConstantMatrixType>(BO->
getLHS()->getType().getCanonicalType()) && "first operand must be a matrix"
) ? void (0) : __assert_fail ("isa<ConstantMatrixType>(BO->getLHS()->getType().getCanonicalType()) && \"first operand must be a matrix\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3260, __extension__ __PRETTY_FUNCTION__))
;
3261 assert(BO->getRHS()->getType().getCanonicalType()->isArithmeticType() &&(static_cast <bool> (BO->getRHS()->getType().getCanonicalType
()->isArithmeticType() && "second operand must be an arithmetic type"
) ? void (0) : __assert_fail ("BO->getRHS()->getType().getCanonicalType()->isArithmeticType() && \"second operand must be an arithmetic type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3262, __extension__ __PRETTY_FUNCTION__))
3262 "second operand must be an arithmetic type")(static_cast <bool> (BO->getRHS()->getType().getCanonicalType
()->isArithmeticType() && "second operand must be an arithmetic type"
) ? void (0) : __assert_fail ("BO->getRHS()->getType().getCanonicalType()->isArithmeticType() && \"second operand must be an arithmetic type\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3262, __extension__ __PRETTY_FUNCTION__))
;
3263 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Ops.FPFeatures);
3264 return MB.CreateScalarDiv(Ops.LHS, Ops.RHS,
3265 Ops.Ty->hasUnsignedIntegerRepresentation());
3266 }
3267
3268 if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
3269 llvm::Value *Val;
3270 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Ops.FPFeatures);
3271 Val = Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
3272 if ((CGF.getLangOpts().OpenCL &&
3273 !CGF.CGM.getCodeGenOpts().OpenCLCorrectlyRoundedDivSqrt) ||
3274 (CGF.getLangOpts().HIP && CGF.getLangOpts().CUDAIsDevice &&
3275 !CGF.CGM.getCodeGenOpts().HIPCorrectlyRoundedDivSqrt)) {
3276 // OpenCL v1.1 s7.4: minimum accuracy of single precision / is 2.5ulp
3277 // OpenCL v1.2 s5.6.4.2: The -cl-fp32-correctly-rounded-divide-sqrt
3278 // build option allows an application to specify that single precision
3279 // floating-point divide (x/y and 1/x) and sqrt used in the program
3280 // source are correctly rounded.
3281 llvm::Type *ValTy = Val->getType();
3282 if (ValTy->isFloatTy() ||
3283 (isa<llvm::VectorType>(ValTy) &&
3284 cast<llvm::VectorType>(ValTy)->getElementType()->isFloatTy()))
3285 CGF.SetFPAccuracy(Val, 2.5);
3286 }
3287 return Val;
3288 }
3289 else if (Ops.isFixedPointOp())
3290 return EmitFixedPointBinOp(Ops);
3291 else if (Ops.Ty->hasUnsignedIntegerRepresentation())
3292 return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
3293 else
3294 return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
3295}
3296
3297Value *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) {
3298 // Rem in C can't be a floating point type: C99 6.5.5p2.
3299 if ((CGF.SanOpts.has(SanitizerKind::IntegerDivideByZero) ||
3300 CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) &&
3301 Ops.Ty->isIntegerType() &&
3302 (Ops.mayHaveIntegerDivisionByZero() || Ops.mayHaveIntegerOverflow())) {
3303 CodeGenFunction::SanitizerScope SanScope(&CGF);
3304 llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty));
3305 EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, false);
3306 }
3307
3308 if (Ops.Ty->hasUnsignedIntegerRepresentation())
3309 return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem");
3310 else
3311 return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem");
3312}
3313
3314Value *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) {
3315 unsigned IID;
3316 unsigned OpID = 0;
3317 SanitizerHandler OverflowKind;
3318
3319 bool isSigned = Ops.Ty->isSignedIntegerOrEnumerationType();
3320 switch (Ops.Opcode) {
3321 case BO_Add:
3322 case BO_AddAssign:
3323 OpID = 1;
3324 IID = isSigned ? llvm::Intrinsic::sadd_with_overflow :
3325 llvm::Intrinsic::uadd_with_overflow;
3326 OverflowKind = SanitizerHandler::AddOverflow;
3327 break;
3328 case BO_Sub:
3329 case BO_SubAssign:
3330 OpID = 2;
3331 IID = isSigned ? llvm::Intrinsic::ssub_with_overflow :
3332 llvm::Intrinsic::usub_with_overflow;
3333 OverflowKind = SanitizerHandler::SubOverflow;
3334 break;
3335 case BO_Mul:
3336 case BO_MulAssign:
3337 OpID = 3;
3338 IID = isSigned ? llvm::Intrinsic::smul_with_overflow :
3339 llvm::Intrinsic::umul_with_overflow;
3340 OverflowKind = SanitizerHandler::MulOverflow;
3341 break;
3342 default:
3343 llvm_unreachable("Unsupported operation for overflow detection")::llvm::llvm_unreachable_internal("Unsupported operation for overflow detection"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3343)
;
3344 }
3345 OpID <<= 1;
3346 if (isSigned)
3347 OpID |= 1;
3348
3349 CodeGenFunction::SanitizerScope SanScope(&CGF);
3350 llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty);
3351
3352 llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, opTy);
3353
3354 Value *resultAndOverflow = Builder.CreateCall(intrinsic, {Ops.LHS, Ops.RHS});
3355 Value *result = Builder.CreateExtractValue(resultAndOverflow, 0);
3356 Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1);
3357
3358 // Handle overflow with llvm.trap if no custom handler has been specified.
3359 const std::string *handlerName =
3360 &CGF.getLangOpts().OverflowHandler;
3361 if (handlerName->empty()) {
3362 // If the signed-integer-overflow sanitizer is enabled, emit a call to its
3363 // runtime. Otherwise, this is a -ftrapv check, so just emit a trap.
3364 if (!isSigned || CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow)) {
3365 llvm::Value *NotOverflow = Builder.CreateNot(overflow);
3366 SanitizerMask Kind = isSigned ? SanitizerKind::SignedIntegerOverflow
3367 : SanitizerKind::UnsignedIntegerOverflow;
3368 EmitBinOpCheck(std::make_pair(NotOverflow, Kind), Ops);
3369 } else
3370 CGF.EmitTrapCheck(Builder.CreateNot(overflow), OverflowKind);
3371 return result;
3372 }
3373
3374 // Branch in case of overflow.
3375 llvm::BasicBlock *initialBB = Builder.GetInsertBlock();
3376 llvm::BasicBlock *continueBB =
3377 CGF.createBasicBlock("nooverflow", CGF.CurFn, initialBB->getNextNode());
3378 llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn);
3379
3380 Builder.CreateCondBr(overflow, overflowBB, continueBB);
3381
3382 // If an overflow handler is set, then we want to call it and then use its
3383 // result, if it returns.
3384 Builder.SetInsertPoint(overflowBB);
3385
3386 // Get the overflow handler.
3387 llvm::Type *Int8Ty = CGF.Int8Ty;
3388 llvm::Type *argTypes[] = { CGF.Int64Ty, CGF.Int64Ty, Int8Ty, Int8Ty };
3389 llvm::FunctionType *handlerTy =
3390 llvm::FunctionType::get(CGF.Int64Ty, argTypes, true);
3391 llvm::FunctionCallee handler =
3392 CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName);
3393
3394 // Sign extend the args to 64-bit, so that we can use the same handler for
3395 // all types of overflow.
3396 llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty);
3397 llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty);
3398
3399 // Call the handler with the two arguments, the operation, and the size of
3400 // the result.
3401 llvm::Value *handlerArgs[] = {
3402 lhs,
3403 rhs,
3404 Builder.getInt8(OpID),
3405 Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())
3406 };
3407 llvm::Value *handlerResult =
3408 CGF.EmitNounwindRuntimeCall(handler, handlerArgs);
3409
3410 // Truncate the result back to the desired size.
3411 handlerResult = Builder.CreateTrunc(handlerResult, opTy);
3412 Builder.CreateBr(continueBB);
3413
3414 Builder.SetInsertPoint(continueBB);
3415 llvm::PHINode *phi = Builder.CreatePHI(opTy, 2);
3416 phi->addIncoming(result, initialBB);
3417 phi->addIncoming(handlerResult, overflowBB);
3418
3419 return phi;
3420}
3421
3422/// Emit pointer + index arithmetic.
3423static Value *emitPointerArithmetic(CodeGenFunction &CGF,
3424 const BinOpInfo &op,
3425 bool isSubtraction) {
3426 // Must have binary (not unary) expr here. Unary pointer
3427 // increment/decrement doesn't use this path.
3428 const BinaryOperator *expr = cast<BinaryOperator>(op.E);
3429
3430 Value *pointer = op.LHS;
3431 Expr *pointerOperand = expr->getLHS();
3432 Value *index = op.RHS;
3433 Expr *indexOperand = expr->getRHS();
3434
3435 // In a subtraction, the LHS is always the pointer.
3436 if (!isSubtraction && !pointer->getType()->isPointerTy()) {
3437 std::swap(pointer, index);
3438 std::swap(pointerOperand, indexOperand);
3439 }
3440
3441 bool isSigned = indexOperand->getType()->isSignedIntegerOrEnumerationType();
3442
3443 unsigned width = cast<llvm::IntegerType>(index->getType())->getBitWidth();
3444 auto &DL = CGF.CGM.getDataLayout();
3445 auto PtrTy = cast<llvm::PointerType>(pointer->getType());
3446
3447 // Some versions of glibc and gcc use idioms (particularly in their malloc
3448 // routines) that add a pointer-sized integer (known to be a pointer value)
3449 // to a null pointer in order to cast the value back to an integer or as
3450 // part of a pointer alignment algorithm. This is undefined behavior, but
3451 // we'd like to be able to compile programs that use it.
3452 //
3453 // Normally, we'd generate a GEP with a null-pointer base here in response
3454 // to that code, but it's also UB to dereference a pointer created that
3455 // way. Instead (as an acknowledged hack to tolerate the idiom) we will
3456 // generate a direct cast of the integer value to a pointer.
3457 //
3458 // The idiom (p = nullptr + N) is not met if any of the following are true:
3459 //
3460 // The operation is subtraction.
3461 // The index is not pointer-sized.
3462 // The pointer type is not byte-sized.
3463 //
3464 if (BinaryOperator::isNullPointerArithmeticExtension(CGF.getContext(),
3465 op.Opcode,
3466 expr->getLHS(),
3467 expr->getRHS()))
3468 return CGF.Builder.CreateIntToPtr(index, pointer->getType());
3469
3470 if (width != DL.getIndexTypeSizeInBits(PtrTy)) {
3471 // Zero-extend or sign-extend the pointer value according to
3472 // whether the index is signed or not.
3473 index = CGF.Builder.CreateIntCast(index, DL.getIndexType(PtrTy), isSigned,
3474 "idx.ext");
3475 }
3476
3477 // If this is subtraction, negate the index.
3478 if (isSubtraction)
3479 index = CGF.Builder.CreateNeg(index, "idx.neg");
3480
3481 if (CGF.SanOpts.has(SanitizerKind::ArrayBounds))
3482 CGF.EmitBoundsCheck(op.E, pointerOperand, index, indexOperand->getType(),
3483 /*Accessed*/ false);
3484
3485 const PointerType *pointerType
3486 = pointerOperand->getType()->getAs<PointerType>();
3487 if (!pointerType) {
3488 QualType objectType = pointerOperand->getType()
3489 ->castAs<ObjCObjectPointerType>()
3490 ->getPointeeType();
3491 llvm::Value *objectSize
3492 = CGF.CGM.getSize(CGF.getContext().getTypeSizeInChars(objectType));
3493
3494 index = CGF.Builder.CreateMul(index, objectSize);
3495
3496 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
3497 result = CGF.Builder.CreateGEP(CGF.Int8Ty, result, index, "add.ptr");
3498 return CGF.Builder.CreateBitCast(result, pointer->getType());
3499 }
3500
3501 QualType elementType = pointerType->getPointeeType();
3502 if (const VariableArrayType *vla
3503 = CGF.getContext().getAsVariableArrayType(elementType)) {
3504 // The element count here is the total number of non-VLA elements.
3505 llvm::Value *numElements = CGF.getVLASize(vla).NumElts;
3506
3507 // Effectively, the multiply by the VLA size is part of the GEP.
3508 // GEP indexes are signed, and scaling an index isn't permitted to
3509 // signed-overflow, so we use the same semantics for our explicit
3510 // multiply. We suppress this if overflow is not undefined behavior.
3511 if (CGF.getLangOpts().isSignedOverflowDefined()) {
3512 index = CGF.Builder.CreateMul(index, numElements, "vla.index");
3513 pointer = CGF.Builder.CreateGEP(
3514 pointer->getType()->getPointerElementType(), pointer, index,
3515 "add.ptr");
3516 } else {
3517 index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index");
3518 pointer =
3519 CGF.EmitCheckedInBoundsGEP(pointer, index, isSigned, isSubtraction,
3520 op.E->getExprLoc(), "add.ptr");
3521 }
3522 return pointer;
3523 }
3524
3525 // Explicitly handle GNU void* and function pointer arithmetic extensions. The
3526 // GNU void* casts amount to no-ops since our void* type is i8*, but this is
3527 // future proof.
3528 if (elementType->isVoidType() || elementType->isFunctionType()) {
3529 Value *result = CGF.EmitCastToVoidPtr(pointer);
3530 result = CGF.Builder.CreateGEP(CGF.Int8Ty, result, index, "add.ptr");
3531 return CGF.Builder.CreateBitCast(result, pointer->getType());
3532 }
3533
3534 if (CGF.getLangOpts().isSignedOverflowDefined())
3535 return CGF.Builder.CreateGEP(
3536 pointer->getType()->getPointerElementType(), pointer, index, "add.ptr");
3537
3538 return CGF.EmitCheckedInBoundsGEP(pointer, index, isSigned, isSubtraction,
3539 op.E->getExprLoc(), "add.ptr");
3540}
3541
3542// Construct an fmuladd intrinsic to represent a fused mul-add of MulOp and
3543// Addend. Use negMul and negAdd to negate the first operand of the Mul or
3544// the add operand respectively. This allows fmuladd to represent a*b-c, or
3545// c-a*b. Patterns in LLVM should catch the negated forms and translate them to
3546// efficient operations.
3547static Value* buildFMulAdd(llvm::Instruction *MulOp, Value *Addend,
3548 const CodeGenFunction &CGF, CGBuilderTy &Builder,
3549 bool negMul, bool negAdd) {
3550 assert(!(negMul && negAdd) && "Only one of negMul and negAdd should be set.")(static_cast <bool> (!(negMul && negAdd) &&
"Only one of negMul and negAdd should be set.") ? void (0) :
__assert_fail ("!(negMul && negAdd) && \"Only one of negMul and negAdd should be set.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3550, __extension__ __PRETTY_FUNCTION__))
;
3551
3552 Value *MulOp0 = MulOp->getOperand(0);
3553 Value *MulOp1 = MulOp->getOperand(1);
3554 if (negMul)
3555 MulOp0 = Builder.CreateFNeg(MulOp0, "neg");
3556 if (negAdd)
3557 Addend = Builder.CreateFNeg(Addend, "neg");
3558
3559 Value *FMulAdd = nullptr;
3560 if (Builder.getIsFPConstrained()) {
3561 assert(isa<llvm::ConstrainedFPIntrinsic>(MulOp) &&(static_cast <bool> (isa<llvm::ConstrainedFPIntrinsic
>(MulOp) && "Only constrained operation should be created when Builder is in FP "
"constrained mode") ? void (0) : __assert_fail ("isa<llvm::ConstrainedFPIntrinsic>(MulOp) && \"Only constrained operation should be created when Builder is in FP \" \"constrained mode\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3563, __extension__ __PRETTY_FUNCTION__))
3562 "Only constrained operation should be created when Builder is in FP "(static_cast <bool> (isa<llvm::ConstrainedFPIntrinsic
>(MulOp) && "Only constrained operation should be created when Builder is in FP "
"constrained mode") ? void (0) : __assert_fail ("isa<llvm::ConstrainedFPIntrinsic>(MulOp) && \"Only constrained operation should be created when Builder is in FP \" \"constrained mode\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3563, __extension__ __PRETTY_FUNCTION__))
3563 "constrained mode")(static_cast <bool> (isa<llvm::ConstrainedFPIntrinsic
>(MulOp) && "Only constrained operation should be created when Builder is in FP "
"constrained mode") ? void (0) : __assert_fail ("isa<llvm::ConstrainedFPIntrinsic>(MulOp) && \"Only constrained operation should be created when Builder is in FP \" \"constrained mode\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3563, __extension__ __PRETTY_FUNCTION__))
;
3564 FMulAdd = Builder.CreateConstrainedFPCall(
3565 CGF.CGM.getIntrinsic(llvm::Intrinsic::experimental_constrained_fmuladd,
3566 Addend->getType()),
3567 {MulOp0, MulOp1, Addend});
3568 } else {
3569 FMulAdd = Builder.CreateCall(
3570 CGF.CGM.getIntrinsic(llvm::Intrinsic::fmuladd, Addend->getType()),
3571 {MulOp0, MulOp1, Addend});
3572 }
3573 MulOp->eraseFromParent();
3574
3575 return FMulAdd;
3576}
3577
3578// Check whether it would be legal to emit an fmuladd intrinsic call to
3579// represent op and if so, build the fmuladd.
3580//
3581// Checks that (a) the operation is fusable, and (b) -ffp-contract=on.
3582// Does NOT check the type of the operation - it's assumed that this function
3583// will be called from contexts where it's known that the type is contractable.
3584static Value* tryEmitFMulAdd(const BinOpInfo &op,
3585 const CodeGenFunction &CGF, CGBuilderTy &Builder,
3586 bool isSub=false) {
3587
3588 assert((op.Opcode == BO_Add || op.Opcode == BO_AddAssign ||(static_cast <bool> ((op.Opcode == BO_Add || op.Opcode ==
BO_AddAssign || op.Opcode == BO_Sub || op.Opcode == BO_SubAssign
) && "Only fadd/fsub can be the root of an fmuladd.")
? void (0) : __assert_fail ("(op.Opcode == BO_Add || op.Opcode == BO_AddAssign || op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) && \"Only fadd/fsub can be the root of an fmuladd.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3590, __extension__ __PRETTY_FUNCTION__))
3589 op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) &&(static_cast <bool> ((op.Opcode == BO_Add || op.Opcode ==
BO_AddAssign || op.Opcode == BO_Sub || op.Opcode == BO_SubAssign
) && "Only fadd/fsub can be the root of an fmuladd.")
? void (0) : __assert_fail ("(op.Opcode == BO_Add || op.Opcode == BO_AddAssign || op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) && \"Only fadd/fsub can be the root of an fmuladd.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3590, __extension__ __PRETTY_FUNCTION__))
3590 "Only fadd/fsub can be the root of an fmuladd.")(static_cast <bool> ((op.Opcode == BO_Add || op.Opcode ==
BO_AddAssign || op.Opcode == BO_Sub || op.Opcode == BO_SubAssign
) && "Only fadd/fsub can be the root of an fmuladd.")
? void (0) : __assert_fail ("(op.Opcode == BO_Add || op.Opcode == BO_AddAssign || op.Opcode == BO_Sub || op.Opcode == BO_SubAssign) && \"Only fadd/fsub can be the root of an fmuladd.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3590, __extension__ __PRETTY_FUNCTION__))
;
3591
3592 // Check whether this op is marked as fusable.
3593 if (!op.FPFeatures.allowFPContractWithinStatement())
3594 return nullptr;
3595
3596 // We have a potentially fusable op. Look for a mul on one of the operands.
3597 // Also, make sure that the mul result isn't used directly. In that case,
3598 // there's no point creating a muladd operation.
3599 if (auto *LHSBinOp = dyn_cast<llvm::BinaryOperator>(op.LHS)) {
3600 if (LHSBinOp->getOpcode() == llvm::Instruction::FMul &&
3601 LHSBinOp->use_empty())
3602 return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder, false, isSub);
3603 }
3604 if (auto *RHSBinOp = dyn_cast<llvm::BinaryOperator>(op.RHS)) {
3605 if (RHSBinOp->getOpcode() == llvm::Instruction::FMul &&
3606 RHSBinOp->use_empty())
3607 return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub, false);
3608 }
3609
3610 if (auto *LHSBinOp = dyn_cast<llvm::CallBase>(op.LHS)) {
3611 if (LHSBinOp->getIntrinsicID() ==
3612 llvm::Intrinsic::experimental_constrained_fmul &&
3613 LHSBinOp->use_empty())
3614 return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder, false, isSub);
3615 }
3616 if (auto *RHSBinOp = dyn_cast<llvm::CallBase>(op.RHS)) {
3617 if (RHSBinOp->getIntrinsicID() ==
3618 llvm::Intrinsic::experimental_constrained_fmul &&
3619 RHSBinOp->use_empty())
3620 return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub, false);
3621 }
3622
3623 return nullptr;
3624}
3625
3626Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &op) {
3627 if (op.LHS->getType()->isPointerTy() ||
3628 op.RHS->getType()->isPointerTy())
3629 return emitPointerArithmetic(CGF, op, CodeGenFunction::NotSubtraction);
3630
3631 if (op.Ty->isSignedIntegerOrEnumerationType()) {
3632 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
3633 case LangOptions::SOB_Defined:
3634 return Builder.CreateAdd(op.LHS, op.RHS, "add");
3635 case LangOptions::SOB_Undefined:
3636 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
3637 return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
3638 LLVM_FALLTHROUGH[[gnu::fallthrough]];
3639 case LangOptions::SOB_Trapping:
3640 if (CanElideOverflowCheck(CGF.getContext(), op))
3641 return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
3642 return EmitOverflowCheckedBinOp(op);
3643 }
3644 }
3645
3646 if (op.Ty->isConstantMatrixType()) {
3647 llvm::MatrixBuilder<CGBuilderTy> MB(Builder);
3648 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, op.FPFeatures);
3649 return MB.CreateAdd(op.LHS, op.RHS);
3650 }
3651
3652 if (op.Ty->isUnsignedIntegerType() &&
3653 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
3654 !CanElideOverflowCheck(CGF.getContext(), op))
3655 return EmitOverflowCheckedBinOp(op);
3656
3657 if (op.LHS->getType()->isFPOrFPVectorTy()) {
3658 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, op.FPFeatures);
3659 // Try to form an fmuladd.
3660 if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder))
3661 return FMulAdd;
3662
3663 return Builder.CreateFAdd(op.LHS, op.RHS, "add");
3664 }
3665
3666 if (op.isFixedPointOp())
3667 return EmitFixedPointBinOp(op);
3668
3669 return Builder.CreateAdd(op.LHS, op.RHS, "add");
3670}
3671
3672/// The resulting value must be calculated with exact precision, so the operands
3673/// may not be the same type.
3674Value *ScalarExprEmitter::EmitFixedPointBinOp(const BinOpInfo &op) {
3675 using llvm::APSInt;
3676 using llvm::ConstantInt;
3677
3678 // This is either a binary operation where at least one of the operands is
3679 // a fixed-point type, or a unary operation where the operand is a fixed-point
3680 // type. The result type of a binary operation is determined by
3681 // Sema::handleFixedPointConversions().
3682 QualType ResultTy = op.Ty;
3683 QualType LHSTy, RHSTy;
3684 if (const auto *BinOp = dyn_cast<BinaryOperator>(op.E)) {
3685 RHSTy = BinOp->getRHS()->getType();
3686 if (const auto *CAO = dyn_cast<CompoundAssignOperator>(BinOp)) {
3687 // For compound assignment, the effective type of the LHS at this point
3688 // is the computation LHS type, not the actual LHS type, and the final
3689 // result type is not the type of the expression but rather the
3690 // computation result type.
3691 LHSTy = CAO->getComputationLHSType();
3692 ResultTy = CAO->getComputationResultType();
3693 } else
3694 LHSTy = BinOp->getLHS()->getType();
3695 } else if (const auto *UnOp = dyn_cast<UnaryOperator>(op.E)) {
3696 LHSTy = UnOp->getSubExpr()->getType();
3697 RHSTy = UnOp->getSubExpr()->getType();
3698 }
3699 ASTContext &Ctx = CGF.getContext();
3700 Value *LHS = op.LHS;
3701 Value *RHS = op.RHS;
3702
3703 auto LHSFixedSema = Ctx.getFixedPointSemantics(LHSTy);
3704 auto RHSFixedSema = Ctx.getFixedPointSemantics(RHSTy);
3705 auto ResultFixedSema = Ctx.getFixedPointSemantics(ResultTy);
3706 auto CommonFixedSema = LHSFixedSema.getCommonSemantics(RHSFixedSema);
3707
3708 // Perform the actual operation.
3709 Value *Result;
3710 llvm::FixedPointBuilder<CGBuilderTy> FPBuilder(Builder);
3711 switch (op.Opcode) {
3712 case BO_AddAssign:
3713 case BO_Add:
3714 Result = FPBuilder.CreateAdd(LHS, LHSFixedSema, RHS, RHSFixedSema);
3715 break;
3716 case BO_SubAssign:
3717 case BO_Sub:
3718 Result = FPBuilder.CreateSub(LHS, LHSFixedSema, RHS, RHSFixedSema);
3719 break;
3720 case BO_MulAssign:
3721 case BO_Mul:
3722 Result = FPBuilder.CreateMul(LHS, LHSFixedSema, RHS, RHSFixedSema);
3723 break;
3724 case BO_DivAssign:
3725 case BO_Div:
3726 Result = FPBuilder.CreateDiv(LHS, LHSFixedSema, RHS, RHSFixedSema);
3727 break;
3728 case BO_ShlAssign:
3729 case BO_Shl:
3730 Result = FPBuilder.CreateShl(LHS, LHSFixedSema, RHS);
3731 break;
3732 case BO_ShrAssign:
3733 case BO_Shr:
3734 Result = FPBuilder.CreateShr(LHS, LHSFixedSema, RHS);
3735 break;
3736 case BO_LT:
3737 return FPBuilder.CreateLT(LHS, LHSFixedSema, RHS, RHSFixedSema);
3738 case BO_GT:
3739 return FPBuilder.CreateGT(LHS, LHSFixedSema, RHS, RHSFixedSema);
3740 case BO_LE:
3741 return FPBuilder.CreateLE(LHS, LHSFixedSema, RHS, RHSFixedSema);
3742 case BO_GE:
3743 return FPBuilder.CreateGE(LHS, LHSFixedSema, RHS, RHSFixedSema);
3744 case BO_EQ:
3745 // For equality operations, we assume any padding bits on unsigned types are
3746 // zero'd out. They could be overwritten through non-saturating operations
3747 // that cause overflow, but this leads to undefined behavior.
3748 return FPBuilder.CreateEQ(LHS, LHSFixedSema, RHS, RHSFixedSema);
3749 case BO_NE:
3750 return FPBuilder.CreateNE(LHS, LHSFixedSema, RHS, RHSFixedSema);
3751 case BO_Cmp:
3752 case BO_LAnd:
3753 case BO_LOr:
3754 llvm_unreachable("Found unimplemented fixed point binary operation")::llvm::llvm_unreachable_internal("Found unimplemented fixed point binary operation"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3754)
;
3755 case BO_PtrMemD:
3756 case BO_PtrMemI:
3757 case BO_Rem:
3758 case BO_Xor:
3759 case BO_And:
3760 case BO_Or:
3761 case BO_Assign:
3762 case BO_RemAssign:
3763 case BO_AndAssign:
3764 case BO_XorAssign:
3765 case BO_OrAssign:
3766 case BO_Comma:
3767 llvm_unreachable("Found unsupported binary operation for fixed point types.")::llvm::llvm_unreachable_internal("Found unsupported binary operation for fixed point types."
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3767)
;
3768 }
3769
3770 bool IsShift = BinaryOperator::isShiftOp(op.Opcode) ||
3771 BinaryOperator::isShiftAssignOp(op.Opcode);
3772 // Convert to the result type.
3773 return FPBuilder.CreateFixedToFixed(Result, IsShift ? LHSFixedSema
3774 : CommonFixedSema,
3775 ResultFixedSema);
3776}
3777
3778Value *ScalarExprEmitter::EmitSub(const BinOpInfo &op) {
3779 // The LHS is always a pointer if either side is.
3780 if (!op.LHS->getType()->isPointerTy()) {
3781 if (op.Ty->isSignedIntegerOrEnumerationType()) {
3782 switch (CGF.getLangOpts().getSignedOverflowBehavior()) {
3783 case LangOptions::SOB_Defined:
3784 return Builder.CreateSub(op.LHS, op.RHS, "sub");
3785 case LangOptions::SOB_Undefined:
3786 if (!CGF.SanOpts.has(SanitizerKind::SignedIntegerOverflow))
3787 return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
3788 LLVM_FALLTHROUGH[[gnu::fallthrough]];
3789 case LangOptions::SOB_Trapping:
3790 if (CanElideOverflowCheck(CGF.getContext(), op))
3791 return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
3792 return EmitOverflowCheckedBinOp(op);
3793 }
3794 }
3795
3796 if (op.Ty->isConstantMatrixType()) {
3797 llvm::MatrixBuilder<CGBuilderTy> MB(Builder);
3798 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, op.FPFeatures);
3799 return MB.CreateSub(op.LHS, op.RHS);
3800 }
3801
3802 if (op.Ty->isUnsignedIntegerType() &&
3803 CGF.SanOpts.has(SanitizerKind::UnsignedIntegerOverflow) &&
3804 !CanElideOverflowCheck(CGF.getContext(), op))
3805 return EmitOverflowCheckedBinOp(op);
3806
3807 if (op.LHS->getType()->isFPOrFPVectorTy()) {
3808 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, op.FPFeatures);
3809 // Try to form an fmuladd.
3810 if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder, true))
3811 return FMulAdd;
3812 return Builder.CreateFSub(op.LHS, op.RHS, "sub");
3813 }
3814
3815 if (op.isFixedPointOp())
3816 return EmitFixedPointBinOp(op);
3817
3818 return Builder.CreateSub(op.LHS, op.RHS, "sub");
3819 }
3820
3821 // If the RHS is not a pointer, then we have normal pointer
3822 // arithmetic.
3823 if (!op.RHS->getType()->isPointerTy())
3824 return emitPointerArithmetic(CGF, op, CodeGenFunction::IsSubtraction);
3825
3826 // Otherwise, this is a pointer subtraction.
3827
3828 // Do the raw subtraction part.
3829 llvm::Value *LHS
3830 = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast");
3831 llvm::Value *RHS
3832 = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast");
3833 Value *diffInChars = Builder.CreateSub(LHS, RHS, "sub.ptr.sub");
3834
3835 // Okay, figure out the element size.
3836 const BinaryOperator *expr = cast<BinaryOperator>(op.E);
3837 QualType elementType = expr->getLHS()->getType()->getPointeeType();
3838
3839 llvm::Value *divisor = nullptr;
3840
3841 // For a variable-length array, this is going to be non-constant.
3842 if (const VariableArrayType *vla
3843 = CGF.getContext().getAsVariableArrayType(elementType)) {
3844 auto VlaSize = CGF.getVLASize(vla);
3845 elementType = VlaSize.Type;
3846 divisor = VlaSize.NumElts;
3847
3848 // Scale the number of non-VLA elements by the non-VLA element size.
3849 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(elementType);
3850 if (!eltSize.isOne())
3851 divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);
3852
3853 // For everything elese, we can just compute it, safe in the
3854 // assumption that Sema won't let anything through that we can't
3855 // safely compute the size of.
3856 } else {
3857 CharUnits elementSize;
3858 // Handle GCC extension for pointer arithmetic on void* and
3859 // function pointer types.
3860 if (elementType->isVoidType() || elementType->isFunctionType())
3861 elementSize = CharUnits::One();
3862 else
3863 elementSize = CGF.getContext().getTypeSizeInChars(elementType);
3864
3865 // Don't even emit the divide for element size of 1.
3866 if (elementSize.isOne())
3867 return diffInChars;
3868
3869 divisor = CGF.CGM.getSize(elementSize);
3870 }
3871
3872 // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since
3873 // pointer difference in C is only defined in the case where both operands
3874 // are pointing to elements of an array.
3875 return Builder.CreateExactSDiv(diffInChars, divisor, "sub.ptr.div");
3876}
3877
3878Value *ScalarExprEmitter::GetWidthMinusOneValue(Value* LHS,Value* RHS) {
3879 llvm::IntegerType *Ty;
3880 if (llvm::VectorType *VT = dyn_cast<llvm::VectorType>(LHS->getType()))
3881 Ty = cast<llvm::IntegerType>(VT->getElementType());
3882 else
3883 Ty = cast<llvm::IntegerType>(LHS->getType());
3884 return llvm::ConstantInt::get(RHS->getType(), Ty->getBitWidth() - 1);
3885}
3886
3887Value *ScalarExprEmitter::ConstrainShiftValue(Value *LHS, Value *RHS,
3888 const Twine &Name) {
3889 llvm::IntegerType *Ty;
3890 if (auto *VT = dyn_cast<llvm::VectorType>(LHS->getType()))
3891 Ty = cast<llvm::IntegerType>(VT->getElementType());
3892 else
3893 Ty = cast<llvm::IntegerType>(LHS->getType());
3894
3895 if (llvm::isPowerOf2_64(Ty->getBitWidth()))
3896 return Builder.CreateAnd(RHS, GetWidthMinusOneValue(LHS, RHS), Name);
3897
3898 return Builder.CreateURem(
3899 RHS, llvm::ConstantInt::get(RHS->getType(), Ty->getBitWidth()), Name);
3900}
3901
3902Value *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) {
3903 // TODO: This misses out on the sanitizer check below.
3904 if (Ops.isFixedPointOp())
3905 return EmitFixedPointBinOp(Ops);
3906
3907 // LLVM requires the LHS and RHS to be the same type: promote or truncate the
3908 // RHS to the same size as the LHS.
3909 Value *RHS = Ops.RHS;
3910 if (Ops.LHS->getType() != RHS->getType())
3911 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
3912
3913 bool SanitizeSignedBase = CGF.SanOpts.has(SanitizerKind::ShiftBase) &&
3914 Ops.Ty->hasSignedIntegerRepresentation() &&
3915 !CGF.getLangOpts().isSignedOverflowDefined() &&
3916 !CGF.getLangOpts().CPlusPlus20;
3917 bool SanitizeUnsignedBase =
3918 CGF.SanOpts.has(SanitizerKind::UnsignedShiftBase) &&
3919 Ops.Ty->hasUnsignedIntegerRepresentation();
3920 bool SanitizeBase = SanitizeSignedBase || SanitizeUnsignedBase;
3921 bool SanitizeExponent = CGF.SanOpts.has(SanitizerKind::ShiftExponent);
3922 // OpenCL 6.3j: shift values are effectively % word size of LHS.
3923 if (CGF.getLangOpts().OpenCL)
3924 RHS = ConstrainShiftValue(Ops.LHS, RHS, "shl.mask");
3925 else if ((SanitizeBase || SanitizeExponent) &&
3926 isa<llvm::IntegerType>(Ops.LHS->getType())) {
3927 CodeGenFunction::SanitizerScope SanScope(&CGF);
3928 SmallVector<std::pair<Value *, SanitizerMask>, 2> Checks;
3929 llvm::Value *WidthMinusOne = GetWidthMinusOneValue(Ops.LHS, Ops.RHS);
3930 llvm::Value *ValidExponent = Builder.CreateICmpULE(Ops.RHS, WidthMinusOne);
3931
3932 if (SanitizeExponent) {
3933 Checks.push_back(
3934 std::make_pair(ValidExponent, SanitizerKind::ShiftExponent));
3935 }
3936
3937 if (SanitizeBase) {
3938 // Check whether we are shifting any non-zero bits off the top of the
3939 // integer. We only emit this check if exponent is valid - otherwise
3940 // instructions below will have undefined behavior themselves.
3941 llvm::BasicBlock *Orig = Builder.GetInsertBlock();
3942 llvm::BasicBlock *Cont = CGF.createBasicBlock("cont");
3943 llvm::BasicBlock *CheckShiftBase = CGF.createBasicBlock("check");
3944 Builder.CreateCondBr(ValidExponent, CheckShiftBase, Cont);
3945 llvm::Value *PromotedWidthMinusOne =
3946 (RHS == Ops.RHS) ? WidthMinusOne
3947 : GetWidthMinusOneValue(Ops.LHS, RHS);
3948 CGF.EmitBlock(CheckShiftBase);
3949 llvm::Value *BitsShiftedOff = Builder.CreateLShr(
3950 Ops.LHS, Builder.CreateSub(PromotedWidthMinusOne, RHS, "shl.zeros",
3951 /*NUW*/ true, /*NSW*/ true),
3952 "shl.check");
3953 if (SanitizeUnsignedBase || CGF.getLangOpts().CPlusPlus) {
3954 // In C99, we are not permitted to shift a 1 bit into the sign bit.
3955 // Under C++11's rules, shifting a 1 bit into the sign bit is
3956 // OK, but shifting a 1 bit out of it is not. (C89 and C++03 don't
3957 // define signed left shifts, so we use the C99 and C++11 rules there).
3958 // Unsigned shifts can always shift into the top bit.
3959 llvm::Value *One = llvm::ConstantInt::get(BitsShiftedOff->getType(), 1);
3960 BitsShiftedOff = Builder.CreateLShr(BitsShiftedOff, One);
3961 }
3962 llvm::Value *Zero = llvm::ConstantInt::get(BitsShiftedOff->getType(), 0);
3963 llvm::Value *ValidBase = Builder.CreateICmpEQ(BitsShiftedOff, Zero);
3964 CGF.EmitBlock(Cont);
3965 llvm::PHINode *BaseCheck = Builder.CreatePHI(ValidBase->getType(), 2);
3966 BaseCheck->addIncoming(Builder.getTrue(), Orig);
3967 BaseCheck->addIncoming(ValidBase, CheckShiftBase);
3968 Checks.push_back(std::make_pair(
3969 BaseCheck, SanitizeSignedBase ? SanitizerKind::ShiftBase
3970 : SanitizerKind::UnsignedShiftBase));
3971 }
3972
3973 assert(!Checks.empty())(static_cast <bool> (!Checks.empty()) ? void (0) : __assert_fail
("!Checks.empty()", "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 3973, __extension__ __PRETTY_FUNCTION__))
;
3974 EmitBinOpCheck(Checks, Ops);
3975 }
3976
3977 return Builder.CreateShl(Ops.LHS, RHS, "shl");
3978}
3979
3980Value *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) {
3981 // TODO: This misses out on the sanitizer check below.
3982 if (Ops.isFixedPointOp())
3983 return EmitFixedPointBinOp(Ops);
3984
3985 // LLVM requires the LHS and RHS to be the same type: promote or truncate the
3986 // RHS to the same size as the LHS.
3987 Value *RHS = Ops.RHS;
3988 if (Ops.LHS->getType() != RHS->getType())
3989 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
3990
3991 // OpenCL 6.3j: shift values are effectively % word size of LHS.
3992 if (CGF.getLangOpts().OpenCL)
3993 RHS = ConstrainShiftValue(Ops.LHS, RHS, "shr.mask");
3994 else if (CGF.SanOpts.has(SanitizerKind::ShiftExponent) &&
3995 isa<llvm::IntegerType>(Ops.LHS->getType())) {
3996 CodeGenFunction::SanitizerScope SanScope(&CGF);
3997 llvm::Value *Valid =
3998 Builder.CreateICmpULE(RHS, GetWidthMinusOneValue(Ops.LHS, RHS));
3999 EmitBinOpCheck(std::make_pair(Valid, SanitizerKind::ShiftExponent), Ops);
4000 }
4001
4002 if (Ops.Ty->hasUnsignedIntegerRepresentation())
4003 return Builder.CreateLShr(Ops.LHS, RHS, "shr");
4004 return Builder.CreateAShr(Ops.LHS, RHS, "shr");
4005}
4006
4007enum IntrinsicType { VCMPEQ, VCMPGT };
4008// return corresponding comparison intrinsic for given vector type
4009static llvm::Intrinsic::ID GetIntrinsic(IntrinsicType IT,
4010 BuiltinType::Kind ElemKind) {
4011 switch (ElemKind) {
4012 default: llvm_unreachable("unexpected element type")::llvm::llvm_unreachable_internal("unexpected element type", "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4012)
;
4013 case BuiltinType::Char_U:
4014 case BuiltinType::UChar:
4015 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p :
4016 llvm::Intrinsic::ppc_altivec_vcmpgtub_p;
4017 case BuiltinType::Char_S:
4018 case BuiltinType::SChar:
4019 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p :
4020 llvm::Intrinsic::ppc_altivec_vcmpgtsb_p;
4021 case BuiltinType::UShort:
4022 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p :
4023 llvm::Intrinsic::ppc_altivec_vcmpgtuh_p;
4024 case BuiltinType::Short:
4025 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p :
4026 llvm::Intrinsic::ppc_altivec_vcmpgtsh_p;
4027 case BuiltinType::UInt:
4028 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p :
4029 llvm::Intrinsic::ppc_altivec_vcmpgtuw_p;
4030 case BuiltinType::Int:
4031 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p :
4032 llvm::Intrinsic::ppc_altivec_vcmpgtsw_p;
4033 case BuiltinType::ULong:
4034 case BuiltinType::ULongLong:
4035 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequd_p :
4036 llvm::Intrinsic::ppc_altivec_vcmpgtud_p;
4037 case BuiltinType::Long:
4038 case BuiltinType::LongLong:
4039 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequd_p :
4040 llvm::Intrinsic::ppc_altivec_vcmpgtsd_p;
4041 case BuiltinType::Float:
4042 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p :
4043 llvm::Intrinsic::ppc_altivec_vcmpgtfp_p;
4044 case BuiltinType::Double:
4045 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_vsx_xvcmpeqdp_p :
4046 llvm::Intrinsic::ppc_vsx_xvcmpgtdp_p;
4047 case BuiltinType::UInt128:
4048 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequq_p
4049 : llvm::Intrinsic::ppc_altivec_vcmpgtuq_p;
4050 case BuiltinType::Int128:
4051 return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequq_p
4052 : llvm::Intrinsic::ppc_altivec_vcmpgtsq_p;
4053 }
4054}
4055
4056Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,
4057 llvm::CmpInst::Predicate UICmpOpc,
4058 llvm::CmpInst::Predicate SICmpOpc,
4059 llvm::CmpInst::Predicate FCmpOpc,
4060 bool IsSignaling) {
4061 TestAndClearIgnoreResultAssign();
4062 Value *Result;
4063 QualType LHSTy = E->getLHS()->getType();
4064 QualType RHSTy = E->getRHS()->getType();
4065 if (const MemberPointerType *MPT = LHSTy->getAs<MemberPointerType>()) {
4066 assert(E->getOpcode() == BO_EQ ||(static_cast <bool> (E->getOpcode() == BO_EQ || E->
getOpcode() == BO_NE) ? void (0) : __assert_fail ("E->getOpcode() == BO_EQ || E->getOpcode() == BO_NE"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4067, __extension__ __PRETTY_FUNCTION__))
4067 E->getOpcode() == BO_NE)(static_cast <bool> (E->getOpcode() == BO_EQ || E->
getOpcode() == BO_NE) ? void (0) : __assert_fail ("E->getOpcode() == BO_EQ || E->getOpcode() == BO_NE"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4067, __extension__ __PRETTY_FUNCTION__))
;
4068 Value *LHS = CGF.EmitScalarExpr(E->getLHS());
4069 Value *RHS = CGF.EmitScalarExpr(E->getRHS());
4070 Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison(
4071 CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE);
4072 } else if (!LHSTy->isAnyComplexType() && !RHSTy->isAnyComplexType()) {
4073 BinOpInfo BOInfo = EmitBinOps(E);
4074 Value *LHS = BOInfo.LHS;
4075 Value *RHS = BOInfo.RHS;
4076
4077 // If AltiVec, the comparison results in a numeric type, so we use
4078 // intrinsics comparing vectors and giving 0 or 1 as a result
4079 if (LHSTy->isVectorType() && !E->getType()->isVectorType()) {
4080 // constants for mapping CR6 register bits to predicate result
4081 enum { CR6_EQ=0, CR6_EQ_REV, CR6_LT, CR6_LT_REV } CR6;
4082
4083 llvm::Intrinsic::ID ID = llvm::Intrinsic::not_intrinsic;
4084
4085 // in several cases vector arguments order will be reversed
4086 Value *FirstVecArg = LHS,
4087 *SecondVecArg = RHS;
4088
4089 QualType ElTy = LHSTy->castAs<VectorType>()->getElementType();
4090 BuiltinType::Kind ElementKind = ElTy->castAs<BuiltinType>()->getKind();
4091
4092 switch(E->getOpcode()) {
4093 default: llvm_unreachable("is not a comparison operation")::llvm::llvm_unreachable_internal("is not a comparison operation"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4093)
;
4094 case BO_EQ:
4095 CR6 = CR6_LT;
4096 ID = GetIntrinsic(VCMPEQ, ElementKind);
4097 break;
4098 case BO_NE:
4099 CR6 = CR6_EQ;
4100 ID = GetIntrinsic(VCMPEQ, ElementKind);
4101 break;
4102 case BO_LT:
4103 CR6 = CR6_LT;
4104 ID = GetIntrinsic(VCMPGT, ElementKind);
4105 std::swap(FirstVecArg, SecondVecArg);
4106 break;
4107 case BO_GT:
4108 CR6 = CR6_LT;
4109 ID = GetIntrinsic(VCMPGT, ElementKind);
4110 break;
4111 case BO_LE:
4112 if (ElementKind == BuiltinType::Float) {
4113 CR6 = CR6_LT;
4114 ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p;
4115 std::swap(FirstVecArg, SecondVecArg);
4116 }
4117 else {
4118 CR6 = CR6_EQ;
4119 ID = GetIntrinsic(VCMPGT, ElementKind);
4120 }
4121 break;
4122 case BO_GE:
4123 if (ElementKind == BuiltinType::Float) {
4124 CR6 = CR6_LT;
4125 ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p;
4126 }
4127 else {
4128 CR6 = CR6_EQ;
4129 ID = GetIntrinsic(VCMPGT, ElementKind);
4130 std::swap(FirstVecArg, SecondVecArg);
4131 }
4132 break;
4133 }
4134
4135 Value *CR6Param = Builder.getInt32(CR6);
4136 llvm::Function *F = CGF.CGM.getIntrinsic(ID);
4137 Result = Builder.CreateCall(F, {CR6Param, FirstVecArg, SecondVecArg});
4138
4139 // The result type of intrinsic may not be same as E->getType().
4140 // If E->getType() is not BoolTy, EmitScalarConversion will do the
4141 // conversion work. If E->getType() is BoolTy, EmitScalarConversion will
4142 // do nothing, if ResultTy is not i1 at the same time, it will cause
4143 // crash later.
4144 llvm::IntegerType *ResultTy = cast<llvm::IntegerType>(Result->getType());
4145 if (ResultTy->getBitWidth() > 1 &&
4146 E->getType() == CGF.getContext().BoolTy)
4147 Result = Builder.CreateTrunc(Result, Builder.getInt1Ty());
4148 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType(),
4149 E->getExprLoc());
4150 }
4151
4152 if (BOInfo.isFixedPointOp()) {
4153 Result = EmitFixedPointBinOp(BOInfo);
4154 } else if (LHS->getType()->isFPOrFPVectorTy()) {
4155 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, BOInfo.FPFeatures);
4156 if (!IsSignaling)
4157 Result = Builder.CreateFCmp(FCmpOpc, LHS, RHS, "cmp");
4158 else
4159 Result = Builder.CreateFCmpS(FCmpOpc, LHS, RHS, "cmp");
4160 } else if (LHSTy->hasSignedIntegerRepresentation()) {
4161 Result = Builder.CreateICmp(SICmpOpc, LHS, RHS, "cmp");
4162 } else {
4163 // Unsigned integers and pointers.
4164
4165 if (CGF.CGM.getCodeGenOpts().StrictVTablePointers &&
4166 !isa<llvm::ConstantPointerNull>(LHS) &&
4167 !isa<llvm::ConstantPointerNull>(RHS)) {
4168
4169 // Dynamic information is required to be stripped for comparisons,
4170 // because it could leak the dynamic information. Based on comparisons
4171 // of pointers to dynamic objects, the optimizer can replace one pointer
4172 // with another, which might be incorrect in presence of invariant
4173 // groups. Comparison with null is safe because null does not carry any
4174 // dynamic information.
4175 if (LHSTy.mayBeDynamicClass())
4176 LHS = Builder.CreateStripInvariantGroup(LHS);
4177 if (RHSTy.mayBeDynamicClass())
4178 RHS = Builder.CreateStripInvariantGroup(RHS);
4179 }
4180
4181 Result = Builder.CreateICmp(UICmpOpc, LHS, RHS, "cmp");
4182 }
4183
4184 // If this is a vector comparison, sign extend the result to the appropriate
4185 // vector integer type and return it (don't convert to bool).
4186 if (LHSTy->isVectorType())
4187 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
4188
4189 } else {
4190 // Complex Comparison: can only be an equality comparison.
4191 CodeGenFunction::ComplexPairTy LHS, RHS;
4192 QualType CETy;
4193 if (auto *CTy = LHSTy->getAs<ComplexType>()) {
4194 LHS = CGF.EmitComplexExpr(E->getLHS());
4195 CETy = CTy->getElementType();
4196 } else {
4197 LHS.first = Visit(E->getLHS());
4198 LHS.second = llvm::Constant::getNullValue(LHS.first->getType());
4199 CETy = LHSTy;
4200 }
4201 if (auto *CTy = RHSTy->getAs<ComplexType>()) {
4202 RHS = CGF.EmitComplexExpr(E->getRHS());
4203 assert(CGF.getContext().hasSameUnqualifiedType(CETy,(static_cast <bool> (CGF.getContext().hasSameUnqualifiedType
(CETy, CTy->getElementType()) && "The element types must always match."
) ? void (0) : __assert_fail ("CGF.getContext().hasSameUnqualifiedType(CETy, CTy->getElementType()) && \"The element types must always match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4205, __extension__ __PRETTY_FUNCTION__))
4204 CTy->getElementType()) &&(static_cast <bool> (CGF.getContext().hasSameUnqualifiedType
(CETy, CTy->getElementType()) && "The element types must always match."
) ? void (0) : __assert_fail ("CGF.getContext().hasSameUnqualifiedType(CETy, CTy->getElementType()) && \"The element types must always match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4205, __extension__ __PRETTY_FUNCTION__))
4205 "The element types must always match.")(static_cast <bool> (CGF.getContext().hasSameUnqualifiedType
(CETy, CTy->getElementType()) && "The element types must always match."
) ? void (0) : __assert_fail ("CGF.getContext().hasSameUnqualifiedType(CETy, CTy->getElementType()) && \"The element types must always match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4205, __extension__ __PRETTY_FUNCTION__))
;
4206 (void)CTy;
4207 } else {
4208 RHS.first = Visit(E->getRHS());
4209 RHS.second = llvm::Constant::getNullValue(RHS.first->getType());
4210 assert(CGF.getContext().hasSameUnqualifiedType(CETy, RHSTy) &&(static_cast <bool> (CGF.getContext().hasSameUnqualifiedType
(CETy, RHSTy) && "The element types must always match."
) ? void (0) : __assert_fail ("CGF.getContext().hasSameUnqualifiedType(CETy, RHSTy) && \"The element types must always match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4211, __extension__ __PRETTY_FUNCTION__))
4211 "The element types must always match.")(static_cast <bool> (CGF.getContext().hasSameUnqualifiedType
(CETy, RHSTy) && "The element types must always match."
) ? void (0) : __assert_fail ("CGF.getContext().hasSameUnqualifiedType(CETy, RHSTy) && \"The element types must always match.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4211, __extension__ __PRETTY_FUNCTION__))
;
4212 }
4213
4214 Value *ResultR, *ResultI;
4215 if (CETy->isRealFloatingType()) {
4216 // As complex comparisons can only be equality comparisons, they
4217 // are never signaling comparisons.
4218 ResultR = Builder.CreateFCmp(FCmpOpc, LHS.first, RHS.first, "cmp.r");
4219 ResultI = Builder.CreateFCmp(FCmpOpc, LHS.second, RHS.second, "cmp.i");
4220 } else {
4221 // Complex comparisons can only be equality comparisons. As such, signed
4222 // and unsigned opcodes are the same.
4223 ResultR = Builder.CreateICmp(UICmpOpc, LHS.first, RHS.first, "cmp.r");
4224 ResultI = Builder.CreateICmp(UICmpOpc, LHS.second, RHS.second, "cmp.i");
4225 }
4226
4227 if (E->getOpcode() == BO_EQ) {
4228 Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
4229 } else {
4230 assert(E->getOpcode() == BO_NE &&(static_cast <bool> (E->getOpcode() == BO_NE &&
"Complex comparison other than == or != ?") ? void (0) : __assert_fail
("E->getOpcode() == BO_NE && \"Complex comparison other than == or != ?\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4231, __extension__ __PRETTY_FUNCTION__))
4231 "Complex comparison other than == or != ?")(static_cast <bool> (E->getOpcode() == BO_NE &&
"Complex comparison other than == or != ?") ? void (0) : __assert_fail
("E->getOpcode() == BO_NE && \"Complex comparison other than == or != ?\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4231, __extension__ __PRETTY_FUNCTION__))
;
4232 Result = Builder.CreateOr(ResultR, ResultI, "or.ri");
4233 }
4234 }
4235
4236 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType(),
4237 E->getExprLoc());
4238}
4239
4240Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) {
4241 bool Ignore = TestAndClearIgnoreResultAssign();
4242
4243 Value *RHS;
4244 LValue LHS;
4245
4246 switch (E->getLHS()->getType().getObjCLifetime()) {
4247 case Qualifiers::OCL_Strong:
4248 std::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore);
4249 break;
4250
4251 case Qualifiers::OCL_Autoreleasing:
4252 std::tie(LHS, RHS) = CGF.EmitARCStoreAutoreleasing(E);
4253 break;
4254
4255 case Qualifiers::OCL_ExplicitNone:
4256 std::tie(LHS, RHS) = CGF.EmitARCStoreUnsafeUnretained(E, Ignore);
4257 break;
4258
4259 case Qualifiers::OCL_Weak:
4260 RHS = Visit(E->getRHS());
4261 LHS = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
4262 RHS = CGF.EmitARCStoreWeak(LHS.getAddress(CGF), RHS, Ignore);
4263 break;
4264
4265 case Qualifiers::OCL_None:
4266 // __block variables need to have the rhs evaluated first, plus
4267 // this should improve codegen just a little.
4268 RHS = Visit(E->getRHS());
4269 LHS = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
4270
4271 // Store the value into the LHS. Bit-fields are handled specially
4272 // because the result is altered by the store, i.e., [C99 6.5.16p1]
4273 // 'An assignment expression has the value of the left operand after
4274 // the assignment...'.
4275 if (LHS.isBitField()) {
4276 CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, &RHS);
4277 } else {
4278 CGF.EmitNullabilityCheck(LHS, RHS, E->getExprLoc());
4279 CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS);
4280 }
4281 }
4282
4283 // If the result is clearly ignored, return now.
4284 if (Ignore)
4285 return nullptr;
4286
4287 // The result of an assignment in C is the assigned r-value.
4288 if (!CGF.getLangOpts().CPlusPlus)
4289 return RHS;
4290
4291 // If the lvalue is non-volatile, return the computed value of the assignment.
4292 if (!LHS.isVolatileQualified())
4293 return RHS;
4294
4295 // Otherwise, reload the value.
4296 return EmitLoadOfLValue(LHS, E->getExprLoc());
4297}
4298
4299Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
4300 // Perform vector logical and on comparisons with zero vectors.
4301 if (E->getType()->isVectorType()) {
4302 CGF.incrementProfileCounter(E);
4303
4304 Value *LHS = Visit(E->getLHS());
4305 Value *RHS = Visit(E->getRHS());
4306 Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType());
4307 if (LHS->getType()->isFPOrFPVectorTy()) {
4308 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(
4309 CGF, E->getFPFeaturesInEffect(CGF.getLangOpts()));
4310 LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp");
4311 RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp");
4312 } else {
4313 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
4314 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
4315 }
4316 Value *And = Builder.CreateAnd(LHS, RHS);
4317 return Builder.CreateSExt(And, ConvertType(E->getType()), "sext");
4318 }
4319
4320 bool InstrumentRegions = CGF.CGM.getCodeGenOpts().hasProfileClangInstr();
4321 llvm::Type *ResTy = ConvertType(E->getType());
4322
4323 // If we have 0 && RHS, see if we can elide RHS, if so, just return 0.
4324 // If we have 1 && X, just emit X without inserting the control flow.
4325 bool LHSCondVal;
4326 if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
4327 if (LHSCondVal) { // If we have 1 && X, just emit X.
4328 CGF.incrementProfileCounter(E);
4329
4330 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
4331
4332 // If we're generating for profiling or coverage, generate a branch to a
4333 // block that increments the RHS counter needed to track branch condition
4334 // coverage. In this case, use "FBlock" as both the final "TrueBlock" and
4335 // "FalseBlock" after the increment is done.
4336 if (InstrumentRegions &&
4337 CodeGenFunction::isInstrumentedCondition(E->getRHS())) {
4338 llvm::BasicBlock *FBlock = CGF.createBasicBlock("land.end");
4339 llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("land.rhscnt");
4340 Builder.CreateCondBr(RHSCond, RHSBlockCnt, FBlock);
4341 CGF.EmitBlock(RHSBlockCnt);
4342 CGF.incrementProfileCounter(E->getRHS());
4343 CGF.EmitBranch(FBlock);
4344 CGF.EmitBlock(FBlock);
4345 }
4346
4347 // ZExt result to int or bool.
4348 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext");
4349 }
4350
4351 // 0 && RHS: If it is safe, just elide the RHS, and return 0/false.
4352 if (!CGF.ContainsLabel(E->getRHS()))
4353 return llvm::Constant::getNullValue(ResTy);
4354 }
4355
4356 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end");
4357 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs");
4358
4359 CodeGenFunction::ConditionalEvaluation eval(CGF);
4360
4361 // Branch on the LHS first. If it is false, go to the failure (cont) block.
4362 CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock,
4363 CGF.getProfileCount(E->getRHS()));
4364
4365 // Any edges into the ContBlock are now from an (indeterminate number of)
4366 // edges from this first condition. All of these values will be false. Start
4367 // setting up the PHI node in the Cont Block for this.
4368 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2,
4369 "", ContBlock);
4370 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
4371 PI != PE; ++PI)
4372 PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI);
4373
4374 eval.begin(CGF);
4375 CGF.EmitBlock(RHSBlock);
4376 CGF.incrementProfileCounter(E);
4377 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
4378 eval.end(CGF);
4379
4380 // Reaquire the RHS block, as there may be subblocks inserted.
4381 RHSBlock = Builder.GetInsertBlock();
4382
4383 // If we're generating for profiling or coverage, generate a branch on the
4384 // RHS to a block that increments the RHS true counter needed to track branch
4385 // condition coverage.
4386 if (InstrumentRegions &&
4387 CodeGenFunction::isInstrumentedCondition(E->getRHS())) {
4388 llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("land.rhscnt");
4389 Builder.CreateCondBr(RHSCond, RHSBlockCnt, ContBlock);
4390 CGF.EmitBlock(RHSBlockCnt);
4391 CGF.incrementProfileCounter(E->getRHS());
4392 CGF.EmitBranch(ContBlock);
4393 PN->addIncoming(RHSCond, RHSBlockCnt);
4394 }
4395
4396 // Emit an unconditional branch from this block to ContBlock.
4397 {
4398 // There is no need to emit line number for unconditional branch.
4399 auto NL = ApplyDebugLocation::CreateEmpty(CGF);
4400 CGF.EmitBlock(ContBlock);
4401 }
4402 // Insert an entry into the phi node for the edge with the value of RHSCond.
4403 PN->addIncoming(RHSCond, RHSBlock);
4404
4405 // Artificial location to preserve the scope information
4406 {
4407 auto NL = ApplyDebugLocation::CreateArtificial(CGF);
4408 PN->setDebugLoc(Builder.getCurrentDebugLocation());
4409 }
4410
4411 // ZExt result to int.
4412 return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext");
4413}
4414
4415Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
4416 // Perform vector logical or on comparisons with zero vectors.
4417 if (E->getType()->isVectorType()) {
4418 CGF.incrementProfileCounter(E);
4419
4420 Value *LHS = Visit(E->getLHS());
4421 Value *RHS = Visit(E->getRHS());
4422 Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType());
4423 if (LHS->getType()->isFPOrFPVectorTy()) {
4424 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(
4425 CGF, E->getFPFeaturesInEffect(CGF.getLangOpts()));
4426 LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp");
4427 RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp");
4428 } else {
4429 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
4430 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
4431 }
4432 Value *Or = Builder.CreateOr(LHS, RHS);
4433 return Builder.CreateSExt(Or, ConvertType(E->getType()), "sext");
4434 }
4435
4436 bool InstrumentRegions = CGF.CGM.getCodeGenOpts().hasProfileClangInstr();
4437 llvm::Type *ResTy = ConvertType(E->getType());
4438
4439 // If we have 1 || RHS, see if we can elide RHS, if so, just return 1.
4440 // If we have 0 || X, just emit X without inserting the control flow.
4441 bool LHSCondVal;
4442 if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
4443 if (!LHSCondVal) { // If we have 0 || X, just emit X.
4444 CGF.incrementProfileCounter(E);
4445
4446 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
4447
4448 // If we're generating for profiling or coverage, generate a branch to a
4449 // block that increments the RHS counter need to track branch condition
4450 // coverage. In this case, use "FBlock" as both the final "TrueBlock" and
4451 // "FalseBlock" after the increment is done.
4452 if (InstrumentRegions &&
4453 CodeGenFunction::isInstrumentedCondition(E->getRHS())) {
4454 llvm::BasicBlock *FBlock = CGF.createBasicBlock("lor.end");
4455 llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("lor.rhscnt");
4456 Builder.CreateCondBr(RHSCond, FBlock, RHSBlockCnt);
4457 CGF.EmitBlock(RHSBlockCnt);
4458 CGF.incrementProfileCounter(E->getRHS());
4459 CGF.EmitBranch(FBlock);
4460 CGF.EmitBlock(FBlock);
4461 }
4462
4463 // ZExt result to int or bool.
4464 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext");
4465 }
4466
4467 // 1 || RHS: If it is safe, just elide the RHS, and return 1/true.
4468 if (!CGF.ContainsLabel(E->getRHS()))
4469 return llvm::ConstantInt::get(ResTy, 1);
4470 }
4471
4472 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end");
4473 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs");
4474
4475 CodeGenFunction::ConditionalEvaluation eval(CGF);
4476
4477 // Branch on the LHS first. If it is true, go to the success (cont) block.
4478 CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock,
4479 CGF.getCurrentProfileCount() -
4480 CGF.getProfileCount(E->getRHS()));
4481
4482 // Any edges into the ContBlock are now from an (indeterminate number of)
4483 // edges from this first condition. All of these values will be true. Start
4484 // setting up the PHI node in the Cont Block for this.
4485 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2,
4486 "", ContBlock);
4487 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock);
4488 PI != PE; ++PI)
4489 PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI);
4490
4491 eval.begin(CGF);
4492
4493 // Emit the RHS condition as a bool value.
4494 CGF.EmitBlock(RHSBlock);
4495 CGF.incrementProfileCounter(E);
4496 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
4497
4498 eval.end(CGF);
4499
4500 // Reaquire the RHS block, as there may be subblocks inserted.
4501 RHSBlock = Builder.GetInsertBlock();
4502
4503 // If we're generating for profiling or coverage, generate a branch on the
4504 // RHS to a block that increments the RHS true counter needed to track branch
4505 // condition coverage.
4506 if (InstrumentRegions &&
4507 CodeGenFunction::isInstrumentedCondition(E->getRHS())) {
4508 llvm::BasicBlock *RHSBlockCnt = CGF.createBasicBlock("lor.rhscnt");
4509 Builder.CreateCondBr(RHSCond, ContBlock, RHSBlockCnt);
4510 CGF.EmitBlock(RHSBlockCnt);
4511 CGF.incrementProfileCounter(E->getRHS());
4512 CGF.EmitBranch(ContBlock);
4513 PN->addIncoming(RHSCond, RHSBlockCnt);
4514 }
4515
4516 // Emit an unconditional branch from this block to ContBlock. Insert an entry
4517 // into the phi node for the edge with the value of RHSCond.
4518 CGF.EmitBlock(ContBlock);
4519 PN->addIncoming(RHSCond, RHSBlock);
4520
4521 // ZExt result to int.
4522 return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext");
4523}
4524
4525Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) {
4526 CGF.EmitIgnoredExpr(E->getLHS());
4527 CGF.EnsureInsertPoint();
4528 return Visit(E->getRHS());
4529}
4530
4531//===----------------------------------------------------------------------===//
4532// Other Operators
4533//===----------------------------------------------------------------------===//
4534
4535/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified
4536/// expression is cheap enough and side-effect-free enough to evaluate
4537/// unconditionally instead of conditionally. This is used to convert control
4538/// flow into selects in some cases.
4539static bool isCheapEnoughToEvaluateUnconditionally(const Expr *E,
4540 CodeGenFunction &CGF) {
4541 // Anything that is an integer or floating point constant is fine.
4542 return E->IgnoreParens()->isEvaluatable(CGF.getContext());
4543
4544 // Even non-volatile automatic variables can't be evaluated unconditionally.
4545 // Referencing a thread_local may cause non-trivial initialization work to
4546 // occur. If we're inside a lambda and one of the variables is from the scope
4547 // outside the lambda, that function may have returned already. Reading its
4548 // locals is a bad idea. Also, these reads may introduce races there didn't
4549 // exist in the source-level program.
4550}
4551
4552
4553Value *ScalarExprEmitter::
4554VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
4555 TestAndClearIgnoreResultAssign();
4556
4557 // Bind the common expression if necessary.
4558 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
4559
4560 Expr *condExpr = E->getCond();
4561 Expr *lhsExpr = E->getTrueExpr();
4562 Expr *rhsExpr = E->getFalseExpr();
4563
4564 // If the condition constant folds and can be elided, try to avoid emitting
4565 // the condition and the dead arm.
4566 bool CondExprBool;
4567 if (CGF.ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
4568 Expr *live = lhsExpr, *dead = rhsExpr;
4569 if (!CondExprBool) std::swap(live, dead);
4570
4571 // If the dead side doesn't have labels we need, just emit the Live part.
4572 if (!CGF.ContainsLabel(dead)) {
4573 if (CondExprBool)
4574 CGF.incrementProfileCounter(E);
4575 Value *Result = Visit(live);
4576
4577 // If the live part is a throw expression, it acts like it has a void
4578 // type, so evaluating it returns a null Value*. However, a conditional
4579 // with non-void type must return a non-null Value*.
4580 if (!Result && !E->getType()->isVoidType())
4581 Result = llvm::UndefValue::get(CGF.ConvertType(E->getType()));
4582
4583 return Result;
4584 }
4585 }
4586
4587 // OpenCL: If the condition is a vector, we can treat this condition like
4588 // the select function.
4589 if ((CGF.getLangOpts().OpenCL && condExpr->getType()->isVectorType()) ||
4590 condExpr->getType()->isExtVectorType()) {
4591 CGF.incrementProfileCounter(E);
4592
4593 llvm::Value *CondV = CGF.EmitScalarExpr(condExpr);
4594 llvm::Value *LHS = Visit(lhsExpr);
4595 llvm::Value *RHS = Visit(rhsExpr);
4596
4597 llvm::Type *condType = ConvertType(condExpr->getType());
4598 auto *vecTy = cast<llvm::FixedVectorType>(condType);
4599
4600 unsigned numElem = vecTy->getNumElements();
4601 llvm::Type *elemType = vecTy->getElementType();
4602
4603 llvm::Value *zeroVec = llvm::Constant::getNullValue(vecTy);
4604 llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec);
4605 llvm::Value *tmp = Builder.CreateSExt(
4606 TestMSB, llvm::FixedVectorType::get(elemType, numElem), "sext");
4607 llvm::Value *tmp2 = Builder.CreateNot(tmp);
4608
4609 // Cast float to int to perform ANDs if necessary.
4610 llvm::Value *RHSTmp = RHS;
4611 llvm::Value *LHSTmp = LHS;
4612 bool wasCast = false;
4613 llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType());
4614 if (rhsVTy->getElementType()->isFloatingPointTy()) {
4615 RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType());
4616 LHSTmp = Builder.CreateBitCast(LHS, tmp->getType());
4617 wasCast = true;
4618 }
4619
4620 llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2);
4621 llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp);
4622 llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond");
4623 if (wasCast)
4624 tmp5 = Builder.CreateBitCast(tmp5, RHS->getType());
4625
4626 return tmp5;
4627 }
4628
4629 if (condExpr->getType()->isVectorType()) {
4630 CGF.incrementProfileCounter(E);
4631
4632 llvm::Value *CondV = CGF.EmitScalarExpr(condExpr);
4633 llvm::Value *LHS = Visit(lhsExpr);
4634 llvm::Value *RHS = Visit(rhsExpr);
4635
4636 llvm::Type *CondType = ConvertType(condExpr->getType());
4637 auto *VecTy = cast<llvm::VectorType>(CondType);
4638 llvm::Value *ZeroVec = llvm::Constant::getNullValue(VecTy);
4639
4640 CondV = Builder.CreateICmpNE(CondV, ZeroVec, "vector_cond");
4641 return Builder.CreateSelect(CondV, LHS, RHS, "vector_select");
4642 }
4643
4644 // If this is a really simple expression (like x ? 4 : 5), emit this as a
4645 // select instead of as control flow. We can only do this if it is cheap and
4646 // safe to evaluate the LHS and RHS unconditionally.
4647 if (isCheapEnoughToEvaluateUnconditionally(lhsExpr, CGF) &&
4648 isCheapEnoughToEvaluateUnconditionally(rhsExpr, CGF)) {
4649 llvm::Value *CondV = CGF.EvaluateExprAsBool(condExpr);
4650 llvm::Value *StepV = Builder.CreateZExtOrBitCast(CondV, CGF.Int64Ty);
4651
4652 CGF.incrementProfileCounter(E, StepV);
4653
4654 llvm::Value *LHS = Visit(lhsExpr);
4655 llvm::Value *RHS = Visit(rhsExpr);
4656 if (!LHS) {
4657 // If the conditional has void type, make sure we return a null Value*.
4658 assert(!RHS && "LHS and RHS types must match")(static_cast <bool> (!RHS && "LHS and RHS types must match"
) ? void (0) : __assert_fail ("!RHS && \"LHS and RHS types must match\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4658, __extension__ __PRETTY_FUNCTION__))
;
4659 return nullptr;
4660 }
4661 return Builder.CreateSelect(CondV, LHS, RHS, "cond");
4662 }
4663
4664 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
4665 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
4666 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
4667
4668 CodeGenFunction::ConditionalEvaluation eval(CGF);
4669 CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock,
4670 CGF.getProfileCount(lhsExpr));
4671
4672 CGF.EmitBlock(LHSBlock);
4673 CGF.incrementProfileCounter(E);
4674 eval.begin(CGF);
4675 Value *LHS = Visit(lhsExpr);
4676 eval.end(CGF);
4677
4678 LHSBlock = Builder.GetInsertBlock();
4679 Builder.CreateBr(ContBlock);
4680
4681 CGF.EmitBlock(RHSBlock);
4682 eval.begin(CGF);
4683 Value *RHS = Visit(rhsExpr);
4684 eval.end(CGF);
4685
4686 RHSBlock = Builder.GetInsertBlock();
4687 CGF.EmitBlock(ContBlock);
4688
4689 // If the LHS or RHS is a throw expression, it will be legitimately null.
4690 if (!LHS)
4691 return RHS;
4692 if (!RHS)
4693 return LHS;
4694
4695 // Create a PHI node for the real part.
4696 llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond");
4697 PN->addIncoming(LHS, LHSBlock);
4698 PN->addIncoming(RHS, RHSBlock);
4699 return PN;
4700}
4701
4702Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) {
4703 return Visit(E->getChosenSubExpr());
4704}
4705
4706Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
4707 QualType Ty = VE->getType();
4708
4709 if (Ty->isVariablyModifiedType())
4710 CGF.EmitVariablyModifiedType(Ty);
4711
4712 Address ArgValue = Address::invalid();
4713 Address ArgPtr = CGF.EmitVAArg(VE, ArgValue);
4714
4715 llvm::Type *ArgTy = ConvertType(VE->getType());
4716
4717 // If EmitVAArg fails, emit an error.
4718 if (!ArgPtr.isValid()) {
4719 CGF.ErrorUnsupported(VE, "va_arg expression");
4720 return llvm::UndefValue::get(ArgTy);
4721 }
4722
4723 // FIXME Volatility.
4724 llvm::Value *Val = Builder.CreateLoad(ArgPtr);
4725
4726 // If EmitVAArg promoted the type, we must truncate it.
4727 if (ArgTy != Val->getType()) {
4728 if (ArgTy->isPointerTy() && !Val->getType()->isPointerTy())
4729 Val = Builder.CreateIntToPtr(Val, ArgTy);
4730 else
4731 Val = Builder.CreateTrunc(Val, ArgTy);
4732 }
4733
4734 return Val;
4735}
4736
4737Value *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *block) {
4738 return CGF.EmitBlockLiteral(block);
4739}
4740
4741// Convert a vec3 to vec4, or vice versa.
4742static Value *ConvertVec3AndVec4(CGBuilderTy &Builder, CodeGenFunction &CGF,
4743 Value *Src, unsigned NumElementsDst) {
4744 static constexpr int Mask[] = {0, 1, 2, -1};
4745 return Builder.CreateShuffleVector(Src,
4746 llvm::makeArrayRef(Mask, NumElementsDst));
4747}
4748
4749// Create cast instructions for converting LLVM value \p Src to LLVM type \p
4750// DstTy. \p Src has the same size as \p DstTy. Both are single value types
4751// but could be scalar or vectors of different lengths, and either can be
4752// pointer.
4753// There are 4 cases:
4754// 1. non-pointer -> non-pointer : needs 1 bitcast
4755// 2. pointer -> pointer : needs 1 bitcast or addrspacecast
4756// 3. pointer -> non-pointer
4757// a) pointer -> intptr_t : needs 1 ptrtoint
4758// b) pointer -> non-intptr_t : needs 1 ptrtoint then 1 bitcast
4759// 4. non-pointer -> pointer
4760// a) intptr_t -> pointer : needs 1 inttoptr
4761// b) non-intptr_t -> pointer : needs 1 bitcast then 1 inttoptr
4762// Note: for cases 3b and 4b two casts are required since LLVM casts do not
4763// allow casting directly between pointer types and non-integer non-pointer
4764// types.
4765static Value *createCastsForTypeOfSameSize(CGBuilderTy &Builder,
4766 const llvm::DataLayout &DL,
4767 Value *Src, llvm::Type *DstTy,
4768 StringRef Name = "") {
4769 auto SrcTy = Src->getType();
4770
4771 // Case 1.
4772 if (!SrcTy->isPointerTy() && !DstTy->isPointerTy())
4773 return Builder.CreateBitCast(Src, DstTy, Name);
4774
4775 // Case 2.
4776 if (SrcTy->isPointerTy() && DstTy->isPointerTy())
4777 return Builder.CreatePointerBitCastOrAddrSpaceCast(Src, DstTy, Name);
4778
4779 // Case 3.
4780 if (SrcTy->isPointerTy() && !DstTy->isPointerTy()) {
4781 // Case 3b.
4782 if (!DstTy->isIntegerTy())
4783 Src = Builder.CreatePtrToInt(Src, DL.getIntPtrType(SrcTy));
4784 // Cases 3a and 3b.
4785 return Builder.CreateBitOrPointerCast(Src, DstTy, Name);
4786 }
4787
4788 // Case 4b.
4789 if (!SrcTy->isIntegerTy())
4790 Src = Builder.CreateBitCast(Src, DL.getIntPtrType(DstTy));
4791 // Cases 4a and 4b.
4792 return Builder.CreateIntToPtr(Src, DstTy, Name);
4793}
4794
4795Value *ScalarExprEmitter::VisitAsTypeExpr(AsTypeExpr *E) {
4796 Value *Src = CGF.EmitScalarExpr(E->getSrcExpr());
4797 llvm::Type *DstTy = ConvertType(E->getType());
4798
4799 llvm::Type *SrcTy = Src->getType();
4800 unsigned NumElementsSrc =
4801 isa<llvm::VectorType>(SrcTy)
4802 ? cast<llvm::FixedVectorType>(SrcTy)->getNumElements()
4803 : 0;
4804 unsigned NumElementsDst =
4805 isa<llvm::VectorType>(DstTy)
4806 ? cast<llvm::FixedVectorType>(DstTy)->getNumElements()
4807 : 0;
4808
4809 // Going from vec3 to non-vec3 is a special case and requires a shuffle
4810 // vector to get a vec4, then a bitcast if the target type is different.
4811 if (NumElementsSrc == 3 && NumElementsDst != 3) {
4812 Src = ConvertVec3AndVec4(Builder, CGF, Src, 4);
4813 Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src,
4814 DstTy);
4815
4816 Src->setName("astype");
4817 return Src;
4818 }
4819
4820 // Going from non-vec3 to vec3 is a special case and requires a bitcast
4821 // to vec4 if the original type is not vec4, then a shuffle vector to
4822 // get a vec3.
4823 if (NumElementsSrc != 3 && NumElementsDst == 3) {
4824 auto *Vec4Ty = llvm::FixedVectorType::get(
4825 cast<llvm::VectorType>(DstTy)->getElementType(), 4);
4826 Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src,
4827 Vec4Ty);
4828
4829 Src = ConvertVec3AndVec4(Builder, CGF, Src, 3);
4830 Src->setName("astype");
4831 return Src;
4832 }
4833
4834 return createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(),
4835 Src, DstTy, "astype");
4836}
4837
4838Value *ScalarExprEmitter::VisitAtomicExpr(AtomicExpr *E) {
4839 return CGF.EmitAtomicExpr(E).getScalarVal();
4840}
4841
4842//===----------------------------------------------------------------------===//
4843// Entry Point into this File
4844//===----------------------------------------------------------------------===//
4845
4846/// Emit the computation of the specified expression of scalar type, ignoring
4847/// the result.
4848Value *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) {
4849 assert(E && hasScalarEvaluationKind(E->getType()) &&(static_cast <bool> (E && hasScalarEvaluationKind
(E->getType()) && "Invalid scalar expression to emit"
) ? void (0) : __assert_fail ("E && hasScalarEvaluationKind(E->getType()) && \"Invalid scalar expression to emit\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4850, __extension__ __PRETTY_FUNCTION__))
4850 "Invalid scalar expression to emit")(static_cast <bool> (E && hasScalarEvaluationKind
(E->getType()) && "Invalid scalar expression to emit"
) ? void (0) : __assert_fail ("E && hasScalarEvaluationKind(E->getType()) && \"Invalid scalar expression to emit\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4850, __extension__ __PRETTY_FUNCTION__))
;
4851
4852 return ScalarExprEmitter(*this, IgnoreResultAssign)
4853 .Visit(const_cast<Expr *>(E));
4854}
4855
4856/// Emit a conversion from the specified type to the specified destination type,
4857/// both of which are LLVM scalar types.
4858Value *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy,
4859 QualType DstTy,
4860 SourceLocation Loc) {
4861 assert(hasScalarEvaluationKind(SrcTy) && hasScalarEvaluationKind(DstTy) &&(static_cast <bool> (hasScalarEvaluationKind(SrcTy) &&
hasScalarEvaluationKind(DstTy) && "Invalid scalar expression to emit"
) ? void (0) : __assert_fail ("hasScalarEvaluationKind(SrcTy) && hasScalarEvaluationKind(DstTy) && \"Invalid scalar expression to emit\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4862, __extension__ __PRETTY_FUNCTION__))
4862 "Invalid scalar expression to emit")(static_cast <bool> (hasScalarEvaluationKind(SrcTy) &&
hasScalarEvaluationKind(DstTy) && "Invalid scalar expression to emit"
) ? void (0) : __assert_fail ("hasScalarEvaluationKind(SrcTy) && hasScalarEvaluationKind(DstTy) && \"Invalid scalar expression to emit\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4862, __extension__ __PRETTY_FUNCTION__))
;
4863 return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy, Loc);
4864}
4865
4866/// Emit a conversion from the specified complex type to the specified
4867/// destination type, where the destination type is an LLVM scalar type.
4868Value *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src,
4869 QualType SrcTy,
4870 QualType DstTy,
4871 SourceLocation Loc) {
4872 assert(SrcTy->isAnyComplexType() && hasScalarEvaluationKind(DstTy) &&(static_cast <bool> (SrcTy->isAnyComplexType() &&
hasScalarEvaluationKind(DstTy) && "Invalid complex -> scalar conversion"
) ? void (0) : __assert_fail ("SrcTy->isAnyComplexType() && hasScalarEvaluationKind(DstTy) && \"Invalid complex -> scalar conversion\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4873, __extension__ __PRETTY_FUNCTION__))
4873 "Invalid complex -> scalar conversion")(static_cast <bool> (SrcTy->isAnyComplexType() &&
hasScalarEvaluationKind(DstTy) && "Invalid complex -> scalar conversion"
) ? void (0) : __assert_fail ("SrcTy->isAnyComplexType() && hasScalarEvaluationKind(DstTy) && \"Invalid complex -> scalar conversion\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4873, __extension__ __PRETTY_FUNCTION__))
;
4874 return ScalarExprEmitter(*this)
4875 .EmitComplexToScalarConversion(Src, SrcTy, DstTy, Loc);
4876}
4877
4878
4879llvm::Value *CodeGenFunction::
4880EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
4881 bool isInc, bool isPre) {
4882 return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre);
4883}
4884
4885LValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) {
4886 // object->isa or (*object).isa
4887 // Generate code as for: *(Class*)object
4888
4889 Expr *BaseExpr = E->getBase();
4890 Address Addr = Address::invalid();
4891 if (BaseExpr->isPRValue()) {
4892 Addr = Address(EmitScalarExpr(BaseExpr), getPointerAlign());
4893 } else {
4894 Addr = EmitLValue(BaseExpr).getAddress(*this);
4895 }
4896
4897 // Cast the address to Class*.
4898 Addr = Builder.CreateElementBitCast(Addr, ConvertType(E->getType()));
4899 return MakeAddrLValue(Addr, E->getType());
4900}
4901
4902
4903LValue CodeGenFunction::EmitCompoundAssignmentLValue(
4904 const CompoundAssignOperator *E) {
4905 ScalarExprEmitter Scalar(*this);
4906 Value *Result = nullptr;
4907 switch (E->getOpcode()) {
4908#define COMPOUND_OP(Op) \
4909 case BO_##Op##Assign: \
4910 return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \
4911 Result)
4912 COMPOUND_OP(Mul);
4913 COMPOUND_OP(Div);
4914 COMPOUND_OP(Rem);
4915 COMPOUND_OP(Add);
4916 COMPOUND_OP(Sub);
4917 COMPOUND_OP(Shl);
4918 COMPOUND_OP(Shr);
4919 COMPOUND_OP(And);
4920 COMPOUND_OP(Xor);
4921 COMPOUND_OP(Or);
4922#undef COMPOUND_OP
4923
4924 case BO_PtrMemD:
4925 case BO_PtrMemI:
4926 case BO_Mul:
4927 case BO_Div:
4928 case BO_Rem:
4929 case BO_Add:
4930 case BO_Sub:
4931 case BO_Shl:
4932 case BO_Shr:
4933 case BO_LT:
4934 case BO_GT:
4935 case BO_LE:
4936 case BO_GE:
4937 case BO_EQ:
4938 case BO_NE:
4939 case BO_Cmp:
4940 case BO_And:
4941 case BO_Xor:
4942 case BO_Or:
4943 case BO_LAnd:
4944 case BO_LOr:
4945 case BO_Assign:
4946 case BO_Comma:
4947 llvm_unreachable("Not valid compound assignment operators")::llvm::llvm_unreachable_internal("Not valid compound assignment operators"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4947)
;
4948 }
4949
4950 llvm_unreachable("Unhandled compound assignment operator")::llvm::llvm_unreachable_internal("Unhandled compound assignment operator"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4950)
;
4951}
4952
4953struct GEPOffsetAndOverflow {
4954 // The total (signed) byte offset for the GEP.
4955 llvm::Value *TotalOffset;
4956 // The offset overflow flag - true if the total offset overflows.
4957 llvm::Value *OffsetOverflows;
4958};
4959
4960/// Evaluate given GEPVal, which is either an inbounds GEP, or a constant,
4961/// and compute the total offset it applies from it's base pointer BasePtr.
4962/// Returns offset in bytes and a boolean flag whether an overflow happened
4963/// during evaluation.
4964static GEPOffsetAndOverflow EmitGEPOffsetInBytes(Value *BasePtr, Value *GEPVal,
4965 llvm::LLVMContext &VMContext,
4966 CodeGenModule &CGM,
4967 CGBuilderTy &Builder) {
4968 const auto &DL = CGM.getDataLayout();
4969
4970 // The total (signed) byte offset for the GEP.
4971 llvm::Value *TotalOffset = nullptr;
4972
4973 // Was the GEP already reduced to a constant?
4974 if (isa<llvm::Constant>(GEPVal)) {
4975 // Compute the offset by casting both pointers to integers and subtracting:
4976 // GEPVal = BasePtr + ptr(Offset) <--> Offset = int(GEPVal) - int(BasePtr)
4977 Value *BasePtr_int =
4978 Builder.CreatePtrToInt(BasePtr, DL.getIntPtrType(BasePtr->getType()));
4979 Value *GEPVal_int =
4980 Builder.CreatePtrToInt(GEPVal, DL.getIntPtrType(GEPVal->getType()));
4981 TotalOffset = Builder.CreateSub(GEPVal_int, BasePtr_int);
4982 return {TotalOffset, /*OffsetOverflows=*/Builder.getFalse()};
4983 }
4984
4985 auto *GEP = cast<llvm::GEPOperator>(GEPVal);
4986 assert(GEP->getPointerOperand() == BasePtr &&(static_cast <bool> (GEP->getPointerOperand() == BasePtr
&& "BasePtr must be the base of the GEP.") ? void (0
) : __assert_fail ("GEP->getPointerOperand() == BasePtr && \"BasePtr must be the base of the GEP.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4987, __extension__ __PRETTY_FUNCTION__))
4987 "BasePtr must be the base of the GEP.")(static_cast <bool> (GEP->getPointerOperand() == BasePtr
&& "BasePtr must be the base of the GEP.") ? void (0
) : __assert_fail ("GEP->getPointerOperand() == BasePtr && \"BasePtr must be the base of the GEP.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4987, __extension__ __PRETTY_FUNCTION__))
;
4988 assert(GEP->isInBounds() && "Expected inbounds GEP")(static_cast <bool> (GEP->isInBounds() && "Expected inbounds GEP"
) ? void (0) : __assert_fail ("GEP->isInBounds() && \"Expected inbounds GEP\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 4988, __extension__ __PRETTY_FUNCTION__))
;
4989
4990 auto *IntPtrTy = DL.getIntPtrType(GEP->getPointerOperandType());
4991
4992 // Grab references to the signed add/mul overflow intrinsics for intptr_t.
4993 auto *Zero = llvm::ConstantInt::getNullValue(IntPtrTy);
4994 auto *SAddIntrinsic =
4995 CGM.getIntrinsic(llvm::Intrinsic::sadd_with_overflow, IntPtrTy);
4996 auto *SMulIntrinsic =
4997 CGM.getIntrinsic(llvm::Intrinsic::smul_with_overflow, IntPtrTy);
4998
4999 // The offset overflow flag - true if the total offset overflows.
5000 llvm::Value *OffsetOverflows = Builder.getFalse();
5001
5002 /// Return the result of the given binary operation.
5003 auto eval = [&](BinaryOperator::Opcode Opcode, llvm::Value *LHS,
5004 llvm::Value *RHS) -> llvm::Value * {
5005 assert((Opcode == BO_Add || Opcode == BO_Mul) && "Can't eval binop")(static_cast <bool> ((Opcode == BO_Add || Opcode == BO_Mul
) && "Can't eval binop") ? void (0) : __assert_fail (
"(Opcode == BO_Add || Opcode == BO_Mul) && \"Can't eval binop\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 5005, __extension__ __PRETTY_FUNCTION__))
;
5006
5007 // If the operands are constants, return a constant result.
5008 if (auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS)) {
5009 if (auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS)) {
5010 llvm::APInt N;
5011 bool HasOverflow = mayHaveIntegerOverflow(LHSCI, RHSCI, Opcode,
5012 /*Signed=*/true, N);
5013 if (HasOverflow)
5014 OffsetOverflows = Builder.getTrue();
5015 return llvm::ConstantInt::get(VMContext, N);
5016 }
5017 }
5018
5019 // Otherwise, compute the result with checked arithmetic.
5020 auto *ResultAndOverflow = Builder.CreateCall(
5021 (Opcode == BO_Add) ? SAddIntrinsic : SMulIntrinsic, {LHS, RHS});
5022 OffsetOverflows = Builder.CreateOr(
5023 Builder.CreateExtractValue(ResultAndOverflow, 1), OffsetOverflows);
5024 return Builder.CreateExtractValue(ResultAndOverflow, 0);
5025 };
5026
5027 // Determine the total byte offset by looking at each GEP operand.
5028 for (auto GTI = llvm::gep_type_begin(GEP), GTE = llvm::gep_type_end(GEP);
5029 GTI != GTE; ++GTI) {
5030 llvm::Value *LocalOffset;
5031 auto *Index = GTI.getOperand();
5032 // Compute the local offset contributed by this indexing step:
5033 if (auto *STy = GTI.getStructTypeOrNull()) {
5034 // For struct indexing, the local offset is the byte position of the
5035 // specified field.
5036 unsigned FieldNo = cast<llvm::ConstantInt>(Index)->getZExtValue();
5037 LocalOffset = llvm::ConstantInt::get(
5038 IntPtrTy, DL.getStructLayout(STy)->getElementOffset(FieldNo));
5039 } else {
5040 // Otherwise this is array-like indexing. The local offset is the index
5041 // multiplied by the element size.
5042 auto *ElementSize = llvm::ConstantInt::get(
5043 IntPtrTy, DL.getTypeAllocSize(GTI.getIndexedType()));
5044 auto *IndexS = Builder.CreateIntCast(Index, IntPtrTy, /*isSigned=*/true);
5045 LocalOffset = eval(BO_Mul, ElementSize, IndexS);
5046 }
5047
5048 // If this is the first offset, set it as the total offset. Otherwise, add
5049 // the local offset into the running total.
5050 if (!TotalOffset || TotalOffset == Zero)
5051 TotalOffset = LocalOffset;
5052 else
5053 TotalOffset = eval(BO_Add, TotalOffset, LocalOffset);
5054 }
5055
5056 return {TotalOffset, OffsetOverflows};
5057}
5058
5059Value *
5060CodeGenFunction::EmitCheckedInBoundsGEP(Value *Ptr, ArrayRef<Value *> IdxList,
5061 bool SignedIndices, bool IsSubtraction,
5062 SourceLocation Loc, const Twine &Name) {
5063 llvm::Type *PtrTy = Ptr->getType();
5064 Value *GEPVal = Builder.CreateInBoundsGEP(
5065 PtrTy->getPointerElementType(), Ptr, IdxList, Name);
5066
5067 // If the pointer overflow sanitizer isn't enabled, do nothing.
5068 if (!SanOpts.has(SanitizerKind::PointerOverflow))
5069 return GEPVal;
5070
5071 // Perform nullptr-and-offset check unless the nullptr is defined.
5072 bool PerformNullCheck = !NullPointerIsDefined(
5073 Builder.GetInsertBlock()->getParent(), PtrTy->getPointerAddressSpace());
5074 // Check for overflows unless the GEP got constant-folded,
5075 // and only in the default address space
5076 bool PerformOverflowCheck =
5077 !isa<llvm::Constant>(GEPVal) && PtrTy->getPointerAddressSpace() == 0;
5078
5079 if (!(PerformNullCheck || PerformOverflowCheck))
5080 return GEPVal;
5081
5082 const auto &DL = CGM.getDataLayout();
5083
5084 SanitizerScope SanScope(this);
5085 llvm::Type *IntPtrTy = DL.getIntPtrType(PtrTy);
5086
5087 GEPOffsetAndOverflow EvaluatedGEP =
5088 EmitGEPOffsetInBytes(Ptr, GEPVal, getLLVMContext(), CGM, Builder);
5089
5090 assert((!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) ||(static_cast <bool> ((!isa<llvm::Constant>(EvaluatedGEP
.TotalOffset) || EvaluatedGEP.OffsetOverflows == Builder.getFalse
()) && "If the offset got constant-folded, we don't expect that there was an "
"overflow.") ? void (0) : __assert_fail ("(!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) || EvaluatedGEP.OffsetOverflows == Builder.getFalse()) && \"If the offset got constant-folded, we don't expect that there was an \" \"overflow.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 5093, __extension__ __PRETTY_FUNCTION__))
5091 EvaluatedGEP.OffsetOverflows == Builder.getFalse()) &&(static_cast <bool> ((!isa<llvm::Constant>(EvaluatedGEP
.TotalOffset) || EvaluatedGEP.OffsetOverflows == Builder.getFalse
()) && "If the offset got constant-folded, we don't expect that there was an "
"overflow.") ? void (0) : __assert_fail ("(!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) || EvaluatedGEP.OffsetOverflows == Builder.getFalse()) && \"If the offset got constant-folded, we don't expect that there was an \" \"overflow.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 5093, __extension__ __PRETTY_FUNCTION__))
5092 "If the offset got constant-folded, we don't expect that there was an "(static_cast <bool> ((!isa<llvm::Constant>(EvaluatedGEP
.TotalOffset) || EvaluatedGEP.OffsetOverflows == Builder.getFalse
()) && "If the offset got constant-folded, we don't expect that there was an "
"overflow.") ? void (0) : __assert_fail ("(!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) || EvaluatedGEP.OffsetOverflows == Builder.getFalse()) && \"If the offset got constant-folded, we don't expect that there was an \" \"overflow.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 5093, __extension__ __PRETTY_FUNCTION__))
5093 "overflow.")(static_cast <bool> ((!isa<llvm::Constant>(EvaluatedGEP
.TotalOffset) || EvaluatedGEP.OffsetOverflows == Builder.getFalse
()) && "If the offset got constant-folded, we don't expect that there was an "
"overflow.") ? void (0) : __assert_fail ("(!isa<llvm::Constant>(EvaluatedGEP.TotalOffset) || EvaluatedGEP.OffsetOverflows == Builder.getFalse()) && \"If the offset got constant-folded, we don't expect that there was an \" \"overflow.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 5093, __extension__ __PRETTY_FUNCTION__))
;
5094
5095 auto *Zero = llvm::ConstantInt::getNullValue(IntPtrTy);
5096
5097 // Common case: if the total offset is zero, and we are using C++ semantics,
5098 // where nullptr+0 is defined, don't emit a check.
5099 if (EvaluatedGEP.TotalOffset == Zero && CGM.getLangOpts().CPlusPlus)
5100 return GEPVal;
5101
5102 // Now that we've computed the total offset, add it to the base pointer (with
5103 // wrapping semantics).
5104 auto *IntPtr = Builder.CreatePtrToInt(Ptr, IntPtrTy);
5105 auto *ComputedGEP = Builder.CreateAdd(IntPtr, EvaluatedGEP.TotalOffset);
5106
5107 llvm::SmallVector<std::pair<llvm::Value *, SanitizerMask>, 2> Checks;
5108
5109 if (PerformNullCheck) {
5110 // In C++, if the base pointer evaluates to a null pointer value,
5111 // the only valid pointer this inbounds GEP can produce is also
5112 // a null pointer, so the offset must also evaluate to zero.
5113 // Likewise, if we have non-zero base pointer, we can not get null pointer
5114 // as a result, so the offset can not be -intptr_t(BasePtr).
5115 // In other words, both pointers are either null, or both are non-null,
5116 // or the behaviour is undefined.
5117 //
5118 // C, however, is more strict in this regard, and gives more
5119 // optimization opportunities: in C, additionally, nullptr+0 is undefined.
5120 // So both the input to the 'gep inbounds' AND the output must not be null.
5121 auto *BaseIsNotNullptr = Builder.CreateIsNotNull(Ptr);
5122 auto *ResultIsNotNullptr = Builder.CreateIsNotNull(ComputedGEP);
5123 auto *Valid =
5124 CGM.getLangOpts().CPlusPlus
5125 ? Builder.CreateICmpEQ(BaseIsNotNullptr, ResultIsNotNullptr)
5126 : Builder.CreateAnd(BaseIsNotNullptr, ResultIsNotNullptr);
5127 Checks.emplace_back(Valid, SanitizerKind::PointerOverflow);
5128 }
5129
5130 if (PerformOverflowCheck) {
5131 // The GEP is valid if:
5132 // 1) The total offset doesn't overflow, and
5133 // 2) The sign of the difference between the computed address and the base
5134 // pointer matches the sign of the total offset.
5135 llvm::Value *ValidGEP;
5136 auto *NoOffsetOverflow = Builder.CreateNot(EvaluatedGEP.OffsetOverflows);
5137 if (SignedIndices) {
5138 // GEP is computed as `unsigned base + signed offset`, therefore:
5139 // * If offset was positive, then the computed pointer can not be
5140 // [unsigned] less than the base pointer, unless it overflowed.
5141 // * If offset was negative, then the computed pointer can not be
5142 // [unsigned] greater than the bas pointere, unless it overflowed.
5143 auto *PosOrZeroValid = Builder.CreateICmpUGE(ComputedGEP, IntPtr);
5144 auto *PosOrZeroOffset =
5145 Builder.CreateICmpSGE(EvaluatedGEP.TotalOffset, Zero);
5146 llvm::Value *NegValid = Builder.CreateICmpULT(ComputedGEP, IntPtr);
5147 ValidGEP =
5148 Builder.CreateSelect(PosOrZeroOffset, PosOrZeroValid, NegValid);
5149 } else if (!IsSubtraction) {
5150 // GEP is computed as `unsigned base + unsigned offset`, therefore the
5151 // computed pointer can not be [unsigned] less than base pointer,
5152 // unless there was an overflow.
5153 // Equivalent to `@llvm.uadd.with.overflow(%base, %offset)`.
5154 ValidGEP = Builder.CreateICmpUGE(ComputedGEP, IntPtr);
5155 } else {
5156 // GEP is computed as `unsigned base - unsigned offset`, therefore the
5157 // computed pointer can not be [unsigned] greater than base pointer,
5158 // unless there was an overflow.
5159 // Equivalent to `@llvm.usub.with.overflow(%base, sub(0, %offset))`.
5160 ValidGEP = Builder.CreateICmpULE(ComputedGEP, IntPtr);
5161 }
5162 ValidGEP = Builder.CreateAnd(ValidGEP, NoOffsetOverflow);
5163 Checks.emplace_back(ValidGEP, SanitizerKind::PointerOverflow);
5164 }
5165
5166 assert(!Checks.empty() && "Should have produced some checks.")(static_cast <bool> (!Checks.empty() && "Should have produced some checks."
) ? void (0) : __assert_fail ("!Checks.empty() && \"Should have produced some checks.\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/clang/lib/CodeGen/CGExprScalar.cpp"
, 5166, __extension__ __PRETTY_FUNCTION__))
;
5167
5168 llvm::Constant *StaticArgs[] = {EmitCheckSourceLocation(Loc)};
5169 // Pass the computed GEP to the runtime to avoid emitting poisoned arguments.
5170 llvm::Value *DynamicArgs[] = {IntPtr, ComputedGEP};
5171 EmitCheck(Checks, SanitizerHandler::PointerOverflow, StaticArgs, DynamicArgs);
5172
5173 return GEPVal;
5174}

/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/llvm/include/llvm/IR/Type.h

1//===- llvm/Type.h - Classes for handling data types ------------*- C++ -*-===//
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 file contains the declaration of the Type class. For more "Type"
10// stuff, look in DerivedTypes.h.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_IR_TYPE_H
15#define LLVM_IR_TYPE_H
16
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/SmallPtrSet.h"
19#include "llvm/Support/CBindingWrapping.h"
20#include "llvm/Support/Casting.h"
21#include "llvm/Support/Compiler.h"
22#include "llvm/Support/ErrorHandling.h"
23#include "llvm/Support/TypeSize.h"
24#include <cassert>
25#include <cstdint>
26#include <iterator>
27
28namespace llvm {
29
30class IntegerType;
31struct fltSemantics;
32class LLVMContext;
33class PointerType;
34class raw_ostream;
35class StringRef;
36
37/// The instances of the Type class are immutable: once they are created,
38/// they are never changed. Also note that only one instance of a particular
39/// type is ever created. Thus seeing if two types are equal is a matter of
40/// doing a trivial pointer comparison. To enforce that no two equal instances
41/// are created, Type instances can only be created via static factory methods
42/// in class Type and in derived classes. Once allocated, Types are never
43/// free'd.
44///
45class Type {
46public:
47 //===--------------------------------------------------------------------===//
48 /// Definitions of all of the base types for the Type system. Based on this
49 /// value, you can cast to a class defined in DerivedTypes.h.
50 /// Note: If you add an element to this, you need to add an element to the
51 /// Type::getPrimitiveType function, or else things will break!
52 /// Also update LLVMTypeKind and LLVMGetTypeKind () in the C binding.
53 ///
54 enum TypeID {
55 // PrimitiveTypes
56 HalfTyID = 0, ///< 16-bit floating point type
57 BFloatTyID, ///< 16-bit floating point type (7-bit significand)
58 FloatTyID, ///< 32-bit floating point type
59 DoubleTyID, ///< 64-bit floating point type
60 X86_FP80TyID, ///< 80-bit floating point type (X87)
61 FP128TyID, ///< 128-bit floating point type (112-bit significand)
62 PPC_FP128TyID, ///< 128-bit floating point type (two 64-bits, PowerPC)
63 VoidTyID, ///< type with no size
64 LabelTyID, ///< Labels
65 MetadataTyID, ///< Metadata
66 X86_MMXTyID, ///< MMX vectors (64 bits, X86 specific)
67 X86_AMXTyID, ///< AMX vectors (8192 bits, X86 specific)
68 TokenTyID, ///< Tokens
69
70 // Derived types... see DerivedTypes.h file.
71 IntegerTyID, ///< Arbitrary bit width integers
72 FunctionTyID, ///< Functions
73 PointerTyID, ///< Pointers
74 StructTyID, ///< Structures
75 ArrayTyID, ///< Arrays
76 FixedVectorTyID, ///< Fixed width SIMD vector type
77 ScalableVectorTyID ///< Scalable SIMD vector type
78 };
79
80private:
81 /// This refers to the LLVMContext in which this type was uniqued.
82 LLVMContext &Context;
83
84 TypeID ID : 8; // The current base type of this type.
85 unsigned SubclassData : 24; // Space for subclasses to store data.
86 // Note that this should be synchronized with
87 // MAX_INT_BITS value in IntegerType class.
88
89protected:
90 friend class LLVMContextImpl;
91
92 explicit Type(LLVMContext &C, TypeID tid)
93 : Context(C), ID(tid), SubclassData(0) {}
94 ~Type() = default;
95
96 unsigned getSubclassData() const { return SubclassData; }
97
98 void setSubclassData(unsigned val) {
99 SubclassData = val;
100 // Ensure we don't have any accidental truncation.
101 assert(getSubclassData() == val && "Subclass data too large for field")(static_cast <bool> (getSubclassData() == val &&
"Subclass data too large for field") ? void (0) : __assert_fail
("getSubclassData() == val && \"Subclass data too large for field\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/llvm/include/llvm/IR/Type.h"
, 101, __extension__ __PRETTY_FUNCTION__))
;
102 }
103
104 /// Keeps track of how many Type*'s there are in the ContainedTys list.
105 unsigned NumContainedTys = 0;
106
107 /// A pointer to the array of Types contained by this Type. For example, this
108 /// includes the arguments of a function type, the elements of a structure,
109 /// the pointee of a pointer, the element type of an array, etc. This pointer
110 /// may be 0 for types that don't contain other types (Integer, Double,
111 /// Float).
112 Type * const *ContainedTys = nullptr;
113
114public:
115 /// Print the current type.
116 /// Omit the type details if \p NoDetails == true.
117 /// E.g., let %st = type { i32, i16 }
118 /// When \p NoDetails is true, we only print %st.
119 /// Put differently, \p NoDetails prints the type as if
120 /// inlined with the operands when printing an instruction.
121 void print(raw_ostream &O, bool IsForDebug = false,
122 bool NoDetails = false) const;
123
124 void dump() const;
125
126 /// Return the LLVMContext in which this type was uniqued.
127 LLVMContext &getContext() const { return Context; }
128
129 //===--------------------------------------------------------------------===//
130 // Accessors for working with types.
131 //
132
133 /// Return the type id for the type. This will return one of the TypeID enum
134 /// elements defined above.
135 TypeID getTypeID() const { return ID; }
136
137 /// Return true if this is 'void'.
138 bool isVoidTy() const { return getTypeID() == VoidTyID; }
139
140 /// Return true if this is 'half', a 16-bit IEEE fp type.
141 bool isHalfTy() const { return getTypeID() == HalfTyID; }
142
143 /// Return true if this is 'bfloat', a 16-bit bfloat type.
144 bool isBFloatTy() const { return getTypeID() == BFloatTyID; }
145
146 /// Return true if this is 'float', a 32-bit IEEE fp type.
147 bool isFloatTy() const { return getTypeID() == FloatTyID; }
148
149 /// Return true if this is 'double', a 64-bit IEEE fp type.
150 bool isDoubleTy() const { return getTypeID() == DoubleTyID; }
151
152 /// Return true if this is x86 long double.
153 bool isX86_FP80Ty() const { return getTypeID() == X86_FP80TyID; }
154
155 /// Return true if this is 'fp128'.
156 bool isFP128Ty() const { return getTypeID() == FP128TyID; }
157
158 /// Return true if this is powerpc long double.
159 bool isPPC_FP128Ty() const { return getTypeID() == PPC_FP128TyID; }
160
161 /// Return true if this is one of the six floating-point types
162 bool isFloatingPointTy() const {
163 return getTypeID() == HalfTyID || getTypeID() == BFloatTyID ||
164 getTypeID() == FloatTyID || getTypeID() == DoubleTyID ||
165 getTypeID() == X86_FP80TyID || getTypeID() == FP128TyID ||
166 getTypeID() == PPC_FP128TyID;
167 }
168
169 const fltSemantics &getFltSemantics() const;
170
171 /// Return true if this is X86 MMX.
172 bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID; }
173
174 /// Return true if this is X86 AMX.
175 bool isX86_AMXTy() const { return getTypeID() == X86_AMXTyID; }
176
177 /// Return true if this is a FP type or a vector of FP.
178 bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); }
179
180 /// Return true if this is 'label'.
181 bool isLabelTy() const { return getTypeID() == LabelTyID; }
182
183 /// Return true if this is 'metadata'.
184 bool isMetadataTy() const { return getTypeID() == MetadataTyID; }
185
186 /// Return true if this is 'token'.
187 bool isTokenTy() const { return getTypeID() == TokenTyID; }
188
189 /// True if this is an instance of IntegerType.
190 bool isIntegerTy() const { return getTypeID() == IntegerTyID; }
191
192 /// Return true if this is an IntegerType of the given width.
193 bool isIntegerTy(unsigned Bitwidth) const;
194
195 /// Return true if this is an integer type or a vector of integer types.
196 bool isIntOrIntVectorTy() const { return getScalarType()->isIntegerTy(); }
197
198 /// Return true if this is an integer type or a vector of integer types of
199 /// the given width.
200 bool isIntOrIntVectorTy(unsigned BitWidth) const {
201 return getScalarType()->isIntegerTy(BitWidth);
202 }
203
204 /// Return true if this is an integer type or a pointer type.
205 bool isIntOrPtrTy() const { return isIntegerTy() || isPointerTy(); }
206
207 /// True if this is an instance of FunctionType.
208 bool isFunctionTy() const { return getTypeID() == FunctionTyID; }
209
210 /// True if this is an instance of StructType.
211 bool isStructTy() const { return getTypeID() == StructTyID; }
212
213 /// True if this is an instance of ArrayType.
214 bool isArrayTy() const { return getTypeID() == ArrayTyID; }
215
216 /// True if this is an instance of PointerType.
217 bool isPointerTy() const { return getTypeID() == PointerTyID; }
4
Assuming the condition is false
5
Returning zero, which participates in a condition later
218
219 /// True if this is an instance of an opaque PointerType.
220 bool isOpaquePointerTy() const;
221
222 /// Return true if this is a pointer type or a vector of pointer types.
223 bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); }
3
Calling 'Type::isPointerTy'
6
Returning from 'Type::isPointerTy'
7
Returning zero, which participates in a condition later
224
225 /// True if this is an instance of VectorType.
226 inline bool isVectorTy() const {
227 return getTypeID() == ScalableVectorTyID || getTypeID() == FixedVectorTyID;
228 }
229
230 /// Return true if this type could be converted with a lossless BitCast to
231 /// type 'Ty'. For example, i8* to i32*. BitCasts are valid for types of the
232 /// same size only where no re-interpretation of the bits is done.
233 /// Determine if this type could be losslessly bitcast to Ty
234 bool canLosslesslyBitCastTo(Type *Ty) const;
235
236 /// Return true if this type is empty, that is, it has no elements or all of
237 /// its elements are empty.
238 bool isEmptyTy() const;
239
240 /// Return true if the type is "first class", meaning it is a valid type for a
241 /// Value.
242 bool isFirstClassType() const {
243 return getTypeID() != FunctionTyID && getTypeID() != VoidTyID;
244 }
245
246 /// Return true if the type is a valid type for a register in codegen. This
247 /// includes all first-class types except struct and array types.
248 bool isSingleValueType() const {
249 return isFloatingPointTy() || isX86_MMXTy() || isIntegerTy() ||
250 isPointerTy() || isVectorTy() || isX86_AMXTy();
251 }
252
253 /// Return true if the type is an aggregate type. This means it is valid as
254 /// the first operand of an insertvalue or extractvalue instruction. This
255 /// includes struct and array types, but does not include vector types.
256 bool isAggregateType() const {
257 return getTypeID() == StructTyID || getTypeID() == ArrayTyID;
258 }
259
260 /// Return true if it makes sense to take the size of this type. To get the
261 /// actual size for a particular target, it is reasonable to use the
262 /// DataLayout subsystem to do this.
263 bool isSized(SmallPtrSetImpl<Type*> *Visited = nullptr) const {
264 // If it's a primitive, it is always sized.
265 if (getTypeID() == IntegerTyID || isFloatingPointTy() ||
266 getTypeID() == PointerTyID || getTypeID() == X86_MMXTyID ||
267 getTypeID() == X86_AMXTyID)
268 return true;
269 // If it is not something that can have a size (e.g. a function or label),
270 // it doesn't have a size.
271 if (getTypeID() != StructTyID && getTypeID() != ArrayTyID && !isVectorTy())
272 return false;
273 // Otherwise we have to try harder to decide.
274 return isSizedDerivedType(Visited);
275 }
276
277 /// Return the basic size of this type if it is a primitive type. These are
278 /// fixed by LLVM and are not target-dependent.
279 /// This will return zero if the type does not have a size or is not a
280 /// primitive type.
281 ///
282 /// If this is a scalable vector type, the scalable property will be set and
283 /// the runtime size will be a positive integer multiple of the base size.
284 ///
285 /// Note that this may not reflect the size of memory allocated for an
286 /// instance of the type or the number of bytes that are written when an
287 /// instance of the type is stored to memory. The DataLayout class provides
288 /// additional query functions to provide this information.
289 ///
290 TypeSize getPrimitiveSizeInBits() const LLVM_READONLY__attribute__((__pure__));
291
292 /// If this is a vector type, return the getPrimitiveSizeInBits value for the
293 /// element type. Otherwise return the getPrimitiveSizeInBits value for this
294 /// type.
295 unsigned getScalarSizeInBits() const LLVM_READONLY__attribute__((__pure__));
296
297 /// Return the width of the mantissa of this type. This is only valid on
298 /// floating-point types. If the FP type does not have a stable mantissa (e.g.
299 /// ppc long double), this method returns -1.
300 int getFPMantissaWidth() const;
301
302 /// Return whether the type is IEEE compatible, as defined by the eponymous
303 /// method in APFloat.
304 bool isIEEE() const;
305
306 /// If this is a vector type, return the element type, otherwise return
307 /// 'this'.
308 inline Type *getScalarType() const {
309 if (isVectorTy())
310 return getContainedType(0);
311 return const_cast<Type *>(this);
312 }
313
314 //===--------------------------------------------------------------------===//
315 // Type Iteration support.
316 //
317 using subtype_iterator = Type * const *;
318
319 subtype_iterator subtype_begin() const { return ContainedTys; }
320 subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
321 ArrayRef<Type*> subtypes() const {
322 return makeArrayRef(subtype_begin(), subtype_end());
323 }
324
325 using subtype_reverse_iterator = std::reverse_iterator<subtype_iterator>;
326
327 subtype_reverse_iterator subtype_rbegin() const {
328 return subtype_reverse_iterator(subtype_end());
329 }
330 subtype_reverse_iterator subtype_rend() const {
331 return subtype_reverse_iterator(subtype_begin());
332 }
333
334 /// This method is used to implement the type iterator (defined at the end of
335 /// the file). For derived types, this returns the types 'contained' in the
336 /// derived type.
337 Type *getContainedType(unsigned i) const {
338 assert(i < NumContainedTys && "Index out of range!")(static_cast <bool> (i < NumContainedTys && "Index out of range!"
) ? void (0) : __assert_fail ("i < NumContainedTys && \"Index out of range!\""
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/llvm/include/llvm/IR/Type.h"
, 338, __extension__ __PRETTY_FUNCTION__))
;
339 return ContainedTys[i];
340 }
341
342 /// Return the number of types in the derived type.
343 unsigned getNumContainedTypes() const { return NumContainedTys; }
344
345 //===--------------------------------------------------------------------===//
346 // Helper methods corresponding to subclass methods. This forces a cast to
347 // the specified subclass and calls its accessor. "getArrayNumElements" (for
348 // example) is shorthand for cast<ArrayType>(Ty)->getNumElements(). This is
349 // only intended to cover the core methods that are frequently used, helper
350 // methods should not be added here.
351
352 inline unsigned getIntegerBitWidth() const;
353
354 inline Type *getFunctionParamType(unsigned i) const;
355 inline unsigned getFunctionNumParams() const;
356 inline bool isFunctionVarArg() const;
357
358 inline StringRef getStructName() const;
359 inline unsigned getStructNumElements() const;
360 inline Type *getStructElementType(unsigned N) const;
361
362 inline uint64_t getArrayNumElements() const;
363
364 Type *getArrayElementType() const {
365 assert(getTypeID() == ArrayTyID)(static_cast <bool> (getTypeID() == ArrayTyID) ? void (
0) : __assert_fail ("getTypeID() == ArrayTyID", "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/llvm/include/llvm/IR/Type.h"
, 365, __extension__ __PRETTY_FUNCTION__))
;
366 return ContainedTys[0];
367 }
368
369 Type *getPointerElementType() const {
370 assert(getTypeID() == PointerTyID)(static_cast <bool> (getTypeID() == PointerTyID) ? void
(0) : __assert_fail ("getTypeID() == PointerTyID", "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/llvm/include/llvm/IR/Type.h"
, 370, __extension__ __PRETTY_FUNCTION__))
;
371 return ContainedTys[0];
372 }
373
374 /// Given vector type, change the element type,
375 /// whilst keeping the old number of elements.
376 /// For non-vectors simply returns \p EltTy.
377 inline Type *getWithNewType(Type *EltTy) const;
378
379 /// Given an integer or vector type, change the lane bitwidth to NewBitwidth,
380 /// whilst keeping the old number of lanes.
381 inline Type *getWithNewBitWidth(unsigned NewBitWidth) const;
382
383 /// Given scalar/vector integer type, returns a type with elements twice as
384 /// wide as in the original type. For vectors, preserves element count.
385 inline Type *getExtendedType() const;
386
387 /// Get the address space of this pointer or pointer vector type.
388 inline unsigned getPointerAddressSpace() const;
389
390 //===--------------------------------------------------------------------===//
391 // Static members exported by the Type class itself. Useful for getting
392 // instances of Type.
393 //
394
395 /// Return a type based on an identifier.
396 static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber);
397
398 //===--------------------------------------------------------------------===//
399 // These are the builtin types that are always available.
400 //
401 static Type *getVoidTy(LLVMContext &C);
402 static Type *getLabelTy(LLVMContext &C);
403 static Type *getHalfTy(LLVMContext &C);
404 static Type *getBFloatTy(LLVMContext &C);
405 static Type *getFloatTy(LLVMContext &C);
406 static Type *getDoubleTy(LLVMContext &C);
407 static Type *getMetadataTy(LLVMContext &C);
408 static Type *getX86_FP80Ty(LLVMContext &C);
409 static Type *getFP128Ty(LLVMContext &C);
410 static Type *getPPC_FP128Ty(LLVMContext &C);
411 static Type *getX86_MMXTy(LLVMContext &C);
412 static Type *getX86_AMXTy(LLVMContext &C);
413 static Type *getTokenTy(LLVMContext &C);
414 static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
415 static IntegerType *getInt1Ty(LLVMContext &C);
416 static IntegerType *getInt8Ty(LLVMContext &C);
417 static IntegerType *getInt16Ty(LLVMContext &C);
418 static IntegerType *getInt32Ty(LLVMContext &C);
419 static IntegerType *getInt64Ty(LLVMContext &C);
420 static IntegerType *getInt128Ty(LLVMContext &C);
421 template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
422 int noOfBits = sizeof(ScalarTy) * CHAR_BIT8;
423 if (std::is_integral<ScalarTy>::value) {
424 return (Type*) Type::getIntNTy(C, noOfBits);
425 } else if (std::is_floating_point<ScalarTy>::value) {
426 switch (noOfBits) {
427 case 32:
428 return Type::getFloatTy(C);
429 case 64:
430 return Type::getDoubleTy(C);
431 }
432 }
433 llvm_unreachable("Unsupported type in Type::getScalarTy")::llvm::llvm_unreachable_internal("Unsupported type in Type::getScalarTy"
, "/build/llvm-toolchain-snapshot-14~++20211110111138+cffbfd01e37b/llvm/include/llvm/IR/Type.h"
, 433)
;
434