Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -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 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/include -I /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/build-llvm/tools/clang/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-01-11-115256-23437-1 -x c++ /build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/lib/CodeGen/CGExprScalar.cpp

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

/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h

<
1//===- Type.h - C Language Family Type Representation -----------*- 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/// \file
10/// C Language Family Type Representation
11///
12/// This file defines the clang::Type interface and subclasses, used to
13/// represent types for languages in the C family.
14//
15//===----------------------------------------------------------------------===//
16
17#ifndef LLVM_CLANG_AST_TYPE_H
18#define LLVM_CLANG_AST_TYPE_H
19
20#include "clang/AST/NestedNameSpecifier.h"
21#include "clang/AST/TemplateName.h"
22#include "clang/Basic/AddressSpaces.h"
23#include "clang/Basic/AttrKinds.h"
24#include "clang/Basic/Diagnostic.h"
25#include "clang/Basic/ExceptionSpecificationType.h"
26#include "clang/Basic/LLVM.h"
27#include "clang/Basic/Linkage.h"
28#include "clang/Basic/PartialDiagnostic.h"
29#include "clang/Basic/SourceLocation.h"
30#include "clang/Basic/Specifiers.h"
31#include "clang/Basic/Visibility.h"
32#include "llvm/ADT/APInt.h"
33#include "llvm/ADT/APSInt.h"
34#include "llvm/ADT/ArrayRef.h"
35#include "llvm/ADT/FoldingSet.h"
36#include "llvm/ADT/None.h"
37#include "llvm/ADT/Optional.h"
38#include "llvm/ADT/PointerIntPair.h"
39#include "llvm/ADT/PointerUnion.h"
40#include "llvm/ADT/StringRef.h"
41#include "llvm/ADT/Twine.h"
42#include "llvm/ADT/iterator_range.h"
43#include "llvm/Support/Casting.h"
44#include "llvm/Support/Compiler.h"
45#include "llvm/Support/ErrorHandling.h"
46#include "llvm/Support/PointerLikeTypeTraits.h"
47#include "llvm/Support/type_traits.h"
48#include "llvm/Support/TrailingObjects.h"
49#include <cassert>
50#include <cstddef>
51#include <cstdint>
52#include <cstring>
53#include <string>
54#include <type_traits>
55#include <utility>
56
57namespace clang {
58
59class ExtQuals;
60class QualType;
61class TagDecl;
62class Type;
63
64enum {
65 TypeAlignmentInBits = 4,
66 TypeAlignment = 1 << TypeAlignmentInBits
67};
68
69namespace serialization {
70 template <class T> class AbstractTypeReader;
71 template <class T> class AbstractTypeWriter;
72}
73
74} // namespace clang
75
76namespace llvm {
77
78 template <typename T>
79 struct PointerLikeTypeTraits;
80 template<>
81 struct PointerLikeTypeTraits< ::clang::Type*> {
82 static inline void *getAsVoidPointer(::clang::Type *P) { return P; }
83
84 static inline ::clang::Type *getFromVoidPointer(void *P) {
85 return static_cast< ::clang::Type*>(P);
86 }
87
88 enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
89 };
90
91 template<>
92 struct PointerLikeTypeTraits< ::clang::ExtQuals*> {
93 static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }
94
95 static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
96 return static_cast< ::clang::ExtQuals*>(P);
97 }
98
99 enum { NumLowBitsAvailable = clang::TypeAlignmentInBits };
100 };
101
102} // namespace llvm
103
104namespace clang {
105
106class ASTContext;
107template <typename> class CanQual;
108class CXXRecordDecl;
109class DeclContext;
110class EnumDecl;
111class Expr;
112class ExtQualsTypeCommonBase;
113class FunctionDecl;
114class IdentifierInfo;
115class NamedDecl;
116class ObjCInterfaceDecl;
117class ObjCProtocolDecl;
118class ObjCTypeParamDecl;
119struct PrintingPolicy;
120class RecordDecl;
121class Stmt;
122class TagDecl;
123class TemplateArgument;
124class TemplateArgumentListInfo;
125class TemplateArgumentLoc;
126class TemplateTypeParmDecl;
127class TypedefNameDecl;
128class UnresolvedUsingTypenameDecl;
129
130using CanQualType = CanQual<Type>;
131
132// Provide forward declarations for all of the *Type classes.
133#define TYPE(Class, Base) class Class##Type;
134#include "clang/AST/TypeNodes.inc"
135
136/// The collection of all-type qualifiers we support.
137/// Clang supports five independent qualifiers:
138/// * C99: const, volatile, and restrict
139/// * MS: __unaligned
140/// * Embedded C (TR18037): address spaces
141/// * Objective C: the GC attributes (none, weak, or strong)
142class Qualifiers {
143public:
144 enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
145 Const = 0x1,
146 Restrict = 0x2,
147 Volatile = 0x4,
148 CVRMask = Const | Volatile | Restrict
149 };
150
151 enum GC {
152 GCNone = 0,
153 Weak,
154 Strong
155 };
156
157 enum ObjCLifetime {
158 /// There is no lifetime qualification on this type.
159 OCL_None,
160
161 /// This object can be modified without requiring retains or
162 /// releases.
163 OCL_ExplicitNone,
164
165 /// Assigning into this object requires the old value to be
166 /// released and the new value to be retained. The timing of the
167 /// release of the old value is inexact: it may be moved to
168 /// immediately after the last known point where the value is
169 /// live.
170 OCL_Strong,
171
172 /// Reading or writing from this object requires a barrier call.
173 OCL_Weak,
174
175 /// Assigning into this object requires a lifetime extension.
176 OCL_Autoreleasing
177 };
178
179 enum {
180 /// The maximum supported address space number.
181 /// 23 bits should be enough for anyone.
182 MaxAddressSpace = 0x7fffffu,
183
184 /// The width of the "fast" qualifier mask.
185 FastWidth = 3,
186
187 /// The fast qualifier mask.
188 FastMask = (1 << FastWidth) - 1
189 };
190
191 /// Returns the common set of qualifiers while removing them from
192 /// the given sets.
193 static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
194 // If both are only CVR-qualified, bit operations are sufficient.
195 if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
196 Qualifiers Q;
197 Q.Mask = L.Mask & R.Mask;
198 L.Mask &= ~Q.Mask;
199 R.Mask &= ~Q.Mask;
200 return Q;
201 }
202
203 Qualifiers Q;
204 unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
205 Q.addCVRQualifiers(CommonCRV);
206 L.removeCVRQualifiers(CommonCRV);
207 R.removeCVRQualifiers(CommonCRV);
208
209 if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
210 Q.setObjCGCAttr(L.getObjCGCAttr());
211 L.removeObjCGCAttr();
212 R.removeObjCGCAttr();
213 }
214
215 if (L.getObjCLifetime() == R.getObjCLifetime()) {
216 Q.setObjCLifetime(L.getObjCLifetime());
217 L.removeObjCLifetime();
218 R.removeObjCLifetime();
219 }
220
221 if (L.getAddressSpace() == R.getAddressSpace()) {
222 Q.setAddressSpace(L.getAddressSpace());
223 L.removeAddressSpace();
224 R.removeAddressSpace();
225 }
226 return Q;
227 }
228
229 static Qualifiers fromFastMask(unsigned Mask) {
230 Qualifiers Qs;
231 Qs.addFastQualifiers(Mask);
232 return Qs;
233 }
234
235 static Qualifiers fromCVRMask(unsigned CVR) {
236 Qualifiers Qs;
237 Qs.addCVRQualifiers(CVR);
238 return Qs;
239 }
240
241 static Qualifiers fromCVRUMask(unsigned CVRU) {
242 Qualifiers Qs;
243 Qs.addCVRUQualifiers(CVRU);
244 return Qs;
245 }
246
247 // Deserialize qualifiers from an opaque representation.
248 static Qualifiers fromOpaqueValue(unsigned opaque) {
249 Qualifiers Qs;
250 Qs.Mask = opaque;
251 return Qs;
252 }
253
254 // Serialize these qualifiers into an opaque representation.
255 unsigned getAsOpaqueValue() const {
256 return Mask;
257 }
258
259 bool hasConst() const { return Mask & Const; }
260 bool hasOnlyConst() const { return Mask == Const; }
261 void removeConst() { Mask &= ~Const; }
262 void addConst() { Mask |= Const; }
263
264 bool hasVolatile() const { return Mask & Volatile; }
265 bool hasOnlyVolatile() const { return Mask == Volatile; }
266 void removeVolatile() { Mask &= ~Volatile; }
267 void addVolatile() { Mask |= Volatile; }
268
269 bool hasRestrict() const { return Mask & Restrict; }
270 bool hasOnlyRestrict() const { return Mask == Restrict; }
271 void removeRestrict() { Mask &= ~Restrict; }
272 void addRestrict() { Mask |= Restrict; }
273
274 bool hasCVRQualifiers() const { return getCVRQualifiers(); }
275 unsigned getCVRQualifiers() const { return Mask & CVRMask; }
276 unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }
277
278 void setCVRQualifiers(unsigned mask) {
279 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 279, __PRETTY_FUNCTION__))
;
280 Mask = (Mask & ~CVRMask) | mask;
281 }
282 void removeCVRQualifiers(unsigned mask) {
283 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 283, __PRETTY_FUNCTION__))
;
284 Mask &= ~mask;
285 }
286 void removeCVRQualifiers() {
287 removeCVRQualifiers(CVRMask);
288 }
289 void addCVRQualifiers(unsigned mask) {
290 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits")((!(mask & ~CVRMask) && "bitmask contains non-CVR bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask) && \"bitmask contains non-CVR bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 290, __PRETTY_FUNCTION__))
;
291 Mask |= mask;
292 }
293 void addCVRUQualifiers(unsigned mask) {
294 assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits")((!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~CVRMask & ~UMask) && \"bitmask contains non-CVRU bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 294, __PRETTY_FUNCTION__))
;
295 Mask |= mask;
296 }
297
298 bool hasUnaligned() const { return Mask & UMask; }
299 void setUnaligned(bool flag) {
300 Mask = (Mask & ~UMask) | (flag ? UMask : 0);
301 }
302 void removeUnaligned() { Mask &= ~UMask; }
303 void addUnaligned() { Mask |= UMask; }
304
305 bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
306 GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
307 void setObjCGCAttr(GC type) {
308 Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
309 }
310 void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
311 void addObjCGCAttr(GC type) {
312 assert(type)((type) ? static_cast<void> (0) : __assert_fail ("type"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 312, __PRETTY_FUNCTION__))
;
313 setObjCGCAttr(type);
314 }
315 Qualifiers withoutObjCGCAttr() const {
316 Qualifiers qs = *this;
317 qs.removeObjCGCAttr();
318 return qs;
319 }
320 Qualifiers withoutObjCLifetime() const {
321 Qualifiers qs = *this;
322 qs.removeObjCLifetime();
323 return qs;
324 }
325 Qualifiers withoutAddressSpace() const {
326 Qualifiers qs = *this;
327 qs.removeAddressSpace();
328 return qs;
329 }
330
331 bool hasObjCLifetime() const { return Mask & LifetimeMask; }
332 ObjCLifetime getObjCLifetime() const {
333 return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
334 }
335 void setObjCLifetime(ObjCLifetime type) {
336 Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
337 }
338 void removeObjCLifetime() { setObjCLifetime(OCL_None); }
339 void addObjCLifetime(ObjCLifetime type) {
340 assert(type)((type) ? static_cast<void> (0) : __assert_fail ("type"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 340, __PRETTY_FUNCTION__))
;
341 assert(!hasObjCLifetime())((!hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
("!hasObjCLifetime()", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 341, __PRETTY_FUNCTION__))
;
342 Mask |= (type << LifetimeShift);
343 }
344
345 /// True if the lifetime is neither None or ExplicitNone.
346 bool hasNonTrivialObjCLifetime() const {
347 ObjCLifetime lifetime = getObjCLifetime();
348 return (lifetime > OCL_ExplicitNone);
349 }
350
351 /// True if the lifetime is either strong or weak.
352 bool hasStrongOrWeakObjCLifetime() const {
353 ObjCLifetime lifetime = getObjCLifetime();
354 return (lifetime == OCL_Strong || lifetime == OCL_Weak);
355 }
356
357 bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
358 LangAS getAddressSpace() const {
359 return static_cast<LangAS>(Mask >> AddressSpaceShift);
360 }
361 bool hasTargetSpecificAddressSpace() const {
362 return isTargetAddressSpace(getAddressSpace());
363 }
364 /// Get the address space attribute value to be printed by diagnostics.
365 unsigned getAddressSpaceAttributePrintValue() const {
366 auto Addr = getAddressSpace();
367 // This function is not supposed to be used with language specific
368 // address spaces. If that happens, the diagnostic message should consider
369 // printing the QualType instead of the address space value.
370 assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace())((Addr == LangAS::Default || hasTargetSpecificAddressSpace())
? static_cast<void> (0) : __assert_fail ("Addr == LangAS::Default || hasTargetSpecificAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 370, __PRETTY_FUNCTION__))
;
371 if (Addr != LangAS::Default)
372 return toTargetAddressSpace(Addr);
373 // TODO: The diagnostic messages where Addr may be 0 should be fixed
374 // since it cannot differentiate the situation where 0 denotes the default
375 // address space or user specified __attribute__((address_space(0))).
376 return 0;
377 }
378 void setAddressSpace(LangAS space) {
379 assert((unsigned)space <= MaxAddressSpace)(((unsigned)space <= MaxAddressSpace) ? static_cast<void
> (0) : __assert_fail ("(unsigned)space <= MaxAddressSpace"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 379, __PRETTY_FUNCTION__))
;
380 Mask = (Mask & ~AddressSpaceMask)
381 | (((uint32_t) space) << AddressSpaceShift);
382 }
383 void removeAddressSpace() { setAddressSpace(LangAS::Default); }
384 void addAddressSpace(LangAS space) {
385 assert(space != LangAS::Default)((space != LangAS::Default) ? static_cast<void> (0) : __assert_fail
("space != LangAS::Default", "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 385, __PRETTY_FUNCTION__))
;
386 setAddressSpace(space);
387 }
388
389 // Fast qualifiers are those that can be allocated directly
390 // on a QualType object.
391 bool hasFastQualifiers() const { return getFastQualifiers(); }
392 unsigned getFastQualifiers() const { return Mask & FastMask; }
393 void setFastQualifiers(unsigned mask) {
394 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 394, __PRETTY_FUNCTION__))
;
395 Mask = (Mask & ~FastMask) | mask;
396 }
397 void removeFastQualifiers(unsigned mask) {
398 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 398, __PRETTY_FUNCTION__))
;
399 Mask &= ~mask;
400 }
401 void removeFastQualifiers() {
402 removeFastQualifiers(FastMask);
403 }
404 void addFastQualifiers(unsigned mask) {
405 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits")((!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"
) ? static_cast<void> (0) : __assert_fail ("!(mask & ~FastMask) && \"bitmask contains non-fast qualifier bits\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 405, __PRETTY_FUNCTION__))
;
406 Mask |= mask;
407 }
408
409 /// Return true if the set contains any qualifiers which require an ExtQuals
410 /// node to be allocated.
411 bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
412 Qualifiers getNonFastQualifiers() const {
413 Qualifiers Quals = *this;
414 Quals.setFastQualifiers(0);
415 return Quals;
416 }
417
418 /// Return true if the set contains any qualifiers.
419 bool hasQualifiers() const { return Mask; }
420 bool empty() const { return !Mask; }
421
422 /// Add the qualifiers from the given set to this set.
423 void addQualifiers(Qualifiers Q) {
424 // If the other set doesn't have any non-boolean qualifiers, just
425 // bit-or it in.
426 if (!(Q.Mask & ~CVRMask))
427 Mask |= Q.Mask;
428 else {
429 Mask |= (Q.Mask & CVRMask);
430 if (Q.hasAddressSpace())
431 addAddressSpace(Q.getAddressSpace());
432 if (Q.hasObjCGCAttr())
433 addObjCGCAttr(Q.getObjCGCAttr());
434 if (Q.hasObjCLifetime())
435 addObjCLifetime(Q.getObjCLifetime());
436 }
437 }
438
439 /// Remove the qualifiers from the given set from this set.
440 void removeQualifiers(Qualifiers Q) {
441 // If the other set doesn't have any non-boolean qualifiers, just
442 // bit-and the inverse in.
443 if (!(Q.Mask & ~CVRMask))
444 Mask &= ~Q.Mask;
445 else {
446 Mask &= ~(Q.Mask & CVRMask);
447 if (getObjCGCAttr() == Q.getObjCGCAttr())
448 removeObjCGCAttr();
449 if (getObjCLifetime() == Q.getObjCLifetime())
450 removeObjCLifetime();
451 if (getAddressSpace() == Q.getAddressSpace())
452 removeAddressSpace();
453 }
454 }
455
456 /// Add the qualifiers from the given set to this set, given that
457 /// they don't conflict.
458 void addConsistentQualifiers(Qualifiers qs) {
459 assert(getAddressSpace() == qs.getAddressSpace() ||((getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace
() || !qs.hasAddressSpace()) ? static_cast<void> (0) : __assert_fail
("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 460, __PRETTY_FUNCTION__))
460 !hasAddressSpace() || !qs.hasAddressSpace())((getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace
() || !qs.hasAddressSpace()) ? static_cast<void> (0) : __assert_fail
("getAddressSpace() == qs.getAddressSpace() || !hasAddressSpace() || !qs.hasAddressSpace()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 460, __PRETTY_FUNCTION__))
;
461 assert(getObjCGCAttr() == qs.getObjCGCAttr() ||((getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() ||
!qs.hasObjCGCAttr()) ? static_cast<void> (0) : __assert_fail
("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 462, __PRETTY_FUNCTION__))
462 !hasObjCGCAttr() || !qs.hasObjCGCAttr())((getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() ||
!qs.hasObjCGCAttr()) ? static_cast<void> (0) : __assert_fail
("getObjCGCAttr() == qs.getObjCGCAttr() || !hasObjCGCAttr() || !qs.hasObjCGCAttr()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 462, __PRETTY_FUNCTION__))
;
463 assert(getObjCLifetime() == qs.getObjCLifetime() ||((getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime
() || !qs.hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 464, __PRETTY_FUNCTION__))
464 !hasObjCLifetime() || !qs.hasObjCLifetime())((getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime
() || !qs.hasObjCLifetime()) ? static_cast<void> (0) : __assert_fail
("getObjCLifetime() == qs.getObjCLifetime() || !hasObjCLifetime() || !qs.hasObjCLifetime()"
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 464, __PRETTY_FUNCTION__))
;
465 Mask |= qs.Mask;
466 }
467
468 /// Returns true if address space A is equal to or a superset of B.
469 /// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
470 /// overlapping address spaces.
471 /// CL1.1 or CL1.2:
472 /// every address space is a superset of itself.
473 /// CL2.0 adds:
474 /// __generic is a superset of any address space except for __constant.
475 static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
476 // Address spaces must match exactly.
477 return A == B ||
478 // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
479 // for __constant can be used as __generic.
480 (A == LangAS::opencl_generic && B != LangAS::opencl_constant) ||
481 // Consider pointer size address spaces to be equivalent to default.
482 ((isPtrSizeAddressSpace(A) || A == LangAS::Default) &&
483 (isPtrSizeAddressSpace(B) || B == LangAS::Default));
484 }
485
486 /// Returns true if the address space in these qualifiers is equal to or
487 /// a superset of the address space in the argument qualifiers.
488 bool isAddressSpaceSupersetOf(Qualifiers other) const {
489 return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
490 }
491
492 /// Determines if these qualifiers compatibly include another set.
493 /// Generally this answers the question of whether an object with the other
494 /// qualifiers can be safely used as an object with these qualifiers.
495 bool compatiblyIncludes(Qualifiers other) const {
496 return isAddressSpaceSupersetOf(other) &&
497 // ObjC GC qualifiers can match, be added, or be removed, but can't
498 // be changed.
499 (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
500 !other.hasObjCGCAttr()) &&
501 // ObjC lifetime qualifiers must match exactly.
502 getObjCLifetime() == other.getObjCLifetime() &&
503 // CVR qualifiers may subset.
504 (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
505 // U qualifier may superset.
506 (!other.hasUnaligned() || hasUnaligned());
507 }
508
509 /// Determines if these qualifiers compatibly include another set of
510 /// qualifiers from the narrow perspective of Objective-C ARC lifetime.
511 ///
512 /// One set of Objective-C lifetime qualifiers compatibly includes the other
513 /// if the lifetime qualifiers match, or if both are non-__weak and the
514 /// including set also contains the 'const' qualifier, or both are non-__weak
515 /// and one is None (which can only happen in non-ARC modes).
516 bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
517 if (getObjCLifetime() == other.getObjCLifetime())
518 return true;
519
520 if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
521 return false;
522
523 if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None)
524 return true;
525
526 return hasConst();
527 }
528
529 /// Determine whether this set of qualifiers is a strict superset of
530 /// another set of qualifiers, not considering qualifier compatibility.
531 bool isStrictSupersetOf(Qualifiers Other) const;
532
533 bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
534 bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }
535
536 explicit operator bool() const { return hasQualifiers(); }
537
538 Qualifiers &operator+=(Qualifiers R) {
539 addQualifiers(R);
540 return *this;
541 }
542
543 // Union two qualifier sets. If an enumerated qualifier appears
544 // in both sets, use the one from the right.
545 friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
546 L += R;
547 return L;
548 }
549
550 Qualifiers &operator-=(Qualifiers R) {
551 removeQualifiers(R);
552 return *this;
553 }
554
555 /// Compute the difference between two qualifier sets.
556 friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
557 L -= R;
558 return L;
559 }
560
561 std::string getAsString() const;
562 std::string getAsString(const PrintingPolicy &Policy) const;
563
564 static std::string getAddrSpaceAsString(LangAS AS);
565
566 bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
567 void print(raw_ostream &OS, const PrintingPolicy &Policy,
568 bool appendSpaceIfNonEmpty = false) const;
569
570 void Profile(llvm::FoldingSetNodeID &ID) const {
571 ID.AddInteger(Mask);
572 }
573
574private:
575 // bits: |0 1 2|3|4 .. 5|6 .. 8|9 ... 31|
576 // |C R V|U|GCAttr|Lifetime|AddressSpace|
577 uint32_t Mask = 0;
578
579 static const uint32_t UMask = 0x8;
580 static const uint32_t UShift = 3;
581 static const uint32_t GCAttrMask = 0x30;
582 static const uint32_t GCAttrShift = 4;
583 static const uint32_t LifetimeMask = 0x1C0;
584 static const uint32_t LifetimeShift = 6;
585 static const uint32_t AddressSpaceMask =
586 ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
587 static const uint32_t AddressSpaceShift = 9;
588};
589
590/// A std::pair-like structure for storing a qualified type split
591/// into its local qualifiers and its locally-unqualified type.
592struct SplitQualType {
593 /// The locally-unqualified type.
594 const Type *Ty = nullptr;
595
596 /// The local qualifiers.
597 Qualifiers Quals;
598
599 SplitQualType() = default;
600 SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}
601
602 SplitQualType getSingleStepDesugaredType() const; // end of this file
603
604 // Make std::tie work.
605 std::pair<const Type *,Qualifiers> asPair() const {
606 return std::pair<const Type *, Qualifiers>(Ty, Quals);
607 }
608
609 friend bool operator==(SplitQualType a, SplitQualType b) {
610 return a.Ty == b.Ty && a.Quals == b.Quals;
611 }
612 friend bool operator!=(SplitQualType a, SplitQualType b) {
613 return a.Ty != b.Ty || a.Quals != b.Quals;
614 }
615};
616
617/// The kind of type we are substituting Objective-C type arguments into.
618///
619/// The kind of substitution affects the replacement of type parameters when
620/// no concrete type information is provided, e.g., when dealing with an
621/// unspecialized type.
622enum class ObjCSubstitutionContext {
623 /// An ordinary type.
624 Ordinary,
625
626 /// The result type of a method or function.
627 Result,
628
629 /// The parameter type of a method or function.
630 Parameter,
631
632 /// The type of a property.
633 Property,
634
635 /// The superclass of a type.
636 Superclass,
637};
638
639/// A (possibly-)qualified type.
640///
641/// For efficiency, we don't store CV-qualified types as nodes on their
642/// own: instead each reference to a type stores the qualifiers. This
643/// greatly reduces the number of nodes we need to allocate for types (for
644/// example we only need one for 'int', 'const int', 'volatile int',
645/// 'const volatile int', etc).
646///
647/// As an added efficiency bonus, instead of making this a pair, we
648/// just store the two bits we care about in the low bits of the
649/// pointer. To handle the packing/unpacking, we make QualType be a
650/// simple wrapper class that acts like a smart pointer. A third bit
651/// indicates whether there are extended qualifiers present, in which
652/// case the pointer points to a special structure.
653class QualType {
654 friend class QualifierCollector;
655
656 // Thankfully, these are efficiently composable.
657 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
658 Qualifiers::FastWidth> Value;
659
660 const ExtQuals *getExtQualsUnsafe() const {
661 return Value.getPointer().get<const ExtQuals*>();
662 }
663
664 const Type *getTypePtrUnsafe() const {
665 return Value.getPointer().get<const Type*>();
666 }
667
668 const ExtQualsTypeCommonBase *getCommonPtr() const {
669 assert(!isNull() && "Cannot retrieve a NULL type pointer")((!isNull() && "Cannot retrieve a NULL type pointer")
? static_cast<void> (0) : __assert_fail ("!isNull() && \"Cannot retrieve a NULL type pointer\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 669, __PRETTY_FUNCTION__))
;
670 auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
671 CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
672 return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
673 }
674
675public:
676 QualType() = default;
677 QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
678 QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
679
680 unsigned getLocalFastQualifiers() const { return Value.getInt(); }
681 void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }
682
683 /// Retrieves a pointer to the underlying (unqualified) type.
684 ///
685 /// This function requires that the type not be NULL. If the type might be
686 /// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
687 const Type *getTypePtr() const;
688
689 const Type *getTypePtrOrNull() const;
690
691 /// Retrieves a pointer to the name of the base type.
692 const IdentifierInfo *getBaseTypeIdentifier() const;
693
694 /// Divides a QualType into its unqualified type and a set of local
695 /// qualifiers.
696 SplitQualType split() const;
697
698 void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }
699
700 static QualType getFromOpaquePtr(const void *Ptr) {
701 QualType T;
702 T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
703 return T;
704 }
705
706 const Type &operator*() const {
707 return *getTypePtr();
708 }
709
710 const Type *operator->() const {
711 return getTypePtr();
712 }
713
714 bool isCanonical() const;
715 bool isCanonicalAsParam() const;
716
717 /// Return true if this QualType doesn't point to a type yet.
718 bool isNull() const {
719 return Value.getPointer().isNull();
720 }
721
722 /// Determine whether this particular QualType instance has the
723 /// "const" qualifier set, without looking through typedefs that may have
724 /// added "const" at a different level.
725 bool isLocalConstQualified() const {
726 return (getLocalFastQualifiers() & Qualifiers::Const);
727 }
728
729 /// Determine whether this type is const-qualified.
730 bool isConstQualified() const;
731
732 /// Determine whether this particular QualType instance has the
733 /// "restrict" qualifier set, without looking through typedefs that may have
734 /// added "restrict" at a different level.
735 bool isLocalRestrictQualified() const {
736 return (getLocalFastQualifiers() & Qualifiers::Restrict);
737 }
738
739 /// Determine whether this type is restrict-qualified.
740 bool isRestrictQualified() const;
741
742 /// Determine whether this particular QualType instance has the
743 /// "volatile" qualifier set, without looking through typedefs that may have
744 /// added "volatile" at a different level.
745 bool isLocalVolatileQualified() const {
746 return (getLocalFastQualifiers() & Qualifiers::Volatile);
747 }
748
749 /// Determine whether this type is volatile-qualified.
750 bool isVolatileQualified() const;
751
752 /// Determine whether this particular QualType instance has any
753 /// qualifiers, without looking through any typedefs that might add
754 /// qualifiers at a different level.
755 bool hasLocalQualifiers() const {
756 return getLocalFastQualifiers() || hasLocalNonFastQualifiers();
757 }
758
759 /// Determine whether this type has any qualifiers.
760 bool hasQualifiers() const;
761
762 /// Determine whether this particular QualType instance has any
763 /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
764 /// instance.
765 bool hasLocalNonFastQualifiers() const {
766 return Value.getPointer().is<const ExtQuals*>();
767 }
768
769 /// Retrieve the set of qualifiers local to this particular QualType
770 /// instance, not including any qualifiers acquired through typedefs or
771 /// other sugar.
772 Qualifiers getLocalQualifiers() const;
773
774 /// Retrieve the set of qualifiers applied to this type.
775 Qualifiers getQualifiers() const;
776
777 /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
778 /// local to this particular QualType instance, not including any qualifiers
779 /// acquired through typedefs or other sugar.
780 unsigned getLocalCVRQualifiers() const {
781 return getLocalFastQualifiers();
782 }
783
784 /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
785 /// applied to this type.
786 unsigned getCVRQualifiers() const;
787
788 bool isConstant(const ASTContext& Ctx) const {
789 return QualType::isConstant(*this, Ctx);
790 }
791
792 /// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
793 bool isPODType(const ASTContext &Context) const;
794
795 /// Return true if this is a POD type according to the rules of the C++98
796 /// standard, regardless of the current compilation's language.
797 bool isCXX98PODType(const ASTContext &Context) const;
798
799 /// Return true if this is a POD type according to the more relaxed rules
800 /// of the C++11 standard, regardless of the current compilation's language.
801 /// (C++0x [basic.types]p9). Note that, unlike
802 /// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
803 bool isCXX11PODType(const ASTContext &Context) const;
804
805 /// Return true if this is a trivial type per (C++0x [basic.types]p9)
806 bool isTrivialType(const ASTContext &Context) const;
807
808 /// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
809 bool isTriviallyCopyableType(const ASTContext &Context) const;
810
811
812 /// Returns true if it is a class and it might be dynamic.
813 bool mayBeDynamicClass() const;
814
815 /// Returns true if it is not a class or if the class might not be dynamic.
816 bool mayBeNotDynamicClass() const;
817
818 // Don't promise in the API that anything besides 'const' can be
819 // easily added.
820
821 /// Add the `const` type qualifier to this QualType.
822 void addConst() {
823 addFastQualifiers(Qualifiers::Const);
824 }
825 QualType withConst() const {
826 return withFastQualifiers(Qualifiers::Const);
827 }
828
829 /// Add the `volatile` type qualifier to this QualType.
830 void addVolatile() {
831 addFastQualifiers(Qualifiers::Volatile);
832 }
833 QualType withVolatile() const {
834 return withFastQualifiers(Qualifiers::Volatile);
835 }
836
837 /// Add the `restrict` qualifier to this QualType.
838 void addRestrict() {
839 addFastQualifiers(Qualifiers::Restrict);
840 }
841 QualType withRestrict() const {
842 return withFastQualifiers(Qualifiers::Restrict);
843 }
844
845 QualType withCVRQualifiers(unsigned CVR) const {
846 return withFastQualifiers(CVR);
847 }
848
849 void addFastQualifiers(unsigned TQs) {
850 assert(!(TQs & ~Qualifiers::FastMask)((!(TQs & ~Qualifiers::FastMask) && "non-fast qualifier bits set in mask!"
) ? static_cast<void> (0) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 851, __PRETTY_FUNCTION__))
851 && "non-fast qualifier bits set in mask!")((!(TQs & ~Qualifiers::FastMask) && "non-fast qualifier bits set in mask!"
) ? static_cast<void> (0) : __assert_fail ("!(TQs & ~Qualifiers::FastMask) && \"non-fast qualifier bits set in mask!\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 851, __PRETTY_FUNCTION__))
;
852 Value.setInt(Value.getInt() | TQs);
853 }
854
855 void removeLocalConst();
856 void removeLocalVolatile();
857 void removeLocalRestrict();
858 void removeLocalCVRQualifiers(unsigned Mask);
859
860 void removeLocalFastQualifiers() { Value.setInt(0); }
861 void removeLocalFastQualifiers(unsigned Mask) {
862 assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers")((!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers"
) ? static_cast<void> (0) : __assert_fail ("!(Mask & ~Qualifiers::FastMask) && \"mask has non-fast qualifiers\""
, "/build/llvm-toolchain-snapshot-10~++20200110111110+a1cc19b5814/clang/include/clang/AST/Type.h"
, 862, __PRETTY_FUNCTION__))
;
863 Value.setInt(Value.getInt() & ~Mask);
864 }
865
866 // Creates a type with the given qualifiers in addition to any
867 // qualifiers already on this type.
868 QualType withFastQualifiers(unsigned TQs) const {
869 QualType T = *this;
870 T.addFastQualifiers(TQs);
871 return T;
872 }
873
874 // Creates a type with exactly the given fast qualifiers, removing
875 // any existing fast qualifiers.
876 QualType withExactLocalFastQualifiers(unsigned TQs) const {
877 return withoutLocalFastQualifiers().withFastQualifiers(TQs);
878 }
879
880 // Removes fast qualifiers, but leaves any extended qualifiers in place.
881 QualType withoutLocalFastQualifiers() const {
882 QualType T = *this;
883 T.removeLocalFastQualifiers();
884 return T;
885 }
886
887 QualType getCanonicalType() const;
888
889 /// Return this type with all of the instance-specific qualifiers
890 /// removed, but without removing any qualifiers that may have been applied
891 /// through typedefs.
892 QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }
893
894 /// Retrieve the unqualified variant of the given type,
895 /// removing as little sugar as possible.
896 ///
897 /// This routine looks through various kinds of sugar to find the
898 /// least-desugared type that is unqualified. For example, given:
899 ///
900 /// \code
901 /// typedef int Integer;
902 /// typedef const Integer CInteger;
903 /// typedef CInteger DifferenceType;
904 /// \endcode
905 ///
906 /// Executing \c getUnqualifiedType() on the type \c DifferenceType will
907 /// desugar until we hit the type \c Integer, which has no qualifiers on it.
908 ///
909 /// The resulting type might still be qualified if it's sugar for an array
910 /// type. To strip qualifiers even from within a sugared array type, use
911 /// ASTContext::getUnqualifiedArrayType.
912 inline QualType getUnqualifiedType() const;
913
914 /// Retrieve the unqualified variant of the given type, removing as little
915 /// sugar as possible.
916 ///
917 /// Like getUnqualifiedType(), but also returns the set of
918 /// qualifiers that were built up.
919 ///
920 /// The resulting type might still be qualified if it's sugar for an array
921 /// type. To strip qualifiers even from within a sugared array type, use
922 /// ASTContext::getUnqualifiedArrayType.
923 inline SplitQualType getSplitUnqualifiedType() const;
924
925 /// Determine whether this type is more qualified than the other
926 /// given type, requiring exact equality for non-CVR qualifiers.
927 bool isMoreQualifiedThan(QualType Other) const;
928
929 /// Determine whether this type is at least as qualified as the other
930 /// given type, requiring exact equality for non-CVR qualifiers.
931 bool isAtLeastAsQualifiedAs(QualType Other) const;
932
933 QualType getNonReferenceType() const;
934
935 /// Determine the type of a (typically non-lvalue) expression with the
936 /// specified result type.
937 ///
938 /// This routine should be used for expressions for which the return type is
939 /// explicitly specified (e.g., in a cast or call) and isn't necessarily
940 /// an lvalue. It removes a top-level reference (since there are no
941 /// expressions of reference type) and deletes top-level cvr-qualifiers
942 /// from non-class types (in C++) or all types (in C).
943 QualType getNonLValueExprType(const ASTContext &Context) const;
944
945 /// Return the specified type with any "sugar" removed from
946 /// the type. This takes off typedefs, typeof's etc. If the outer level of
947 /// the type is already concrete, it returns it unmodified. This is similar