Expr.cpp Source File (original) (raw)

35#include "llvm/Support/ErrorHandling.h"

36#include "llvm/Support/Format.h"

37#include "llvm/Support/raw_ostream.h"

38#include

39#include

40#include

41using namespace clang;

44 const Expr *E = this;

45 while (true) {

49 if (auto *BO = dyn_cast(E)) {

50 if (BO->getOpcode() == BO_Comma) {

51 E = BO->getRHS();

52 continue;

53 }

54 }

57 if (auto *MTE = dyn_cast(E)) {

58 E = MTE->getSubExpr();

59 continue;

60 }

62 break;

63 }

65 return E;

66}

75 DerivedType = ATy->getElementType();

78 return nullptr;

81}

86 const Expr *E = this;

87 while (true) {

90 if (const auto *CE = dyn_cast(E)) {

91 if ((CE->getCastKind() == CK_DerivedToBase ||

92 CE->getCastKind() == CK_UncheckedDerivedToBase) &&

94 E = CE->getSubExpr();

97 continue;

98 }

100 if (CE->getCastKind() == CK_NoOp) {

101 E = CE->getSubExpr();

102 continue;

103 }

104 } else if (const auto *ME = dyn_cast(E)) {

105 if (!ME->isArrow()) {

106 assert(ME->getBase()->getType()->getAsRecordDecl());

107 if (const auto *Field = dyn_cast(ME->getMemberDecl())) {

108 if (!Field->isBitField() && !Field->getType()->isReferenceType()) {

109 E = ME->getBase();

111 continue;

112 }

113 }

114 }

115 } else if (const auto *BO = dyn_cast(E)) {

116 if (BO->getOpcode() == BO_PtrMemD) {

117 assert(BO->getRHS()->isPRValue());

118 E = BO->getLHS();

121 continue;

122 }

123 if (BO->getOpcode() == BO_Comma) {

124 CommaLHSs.push_back(BO->getLHS());

125 E = BO->getRHS();

126 continue;

127 }

128 }

129

130

131 break;

132 }

133 return E;

134}

135

138

139

141

143

144 if (const UnaryOperator *UO = dyn_cast(E)) {

145 switch (UO->getOpcode()) {

146 case UO_Plus:

147 return UO->getSubExpr()->isKnownToHaveBooleanValue(Semantic);

148 case UO_LNot:

149 return true;

150 default:

151 return false;

152 }

153 }

154

155

156

157

158 if (const ImplicitCastExpr *CE = dyn_cast(E))

159 return CE->getSubExpr()->isKnownToHaveBooleanValue(Semantic);

160

161 if (const BinaryOperator *BO = dyn_cast(E)) {

162 switch (BO->getOpcode()) {

163 default: return false;

164 case BO_LT:

165 case BO_GT:

166 case BO_LE:

167 case BO_GE:

168 case BO_EQ:

169 case BO_NE:

170 case BO_LAnd:

171 case BO_LOr:

172 return true;

173

174 case BO_And:

175 case BO_Xor:

176 case BO_Or:

177

178 return BO->getLHS()->isKnownToHaveBooleanValue(Semantic) &&

179 BO->getRHS()->isKnownToHaveBooleanValue(Semantic);

180

181 case BO_Comma:

182 case BO_Assign:

183 return BO->getRHS()->isKnownToHaveBooleanValue(Semantic);

184 }

185 }

186

188 return CO->getTrueExpr()->isKnownToHaveBooleanValue(Semantic) &&

189 CO->getFalseExpr()->isKnownToHaveBooleanValue(Semantic);

190

192 return true;

193

194 if (const auto *OVE = dyn_cast(E))

195 return OVE->getSourceExpr()->isKnownToHaveBooleanValue(Semantic);

196

198 if (!Semantic && FD->getType()->isUnsignedIntegerType() &&

199 !FD->getBitWidth()->isValueDependent() && FD->getBitWidthValue() == 1)

200 return true;

201

202 return false;

203}

204

208 bool IgnoreTemplateOrMacroSubstitution) const {

210 const Decl *D = nullptr;

211

212 if (const auto *ME = dyn_cast(E))

213 D = ME->getMemberDecl();

214 else if (const auto *DRE = dyn_cast(E))

215 D = DRE->getDecl();

216 else if (const auto *IRE = dyn_cast(E))

217 D = IRE->getDecl();

218

220 StrictFlexArraysLevel,

221 IgnoreTemplateOrMacroSubstitution);

222}

223

227

230

231 if (Value.isMemberPointer())

232 return Value.getMemberPointerDecl();

233

234 if (Value.isLValue() && Value.getLValueOffset().isZero())

235 return Value.getLValueBase().dyn_cast<const ValueDecl *>();

236 }

237

238 return nullptr;

239}

240

241

242

243

244

245namespace {

246

247

248 template <class E, class T>

251 return static_cast<const E*>(expr)->getExprLoc();

252 }

253

254

255

256

257

258 template

261 return static_cast<const E *>(expr)->getBeginLoc();

262 }

263}

264

269 const auto *ED = cast(ECD->getDeclContext());

270 if (ED->isCompleteDefinition())

272 }

274}

275

278 case Stmt::NoStmtClass: llvm_unreachable("statement without class");

279#define ABSTRACT_STMT(type)

280#define STMT(type, base) \

281 case Stmt::type##Class: break;

282#define EXPR(type, base) \

283 case Stmt::type##Class: return getExprLocImpl(this, &type::getExprLoc);

284#include "clang/AST/StmtNodes.inc"

285 }

286 llvm_unreachable("unknown expression kind");

287}

288

289

290

291

292

297 "Invalid StorageKind Value");

298 (void)Kind;

299}

300

307 if ( Value .getInt().needsCleanup())

309 [[fallthrough]];

310 default:

312 }

313}

314

317 if (T->isIntegralOrEnumerationType() && Context.getTypeInfo(T).Width <= 64)

320}

321

323 bool IsImmediateInvocation)

324 : FullExpr(ConstantExprClass, SubExpr) {

325 ConstantExprBits.ResultKind = llvm::to_underlying(StorageKind);

330 ConstantExprBits.IsImmediateInvocation = IsImmediateInvocation;

331

333 ::new (getTrailingObjects()) APValue();

334}

335

338 bool IsImmediateInvocation) {

341

342 unsigned Size = totalSizeToAlloc<APValue, uint64_t>(

345 void *Mem = Context.Allocate(Size, alignof(ConstantExpr));

346 return new (Mem) ConstantExpr(E, StorageKind, IsImmediateInvocation);

347}

348

352 ConstantExpr *Self = Create(Context, E, StorageKind);

355}

356

357ConstantExpr::ConstantExpr(EmptyShell Empty,

360 ConstantExprBits.ResultKind = llvm::to_underlying(StorageKind);

361

363 ::new (getTrailingObjects()) APValue();

364}

365

369

370 unsigned Size = totalSizeToAlloc<APValue, uint64_t>(

373 void *Mem = Context.Allocate(Size, alignof(ConstantExpr));

374 return new (Mem) ConstantExpr(EmptyShell(), StorageKind);

375}

376

379 "Invalid storage for this value kind");

383 return;

385 Int64Result() = *Value.getInt().getRawData();

388 return;

392 Context.addDestruction(&APValueResult());

393 }

394 APValueResult() = std::move(Value);

395 return;

396 }

397 llvm_unreachable("Invalid ResultKind Bits");

398}

399

403 return APValueResult().getInt();

405 return llvm::APSInt(llvm::APInt(ConstantExprBits.BitWidth, Int64Result()),

407 default:

408 llvm_unreachable("invalid Accessor");

409 }

410}

411

413

416 return APValueResult();

419 llvm::APSInt(llvm::APInt(ConstantExprBits.BitWidth, Int64Result()),

425 }

426 llvm_unreachable("invalid ResultKind");

427}

428

430 bool RefersToEnclosingVariableOrCapture, QualType T,

440 RefersToEnclosingVariableOrCapture;

441 DeclRefExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter = false;

446}

447

448DeclRefExpr::DeclRefExpr(const ASTContext &Ctx,

451 bool RefersToEnclosingVariableOrCapture,

456 DNLoc(NameInfo.getInfo()) {

459 if (QualifierLoc)

460 new (getTrailingObjects())

463 if (FoundD)

464 *getTrailingObjects<NamedDecl *>() = FoundD;

466 = (TemplateArgs || TemplateKWLoc.isValid()) ? 1 : 0;

468 RefersToEnclosingVariableOrCapture;

469 DeclRefExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter = false;

471 if (TemplateArgs) {

472 auto Deps = TemplateArgumentDependence::None;

473 getTrailingObjects()->initializeFrom(

474 TemplateKWLoc, *TemplateArgs, getTrailingObjects(),

475 Deps);

476 assert(!(Deps & TemplateArgumentDependence::Dependent) &&

477 "built a DeclRefExpr with dependent template args");

478 } else if (TemplateKWLoc.isValid()) {

479 getTrailingObjects()->initializeFrom(

480 TemplateKWLoc);

481 }

485}

486

490 bool RefersToEnclosingVariableOrCapture,

495 return Create(Context, QualifierLoc, TemplateKWLoc, D,

496 RefersToEnclosingVariableOrCapture,

498 T, VK, FoundD, TemplateArgs, NOUR);

499}

500

504 bool RefersToEnclosingVariableOrCapture,

510

511 if (D == FoundD)

512 FoundD = nullptr;

513

514 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.isValid();

515 std::size_t Size =

518 QualifierLoc ? 1 : 0, FoundD ? 1 : 0,

519 HasTemplateKWAndArgsInfo ? 1 : 0,

520 TemplateArgs ? TemplateArgs->size() : 0);

521

522 void *Mem = Context.Allocate(Size, alignof(DeclRefExpr));

523 return new (Mem) DeclRefExpr(Context, QualifierLoc, TemplateKWLoc, D,

524 RefersToEnclosingVariableOrCapture, NameInfo,

525 FoundD, TemplateArgs, T, VK, NOUR);

526}

527

529 bool HasQualifier,

530 bool HasFoundDecl,

531 bool HasTemplateKWAndArgsInfo,

532 unsigned NumTemplateArgs) {

533 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);

534 std::size_t Size =

537 HasQualifier ? 1 : 0, HasFoundDecl ? 1 : 0, HasTemplateKWAndArgsInfo,

538 NumTemplateArgs);

539 void *Mem = Context.Allocate(Size, alignof(DeclRefExpr));

540 return new (Mem) DeclRefExpr(EmptyShell());

541}

542

544 D = NewD;

545 if (getType()->isUndeducedType())

548}

549

555

556SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(SourceLocation OpLoc,

562 OpLoc(OpLoc), LParen(LParen), RParen(RParen) {

563 setTypeSourceInfo(TSI);

565}

566

567SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(EmptyShell Empty,

570

576 return new (Ctx)

577 SYCLUniqueStableNameExpr(OpLoc, LParen, RParen, ResultTy, TSI);

578}

579

583 return new (Ctx) SYCLUniqueStableNameExpr(EmptyShell(), ResultTy);

584}

585

590

593 auto MangleCallback = [](ASTContext &Ctx,

595 if (const auto *RD = dyn_cast(ND))

596 return RD->getDeviceLambdaManglingNumber();

597 return std::nullopt;

598 };

599

601 Context, Context.getDiagnostics(), MangleCallback)};

602

603 std::string Buffer;

604 Buffer.reserve(128);

605 llvm::raw_string_ostream Out(Buffer);

606 Ctx->mangleCanonicalTypeName(Ty, Out);

607

608 return Buffer;

609}

610

616 assert((getIdentKind() == IK) &&

617 "IdentKind do not fit in PredefinedExprBitfields!");

618 bool HasFunctionName = SL != nullptr;

622 if (HasFunctionName)

623 setFunctionName(SL);

625}

626

627PredefinedExpr::PredefinedExpr(EmptyShell Empty, bool HasFunctionName)

628 : Expr(PredefinedExprClass, Empty) {

630}

631

635 bool HasFunctionName = SL != nullptr;

636 void *Mem = Ctx.Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),

637 alignof(PredefinedExpr));

638 return new (Mem) PredefinedExpr(L, FNTy, IK, IsTransparent, SL);

639}

640

642 bool HasFunctionName) {

643 void *Mem = Ctx.Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),

644 alignof(PredefinedExpr));

645 return new (Mem) PredefinedExpr(EmptyShell(), HasFunctionName);

646}

647

649 switch (IK) {

651 return "__func__";

653 return "__FUNCTION__";

655 return "__FUNCDNAME__";

657 return "L__FUNCTION__";

659 return "__PRETTY_FUNCTION__";

661 return "__FUNCSIG__";

663 return "L__FUNCSIG__";

665 break;

666 }

667 llvm_unreachable("Unknown ident kind for PredefinedExpr");

668}

669

670

671

673 const Decl *CurrentDecl,

674 bool ForceElaboratedPrinting) {

676

678 if (const NamedDecl *ND = dyn_cast(CurrentDecl)) {

679 std::unique_ptr MC;

680 MC.reset(Context.createMangleContext());

681

682 if (MC->shouldMangleDeclName(ND)) {

684 llvm::raw_svector_ostream Out(Buffer);

688 else if (const CXXDestructorDecl *DD = dyn_cast(ND))

690 else if (auto FD = dyn_cast(ND)) {

692 } else

694 MC->mangleName(GD, Out);

695

696 if (!Buffer.empty() && Buffer.front() == '\01')

697 return std::string(Buffer.substr(1));

698 return std::string(Buffer);

699 }

700 return std::string(ND->getIdentifier()->getName());

701 }

702 return "";

703 }

705

706

707

709 if (DC->isFileContext())

710 return "";

711

713 llvm::raw_svector_ostream Out(Buffer);

714 if (auto *DCBlock = dyn_cast(DC))

715

717 else if (auto *DCDecl = dyn_cast(DC))

718 Out << ComputeName(IK, DCDecl) << "_block_invoke";

719 return std::string(Out.str());

720 }

721 if (const FunctionDecl *FD = dyn_cast(CurrentDecl)) {

722 const auto &LO = Context.getLangOpts();

723 bool IsFuncOrFunctionInNonMSVCCompatEnv =

725 IK == PredefinedIdentKind ::Function) &&

726 !LO.MSVCCompat);

727 bool IsLFunctionInMSVCCommpatEnv =

729 bool IsFuncOrFunctionOrLFunctionOrFuncDName =

734 if ((ForceElaboratedPrinting &&

735 (IsFuncOrFunctionInNonMSVCCompatEnv || IsLFunctionInMSVCCommpatEnv)) ||

736 (!ForceElaboratedPrinting && IsFuncOrFunctionOrLFunctionOrFuncDName))

737 return FD->getNameAsString();

738

740 llvm::raw_svector_ostream Out(Name);

741

742 if (const CXXMethodDecl *MD = dyn_cast(FD)) {

744 Out << "virtual ";

745 if (MD->isStatic() && !ForceElaboratedPrinting)

746 Out << "static ";

747 }

748

750 public:

751 PrettyCallbacks(const LangOptions &LO) : LO(LO) {}

752 std::string remapPath(StringRef Path) const override {

755 return std::string(p);

756 }

757

758 private:

760 };

762 PrettyCallbacks PrettyCB(Context.getLangOpts());

766 std::string Proto;

767 llvm::raw_string_ostream POut(Proto);

768

771 Decl = Pattern;

772

773

774

775

776 const Type *Ty = Decl->getType().getTypePtrOrNull();

777 if (!Ty)

778 return "";

779

782 if (FD->hasWrittenPrototype())

783 FT = dyn_cast(AFT);

784

788 case CC_C: POut << "__cdecl "; break;

794

795 default: break;

796 }

797 }

798

799 FD->printQualifiedName(POut, Policy);

800

802 Out << Proto;

803 return std::string(Name);

804 }

805

806 POut << "(";

807 if (FT) {

808 for (unsigned i = 0, e = Decl->getNumParams(); i != e; ++i) {

809 if (i) POut << ", ";

810 POut << Decl->getParamDecl(i)->getType().stream(Policy);

811 }

812

813 if (FT->isVariadic()) {

814 if (FD->getNumParams()) POut << ", ";

815 POut << "...";

818 !Context.getLangOpts().CPlusPlus) &&

819 Decl ->getNumParams()) {

820 POut << "void";

821 }

822 }

823 POut << ")";

824

825 if (const CXXMethodDecl *MD = dyn_cast(FD)) {

826 assert(FT && "We must have a written prototype in this case.");

827 if (FT->isConst())

828 POut << " const";

829 if (FT->isVolatile())

830 POut << " volatile";

833 POut << " &";

835 POut << " &&";

836 }

837

839 SpecsTy Specs;

840 const DeclContext *Ctx = FD->getDeclContext();

841 while (isa_and_nonnull(Ctx)) {

843 = dyn_cast(Ctx);

845 Specs.push_back(Spec);

847 }

848

849 std::string TemplateParams;

850 llvm::raw_string_ostream TOut(TemplateParams);

853 D->getSpecializedTemplate()->getTemplateParameters();

855 assert(Params->size() == Args.size());

856 for (unsigned i = 0, numParams = Params->size(); i != numParams; ++i) {

858 if (Param.empty()) continue;

859 TOut << Param << " = ";

860 Args.get(i).print(Policy, TOut,

862 Policy, Params, i));

863 TOut << ", ";

864 }

865 }

866

868 = FD->getTemplateSpecializationInfo();

873 assert(Params->size() == Args->size());

874 for (unsigned i = 0, e = Params->size(); i != e; ++i) {

876 if (Param.empty()) continue;

877 TOut << Param << " = ";

878 Args->get(i).print(Policy, TOut, true);

879 TOut << ", ";

880 }

881 }

882

883 if (!TemplateParams.empty()) {

884

885 TemplateParams.resize(TemplateParams.size() - 2);

886 POut << " [" << TemplateParams << "]";

887 }

888

889

890

891

892

894 Proto = "auto " + Proto;

895 else if (FT && FT->getReturnType()->getAs())

896 FT->getReturnType()

897 ->getAs()

902

903 Out << Proto;

904

905 return std::string(Name);

906 }

907 if (const CapturedDecl *CD = dyn_cast(CurrentDecl)) {

909

910

911 if (DC->isFunctionOrMethod() && (DC->getDeclKind() != Decl::Captured)) {

914 }

915 llvm_unreachable("CapturedDecl not inside a function or method");

916 }

917 if (const ObjCMethodDecl *MD = dyn_cast(CurrentDecl)) {

919 llvm::raw_svector_ostream Out(Name);

920 Out << (MD->isInstanceMethod() ? '-' : '+');

921 Out << '[';

922

923

924

926 Out << *ID;

927

929 dyn_cast(MD->getDeclContext()))

930 Out << '(' << *CID << ')';

931

932 Out << ' ';

933 MD->getSelector().print(Out);

934 Out << ']';

935

936 return std::string(Name);

937 }

940

941 return "top level";

942 }

943 return "";

944}

945

947 const llvm::APInt &Val) {

948 if (hasAllocation())

949 C.Deallocate(pVal);

950

951 BitWidth = Val.getBitWidth();

952 unsigned NumWords = Val.getNumWords();

953 const uint64_t* Words = Val.getRawData();

954 if (NumWords > 1) {

955 pVal = new (C) uint64_t[NumWords];

956 std::copy(Words, Words + NumWords, pVal);

957 } else if (NumWords == 1)

958 VAL = Words[0];

959 else

961}

962

963IntegerLiteral::IntegerLiteral(const ASTContext &C, const llvm::APInt &V,

966 assert(type->isIntegerType() && "Illegal type in IntegerLiteral");

967 assert(V.getBitWidth() == C.getIntWidth(type) &&

968 "Integer type is not the correct size for constant.");

971}

972

976 return new (C) IntegerLiteral(C, V, type, l);

977}

978

981 return new (C) IntegerLiteral(Empty);

982}

983

984FixedPointLiteral::FixedPointLiteral(const ASTContext &C, const llvm::APInt &V,

986 unsigned Scale)

988 Scale(Scale) {

989 assert(type->isFixedPointType() && "Illegal type in FixedPointLiteral");

990 assert(V.getBitWidth() == C.getTypeInfo(type).Width &&

991 "Fixed point type is not the correct size for constant.");

994}

995

997 const llvm::APInt &V,

1000 unsigned Scale) {

1001 return new (C) FixedPointLiteral(C, V, type, l, Scale);

1002}

1003

1006 return new (C) FixedPointLiteral(Empty);

1007}

1008

1010

1011

1012

1015 S, llvm::APSInt::getUnsigned(getValue().getZExtValue()), Scale);

1016 return std::string(S);

1017}

1018

1020 raw_ostream &OS) {

1021 switch (Kind) {

1023 break;

1025 OS << 'L';

1026 break;

1028 OS << "u8";

1029 break;

1031 OS << 'u';

1032 break;

1034 OS << 'U';

1035 break;

1036 }

1037

1039 if (!Escaped.empty()) {

1040 OS << "'" << Escaped << "'";

1041 } else {

1042

1043

1044

1045

1047 Val &= 0xFFu;

1048 if (Val < 256 && isPrintable((unsigned char)Val))

1049 OS << "'" << (char)Val << "'";

1050 else if (Val < 256)

1051 OS << "'\\x" << llvm::format("%02x", Val) << "'";

1052 else if (Val <= 0xFFFF)

1053 OS << "'\\u" << llvm::format("%04x", Val) << "'";

1054 else

1055 OS << "'\\U" << llvm::format("%08x", Val) << "'";

1056 }

1057}

1058

1059FloatingLiteral::FloatingLiteral(const ASTContext &C, const llvm::APFloat &V,

1062 setSemantics(V.getSemantics());

1066}

1067

1068FloatingLiteral::FloatingLiteral(const ASTContext &C, EmptyShell Empty)

1069 : Expr(FloatingLiteralClass, Empty) {

1070 setRawSemantics(llvm::APFloatBase::S_IEEEhalf);

1072}

1073

1077 return new (C) FloatingLiteral(C, V, isexact, Type, L);

1078}

1079

1082 return new (C) FloatingLiteral(C, Empty);

1083}

1084

1085

1086

1087

1090 bool ignored;

1091 V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,

1092 &ignored);

1093 return V.convertToDouble();

1094}

1095

1096unsigned StringLiteral::mapCharByteWidth(TargetInfo const &Target,

1098 unsigned CharByteWidth = 0;

1099 switch (SK) {

1103 CharByteWidth = Target.getCharWidth();

1104 break;

1106 CharByteWidth = Target.getWCharWidth();

1107 break;

1109 CharByteWidth = Target.getChar16Width();

1110 break;

1112 CharByteWidth = Target.getChar32Width();

1113 break;

1115 return sizeof(char);

1116 }

1117 assert((CharByteWidth & 7) == 0 && "Assumes character size is byte multiple");

1118 CharByteWidth /= 8;

1119 assert((CharByteWidth == 1 || CharByteWidth == 2 || CharByteWidth == 4) &&

1120 "The only supported character byte widths are 1,2 and 4!");

1121 return CharByteWidth;

1122}

1123

1124StringLiteral::StringLiteral(const ASTContext &Ctx, StringRef Str,

1128

1129 unsigned Length = Str.size();

1130

1133

1136 "StringLiteral must be of constant array type!");

1137 unsigned CharByteWidth = mapCharByteWidth(Ctx.getTargetInfo(), Kind);

1138 unsigned ByteLength = Str.size();

1139 assert((ByteLength % CharByteWidth == 0) &&

1140 "The size of the data must be a multiple of CharByteWidth!");

1141

1142

1143

1144

1145 switch (CharByteWidth) {

1146 case 1:

1147 Length = ByteLength;

1148 break;

1149 case 2:

1150 Length = ByteLength / 2;

1151 break;

1152 case 4:

1153 Length = ByteLength / 4;

1154 break;

1155 default:

1156 llvm_unreachable("Unsupported character width!");

1157 }

1158

1161 } else {

1162 assert(!Pascal && "Can't make an unevaluated Pascal string");

1165 }

1166

1167 *getTrailingObjects() = Length;

1168

1169

1170

1171 llvm::copy(Locs, getTrailingObjects());

1172

1173

1174 llvm::copy(Str, getTrailingObjects());

1175

1177}

1178

1179StringLiteral::StringLiteral(EmptyShell Empty, unsigned NumConcatenated,

1180 unsigned Length, unsigned CharByteWidth)

1181 : Expr(StringLiteralClass, Empty) {

1184 *getTrailingObjects() = Length;

1185}

1186

1191 void *Mem = Ctx.Allocate(totalSizeToAlloc<unsigned, SourceLocation, char>(

1192 1, Locs.size(), Str.size()),

1193 alignof(StringLiteral));

1194 return new (Mem) StringLiteral(Ctx, Str, Kind, Pascal, Ty, Locs);

1195}

1196

1198 unsigned NumConcatenated,

1199 unsigned Length,

1200 unsigned CharByteWidth) {

1201 void *Mem = Ctx.Allocate(totalSizeToAlloc<unsigned, SourceLocation, char>(

1202 1, NumConcatenated, Length * CharByteWidth),

1203 alignof(StringLiteral));

1204 return new (Mem)

1205 StringLiteral(EmptyShell(), NumConcatenated, Length, CharByteWidth);

1206}

1207

1213 break;

1215 OS << 'L';

1216 break;

1218 OS << "u8";

1219 break;

1221 OS << 'u';

1222 break;

1224 OS << 'U';

1225 break;

1226 }

1227 OS << '"';

1228 static const char Hex[] = "0123456789ABCDEF";

1229

1230 unsigned LastSlashX = getLength();

1231 for (unsigned I = 0, N = getLength(); I != N; ++I) {

1234 if (Escaped.empty()) {

1235

1236

1237

1238

1240 Char >= 0xd800 && Char <= 0xdbff) {

1242 if (Trail >= 0xdc00 && Trail <= 0xdfff) {

1243 Char = 0x10000 + ((Char - 0xd800) << 10) + (Trail - 0xdc00);

1244 ++I;

1245 }

1246 }

1247

1248 if (Char > 0xff) {

1249

1250

1251

1253 (Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) {

1254

1255 OS << "\\x";

1256 int Shift = 28;

1257 while ((Char >> Shift) == 0)

1258 Shift -= 4;

1259 for (; Shift >= 0; Shift -= 4)

1260 OS << Hex[(Char >> Shift) & 15];

1261 LastSlashX = I;

1262 continue;

1263 }

1264

1265 if (Char > 0xffff)

1266 OS << "\\U00"

1267 << Hex[(Char >> 20) & 15]

1268 << Hex[(Char >> 16) & 15];

1269 else

1270 OS << "\\u";

1271 OS << Hex[(Char >> 12) & 15]

1272 << Hex[(Char >> 8) & 15]

1273 << Hex[(Char >> 4) & 15]

1274 << Hex[(Char >> 0) & 15];

1275 continue;

1276 }

1277

1278

1279

1280 if (LastSlashX + 1 == I) {

1281 switch (Char) {

1282 case '0': case '1': case '2': case '3': case '4':

1283 case '5': case '6': case '7': case '8': case '9':

1284 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':

1285 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':

1286 OS << "\"\"";

1287 }

1288 }

1289

1290 assert(Char <= 0xff &&

1291 "Characters above 0xff should already have been handled.");

1292

1294 OS << (char)Char;

1295 else

1296 OS << '\\'

1297 << (char)('0' + ((Char >> 6) & 7))

1298 << (char)('0' + ((Char >> 3) & 7))

1299 << (char)('0' + ((Char >> 0) & 7));

1300 } else {

1301

1302 OS << Escaped;

1303 }

1304 }

1305 OS << '"';

1306}

1307

1308

1309

1310

1311

1312

1313

1314

1315

1316

1317

1318

1319

1320

1321

1322

1323

1328 unsigned *StartTokenByteOffset) const {

1329

1330

1333

1337 "Only narrow string literals are currently supported");

1338

1339

1340

1341 unsigned TokNo = 0;

1342 unsigned StringOffset = 0;

1343 if (StartToken)

1344 TokNo = *StartToken;

1345 if (StartTokenByteOffset) {

1346 StringOffset = *StartTokenByteOffset;

1347 ByteNo -= StringOffset;

1348 }

1349 while (true) {

1352

1353

1354

1355

1356 SourceLocation StrTokSpellingLoc = SM.getSpellingLoc(StrTokLoc);

1357

1358

1359 FileIDAndOffset LocInfo = SM.getDecomposedLoc(StrTokSpellingLoc);

1361 StringRef Buffer = SM.getBufferData(LocInfo.first, &Invalid);

1363 if (StartTokenByteOffset != nullptr)

1364 *StartTokenByteOffset = StringOffset;

1365 if (StartToken != nullptr)

1366 *StartToken = TokNo;

1367 return StrTokSpellingLoc;

1368 }

1369

1370 const char *StrData = Buffer.data()+LocInfo.second;

1371

1372

1373 Lexer TheLexer(SM.getLocForStartOfFile(LocInfo.first), Features,

1374 Buffer.begin(), StrData, Buffer.end());

1377

1378

1381

1382

1383 if (ByteNo < TokNumBytes ||

1386

1387

1388

1389 if (StartTokenByteOffset != nullptr)

1390 *StartTokenByteOffset = StringOffset;

1391 if (StartToken != nullptr)

1392 *StartToken = TokNo;

1394 }

1395

1396

1397 StringOffset += TokNumBytes;

1398 ++TokNo;

1399 ByteNo -= TokNumBytes;

1400 }

1401}

1402

1403

1404

1406 switch (Op) {

1407#define UNARY_OPERATION(Name, Spelling) case UO_##Name: return Spelling;

1408#include "clang/AST/OperationKinds.def"

1409 }

1410 llvm_unreachable("Unknown unary operator");

1411}

1412

1415 switch (OO) {

1416 default: llvm_unreachable("No unary operator for overloaded function");

1417 case OO_PlusPlus: return Postfix ? UO_PostInc : UO_PreInc;

1418 case OO_MinusMinus: return Postfix ? UO_PostDec : UO_PreDec;

1419 case OO_Amp: return UO_AddrOf;

1420 case OO_Star: return UO_Deref;

1421 case OO_Plus: return UO_Plus;

1422 case OO_Minus: return UO_Minus;

1423 case OO_Tilde: return UO_Not;

1424 case OO_Exclaim: return UO_LNot;

1425 case OO_Coawait: return UO_Coawait;

1426 }

1427}

1428

1430 switch (Opc) {

1431 case UO_PostInc: case UO_PreInc: return OO_PlusPlus;

1432 case UO_PostDec: case UO_PreDec: return OO_MinusMinus;

1433 case UO_AddrOf: return OO_Amp;

1434 case UO_Deref: return OO_Star;

1435 case UO_Plus: return OO_Plus;

1436 case UO_Minus: return OO_Minus;

1437 case UO_Not: return OO_Tilde;

1438 case UO_LNot: return OO_Exclaim;

1439 case UO_Coawait: return OO_Coawait;

1440 default: return OO_None;

1441 }

1442}

1443

1444

1445

1446

1447

1448#ifndef NDEBUG

1450 switch (SC) {

1451 case Expr::CallExprClass:

1453 case Expr::CXXOperatorCallExprClass:

1455 case Expr::CXXMemberCallExprClass:

1457 case Expr::UserDefinedLiteralClass:

1459 case Expr::CUDAKernelCallExprClass:

1461 default:

1462 llvm_unreachable("unexpected class deriving from CallExpr!");

1463 }

1464}

1465#endif

1466

1467

1468

1470 "we assume CXXOperatorCallExpr is at most 32 bytes");

1471

1477 NumArgs = std::max(Args.size(), MinNumArgs);

1478 unsigned NumPreArgs = PreArgs.size();

1480 assert((NumPreArgs == getNumPreArgs()) && "NumPreArgs overflow!");

1482 "This CallExpr subclass is too big or unsupported");

1483

1485

1487 for (unsigned I = 0; I != NumPreArgs; ++I)

1489 for (unsigned I = 0; I != Args.size(); ++I)

1491 for (unsigned I = Args.size(); I != NumArgs; ++I)

1493

1495

1498 CallExprBits.ExplicitObjectMemFunUsingMemberSyntax = false;

1500

1503}

1504

1507 : Expr(SC, Empty), NumArgs(NumArgs) {

1509 assert((NumPreArgs == getNumPreArgs()) && "NumPreArgs overflow!");

1512 CallExprBits.ExplicitObjectMemFunUsingMemberSyntax = false;

1514}

1515

1521 unsigned NumArgs = std::max(Args.size(), MinNumArgs);

1528 new (Mem) CallExpr(CallExprClass, Fn, {}, Args, Ty, VK,

1529 RParenLoc, FPFeatures, MinNumArgs, UsesADL);

1530 E->updateTrailingSourceLoc();

1531 return E;

1532}

1533

1536 unsigned SizeOfTrailingObjects =

1541 return new (Mem)

1542 CallExpr(CallExprClass, 0, NumArgs, HasFPFeatures, Empty);

1543}

1544

1546

1547

1548

1549

1551

1552 if (auto *DRE = dyn_cast(CEE))

1553 return DRE->getDecl();

1554

1555 if (auto *ME = dyn_cast(CEE))

1556 return ME->getMemberDecl();

1557

1559

1560 while (auto *NTTP = dyn_cast(CEE))

1562

1563

1564 while (true) {

1565 if (auto *BO = dyn_cast(CEE)) {

1566 if (BO->isPtrMemOp()) {

1568 continue;

1569 }

1570 } else if (auto *UO = dyn_cast(CEE)) {

1571 if (UO->getOpcode() == UO_Deref || UO->getOpcode() == UO_AddrOf ||

1572 UO->getOpcode() == UO_Plus) {

1574 continue;

1575 }

1576 }

1577 break;

1578 }

1579

1580 if (auto *DRE = dyn_cast(CEE))

1581 return DRE->getDecl();

1582 if (auto *ME = dyn_cast(CEE))

1583 return ME->getMemberDecl();

1584 if (auto *BE = dyn_cast(CEE))

1585 return BE->getBlockDecl();

1586

1587 return nullptr;

1588}

1589

1590

1593 return FDecl ? FDecl->getBuiltinID() : 0;

1594}

1595

1601

1604 QualType CalleeType = Callee->getType();

1605 if (const auto *FnTypePtr = CalleeType->getAs<PointerType>()) {

1612

1615

1616

1618 assert(!CalleeType.isNull());

1620

1621

1626 }

1627

1630}

1631

1632std::pair<const NamedDecl *, const WarnUnusedResultAttr *>

1634

1635 if (Callee != nullptr)

1636 if (const auto *A = Callee->getAttr())

1637 return {nullptr, A};

1638

1639

1640

1642 if (const auto *A = TD->getAttr())

1643 return {TD, A};

1644

1647 if (const auto *A = TD->getDecl()->getAttr())

1648 return {TD->getDecl(), A};

1649 return {nullptr, nullptr};

1650}

1651

1658 void *Mem = C.Allocate(

1659 totalSizeToAlloc<OffsetOfNode, Expr *>(comps.size(), exprs.size()));

1660

1661 return new (Mem) OffsetOfExpr(C, type, OperatorLoc, tsi, comps, exprs,

1662 RParenLoc);

1663}

1664

1666 unsigned numComps, unsigned numExprs) {

1667 void *Mem =

1668 C.Allocate(totalSizeToAlloc<OffsetOfNode, Expr *>(numComps, numExprs));

1669 return new (Mem) OffsetOfExpr(numComps, numExprs);

1670}

1671

1677 OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),

1678 NumComps(comps.size()), NumExprs(exprs.size()) {

1679 for (unsigned i = 0; i != comps.size(); ++i)

1681 for (unsigned i = 0; i != exprs.size(); ++i)

1683

1685}

1686

1694

1699 OpLoc(op), RParenLoc(rp) {

1700 assert(ExprKind <= UETT_Last && "invalid enum value!");

1703 "UnaryExprOrTypeTraitExprBits.Kind overflow!");

1705 Argument.Ex = E;

1707}

1708

1717 : Expr(MemberExprClass, T, VK, OK), Base(Base), MemberDecl(MemberDecl),

1718 MemberDNLoc(NameInfo.getInfo()), MemberLoc(NameInfo.getLoc()) {

1719 assert(!NameInfo.getName() ||

1724 FoundDecl.getDecl() != MemberDecl ||

1727 TemplateArgs || TemplateKWLoc.isValid();

1731

1732 if (hasQualifier())

1733 new (getTrailingObjects())

1735 if (hasFoundDecl())

1736 *getTrailingObjects() = FoundDecl;

1737 if (TemplateArgs) {

1738 auto Deps = TemplateArgumentDependence::None;

1739 getTrailingObjects()->initializeFrom(

1740 TemplateKWLoc, *TemplateArgs, getTrailingObjects(),

1741 Deps);

1742 } else if (TemplateKWLoc.isValid()) {

1743 getTrailingObjects()->initializeFrom(

1744 TemplateKWLoc);

1745 }

1747}

1748

1755 bool HasQualifier = QualifierLoc.hasQualifier();

1756 bool HasFoundDecl = FoundDecl.getDecl() != MemberDecl ||

1757 FoundDecl.getAccess() != MemberDecl->getAccess();

1758 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.isValid();

1759 std::size_t Size =

1762 HasQualifier, HasFoundDecl, HasTemplateKWAndArgsInfo,

1763 TemplateArgs ? TemplateArgs->size() : 0);

1764

1765 void *Mem = C.Allocate(Size, alignof(MemberExpr));

1766 return new (Mem) MemberExpr(Base, IsArrow, OperatorLoc, QualifierLoc,

1767 TemplateKWLoc, MemberDecl, FoundDecl, NameInfo,

1768 TemplateArgs, T, VK, OK, NOUR);

1769}

1770

1772 bool HasQualifier, bool HasFoundDecl,

1773 bool HasTemplateKWAndArgsInfo,

1774 unsigned NumTemplateArgs) {

1775 assert((!NumTemplateArgs || HasTemplateKWAndArgsInfo) &&

1776 "template args but no template arg info?");

1777 std::size_t Size =

1780 HasQualifier, HasFoundDecl, HasTemplateKWAndArgsInfo,

1781 NumTemplateArgs);

1782 void *Mem = Context.Allocate(Size, alignof(MemberExpr));

1783 return new (Mem) MemberExpr(EmptyShell());

1784}

1785

1787 MemberDecl = NewD;

1788 if (getType()->isUndeducedType())

1791}

1792

1797 return MemberLoc;

1798 }

1799

1800

1801

1803 if (BaseStartLoc.isValid())

1804 return BaseStartLoc;

1805 return MemberLoc;

1806}

1813 return EndLoc;

1814}

1815

1816bool CastExpr::CastConsistency() const {

1818 case CK_DerivedToBase:

1819 case CK_UncheckedDerivedToBase:

1820 case CK_DerivedToBaseMemberPointer:

1821 case CK_BaseToDerived:

1822 case CK_BaseToDerivedMemberPointer:

1823 assert( $path\_empty$ () && "Cast kind should have a base path!");

1824 break;

1825

1826 case CK_CPointerToObjCPointerCast:

1827 assert(getType()->isObjCObjectPointerType());

1829 goto CheckNoBasePath;

1830

1831 case CK_BlockPointerToObjCPointerCast:

1832 assert(getType()->isObjCObjectPointerType());

1834 goto CheckNoBasePath;

1835

1836 case CK_ReinterpretMemberPointer:

1837 assert(getType()->isMemberPointerType());

1839 goto CheckNoBasePath;

1840

1841 case CK_BitCast:

1842

1843

1844

1845 if ( getType ()->isPointerType()) {

1846 assert(getType()->isObjCObjectPointerType() ==

1848 assert(getType()->isBlockPointerType() ==

1850 }

1851 goto CheckNoBasePath;

1852

1853 case CK_AnyPointerToBlockPointerCast:

1854 assert(getType()->isBlockPointerType());

1857 goto CheckNoBasePath;

1858

1859 case CK_CopyAndAutoreleaseBlockObject:

1860 assert(getType()->isBlockPointerType());

1862 goto CheckNoBasePath;

1863

1864 case CK_FunctionToPointerDecay:

1865 assert(getType()->isPointerType());

1867 goto CheckNoBasePath;

1868

1869 case CK_AddressSpaceConversion: {

1876 }

1877 assert((Ty->isDependentType() || SETy->isDependentType()) ||

1878 (!Ty.isNull() && !SETy.isNull() &&

1880 goto CheckNoBasePath;

1881 }

1882

1883 case CK_Dynamic:

1884 case CK_ToUnion:

1885 case CK_ArrayToPointerDecay:

1886 case CK_NullToMemberPointer:

1887 case CK_NullToPointer:

1888 case CK_ConstructorConversion:

1889 case CK_IntegralToPointer:

1890 case CK_PointerToIntegral:

1891 case CK_ToVoid:

1892 case CK_VectorSplat:

1893 case CK_IntegralCast:

1894 case CK_BooleanToSignedIntegral:

1895 case CK_IntegralToFloating:

1896 case CK_FloatingToIntegral:

1897 case CK_FloatingCast:

1898 case CK_ObjCObjectLValueCast:

1899 case CK_FloatingRealToComplex:

1900 case CK_FloatingComplexToReal:

1901 case CK_FloatingComplexCast:

1902 case CK_FloatingComplexToIntegralComplex:

1903 case CK_IntegralRealToComplex:

1904 case CK_IntegralComplexToReal:

1905 case CK_IntegralComplexCast:

1906 case CK_IntegralComplexToFloatingComplex:

1907 case CK_ARCProduceObject:

1908 case CK_ARCConsumeObject:

1909 case CK_ARCReclaimReturnedObject:

1910 case CK_ARCExtendBlockObject:

1911 case CK_ZeroToOCLOpaqueType:

1912 case CK_IntToOCLSampler:

1913 case CK_FloatingToFixedPoint:

1914 case CK_FixedPointToFloating:

1915 case CK_FixedPointCast:

1916 case CK_FixedPointToIntegral:

1917 case CK_IntegralToFixedPoint:

1918 case CK_MatrixCast:

1920 goto CheckNoBasePath;

1921

1922 case CK_Dependent:

1923 case CK_LValueToRValue:

1924 case CK_NoOp:

1925 case CK_AtomicToNonAtomic:

1926 case CK_NonAtomicToAtomic:

1927 case CK_PointerToBoolean:

1928 case CK_IntegralToBoolean:

1929 case CK_FloatingToBoolean:

1930 case CK_MemberPointerToBoolean:

1931 case CK_FloatingComplexToBoolean:

1932 case CK_IntegralComplexToBoolean:

1933 case CK_LValueBitCast:

1934 case CK_LValueToRValueBitCast:

1935 case CK_UserDefinedConversion:

1936 case CK_BuiltinFnToFnPtr:

1937 case CK_FixedPointToBoolean:

1938 case CK_HLSLArrayRValue:

1939 case CK_HLSLVectorTruncation:

1940 case CK_HLSLMatrixTruncation:

1941 case CK_HLSLElementwiseCast:

1942 case CK_HLSLAggregateSplatCast:

1943 CheckNoBasePath:

1944 assert(path_empty() && "Cast kind should not have a base path!");

1945 break;

1946 }

1947 return true;

1948}

1949

1951 switch (CK) {

1952#define CAST_OPERATION(Name) case CK_##Name: return #Name;

1953#include "clang/AST/OperationKinds.def"

1954 }

1955 llvm_unreachable("Unhandled cast kind!");

1956}

1957

1958namespace {

1959

1960

1961static Expr *ignoreImplicitSemaNodes(Expr *E) {

1962 if (auto *Materialize = dyn_cast(E))

1963 return Materialize->getSubExpr();

1964

1965 if (auto *Binder = dyn_cast(E))

1966 return Binder->getSubExpr();

1967

1968 if (auto *Full = dyn_cast(E))

1969 return Full->getSubExpr();

1970

1971 if (auto *CPLIE = dyn_cast(E);

1972 CPLIE && CPLIE->getInitExprs().size() == 1)

1973 return CPLIE->getInitExprs()[0];

1974

1975 return E;

1976}

1977}

1978

1980 const Expr *SubExpr = nullptr;

1981

1982 for (const CastExpr *E = this; E; E = dyn_cast(SubExpr)) {

1983 SubExpr = IgnoreExprNodes(E->getSubExpr(), ignoreImplicitSemaNodes);

1984

1985

1986

1987 if (E->getCastKind() == CK_ConstructorConversion) {

1989 ignoreImplicitSemaNodes);

1990 } else if (E->getCastKind() == CK_UserDefinedConversion) {

1992 "Unexpected SubExpr for CK_UserDefinedConversion.");

1993 if (auto *MCE = dyn_cast(SubExpr))

1994 SubExpr = MCE->getImplicitObjectArgument();

1995 }

1996 }

1997

1998 return const_cast<Expr *>(SubExpr);

1999}

2000

2002 const Expr *SubExpr = nullptr;

2003

2004 for (const CastExpr *E = this; E; E = dyn_cast(SubExpr)) {

2005 SubExpr = IgnoreExprNodes(E->getSubExpr(), ignoreImplicitSemaNodes);

2006

2007 if (E->getCastKind() == CK_ConstructorConversion)

2009

2010 if (E->getCastKind() == CK_UserDefinedConversion) {

2011 if (auto *MCE = dyn_cast(SubExpr))

2012 return MCE->getMethodDecl();

2013 }

2014 }

2015

2016 return nullptr;

2017}

2018

2021#define ABSTRACT_STMT(x)

2022#define CASTEXPR(Type, Base) \

2023 case Stmt::Type##Class: \

2024 return static_cast<Type *>(this) \

2025 ->getTrailingObjectsNonStrict<CXXBaseSpecifier *>();

2026#define STMT(Type, Base)

2027#include "clang/AST/StmtNodes.inc"

2028 default:

2029 llvm_unreachable("non-cast expressions not possible here");

2030 }

2031}

2032

2037

2043 Field != FieldEnd; ++Field) {

2045 !Field->isUnnamedBitField()) {

2046 return *Field;

2047 }

2048 }

2049 return nullptr;

2050}

2051

2055 case ImplicitCastExprClass:

2057 ->getTrailingObjects();

2058 case CStyleCastExprClass:

2060 ->getTrailingObjects();

2061 case CXXFunctionalCastExprClass:

2063 ->getTrailingObjects();

2064 case CXXStaticCastExprClass:

2066 ->getTrailingObjects();

2067 default:

2068 llvm_unreachable("Cast does not have FPFeatures");

2069 }

2070}

2071

2077 unsigned PathSize = (BasePath ? BasePath->size() : 0);

2078 void *Buffer =

2079 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

2081

2082

2083 assert((Kind != CK_LValueToRValue ||

2084 !(T->isNullPtrType() || T->getAsCXXRecordDecl())) &&

2085 "invalid type for lvalue-to-rvalue conversion");

2086 ImplicitCastExpr *E =

2087 new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, FPO, VK);

2088 if (PathSize)

2089 llvm::uninitialized_copy(*BasePath,

2091 return E;

2092}

2093

2095 unsigned PathSize,

2096 bool HasFPFeatures) {

2097 void *Buffer =

2098 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

2099 PathSize, HasFPFeatures));

2100 return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize, HasFPFeatures);

2101}

2102

2109 unsigned PathSize = (BasePath ? BasePath->size() : 0);

2110 void *Buffer =

2111 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

2113 CStyleCastExpr *E =

2114 new (Buffer) CStyleCastExpr(T, VK, K, Op, PathSize, FPO, WrittenTy, L, R);

2115 if (PathSize)

2116 llvm::uninitialized_copy(*BasePath,

2118 return E;

2119}

2120

2122 unsigned PathSize,

2123 bool HasFPFeatures) {

2124 void *Buffer =

2125 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

2126 PathSize, HasFPFeatures));

2127 return new (Buffer) CStyleCastExpr(EmptyShell(), PathSize, HasFPFeatures);

2128}

2129

2130

2131

2133 switch (Op) {

2134#define BINARY_OPERATION(Name, Spelling) case BO_##Name: return Spelling;

2135#include "clang/AST/OperationKinds.def"

2136 }

2137 llvm_unreachable("Invalid OpCode!");

2138}

2139

2142 switch (OO) {

2143 default: llvm_unreachable("Not an overloadable binary operator");

2144 case OO_Plus: return BO_Add;

2145 case OO_Minus: return BO_Sub;

2146 case OO_Star: return BO_Mul;

2147 case OO_Slash: return BO_Div;

2148 case OO_Percent: return BO_Rem;

2149 case OO_Caret: return BO_Xor;

2150 case OO_Amp: return BO_And;

2151 case OO_Pipe: return BO_Or;

2152 case OO_Equal: return BO_Assign;

2153 case OO_Spaceship: return BO_Cmp;

2154 case OO_Less: return BO_LT;

2155 case OO_Greater: return BO_GT;

2156 case OO_PlusEqual: return BO_AddAssign;

2157 case OO_MinusEqual: return BO_SubAssign;

2158 case OO_StarEqual: return BO_MulAssign;

2159 case OO_SlashEqual: return BO_DivAssign;

2160 case OO_PercentEqual: return BO_RemAssign;

2161 case OO_CaretEqual: return BO_XorAssign;

2162 case OO_AmpEqual: return BO_AndAssign;

2163 case OO_PipeEqual: return BO_OrAssign;

2164 case OO_LessLess: return BO_Shl;

2165 case OO_GreaterGreater: return BO_Shr;

2166 case OO_LessLessEqual: return BO_ShlAssign;

2167 case OO_GreaterGreaterEqual: return BO_ShrAssign;

2168 case OO_EqualEqual: return BO_EQ;

2169 case OO_ExclaimEqual: return BO_NE;

2170 case OO_LessEqual: return BO_LE;

2171 case OO_GreaterEqual: return BO_GE;

2172 case OO_AmpAmp: return BO_LAnd;

2173 case OO_PipePipe: return BO_LOr;

2174 case OO_Comma: return BO_Comma;

2175 case OO_ArrowStar: return BO_PtrMemI;

2176 }

2177}

2178

2181 OO_None, OO_ArrowStar,

2182 OO_Star, OO_Slash, OO_Percent,

2183 OO_Plus, OO_Minus,

2184 OO_LessLess, OO_GreaterGreater,

2185 OO_Spaceship,

2186 OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,

2187 OO_EqualEqual, OO_ExclaimEqual,

2188 OO_Amp,

2189 OO_Caret,

2190 OO_Pipe,

2191 OO_AmpAmp,

2192 OO_PipePipe,

2193 OO_Equal, OO_StarEqual,

2194 OO_SlashEqual, OO_PercentEqual,

2195 OO_PlusEqual, OO_MinusEqual,

2196 OO_LessLessEqual, OO_GreaterGreaterEqual,

2197 OO_AmpEqual, OO_CaretEqual,

2198 OO_PipeEqual,

2199 OO_Comma

2200 };

2201 return OverOps[Opc];

2202}

2203

2206 const Expr *LHS,

2207 const Expr *RHS) {

2208 if (Opc != BO_Add)

2209 return false;

2210

2211

2212 const Expr *PExp;

2213 if (LHS->getType()->isPointerType()) {

2214 if (!RHS->getType()->isIntegerType())

2215 return false;

2216 PExp = LHS;

2217 } else if (RHS->getType()->isPointerType()) {

2218 if (!LHS->getType()->isIntegerType())

2219 return false;

2220 PExp = RHS;

2221 } else {

2222 return false;

2223 }

2224

2225

2226 if (auto *Select =

2228

2230 if (!Select->getCond()->EvaluateAsBooleanCondition(EvalResult, Ctx))

2231 return false;

2232 PExp = EvalResult ? Select->getTrueExpr() : Select->getFalseExpr();

2233 }

2234

2235

2238 return false;

2239

2240

2243 return false;

2244

2245 return true;

2246}

2247

2253 BuiltinLoc(BLoc), RParenLoc(RParenLoc), ParentContext(ParentContext) {

2255

2257 ? ExprDependence::Value

2258 : ExprDependence::None);

2259}

2260

2264 return "__builtin_FILE";

2266 return "__builtin_FILE_NAME";

2268 return "__builtin_FUNCTION";

2270 return "__builtin_FUNCSIG";

2272 return "__builtin_LINE";

2274 return "__builtin_COLUMN";

2276 return "__builtin_source_location";

2277 }

2278 llvm_unreachable("unexpected IdentKind!");

2279}

2280

2282 const Expr *DefaultExpr) const {

2285

2286 if (const auto *DIE = dyn_cast_if_present(DefaultExpr)) {

2287 Loc = DIE->getUsedLocation();

2288 Context = DIE->getUsedContext();

2289 } else if (const auto *DAE =

2290 dyn_cast_if_present(DefaultExpr)) {

2291 Loc = DAE->getUsedLocation();

2292 Context = DAE->getUsedContext();

2293 } else {

2296 }

2297

2298

2299

2300

2301

2302

2303 if (const auto *D = dyn_cast(Context);

2305 Context = D->getParent()->getParent();

2306

2309

2310 auto MakeStringLiteral = [&](StringRef Tmp) {

2313

2314 LValuePathEntry Path[1] = {LValuePathEntry::ArrayIndex(0)};

2316 };

2317

2320

2321

2325 return MakeStringLiteral(FileName);

2326 }

2331 return MakeStringLiteral(Path);

2332 }

2335 const auto *CurDecl = dyn_cast(Context);

2339 return MakeStringLiteral(

2341 }

2347

2348

2349

2351 assert(ImplDecl);

2352

2353

2354

2355

2356

2359 StringRef Name = F->getName();

2360 if (Name == "_M_file_name") {

2364 Value.getStructField(F->getFieldIndex()) = MakeStringLiteral(Path);

2365 } else if (Name == "_M_function_name") {

2366

2367

2368 const auto *CurDecl = dyn_cast(Context);

2369 Value.getStructField(F->getFieldIndex()) = MakeStringLiteral(

2373 : "");

2374 } else if (Name == "_M_line") {

2376 Value.getStructField(F->getFieldIndex()) = APValue(IntVal);

2377 } else if (Name == "_M_column") {

2379 Value.getStructField(F->getFieldIndex()) = APValue(IntVal);

2380 }

2381 }

2382

2385

2387 false);

2388 }

2389 }

2390 llvm_unreachable("unhandled case");

2391}

2392

2395 unsigned NumOfElements)

2397 EmbedKeywordLoc(Loc), Ctx(&Ctx), Data(Data), Begin(Begin),

2398 NumOfElements(NumOfElements) {

2401 Ctx, llvm::APInt::getZero(Ctx.getTypeSize(getType())), getType(), Loc);

2402 assert(getType()->isSignedIntegerType() && "IntTy should be signed");

2403}

2404

2408 InitExprs(C, initExprs.size()), LBraceLoc(lbraceloc),

2409 RBraceLoc(rbraceloc), AltForm(nullptr, true) {

2411 InitExprs.insert(C, InitExprs.end(), initExprs.begin(), initExprs.end());

2412

2414}

2415

2417 if (NumInits > InitExprs.size())

2418 InitExprs.reserve(C, NumInits);

2419}

2420

2422 InitExprs.resize(C, NumInits, nullptr);

2423}

2424

2426 if (Init >= InitExprs.size()) {

2427 InitExprs.insert(C, InitExprs.end(), Init - InitExprs.size() + 1, nullptr);

2429 return nullptr;

2430 }

2431

2435}

2436

2439 ArrayFillerOrUnionFieldInit = filler;

2440

2442 for (unsigned i = 0, e = getNumInits(); i != e; ++i)

2443 if (inits[i] == nullptr)

2444 inits[i] = filler;

2445}

2446

2449 return false;

2452 return false;

2453

2456 return false;

2457 Init = Init->IgnoreParenImpCasts();

2459}

2460

2462 assert(isSemanticForm() && "syntactic form never semantically transparent");

2463

2464

2466 assert(getNumInits() == 1 && "multiple inits in glvalue init list");

2467 return true;

2468 }

2469

2470

2471

2473 return false;

2474

2475

2476

2478 return false;

2479

2482}

2483

2485 assert(isSyntacticForm() && "only test syntactic form as zero initializer");

2486

2488 return false;

2489 }

2490

2492 return Lit && Lit->getValue() == 0;

2493}

2494

2497 return SyntacticForm->getBeginLoc();

2500

2502 E = InitExprs.end();

2503 I != E; ++I) {

2504 if (Stmt *S = *I) {

2505 Beg = S->getBeginLoc();

2506 break;

2507 }

2508 }

2509 }

2510 return Beg;

2511}

2512

2515 return SyntacticForm->getEndLoc();

2518

2519 for (Stmt *S : llvm::reverse(InitExprs)) {

2520 if (S) {

2521 End = S->getEndLoc();

2522 break;

2523 }

2524 }

2525 }

2526 return End;

2527}

2528

2529

2530

2536

2538 return TheBlock->getCaretLocation();

2539}

2546

2547

2548

2549

2550

2551

2552

2553

2554

2557 const auto *Ref = dyn_cast(Unwrapped);

2558 if (!Ref)

2559 return false;

2560

2561 return isa_and_nonnull(Ref->getDecl());

2562}

2563

2565

2566

2567

2568

2569

2571 return false;

2572

2574

2575

2577 return true;

2578

2579

2581 return true;

2582

2583

2585 return true;

2586

2587

2588 if (auto *UO = dyn_cast(E))

2589 if (UO->getOpcode() == UO_Deref)

2590 return true;

2591

2592 if (auto *BO = dyn_cast(E)) {

2593

2594 if (BO->isPtrMemOp())

2595 return true;

2596

2597

2598 if (BO->getOpcode() == BO_Comma)

2599 return BO->getRHS()->isReadIfDiscardedInCPlusPlus11();

2600 }

2601

2602

2603

2604 if (auto *CO = dyn_cast(E))

2605 return CO->getTrueExpr()->isReadIfDiscardedInCPlusPlus11() &&

2606 CO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();

2607

2608 if (auto *BCO =

2609 dyn_cast(E)) {

2610 if (auto *OVE = dyn_cast(BCO->getTrueExpr()))

2611 return OVE->getSourceExpr()->isReadIfDiscardedInCPlusPlus11() &&

2612 BCO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();

2613 }

2614

2615

2617 return true;

2618 if (const auto *POE = dyn_cast(E)) {

2620 return true;

2621 }

2622

2623 return false;

2624}

2625

2626

2627

2628

2629

2633

2634

2636 return false;

2637

2639 default:

2640 if (getType()->isVoidType())

2641 return false;

2642 WarnE = this;

2645 return true;

2646 case ParenExprClass:

2649 case GenericSelectionExprClass:

2652 case CoawaitExprClass:

2653 case CoyieldExprClass:

2656 case ChooseExprClass:

2659 case UnaryOperatorClass: {

2661

2663 case UO_Plus:

2664 case UO_Minus:

2665 case UO_AddrOf:

2666 case UO_Not:

2667 case UO_LNot:

2668 case UO_Deref:

2669 break;

2670 case UO_Coawait:

2671

2672

2673 case UO_PostInc:

2674 case UO_PostDec:

2675 case UO_PreInc:

2676 case UO_PreDec:

2677 return false;

2678 case UO_Real:

2679 case UO_Imag:

2680

2683 return false;

2684 break;

2685 case UO_Extension:

2687 }

2688 WarnE = this;

2691 return true;

2692 }

2693 case BinaryOperatorClass: {

2696 default:

2697 break;

2698

2699

2700 case BO_Comma:

2701

2702

2705 if (IE->getValue() == 0)

2706 return false;

2708

2709 case BO_LAnd:

2710 case BO_LOr:

2713 return false;

2714 break;

2715 }

2717 return false;

2718 WarnE = this;

2722 return true;

2723 }

2724 case CompoundAssignOperatorClass:

2725 case VAArgExprClass:

2726 case AtomicExprClass:

2727 return false;

2728

2729 case ConditionalOperatorClass: {

2730

2731

2732

2734 return Exp->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) &&

2735 Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);

2736 }

2737 case BinaryConditionalOperatorClass: {

2739 return Exp->getFalseExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);

2740 }

2741

2742 case MemberExprClass:

2743 WarnE = this;

2747 return true;

2748

2749 case ArraySubscriptExprClass:

2750 WarnE = this;

2754 return true;

2755

2756 case CXXOperatorCallExprClass: {

2757

2758

2759

2760

2761

2762

2765 default:

2766 break;

2767 case OO_EqualEqual:

2768 case OO_ExclaimEqual:

2769 case OO_Less:

2770 case OO_Greater:

2771 case OO_GreaterEqual:

2772 case OO_LessEqual:

2775 break;

2776 WarnE = this;

2779 return true;

2780 }

2781

2782

2783 [[fallthrough]];

2784 }

2785 case CallExprClass:

2786 case CXXMemberCallExprClass:

2787 case UserDefinedLiteralClass: {

2788

2790

2791

2792

2793

2795 bool PureOrConst =

2796 FD && (FD->hasAttr() || FD->hasAttr());

2798 WarnE = this;

2801

2802 if (unsigned NumArgs = CE->getNumArgs())

2805 return true;

2806 }

2807 return false;

2808 }

2809

2810

2811 case UnresolvedLookupExprClass:

2812 case CXXUnresolvedConstructExprClass:

2813 case RecoveryExprClass:

2814 return false;

2815

2816 case CXXTemporaryObjectExprClass:

2817 case CXXConstructExprClass: {

2820

2822 CE->hasUnusedResultAttr(Ctx)) {

2823 WarnE = this;

2826

2827 if (unsigned NumArgs = CE->getNumArgs())

2828 R2 = SourceRange(CE->getArg(0)->getBeginLoc(),

2829 CE->getArg(NumArgs - 1)->getEndLoc());

2830 return true;

2831 }

2832 return false;

2833 }

2834

2835 case ObjCMessageExprClass: {

2837 if (Ctx.getLangOpts().ObjCAutoRefCount &&

2841 WarnE = this;

2844 return true;

2845 }

2846

2848 WarnE = this;

2850 return true;

2851 }

2852

2853 return false;

2854 }

2855

2856 case ObjCPropertyRefExprClass:

2857 case ObjCSubscriptRefExprClass:

2858 WarnE = this;

2861 return true;

2862

2863 case PseudoObjectExprClass: {

2865

2866

2868 POE->getSyntacticForm())) {

2869 WarnE = this;

2872 return true;

2873 }

2874

2875

2876 if (auto *BO = dyn_cast(POE->getSyntacticForm()))

2877 if (BO->isAssignmentOp())

2878 return false;

2879 if (auto *UO = dyn_cast(POE->getSyntacticForm()))

2880 if (UO->isIncrementDecrementOp())

2881 return false;

2882

2883

2884 const Expr *Result = POE->getResultExpr();

2885 return Result && Result->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);

2886 }

2887

2888 case StmtExprClass: {

2889

2890

2891

2892

2893

2896 if (const Expr *E = dyn_cast(CS->body_back()))

2899 if (const Expr *E = dyn_cast(Label->getSubStmt()))

2901 }

2902

2903 if (getType()->isVoidType())

2904 return false;

2905 WarnE = this;

2908 return true;

2909 }

2910 case CXXFunctionalCastExprClass:

2911 case CStyleCastExprClass: {

2912

2913

2914

2915

2916

2917

2923

2924

2925 if (auto *DRE = dyn_cast(SubE))

2926 if (auto *VD = dyn_cast(DRE->getDecl()))

2927 if (!VD->isExternallyVisible())

2928 return false;

2929

2930

2931

2932

2934 return false;

2935

2937 }

2938 return false;

2939 }

2940

2941

2942

2943 if (CE->getCastKind() == CK_ConstructorConversion)

2946 return false;

2947

2948 WarnE = this;

2950 dyn_cast(this)) {

2951 Loc = CXXCE->getBeginLoc();

2952 R1 = CXXCE->getSubExpr()->getSourceRange();

2953 } else {

2957 }

2958 return true;

2959 }

2960 case ImplicitCastExprClass: {

2962

2963

2964 if (ICE->getCastKind() == CK_LValueToRValue &&

2966 return false;

2967

2969 }

2970 case CXXDefaultArgExprClass:

2973 case CXXDefaultInitExprClass:

2976

2977 case CXXNewExprClass:

2978

2979

2980 case CXXDeleteExprClass:

2981 return false;

2982 case MaterializeTemporaryExprClass:

2984 ->getSubExpr()

2985 ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);

2986 case CXXBindTemporaryExprClass:

2988 ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);

2989 case ExprWithCleanupsClass:

2991 ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);

2992 case OpaqueValueExprClass:

2994 WarnE, Loc, R1, R2, Ctx);

2995 }

2996}

2997

2998

2999

3003 default:

3004 return false;

3005 case ObjCIvarRefExprClass:

3006 return true;

3007 case Expr::UnaryOperatorClass:

3009 case ImplicitCastExprClass:

3011 case MaterializeTemporaryExprClass:

3013 Ctx);

3014 case CStyleCastExprClass:

3016 case DeclRefExprClass: {

3018

3019 if (const VarDecl *VD = dyn_cast(D)) {

3020 if (VD->hasGlobalStorage())

3021 return true;

3023

3024

3025 return T->isPointerType() &&

3027 }

3028 return false;

3029 }

3030 case MemberExprClass: {

3033 }

3034 case ArraySubscriptExprClass:

3036 }

3037}

3038

3044

3046 assert(expr->hasPlaceholderType(BuiltinType::BoundMember));

3047

3048

3049

3050

3051

3052 expr = expr->IgnoreParens();

3053 if (const MemberExpr *mem = dyn_cast(expr)) {

3055 return mem->getMemberDecl()->getType();

3056 }

3057

3061 assert(type->isFunctionType());

3062 return type;

3063 }

3064

3067}

3068

3072

3076

3080

3084

3088

3093

3097

3099 if (auto *MCE = dyn_cast(this)) {

3100 if (isa_and_nonnull(MCE->getMethodDecl()))

3101 return MCE->getImplicitObjectArgument();

3102 }

3103 return this;

3104}

3105

3110

3115

3117 auto IgnoreNoopCastsSingleStep = [&Ctx](Expr *E) {

3118 if (auto *CE = dyn_cast(E)) {

3119

3120

3121 Expr *SubExpr = CE->getSubExpr();

3122 bool IsIdentityCast =

3124 bool IsSameWidthCast = (E->getType()->isPointerType() ||

3126 (SubExpr->getType()->isPointerType() ||

3130

3131 if (IsIdentityCast || IsSameWidthCast)

3132 return SubExpr;

3133 } else if (auto *NTTP = dyn_cast(E))

3134 return NTTP->getReplacement();

3135

3136 return E;

3137 };

3139 IgnoreNoopCastsSingleStep);

3140}

3141

3144 if (auto *Cast = dyn_cast(E)) {

3145 auto *SE = Cast->getSubExpr();

3147 return SE;

3148 }

3149

3150 if (auto *C = dyn_cast(E)) {

3151 auto NumArgs = C->getNumArgs();

3152 if (NumArgs == 1 ||

3154 Expr *A = C->getArg(0);

3156 return A;

3157 }

3158 }

3159 return E;

3160 };

3161 auto IgnoreImplicitMemberCallSingleStep = [](Expr *E) {

3162 if (auto *C = dyn_cast(E)) {

3163 Expr *ExprNode = C->getImplicitObjectArgument();

3165 return ExprNode;

3166 }

3167 if (auto *PE = dyn_cast(ExprNode)) {

3168 if (PE->getSourceRange() == C->getSourceRange()) {

3170 }

3171 }

3174 return ExprNode;

3175 }

3176 return E;

3177 };

3178

3179

3180

3181 auto IgnoreImplicitCallSingleStep = [](Expr *E) {

3182 auto *C = dyn_cast(E);

3183 if ()

3184 return E;

3185

3186

3187

3188

3189 unsigned NumArgs = C->getNumArgs();

3191 return E;

3192

3193 Expr *A = C->getArg(0);

3194

3195

3197 return E;

3198

3199

3200

3202 return A;

3203

3204 return E;

3205 };

3206

3210 IgnoreImplicitMemberCallSingleStep, IgnoreImplicitCallSingleStep);

3211}

3212

3214 const Expr *E = this;

3216 E = M->getSubExpr();

3217

3218 while (const ImplicitCastExpr *ICE = dyn_cast(E))

3219 E = ICE->getSubExprAsWritten();

3220

3222}

3223

3224

3225

3228 E = M->getSubExpr();

3229

3230 while (const ImplicitCastExpr *ICE = dyn_cast(E)) {

3231 if (ICE->getCastKind() == CK_NoOp)

3232 E = ICE->getSubExpr();

3233 else

3234 break;

3235 }

3236

3238 E = BE->getSubExpr();

3239

3240 while (const ImplicitCastExpr *ICE = dyn_cast(E)) {

3241 if (ICE->getCastKind() == CK_NoOp)

3242 E = ICE->getSubExpr();

3243 else

3244 break;

3245 }

3246

3248}

3249

3250

3251

3253 if (.hasSameUnqualifiedType(getType(), C.getCanonicalTagType(TempTy)))

3254 return false;

3255

3257

3258

3260

3262 return false;

3263 }

3264

3265

3266

3267

3268

3269 if (const auto *ICE = dyn_cast(E)) {

3270 switch (ICE->getCastKind()) {

3271 case CK_DerivedToBase:

3272 case CK_UncheckedDerivedToBase:

3273 return false;

3274 default:

3275 break;

3276 }

3277 }

3278

3279

3281 return false;

3282

3283 if (const auto *BO = dyn_cast(E))

3284 if (BO->isPtrMemOp())

3285 return false;

3286

3287

3289 return false;

3290

3291 return true;

3292}

3293

3295 const Expr *E = this;

3296

3297

3298 while (true) {

3299 if (const ParenExpr *Paren = dyn_cast(E)) {

3300 E = Paren->getSubExpr();

3301 continue;

3302 }

3303

3304 if (const ImplicitCastExpr *ICE = dyn_cast(E)) {

3305 if (ICE->getCastKind() == CK_NoOp ||

3306 ICE->getCastKind() == CK_LValueToRValue ||

3307 ICE->getCastKind() == CK_DerivedToBase ||

3308 ICE->getCastKind() == CK_UncheckedDerivedToBase) {

3309 E = ICE->getSubExpr();

3310 continue;

3311 }

3312 }

3313

3314 if (const UnaryOperator* UnOp = dyn_cast(E)) {

3315 if (UnOp->getOpcode() == UO_Extension) {

3316 E = UnOp->getSubExpr();

3317 continue;

3318 }

3319 }

3320

3322 = dyn_cast(E)) {

3323 E = M->getSubExpr();

3324 continue;

3325 }

3326

3327 break;

3328 }

3329

3331 return This->isImplicit();

3332

3333 return false;

3334}

3335

3336

3337

3339 for (unsigned I = 0; I < Exprs.size(); ++I)

3341 return true;

3342

3343 return false;

3344}

3345

3347 const Expr **Culprit) const {

3349 "Expression evaluator can't be called on a dependent expression.");

3350

3351

3352

3353

3354

3355

3356

3357

3358

3359

3360 if (IsForRef) {

3361 if (auto *EWC = dyn_cast(this))

3362 return EWC->getSubExpr()->isConstantInitializer(Ctx, true, Culprit);

3363 if (auto *MTE = dyn_cast(this))

3364 return MTE->getSubExpr()->isConstantInitializer(Ctx, false, Culprit);

3367 return true;

3368 if (Culprit)

3369 *Culprit = this;

3370 return false;

3371 }

3372

3374 default: break;

3375 case Stmt::ExprWithCleanupsClass:

3377 Ctx, IsForRef, Culprit);

3378 case StringLiteralClass:

3379 case ObjCEncodeExprClass:

3380 return true;

3381 case CXXTemporaryObjectExprClass:

3382 case CXXConstructExprClass: {

3384

3387

3389

3390

3391 assert(CE->getNumArgs() == 1 && "trivial ctor with > 1 argument");

3393 }

3394

3395 break;

3396 }

3397 case ConstantExprClass: {

3398

3399

3402 }

3403 case CompoundLiteralExprClass: {

3404

3405

3406

3409 }

3410 case DesignatedInitUpdateExprClass: {

3414 }

3415 case InitListExprClass: {

3416

3417

3418

3419

3420

3421

3423 assert(ILE->isSemanticForm() && "InitListExpr must be in semantic form");

3424

3427

3430 for (unsigned i = 0; i < numInits; i++) {

3432 return false;

3433 }

3434 return true;

3435 }

3436

3438 unsigned ElementNo = 0;

3440

3441

3442

3443 if (const auto *CXXRD = dyn_cast(RD)) {

3444 for (unsigned i = 0, e = CXXRD->getNumBases(); i < e; i++) {

3445 if (ElementNo < ILE->getNumInits()) {

3446 const Expr *Elt = ILE->getInit(ElementNo++);

3448 return false;

3449 }

3450 }

3451 }

3452

3453 for (const auto *Field : RD->fields()) {

3454

3456 continue;

3457

3458

3459 if (Field->isUnnamedBitField())

3460 continue;

3461

3462 if (ElementNo < ILE->getNumInits()) {

3463 const Expr *Elt = ILE->getInit(ElementNo++);

3464 if (Field->isBitField()) {

3465

3468 if (Culprit)

3469 *Culprit = Elt;

3470 return false;

3471 }

3472 } else {

3473 bool RefType = Field->getType()->isReferenceType();

3475 return false;

3476 }

3477 }

3478 }

3479 return true;

3480 }

3481

3482 break;

3483 }

3484 case ImplicitValueInitExprClass:

3485 case NoInitExprClass:

3486 return true;

3487 case ParenExprClass:

3489 ->isConstantInitializer(Ctx, IsForRef, Culprit);

3490 case GenericSelectionExprClass:

3492 ->isConstantInitializer(Ctx, IsForRef, Culprit);

3493 case ChooseExprClass:

3495 if (Culprit)

3496 *Culprit = this;

3497 return false;

3498 }

3500 ->isConstantInitializer(Ctx, IsForRef, Culprit);

3501 case UnaryOperatorClass: {

3503 if (Exp->getOpcode() == UO_Extension)

3505 break;

3506 }

3507 case PackIndexingExprClass: {

3509 ->getSelectedExpr()

3510 ->isConstantInitializer(Ctx, false, Culprit);

3511 }

3512 case CXXFunctionalCastExprClass:

3513 case CXXStaticCastExprClass:

3514 case ImplicitCastExprClass:

3515 case CStyleCastExprClass:

3516 case ObjCBridgedCastExprClass:

3517 case CXXDynamicCastExprClass:

3518 case CXXReinterpretCastExprClass:

3519 case CXXAddrspaceCastExprClass:

3520 case CXXConstCastExprClass: {

3522

3523

3525 CE->getCastKind() == CK_LValueToRValue ||

3527 CE->getCastKind() == CK_ConstructorConversion ||

3528 CE->getCastKind() == CK_NonAtomicToAtomic ||

3529 CE->getCastKind() == CK_AtomicToNonAtomic ||

3530 CE->getCastKind() == CK_NullToPointer ||

3531 CE->getCastKind() == CK_IntToOCLSampler)

3533

3534 break;

3535 }

3536 case MaterializeTemporaryExprClass:

3538 ->getSubExpr()

3539 ->isConstantInitializer(Ctx, false, Culprit);

3540

3541 case SubstNonTypeTemplateParmExprClass:

3543 ->isConstantInitializer(Ctx, false, Culprit);

3544 case CXXDefaultArgExprClass:

3546 ->isConstantInitializer(Ctx, false, Culprit);

3547 case CXXDefaultInitExprClass:

3549 ->isConstantInitializer(Ctx, false, Culprit);

3550 }

3551

3552

3553

3555 return true;

3556 if (Culprit)

3557 *Culprit = this;

3558 return false;

3559}

3560

3563 if (BuiltinID != Builtin::BI__assume &&

3564 BuiltinID != Builtin::BI__builtin_assume)

3565 return false;

3566

3568 bool ArgVal;

3571}

3572

3575 return DirectCallee->getAttr();

3577 return IndirectCallee->getAttr();

3578 return nullptr;

3579}

3580

3581std::optionalllvm::APInt

3584

3585 assert(AllocSize && AllocSize->getElemSizeParam().isValid());

3586 unsigned SizeArgNo = AllocSize->getElemSizeParam().getASTIndex();

3589 return std::nullopt;

3590

3591 auto EvaluateAsSizeT = [&](const Expr *E, llvm::APSInt &Into) {

3595 return false;

3597 if (Into.isNegative() || !Into.isIntN(BitsInSizeT))

3598 return false;

3599 Into = Into.zext(BitsInSizeT);

3600 return true;

3601 };

3602

3603 llvm::APSInt SizeOfElem;

3604 if (!EvaluateAsSizeT(getArg(SizeArgNo), SizeOfElem))

3605 return std::nullopt;

3606

3607 if (!AllocSize->getNumElemsParam().isValid())

3608 return SizeOfElem;

3609

3610 llvm::APSInt NumberOfElems;

3611 unsigned NumArgNo = AllocSize->getNumElemsParam().getASTIndex();

3612 if (!EvaluateAsSizeT(getArg(NumArgNo), NumberOfElems))

3613 return std::nullopt;

3614

3615 bool Overflow;

3616 llvm::APInt BytesAvailable = SizeOfElem.umul_ov(NumberOfElems, Overflow);

3617 if (Overflow)

3618 return std::nullopt;

3619

3620 return BytesAvailable;

3621}

3622

3626

3627namespace {

3628

3631 const bool IncludePossibleEffects;

3632 bool HasSideEffects;

3633

3634 public:

3635 explicit SideEffectFinder(const ASTContext &Context, bool IncludePossible)

3636 : Inherited(Context),

3637 IncludePossibleEffects(IncludePossible), HasSideEffects(false) { }

3638

3639 bool hasSideEffects() const { return HasSideEffects; }

3640

3641 void VisitDecl(const Decl *D) {

3642 if (!D)

3643 return;

3644

3645

3646

3647 if (auto *VD = dyn_cast(D)) {

3648

3649 if (IncludePossibleEffects && VD->isThisDeclarationADefinition() &&

3650 VD->needsDestruction(Context))

3651 HasSideEffects = true;

3652 }

3653 }

3654

3655 void VisitDeclStmt(const DeclStmt *DS) {

3656 for (auto *D : DS->decls())

3657 VisitDecl(D);

3658 Inherited::VisitDeclStmt(DS);

3659 }

3660

3661 void VisitExpr(const Expr *E) {

3662 if (!HasSideEffects &&

3664 HasSideEffects = true;

3665 }

3666 };

3667}

3668

3670 bool IncludePossibleEffects) const {

3671

3672

3673

3674 if (!IncludePossibleEffects && getExprLoc().isMacroID())

3675 return false;

3676

3679#define ABSTRACT_STMT(Type)

3680#define STMT(Type, Base) case Type##Class:

3681#define EXPR(Type, Base)

3682#include "clang/AST/StmtNodes.inc"

3683 llvm_unreachable("unexpected Expr kind");

3684

3685 case DependentScopeDeclRefExprClass:

3686 case CXXUnresolvedConstructExprClass:

3687 case CXXDependentScopeMemberExprClass:

3688 case UnresolvedLookupExprClass:

3689 case UnresolvedMemberExprClass:

3690 case PackExpansionExprClass:

3691 case SubstNonTypeTemplateParmPackExprClass:

3692 case FunctionParmPackExprClass:

3693 case RecoveryExprClass:

3694 case CXXFoldExprClass:

3695

3696 return IncludePossibleEffects;

3697

3698 case DeclRefExprClass:

3699 case ObjCIvarRefExprClass:

3700 case PredefinedExprClass:

3701 case IntegerLiteralClass:

3702 case FixedPointLiteralClass:

3703 case FloatingLiteralClass:

3704 case ImaginaryLiteralClass:

3705 case StringLiteralClass:

3706 case CharacterLiteralClass:

3707 case OffsetOfExprClass:

3708 case ImplicitValueInitExprClass:

3709 case UnaryExprOrTypeTraitExprClass:

3710 case AddrLabelExprClass:

3711 case GNUNullExprClass:

3712 case ArrayInitIndexExprClass:

3713 case NoInitExprClass:

3714 case CXXBoolLiteralExprClass:

3715 case CXXNullPtrLiteralExprClass:

3716 case CXXThisExprClass:

3717 case CXXScalarValueInitExprClass:

3718 case TypeTraitExprClass:

3719 case ArrayTypeTraitExprClass:

3720 case ExpressionTraitExprClass:

3721 case CXXNoexceptExprClass:

3722 case SizeOfPackExprClass:

3723 case ObjCStringLiteralClass:

3724 case ObjCEncodeExprClass:

3725 case ObjCBoolLiteralExprClass:

3726 case ObjCAvailabilityCheckExprClass:

3727 case CXXUuidofExprClass:

3728 case OpaqueValueExprClass:

3729 case SourceLocExprClass:

3730 case EmbedExprClass:

3731 case ConceptSpecializationExprClass:

3732 case RequiresExprClass:

3733 case SYCLUniqueStableNameExprClass:

3734 case PackIndexingExprClass:

3735 case HLSLOutArgExprClass:

3736 case OpenACCAsteriskSizeExprClass:

3737

3738 return false;

3739

3740 case ConstantExprClass:

3741

3743 Ctx, IncludePossibleEffects);

3744

3745 case CallExprClass:

3746 case CXXOperatorCallExprClass:

3747 case CXXMemberCallExprClass:

3748 case CUDAKernelCallExprClass:

3749 case UserDefinedLiteralClass: {

3750

3751

3752

3754 bool IsPure = FD && (FD->hasAttr() || FD->hasAttr());

3755 if (IsPure || !IncludePossibleEffects)

3756 break;

3757 return true;

3758 }

3759

3760 case BlockExprClass:

3761 case CXXBindTemporaryExprClass:

3762 if (!IncludePossibleEffects)

3763 break;

3764 return true;

3765

3766 case MSPropertyRefExprClass:

3767 case MSPropertySubscriptExprClass:

3768 case CompoundAssignOperatorClass:

3769 case VAArgExprClass:

3770 case AtomicExprClass:

3771 case CXXThrowExprClass:

3772 case CXXNewExprClass:

3773 case CXXDeleteExprClass:

3774 case CoawaitExprClass:

3775 case DependentCoawaitExprClass:

3776 case CoyieldExprClass:

3777

3778 return true;

3779

3780 case StmtExprClass: {

3781

3782 SideEffectFinder Finder(Ctx, IncludePossibleEffects);

3784 return Finder.hasSideEffects();

3785 }

3786

3787 case ExprWithCleanupsClass:

3788 if (IncludePossibleEffects)

3790 return true;

3791 break;

3792

3793 case ParenExprClass:

3794 case ArraySubscriptExprClass:

3795 case MatrixSubscriptExprClass:

3796 case ArraySectionExprClass:

3797 case OMPArrayShapingExprClass:

3798 case OMPIteratorExprClass:

3799 case MemberExprClass:

3800 case ConditionalOperatorClass:

3801 case BinaryConditionalOperatorClass:

3802 case CompoundLiteralExprClass:

3803 case ExtVectorElementExprClass:

3804 case DesignatedInitExprClass:

3805 case DesignatedInitUpdateExprClass:

3806 case ArrayInitLoopExprClass:

3807 case ParenListExprClass:

3808 case CXXPseudoDestructorExprClass:

3809 case CXXRewrittenBinaryOperatorClass:

3810 case CXXStdInitializerListExprClass:

3811 case SubstNonTypeTemplateParmExprClass:

3812 case MaterializeTemporaryExprClass:

3813 case ShuffleVectorExprClass:

3814 case ConvertVectorExprClass:

3815 case AsTypeExprClass:

3816 case CXXParenListInitExprClass:

3817

3818 break;

3819

3820 case UnaryOperatorClass:

3822 return true;

3823 break;

3824

3825 case BinaryOperatorClass:

3827 return true;

3828 break;

3829

3830 case InitListExprClass:

3831

3834 return true;

3835 break;

3836

3837 case GenericSelectionExprClass:

3839 Ctx, IncludePossibleEffects);

3840

3841 case ChooseExprClass:

3842 return cast(this)->getChosenSubExpr()->HasSideEffects(

3843 Ctx, IncludePossibleEffects);

3844

3845 case CXXDefaultArgExprClass:

3847 Ctx, IncludePossibleEffects);

3848

3849 case CXXDefaultInitExprClass: {

3852 return E->HasSideEffects(Ctx, IncludePossibleEffects);

3853

3854 return true;

3855 }

3856

3857 case CXXDynamicCastExprClass: {

3858

3862 return true;

3863 }

3864 [[fallthrough]];

3865 case ImplicitCastExprClass:

3866 case CStyleCastExprClass:

3867 case CXXStaticCastExprClass:

3868 case CXXReinterpretCastExprClass:

3869 case CXXConstCastExprClass:

3870 case CXXAddrspaceCastExprClass:

3871 case CXXFunctionalCastExprClass:

3872 case BuiltinBitCastExprClass: {

3873

3874

3875

3876

3877 if (!IncludePossibleEffects)

3878 break;

3879

3881 if (CE->getCastKind() == CK_LValueToRValue &&

3883 return true;

3884 break;

3885 }

3886

3887 case CXXTypeidExprClass: {

3889 if (!TE->isPotentiallyEvaluated())

3890 return false;

3891

3892

3893

3894 if (IncludePossibleEffects && TE->hasNullCheck())

3895 return true;

3896

3897 break;

3898 }

3899

3900 case CXXConstructExprClass:

3901 case CXXTemporaryObjectExprClass: {

3904 return true;

3905

3906

3907 break;

3908 }

3909

3910 case CXXInheritedCtorInitExprClass: {

3912 if (!ICIE->getConstructor()->isTrivial() && IncludePossibleEffects)

3913 return true;

3914 break;

3915 }

3916

3917 case LambdaExprClass: {

3919 for (Expr *E : LE->capture_inits())

3920 if (E && E->HasSideEffects(Ctx, IncludePossibleEffects))

3921 return true;

3922 return false;

3923 }

3924

3925 case PseudoObjectExprClass: {

3926

3927

3931 I != E; ++I) {

3932 const Expr *Subexpr = *I;

3933 if (const OpaqueValueExpr *OVE = dyn_cast(Subexpr))

3934 Subexpr = OVE->getSourceExpr();

3935 if (Subexpr->HasSideEffects(Ctx, IncludePossibleEffects))

3936 return true;

3937 }

3938 return false;

3939 }

3940

3941 case ObjCBoxedExprClass:

3942 case ObjCArrayLiteralClass:

3943 case ObjCDictionaryLiteralClass:

3944 case ObjCSelectorExprClass:

3945 case ObjCProtocolExprClass:

3946 case ObjCIsaExprClass:

3947 case ObjCIndirectCopyRestoreExprClass:

3948 case ObjCSubscriptRefExprClass:

3949 case ObjCBridgedCastExprClass:

3950 case ObjCMessageExprClass:

3951 case ObjCPropertyRefExprClass:

3952

3953 if (IncludePossibleEffects)

3954 return true;

3955 break;

3956 }

3957

3958

3960 if (SubStmt &&

3962 return true;

3963

3964 return false;

3965}

3966

3968 if (auto Call = dyn_cast(this))

3969 return Call->getFPFeaturesInEffect(LO);

3970 if (auto UO = dyn_cast(this))

3971 return UO->getFPFeaturesInEffect(LO);

3972 if (auto BO = dyn_cast(this))

3973 return BO->getFPFeaturesInEffect(LO);

3974 if (auto Cast = dyn_cast(this))

3975 return Cast->getFPFeaturesInEffect(LO);

3976 if (auto ConvertVector = dyn_cast(this))

3977 return ConvertVector->getFPFeaturesInEffect(LO);

3979}

3980

3981namespace {

3982

3984 {

3986

3987 bool NonTrivial;

3988

3989 public:

3990 explicit NonTrivialCallFinder(const ASTContext &Context)

3991 : Inherited(Context), NonTrivial(false) { }

3992

3993 bool hasNonTrivialCall() const { return NonTrivial; }

3994

3995 void VisitCallExpr(const CallExpr *E) {

3996 if (const CXXMethodDecl *Method

3997 = dyn_cast_or_null(E->getCalleeDecl())) {

3998 if (Method->isTrivial()) {

3999

4000 Inherited::VisitStmt(E);

4001 return;

4002 }

4003 }

4004

4005 NonTrivial = true;

4006 }

4007

4008 void VisitCXXConstructExpr(const CXXConstructExpr *E) {

4010

4011 Inherited::VisitStmt(E);

4012 return;

4013 }

4014

4015 NonTrivial = true;

4016 }

4017

4018 void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *E) {

4019

4020

4021 if (const CXXDestructorDecl *DtorDecl =

4023 if (DtorDecl->isTrivial()) {

4024 Inherited::VisitStmt(E);

4025 return;

4026 }

4027 }

4028

4029 NonTrivial = true;

4030 }

4031 };

4032}

4033

4035 NonTrivialCallFinder Finder(Ctx);

4036 Finder.Visit(this);

4037 return Finder.hasNonTrivialCall();

4038}

4039

4040

4041

4042

4043

4044

4050

4053 switch (NPC) {

4055 llvm_unreachable("Unexpected value dependent expression!");

4059 else

4061

4064 }

4065 }

4066

4067

4068 if (const ExplicitCastExpr *CE = dyn_cast(this)) {

4070

4074

4075

4076

4077

4081

4083 CE->getSubExpr()->getType()->isIntegerType())

4084 return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);

4085 }

4086 }

4087 } else if (const ImplicitCastExpr *ICE = dyn_cast(this)) {

4088

4089 return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);

4090 } else if (const ParenExpr *PE = dyn_cast(this)) {

4091

4092

4093 return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);

4095 dyn_cast(this)) {

4096 if (GE->isResultDependent())

4098 return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC);

4099 } else if (const ChooseExpr *CE = dyn_cast(this)) {

4100 if (CE->isConditionDependent())

4102 return CE->getChosenSubExpr()->isNullPointerConstant(Ctx, NPC);

4104 = dyn_cast(this)) {

4105

4106 return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);

4108 = dyn_cast(this)) {

4109

4110 return DefaultInit->getExpr()->isNullPointerConstant(Ctx, NPC);

4112

4115 = dyn_cast(this)) {

4116 return M->getSubExpr()->isNullPointerConstant(Ctx, NPC);

4117 } else if (const OpaqueValueExpr *OVE = dyn_cast(this)) {

4118 if (const Expr *Source = OVE->getSourceExpr())

4119 return Source->isNullPointerConstant(Ctx, NPC);

4120 }

4121

4122

4123

4126

4127

4128 if (getType()->isNullPtrType())

4130

4131 if (const RecordType *UT = getType()->getAsUnionType())

4132 if (!Ctx.getLangOpts().CPlusPlus11 && UT &&

4133 UT->getDecl()->getMostRecentDecl()->hasAttr())

4134 if (const CompoundLiteralExpr *CLE = dyn_cast(this)){

4135 const Expr *InitExpr = CLE->getInitializer();

4136 if (const InitListExpr *ILE = dyn_cast(InitExpr))

4137 return ILE->getInit(0)->isNullPointerConstant(Ctx, NPC);

4138 }

4139

4140 if ( getType ()->isIntegerType() ||

4143

4145

4146

4147

4148 const IntegerLiteral *Lit = dyn_cast(this);

4149 if (Lit && !Lit->getValue())

4153 } else {

4154

4155

4158 }

4159

4162

4166}

4167

4168

4169

4171 const Expr *E = this;

4172 while (true) {

4174 "expression is not a property reference");

4176 if (const BinaryOperator *BO = dyn_cast(E)) {

4177 if (BO->getOpcode() == BO_Comma) {

4178 E = BO->getRHS();

4179 continue;

4180 }

4181 }

4182

4183 break;

4184 }

4185

4187}

4188

4191

4192 const DeclRefExpr *DRE = dyn_cast(E);

4193 if (!DRE)

4194 return false;

4195

4197 if (!Param)

4198 return false;

4199

4200 const ObjCMethodDecl *M = dyn_cast(Param->getDeclContext());

4201 if (!M)

4202 return false;

4203

4205}

4206

4209

4210 while (ImplicitCastExpr *ICE = dyn_cast(E)) {

4211 if (ICE->getCastKind() == CK_LValueToRValue ||

4212 (ICE->isGLValue() && ICE->getCastKind() == CK_NoOp))

4214 else

4215 break;

4216 }

4217

4218 if (MemberExpr *MemRef = dyn_cast(E))

4219 if (FieldDecl *Field = dyn_cast(MemRef->getMemberDecl()))

4220 if (Field->isBitField())

4221 return Field;

4222

4223 if (ObjCIvarRefExpr *IvarRef = dyn_cast(E)) {

4224 FieldDecl *Ivar = IvarRef->getDecl();

4226 return Ivar;

4227 }

4228

4229 if (DeclRefExpr *DeclRef = dyn_cast(E)) {

4230 if (FieldDecl *Field = dyn_cast(DeclRef->getDecl()))

4231 if (Field->isBitField())

4232 return Field;

4233

4234 if (BindingDecl *BD = dyn_cast(DeclRef->getDecl()))

4235 if (Expr *E = BD->getBinding())

4237 }

4238

4239 if (BinaryOperator *BinOp = dyn_cast(E)) {

4240 if (BinOp->isAssignmentOp() && BinOp->getLHS())

4241 return BinOp->getLHS()->getSourceBitField();

4242

4243 if (BinOp->getOpcode() == BO_Comma && BinOp->getRHS())

4244 return BinOp->getRHS()->getSourceBitField();

4245 }

4246

4247 if (UnaryOperator *UnOp = dyn_cast(E))

4248 if (UnOp->isPrefix() && UnOp->isIncrementDecrementOp())

4249 return UnOp->getSubExpr()->getSourceBitField();

4250

4251 return nullptr;

4252}

4253

4256 if (auto *DRE = dyn_cast(E))

4257 return dyn_cast(DRE->getDecl());

4258 return nullptr;

4259}

4260

4262

4264

4265 while (const ImplicitCastExpr *ICE = dyn_cast(E)) {

4266 if (ICE->isGLValue() && ICE->getCastKind() == CK_NoOp)

4268 else

4269 break;

4270 }

4271

4272 if (const ArraySubscriptExpr *ASE = dyn_cast(E))

4273 return ASE->getBase()->getType()->isVectorType();

4274

4276 return true;

4277

4278 if (auto *DRE = dyn_cast(E))

4279 if (auto *BD = dyn_cast(DRE->getDecl()))

4280 if (auto *E = BD->getBinding())

4282

4283 return false;

4284}

4285

4288

4289 if (const DeclRefExpr *DRE = dyn_cast(E))

4290 if (const auto *VD = dyn_cast(DRE->getDecl()))

4291 if (VD->getStorageClass() == SC_Register &&

4292 VD->hasAttr() && !VD->isLocalVarDecl())

4293 return true;

4294

4295 return false;

4296}

4297

4301

4303 return false;

4304

4306 default:

4307 return false;

4308 case CXXThisExprClass:

4309 return true;

4310 case DeclRefExprClass: {

4311

4312

4315

4316 if (DRE1->getDecl() != DRE2->getDecl())

4317 return false;

4318

4319 if ((DRE1->isPRValue() && DRE2->isPRValue()) ||

4320 (DRE1->isLValue() && DRE2->isLValue()))

4321 return true;

4322

4323 return false;

4324 }

4325 case ImplicitCastExprClass: {

4326

4327 while (true) {

4328 const auto *ICE1 = dyn_cast(E1);

4329 const auto *ICE2 = dyn_cast(E2);

4330 if (!ICE1 || !ICE2)

4331 return false;

4332 if (ICE1->getCastKind() != ICE2->getCastKind())

4334 ICE2->IgnoreParenImpCasts());

4337

4338 if (ICE1->getCastKind() == CK_LValueToRValue ||

4339 ICE1->getCastKind() == CK_ArrayToPointerDecay ||

4340 ICE1->getCastKind() == CK_FunctionToPointerDecay) {

4341 break;

4342 }

4343 }

4344

4345 const auto *DRE1 = dyn_cast(E1);

4346 const auto *DRE2 = dyn_cast(E2);

4347 if (DRE1 && DRE2)

4349

4350 const auto *Ivar1 = dyn_cast(E1);

4351 const auto *Ivar2 = dyn_cast(E2);

4352 if (Ivar1 && Ivar2) {

4353 return Ivar1->isFreeIvar() && Ivar2->isFreeIvar() &&

4355 }

4356

4357 const auto *Array1 = dyn_cast(E1);

4358 const auto *Array2 = dyn_cast(E2);

4359 if (Array1 && Array2) {

4361 return false;

4362

4363 auto Idx1 = Array1->getIdx();

4364 auto Idx2 = Array2->getIdx();

4365 const auto Integer1 = dyn_cast(Idx1);

4366 const auto Integer2 = dyn_cast(Idx2);

4367 if (Integer1 && Integer2) {

4368 if (!llvm::APInt::isSameValue(Integer1->getValue(),

4369 Integer2->getValue()))

4370 return false;

4371 } else {

4373 return false;

4374 }

4375

4376 return true;

4377 }

4378

4379

4383 if ( declaresSameEntity (ME1->getMemberDecl(), ME2->getMemberDecl()))

4384 return false;

4385 if (const auto *D = dyn_cast(ME1->getMemberDecl()))

4386 if (D->isStaticDataMember())

4387 return true;

4390 }

4391

4393 return true;

4394

4395

4396

4397 auto getAnyDecl = [](const Expr *E) -> const ValueDecl * {

4398 if (const auto *DRE = dyn_cast(E))

4399 return DRE->getDecl();

4400 if (const auto *ME = dyn_cast(E))

4401 return ME->getMemberDecl();

4402 return nullptr;

4403 };

4404

4405 const ValueDecl *VD1 = getAnyDecl(E1);

4406 const ValueDecl *VD2 = getAnyDecl(E2);

4408 }

4409 }

4410}

4411

4412

4413

4417

4420 return VT->getNumElements();

4421 return 1;

4422}

4423

4424

4426

4427

4428 StringRef Comp = Accessor->getName();

4429

4430

4431 if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd")

4432 return false;

4433

4434

4435 if (Comp[0] == 's' || Comp[0] == 'S')

4436 Comp = Comp.substr(1);

4437

4438 for (unsigned i = 0, e = Comp.size(); i != e; ++i)

4439 if (Comp.substr(i + 1).contains(Comp[i]))

4440 return true;

4441

4442 return false;

4443}

4444

4445

4448 StringRef Comp = Accessor->getName();

4449 bool isNumericAccessor = false;

4450 if (Comp[0] == 's' || Comp[0] == 'S') {

4451 Comp = Comp.substr(1);

4452 isNumericAccessor = true;

4453 }

4454

4455 bool isHi = Comp == "hi";

4456 bool isLo = Comp == "lo";

4457 bool isEven = Comp == "even";

4458 bool isOdd = Comp == "odd";

4459

4460 for (unsigned i = 0, e = getNumElements(); i != e; ++i) {

4461 uint64_t Index;

4462

4463 if (isHi)

4464 Index = e + i;

4465 else if (isLo)

4466 Index = i;

4467 else if (isEven)

4468 Index = 2 * i;

4469 else if (isOdd)

4470 Index = 2 * i + 1;

4471 else

4473

4474 Elts.push_back(Index);

4475 }

4476}

4477

4482 BuiltinLoc(BLoc), RParenLoc(RP) {

4484 SubExprs = new (C) Stmt*[args.size()];

4485 for (unsigned i = 0; i != args.size(); i++)

4486 SubExprs[i] = args[i];

4487

4489}

4490

4492 if (SubExprs) C.Deallocate(SubExprs);

4493

4496 llvm::copy(Exprs, SubExprs);

4497}

4498

4499GenericSelectionExpr::GenericSelectionExpr(

4503 bool ContainsUnexpandedParameterPack, unsigned ResultIndex)

4504 : Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),

4505 AssocExprs[ResultIndex]->getValueKind(),

4506 AssocExprs[ResultIndex]->getObjectKind()),

4507 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),

4508 IsExprPredicate(true), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {

4509 assert(AssocTypes.size() == AssocExprs.size() &&

4510 "Must have the same number of association expressions"

4511 " and TypeSourceInfo!");

4512 assert(ResultIndex < NumAssocs && "ResultIndex is out-of-bounds!");

4513

4515 getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()] =

4516 ControllingExpr;

4517 llvm::copy(AssocExprs,

4518 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());

4519 llvm::copy(AssocTypes, getTrailingObjects<TypeSourceInfo *>() +

4520 getIndexOfStartOfAssociatedTypes());

4521

4523}

4524

4525GenericSelectionExpr::GenericSelectionExpr(

4529 SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack,

4530 unsigned ResultIndex)

4531 : Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),

4532 AssocExprs[ResultIndex]->getValueKind(),

4533 AssocExprs[ResultIndex]->getObjectKind()),

4534 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),

4535 IsExprPredicate(false), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {

4536 assert(AssocTypes.size() == AssocExprs.size() &&

4537 "Must have the same number of association expressions"

4538 " and TypeSourceInfo!");

4539 assert(ResultIndex < NumAssocs && "ResultIndex is out-of-bounds!");

4540

4542 getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()] =

4543 ControllingType;

4544 llvm::copy(AssocExprs,

4545 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());

4546 llvm::copy(AssocTypes, getTrailingObjects<TypeSourceInfo *>() +

4547 getIndexOfStartOfAssociatedTypes());

4548

4550}

4551

4552GenericSelectionExpr::GenericSelectionExpr(

4556 bool ContainsUnexpandedParameterPack)

4557 : Expr(GenericSelectionExprClass, Context.DependentTy, VK_PRValue,

4559 NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),

4560 IsExprPredicate(true), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {

4561 assert(AssocTypes.size() == AssocExprs.size() &&

4562 "Must have the same number of association expressions"

4563 " and TypeSourceInfo!");

4564

4566 getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()] =

4567 ControllingExpr;

4568 llvm::copy(AssocExprs,

4569 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());

4570 llvm::copy(AssocTypes, getTrailingObjects<TypeSourceInfo *>() +

4571 getIndexOfStartOfAssociatedTypes());

4572

4574}

4575

4576GenericSelectionExpr::GenericSelectionExpr(

4580 SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack)

4581 : Expr(GenericSelectionExprClass, Context.DependentTy, VK_PRValue,

4583 NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),

4584 IsExprPredicate(false), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {

4585 assert(AssocTypes.size() == AssocExprs.size() &&

4586 "Must have the same number of association expressions"

4587 " and TypeSourceInfo!");

4588

4590 getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()] =

4591 ControllingType;

4592 llvm::copy(AssocExprs,

4593 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());

4594 llvm::copy(AssocTypes, getTrailingObjects<TypeSourceInfo *>() +

4595 getIndexOfStartOfAssociatedTypes());

4596

4598}

4599

4600GenericSelectionExpr::GenericSelectionExpr(EmptyShell Empty, unsigned NumAssocs)

4601 : Expr(GenericSelectionExprClass, Empty), NumAssocs(NumAssocs) {}

4602

4607 bool ContainsUnexpandedParameterPack, unsigned ResultIndex) {

4608 unsigned NumAssocs = AssocExprs.size();

4609 void *Mem = Context.Allocate(

4610 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),

4611 alignof(GenericSelectionExpr));

4612 return new (Mem) GenericSelectionExpr(

4613 Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,

4614 RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);

4615}

4616

4621 bool ContainsUnexpandedParameterPack) {

4622 unsigned NumAssocs = AssocExprs.size();

4623 void *Mem = Context.Allocate(

4624 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),

4625 alignof(GenericSelectionExpr));

4626 return new (Mem) GenericSelectionExpr(

4627 Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,

4628 RParenLoc, ContainsUnexpandedParameterPack);

4629}

4630

4635 SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack,

4636 unsigned ResultIndex) {

4637 unsigned NumAssocs = AssocExprs.size();

4638 void *Mem = Context.Allocate(

4639 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),

4640 alignof(GenericSelectionExpr));

4641 return new (Mem) GenericSelectionExpr(

4642 Context, GenericLoc, ControllingType, AssocTypes, AssocExprs, DefaultLoc,

4643 RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);

4644}

4645

4650 SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack) {

4651 unsigned NumAssocs = AssocExprs.size();

4652 void *Mem = Context.Allocate(

4653 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),

4654 alignof(GenericSelectionExpr));

4655 return new (Mem) GenericSelectionExpr(

4656 Context, GenericLoc, ControllingType, AssocTypes, AssocExprs, DefaultLoc,

4657 RParenLoc, ContainsUnexpandedParameterPack);

4658}

4659

4662 unsigned NumAssocs) {

4663 void *Mem = Context.Allocate(

4664 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),

4665 alignof(GenericSelectionExpr));

4666 return new (Mem) GenericSelectionExpr(EmptyShell(), NumAssocs);

4667}

4668

4669

4670

4671

4672

4679

4683 bool GNUSyntax,

4687 EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),

4688 NumDesignators(Designators.size()), NumSubExprs(IndexExprs.size() + 1) {

4689 this->Designators = new (C) Designator[NumDesignators];

4690

4691

4693 *Child++ = Init;

4694

4695

4696

4697 unsigned IndexIdx = 0;

4698 for (unsigned I = 0; I != NumDesignators; ++I) {

4699 this->Designators[I] = Designators[I];

4701

4702 *Child++ = IndexExprs[IndexIdx++];

4704

4705 *Child++ = IndexExprs[IndexIdx++];

4706 *Child++ = IndexExprs[IndexIdx++];

4707 }

4708 }

4709

4710 assert(IndexIdx == IndexExprs.size() && "Wrong number of index expressions");

4712}

4713

4718 bool UsesColonSyntax,

4720 void *Mem = C.Allocate(totalSizeToAlloc<Stmt *>(IndexExprs.size() + 1),

4721 alignof(DesignatedInitExpr));

4722 return new (Mem) DesignatedInitExpr(C, C.VoidTy, Designators,

4723 ColonOrEqualLoc, UsesColonSyntax,

4724 IndexExprs, Init);

4725}

4726

4728 unsigned NumIndexExprs) {

4729 void *Mem = C.Allocate(totalSizeToAlloc<Stmt *>(NumIndexExprs + 1),

4730 alignof(DesignatedInitExpr));

4731 return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);

4732}

4733

4736 unsigned NumDesigs) {

4737 Designators = new (C) Designator[NumDesigs];

4738 NumDesignators = NumDesigs;

4739 for (unsigned I = 0; I != NumDesigs; ++I)

4740 Designators[I] = Desigs[I];

4741}

4742

4744 DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this);

4745 if (size() == 1)

4749}

4750

4752 auto *DIE = const_cast<DesignatedInitExpr *>(this);

4754 if (First.isFieldDesignator()) {

4755

4756

4757 for (unsigned int i = 0; i < DIE->size(); i++) {

4758 Designator &Des = *DIE->getDesignator(i);

4761 continue;

4762 return retval;

4763 }

4764 }

4765 return First.getLBracketLoc();

4766}

4767

4771

4776

4781

4786

4787

4788

4792 unsigned NumNewDesignators = Last - First;

4793 if (NumNewDesignators == 0) {

4794 std::copy_backward(Designators + Idx + 1,

4795 Designators + NumDesignators,

4796 Designators + Idx);

4797 --NumNewDesignators;

4798 return;

4799 }

4800 if (NumNewDesignators == 1) {

4801 Designators[Idx] = *First;

4802 return;

4803 }

4804

4806 = new (C) Designator[NumDesignators - 1 + NumNewDesignators];

4807 std::copy(Designators, Designators + Idx, NewDesignators);

4808 std::copy(First, Last, NewDesignators + Idx);

4809 std::copy(Designators + Idx + 1, Designators + NumDesignators,

4810 NewDesignators + Idx + NumNewDesignators);

4811 Designators = NewDesignators;

4812 NumDesignators = NumDesignators - 1 + NumNewDesignators;

4813}

4814

4817 Expr *baseExpr,

4821 BaseAndUpdaterExprs[0] = baseExpr;

4822

4825 BaseAndUpdaterExprs[1] = ILE;

4826

4827

4829}

4830

4834

4838

4842 LParenLoc(LParenLoc), RParenLoc(RParenLoc) {

4844 llvm::copy(Exprs, getTrailingObjects());

4846}

4847

4848ParenListExpr::ParenListExpr(EmptyShell Empty, unsigned NumExprs)

4849 : Expr(ParenListExprClass, Empty) {

4851}

4852

4857 void *Mem = Ctx.Allocate(totalSizeToAlloc<Stmt *>(Exprs.size()),

4858 alignof(ParenListExpr));

4859 return new (Mem) ParenListExpr(LParenLoc, Exprs, RParenLoc);

4860}

4861

4863 unsigned NumExprs) {

4864 void *Mem =

4865 Ctx.Allocate(totalSizeToAlloc<Stmt *>(NumExprs), alignof(ParenListExpr));

4866 return new (Mem) ParenListExpr(EmptyShell(), NumExprs);

4867}

4868

4869

4870

4871

4872

4873static std::optional<BinaryOperator *>

4878 ComparedTo = E->getRHS();

4879 } else if (E->getOpcode() == BO_GT) {

4881 ComparedTo = E->getLHS();

4882 } else {

4883 return {};

4884 }

4885

4886 const Expr *AddLHS = nullptr, *AddRHS = nullptr;

4888

4889 if (BO && BO->getOpcode() == clang::BO_Add) {

4890

4891 AddLHS = BO->getLHS();

4892 AddRHS = BO->getRHS();

4893 }

4894

4895 if (!AddLHS || !AddRHS)

4896 return {};

4897

4898 const Decl *LHSDecl, *RHSDecl, *OtherDecl;

4899

4901 RHSDecl = AddRHS->IgnoreParenImpCasts()->getReferencedDeclOfCallee();

4903

4904 if (!OtherDecl)

4905 return {};

4906

4907 if (!LHSDecl && !RHSDecl)

4908 return {};

4909

4910 if ((LHSDecl && LHSDecl == OtherDecl && LHSDecl != RHSDecl) ||

4911 (RHSDecl && RHSDecl == OtherDecl && RHSDecl != LHSDecl))

4912 return BO;

4913 return {};

4914}

4915

4916

4917

4918

4919

4923 if (!Result.has_value())

4924 return;

4925 QualType AdditionResultType = Result.value()->getType();

4926

4933 Result.value()->setExcludedOverflowPattern(true);

4934}

4935

4940 : Expr(BinaryOperatorClass, ResTy, VK, OK) {

4943 "Use CompoundAssignOperator for compound assignments");

4946 SubExprs[LHS] = lhs;

4947 SubExprs[RHS] = rhs;

4953}

4954

4959 : Expr(CompoundAssignOperatorClass, ResTy, VK, OK) {

4963 "Use CompoundAssignOperator for compound assignments");

4965 SubExprs[LHS] = lhs;

4966 SubExprs[RHS] = rhs;

4971}

4972

4974 bool HasFPFeatures) {

4976 void *Mem =

4979}

4980

4988 void *Mem =

4990 return new (Mem)

4991 BinaryOperator(C, lhs, rhs, opc, ResTy, VK, OK, opLoc, FPFeatures);

4992}

4993

4997 void *Mem = C.Allocate(sizeof(CompoundAssignOperator) + Extra,

4998 alignof(CompoundAssignOperator));

4999 return new (Mem) CompoundAssignOperator(C, EmptyShell(), HasFPFeatures);

5000}

5001

5010 void *Mem = C.Allocate(sizeof(CompoundAssignOperator) + Extra,

5011 alignof(CompoundAssignOperator));

5012 return new (Mem)

5013 CompoundAssignOperator(C, lhs, rhs, opc, ResTy, VK, OK, opLoc, FPFeatures,

5014 CompLHSType, CompResultType);

5015}

5016

5018 bool hasFPFeatures) {

5019 void *Mem = C.Allocate(totalSizeToAlloc(hasFPFeatures),

5022}

5023

5028 : Expr(UnaryOperatorClass, type, VK, OK), Val(input) {

5036}

5037

5044 unsigned Size = totalSizeToAlloc(HasFPFeatures);

5045 void *Mem = C.Allocate(Size, alignof(UnaryOperator));

5046 return new (Mem)

5048}

5049

5051 if (const ExprWithCleanups *ewc = dyn_cast(e))

5052 e = ewc->getSubExpr();

5054 e = m->getSubExpr();

5056 while (const ImplicitCastExpr *ice = dyn_cast(e))

5057 e = ice->getSubExpr();

5059}

5060

5063 unsigned numSemanticExprs) {

5064 void *buffer =

5065 Context.Allocate(totalSizeToAlloc<Expr *>(1 + numSemanticExprs),

5066 alignof(PseudoObjectExpr));

5067 return new(buffer) PseudoObjectExpr(sh, numSemanticExprs);

5068}

5069

5070PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell, unsigned numSemanticExprs)

5071 : Expr(PseudoObjectExprClass, shell) {

5073}

5074

5077 unsigned resultIndex) {

5078 assert(syntax && "no syntactic expression!");

5079 assert(semantics.size() && "no semantic expressions!");

5080

5083 if (resultIndex == NoResult) {

5084 type = C.VoidTy;

5086 } else {

5087 assert(resultIndex < semantics.size());

5089 VK = semantics[resultIndex]->getValueKind();

5091 }

5092

5093 void *buffer = C.Allocate(totalSizeToAlloc<Expr *>(semantics.size() + 1),

5094 alignof(PseudoObjectExpr));

5096 resultIndex);

5097}

5098

5101 unsigned resultIndex)

5107

5109 [](const Expr *E) {

5112 nullptr;

5113 }) &&

5114 "opaque-value semantic expressions for pseudo-object "

5115 "operations must have sources");

5116

5117 llvm::copy(semantics, Trail.drop_front().begin());

5119}

5120

5121

5122

5123

5124

5125

5131

5133

5134

5135

5138 dyn_cast(getArgumentType().getTypePtr()))

5141 }

5143}

5144

5148 NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) {

5149 assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions");

5150 for (unsigned i = 0; i != args.size(); i++)

5151 SubExprs[i] = args[i];

5153}

5154

5156 switch (Op) {

5157 case AO__c11_atomic_init:

5158 case AO__opencl_atomic_init:

5159 case AO__c11_atomic_load:

5160 case AO__atomic_load_n:

5161 case AO__atomic_test_and_set:

5162 case AO__atomic_clear:

5163 return 2;

5164

5165 case AO__scoped_atomic_load_n:

5166 case AO__opencl_atomic_load:

5167 case AO__hip_atomic_load:

5168 case AO__c11_atomic_store:

5169 case AO__c11_atomic_exchange:

5170 case AO__atomic_load:

5171 case AO__atomic_store:

5172 case AO__atomic_store_n:

5173 case AO__atomic_exchange_n:

5174 case AO__c11_atomic_fetch_add:

5175 case AO__c11_atomic_fetch_sub:

5176 case AO__c11_atomic_fetch_and:

5177 case AO__c11_atomic_fetch_or:

5178 case AO__c11_atomic_fetch_xor:

5179 case AO__c11_atomic_fetch_nand:

5180 case AO__c11_atomic_fetch_max:

5181 case AO__c11_atomic_fetch_min:

5182 case AO__atomic_fetch_add:

5183 case AO__atomic_fetch_sub:

5184 case AO__atomic_fetch_and:

5185 case AO__atomic_fetch_or:

5186 case AO__atomic_fetch_xor:

5187 case AO__atomic_fetch_nand:

5188 case AO__atomic_add_fetch:

5189 case AO__atomic_sub_fetch:

5190 case AO__atomic_and_fetch:

5191 case AO__atomic_or_fetch:

5192 case AO__atomic_xor_fetch:

5193 case AO__atomic_nand_fetch:

5194 case AO__atomic_min_fetch:

5195 case AO__atomic_max_fetch:

5196 case AO__atomic_fetch_min:

5197 case AO__atomic_fetch_max:

5198 return 3;

5199

5200 case AO__scoped_atomic_load:

5201 case AO__scoped_atomic_store:

5202 case AO__scoped_atomic_store_n:

5203 case AO__scoped_atomic_fetch_add:

5204 case AO__scoped_atomic_fetch_sub:

5205 case AO__scoped_atomic_fetch_and:

5206 case AO__scoped_atomic_fetch_or:

5207 case AO__scoped_atomic_fetch_xor:

5208 case AO__scoped_atomic_fetch_nand:

5209 case AO__scoped_atomic_add_fetch:

5210 case AO__scoped_atomic_sub_fetch:

5211 case AO__scoped_atomic_and_fetch:

5212 case AO__scoped_atomic_or_fetch:

5213 case AO__scoped_atomic_xor_fetch:

5214 case AO__scoped_atomic_nand_fetch:

5215 case AO__scoped_atomic_min_fetch:

5216 case AO__scoped_atomic_max_fetch:

5217 case AO__scoped_atomic_fetch_min:

5218 case AO__scoped_atomic_fetch_max:

5219 case AO__scoped_atomic_exchange_n:

5220 case AO__scoped_atomic_uinc_wrap:

5221 case AO__scoped_atomic_udec_wrap:

5222 case AO__hip_atomic_exchange:

5223 case AO__hip_atomic_fetch_add:

5224 case AO__hip_atomic_fetch_sub:

5225 case AO__hip_atomic_fetch_and:

5226 case AO__hip_atomic_fetch_or:

5227 case AO__hip_atomic_fetch_xor:

5228 case AO__hip_atomic_fetch_min:

5229 case AO__hip_atomic_fetch_max:

5230 case AO__opencl_atomic_store:

5231 case AO__hip_atomic_store:

5232 case AO__opencl_atomic_exchange:

5233 case AO__opencl_atomic_fetch_add:

5234 case AO__opencl_atomic_fetch_sub:

5235 case AO__opencl_atomic_fetch_and:

5236 case AO__opencl_atomic_fetch_or:

5237 case AO__opencl_atomic_fetch_xor:

5238 case AO__opencl_atomic_fetch_min:

5239 case AO__opencl_atomic_fetch_max:

5240 case AO__atomic_exchange:

5241 return 4;

5242

5243 case AO__scoped_atomic_exchange:

5244 case AO__c11_atomic_compare_exchange_strong:

5245 case AO__c11_atomic_compare_exchange_weak:

5246 return 5;

5247 case AO__hip_atomic_compare_exchange_strong:

5248 case AO__opencl_atomic_compare_exchange_strong:

5249 case AO__opencl_atomic_compare_exchange_weak:

5250 case AO__hip_atomic_compare_exchange_weak:

5251 case AO__atomic_compare_exchange:

5252 case AO__atomic_compare_exchange_n:

5253 return 6;

5254

5255 case AO__scoped_atomic_compare_exchange:

5256 case AO__scoped_atomic_compare_exchange_n:

5257 return 7;

5258 }

5259 llvm_unreachable("unknown atomic op");

5260}

5261

5265 return AT->getValueType();

5266 return T;

5267}

5268

5270 unsigned ArraySectionCount = 0;

5271 while (auto *OASE = dyn_cast(Base->IgnoreParens())) {

5272 Base = OASE->getBase();

5273 ++ArraySectionCount;

5274 }

5275 while (auto *ASE =

5276 dyn_cast(Base->IgnoreParenImpCasts())) {

5277 Base = ASE->getBase();

5278 ++ArraySectionCount;

5279 }

5280 Base = Base->IgnoreParenImpCasts();

5281 auto OriginalTy = Base->getType();

5282 if (auto *DRE = dyn_cast(Base))

5283 if (auto *PVD = dyn_cast(DRE->getDecl()))

5284 OriginalTy = PVD->getOriginalType().getNonReferenceType();

5285

5286 for (unsigned Cnt = 0; Cnt < ArraySectionCount; ++Cnt) {

5287 if (OriginalTy->isAnyPointerType())

5288 OriginalTy = OriginalTy->getPointeeType();

5289 else if (OriginalTy->isArrayType())

5290 OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();

5291 else

5292 return {};

5293 }

5294 return OriginalTy;

5295}

5296

5299

5300

5302 BaseTy = ASE->getElementType();

5303

5308

5309

5310

5312 return BaseTy;

5313}

5314

5316

5317

5319 return ASE->getElementType();

5320

5322}

5323

5326 : Expr(RecoveryExprClass, T.getNonReferenceType(),

5327 T->isDependentType() ? VK_LValue : getValueKindForType(T),

5329 BeginLoc(BeginLoc), EndLoc(EndLoc), NumExprs(SubExprs.size()) {

5330 assert(.isNull());

5331 assert(!llvm::is_contained(SubExprs, nullptr));

5332

5333 llvm::copy(SubExprs, getTrailingObjects());

5335}

5336

5341 void *Mem = Ctx.Allocate(totalSizeToAlloc<Expr *>(SubExprs.size()),

5342 alignof(RecoveryExpr));

5343 return new (Mem) RecoveryExpr(Ctx, T, BeginLoc, EndLoc, SubExprs);

5344}

5345

5347 void *Mem = Ctx.Allocate(totalSizeToAlloc<Expr *>(NumSubExprs),

5348 alignof(RecoveryExpr));

5349 return new (Mem) RecoveryExpr(EmptyShell(), NumSubExprs);

5350}

5351

5352void OMPArrayShapingExpr::setDimensions(ArrayRef<Expr *> Dims) {

5353 assert(

5354 NumDims == Dims.size() &&

5355 "Preallocated number of dimensions is different from the provided one.");

5356 llvm::copy(Dims, getTrailingObjects<Expr *>());

5357}

5358

5360 assert(

5361 NumDims == BR.size() &&

5362 "Preallocated number of dimensions is different from the provided one.");

5363 llvm::copy(BR, getTrailingObjects());

5364}

5365

5366OMPArrayShapingExpr::OMPArrayShapingExpr(QualType ExprTy, Expr *Op,

5370 RPLoc(R), NumDims(Dims.size()) {

5371 setBase(Op);

5372 setDimensions(Dims);

5374}

5375

5381 assert(Dims.size() == BracketRanges.size() &&

5382 "Different number of dimensions and brackets ranges.");

5383 void *Mem = Context.Allocate(

5384 totalSizeToAlloc<Expr *, SourceRange>(Dims.size() + 1, Dims.size()),

5385 alignof(OMPArrayShapingExpr));

5386 auto *E = new (Mem) OMPArrayShapingExpr(T, Op, L, R, Dims);

5387 E->setBracketsRanges(BracketRanges);

5388 return E;

5389}

5390

5392 unsigned NumDims) {

5393 void *Mem = Context.Allocate(

5394 totalSizeToAlloc<Expr *, SourceRange>(NumDims + 1, NumDims),

5395 alignof(OMPArrayShapingExpr));

5396 return new (Mem) OMPArrayShapingExpr(EmptyShell(), NumDims);

5397}

5398

5399void OMPIteratorExpr::setIteratorDeclaration(unsigned I, Decl *D) {

5400 getTrailingObjects<Decl *>(NumIterators)[I] = D;

5401}

5402

5403void OMPIteratorExpr::setAssignmentLoc(unsigned I, SourceLocation Loc) {

5404 assert(I < NumIterators &&

5405 "Idx is greater or equal the number of iterators definitions.");

5406 getTrailingObjects<

5407 SourceLocation>()[I * static_cast<int>(RangeLocOffset::Total) +

5408 static_cast<int>(RangeLocOffset::AssignLoc)] = Loc;

5409}

5410

5411void OMPIteratorExpr::setIteratorRange(unsigned I, Expr *Begin,

5414 Expr *Step) {

5415 assert(I < NumIterators &&

5416 "Idx is greater or equal the number of iterators definitions.");

5417 getTrailingObjects<Expr *>()[I * static_cast<int>(RangeExprOffset::Total) +

5418 static_cast<int>(RangeExprOffset::Begin)] =

5419 Begin;

5420 getTrailingObjects<Expr *>()[I * static_cast<int>(RangeExprOffset::Total) +

5421 static_cast<int>(RangeExprOffset::End)] = End;

5422 getTrailingObjects<Expr *>()[I * static_cast<int>(RangeExprOffset::Total) +

5423 static_cast<int>(RangeExprOffset::Step)] = Step;

5424 getTrailingObjects<

5425 SourceLocation>()[I * static_cast<int>(RangeLocOffset::Total) +

5426 static_cast<int>(RangeLocOffset::FirstColonLoc)] =

5427 ColonLoc;

5428 getTrailingObjects<

5429 SourceLocation>()[I * static_cast<int>(RangeLocOffset::Total) +

5430 static_cast<int>(RangeLocOffset::SecondColonLoc)] =

5431 SecondColonLoc;

5432}

5433

5435 return getTrailingObjects<Decl *>()[I];

5436}

5437

5441 getTrailingObjects<Expr *>()[I * static_cast<int>(

5442 RangeExprOffset::Total) +

5443 static_cast<int>(RangeExprOffset::Begin)];

5444 Res.End =

5445 getTrailingObjects<Expr *>()[I * static_cast<int>(

5446 RangeExprOffset::Total) +

5447 static_cast<int>(RangeExprOffset::End)];

5449 getTrailingObjects<Expr *>()[I * static_cast<int>(

5450 RangeExprOffset::Total) +

5451 static_cast<int>(RangeExprOffset::Step)];

5452 return Res;

5453}

5454

5456 return getTrailingObjects<

5457 SourceLocation>()[I * static_cast<int>(RangeLocOffset::Total) +

5458 static_cast<int>(RangeLocOffset::AssignLoc)];

5459}

5460

5462 return getTrailingObjects<

5463 SourceLocation>()[I * static_cast<int>(RangeLocOffset::Total) +

5464 static_cast<int>(RangeLocOffset::FirstColonLoc)];

5465}

5466

5468 return getTrailingObjects<

5469 SourceLocation>()[I * static_cast<int>(RangeLocOffset::Total) +

5470 static_cast<int>(RangeLocOffset::SecondColonLoc)];

5471}

5472

5474 getTrailingObjects()[I] = D;

5475}

5476

5478 return getTrailingObjects()[I];

5479}

5480

5482 return getTrailingObjects()[I];

5483}

5484

5485OMPIteratorExpr::OMPIteratorExpr(

5490 IteratorKwLoc(IteratorKwLoc), LPLoc(L), RPLoc(R),

5491 NumIterators(Data.size()) {

5492 for (unsigned I = 0, E = Data.size(); I < E; ++I) {

5493 const IteratorDefinition &D = Data[I];

5494 setIteratorDeclaration(I, D.IteratorDecl);

5495 setAssignmentLoc(I, D.AssignmentLoc);

5496 setIteratorRange(I, D.Range.Begin, D.ColonLoc, D.Range.End,

5497 D.SecondColonLoc, D.Range.Step);

5498 setHelper(I, Helpers[I]);

5499 }

5501}

5502

5509 assert(Data.size() == Helpers.size() &&

5510 "Data and helpers must have the same size.");

5511 void *Mem = Context.Allocate(

5512 totalSizeToAlloc<Decl *, Expr *, SourceLocation, OMPIteratorHelperData>(

5513 Data.size(), Data.size() * static_cast<int>(RangeExprOffset::Total),

5514 Data.size() * static_cast<int>(RangeLocOffset::Total),

5515 Helpers.size()),

5516 alignof(OMPIteratorExpr));

5517 return new (Mem) OMPIteratorExpr(T, IteratorKwLoc, L, R, Data, Helpers);

5518}

5519

5521 unsigned NumIterators) {

5522 void *Mem = Context.Allocate(

5523 totalSizeToAlloc<Decl *, Expr *, SourceLocation, OMPIteratorHelperData>(

5524 NumIterators, NumIterators * static_cast<int>(RangeExprOffset::Total),

5525 NumIterators * static_cast<int>(RangeLocOffset::Total), NumIterators),

5526 alignof(OMPIteratorExpr));

5527 return new (Mem) OMPIteratorExpr(EmptyShell(), NumIterators);

5528}

5529

5533 bool IsInOut) {

5534 return new (C) HLSLOutArgExpr(Ty, Base, OpV, WB, IsInOut);

5535}

5536

5538 return new (C) HLSLOutArgExpr(EmptyShell());

5539}

5540

5543 return new (C) OpenACCAsteriskSizeExpr(Loc, C.IntTy);

5544}

5545

5548 return new (C) OpenACCAsteriskSizeExpr({}, C.IntTy);

5549}

5550

5552 bool hasFPFeatures) {

5553 void *Mem = C.Allocate(totalSizeToAlloc(hasFPFeatures),

5554 alignof(ConvertVectorExpr));

5555 return new (Mem) ConvertVectorExpr(hasFPFeatures, EmptyShell());

5556}

5557

5563 unsigned Size = totalSizeToAlloc(HasFPFeatures);

5564 void *Mem = C.Allocate(Size, alignof(ConvertVectorExpr));

5565 return new (Mem) ConvertVectorExpr(SrcExpr, TI, DstType, VK, OK, BuiltinLoc,

5566 RParenLoc, FPFeatures);

5567}

5568

5571 if (!StaticValue) {

5572 StaticValue = new (Ctx) APValue;

5574 }

5575 return *StaticValue;

5576}

5577

5579 assert(StaticValue);

5580 return *StaticValue;

5581}

Defines the clang::ASTContext interface.

This file provides some common utility functions for processing Lambda related AST Constructs.

static bool isBooleanType(QualType Ty)

static Expr * IgnoreImplicitConstructorSingleStep(Expr *E)

Defines enum values for all the target-independent builtin functions.

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

Defines the C++ template declaration subclasses.

Defines the clang::Expr interface and subclasses for C++ expressions.

static const Expr * skipTemporaryBindingsNoOpCastsAndParens(const Expr *E)

Skip over any no-op casts and any temporary-binding expressions.

Definition Expr.cpp:3226

static bool IsDecompositionDeclRefExpr(const Expr *E)

Helper to determine wether E is a CXXConstructExpr constructing a DecompositionDecl.

Definition Expr.cpp:2555

static unsigned SizeOfCallExprInstance(Expr::StmtClass SC)

Definition Expr.cpp:1449

static void AssertResultStorageKind(ConstantResultStorageKind Kind)

Definition Expr.cpp:293

static void computeOverflowPatternExclusion(const ASTContext &Ctx, const BinaryOperator *E)

Compute and set the OverflowPatternExclusion bit based on whether the BinaryOperator expression match...

Definition Expr.cpp:4920

static std::optional< BinaryOperator * > getOverflowPatternBinOp(const BinaryOperator *E)

Certain overflow-dependent code patterns can have their integer overflow sanitization disabled.

Definition Expr.cpp:4874

TokenType getType() const

Returns the token's type, e.g.

Defines the clang::Preprocessor interface.

static QualType getUnderlyingType(const SubRegion *R)

static bool isRecordType(QualType T)

Defines the SourceManager interface.

Expr * getExpr()

Get 'expr' part of the associated expression/statement.

static QualType getPointeeType(const MemRegion *R)

static const TypeInfo & getInfo(unsigned id)

a trap message and trap category.

void setValue(const ASTContext &C, const llvm::APInt &Val)

llvm::APInt getValue() const

uint64_t * pVal

Used to store the >64 bits integer value.

uint64_t VAL

Used to store the <= 64 bits integer value.

void setIntValue(const ASTContext &C, const llvm::APInt &Val)

Definition Expr.cpp:946

A non-discriminated union of a base, field, or array index.

APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...

static APValue IndeterminateValue()

@ Indeterminate

This object has an indeterminate value (C++ [basic.indet]).

@ None

There is no such object (it's outside its lifetime).

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

SourceManager & getSourceManager()

const ConstantArrayType * getAsConstantArrayType(QualType T) const

static CanQualType getCanonicalType(QualType T)

Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...

QualType getPointerType(QualType T) const

Return the uniqued reference to the type for a pointer to the specified type.

Builtin::Context & BuiltinInfo

const LangOptions & getLangOpts() const

Qualifiers::GC getObjCGCAttrKind(QualType Ty) const

Return one of the GCNone, Weak or Strong Objective-C garbage collection attributes.

LangAS getDefaultOpenCLPointeeAddrSpace()

Returns default address space based on OpenCL version and enabled features.

uint64_t getTypeSize(QualType T) const

Return the size of the specified (complete) type T, in bits.

void * Allocate(size_t Size, unsigned Align=8) const

CanQualType UnsignedIntTy

llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const

Make an APSInt of the appropriate width and signedness for the given Value and integer Type.

StringLiteral * getPredefinedStringLiteralFromCache(StringRef Key) const

Return a string representing the human readable name for the specified function declaration or file n...

QualType getSizeType() const

Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.

UnnamedGlobalConstantDecl * getUnnamedGlobalConstantDecl(QualType Ty, const APValue &Value) const

Return a declaration for a uniquified anonymous global constant corresponding to a given APValue.

const TargetInfo & getTargetInfo() const

void addDestruction(T *Ptr) const

If T isn't trivially destructible, calls AddDeallocation to register it for destruction.

CanQualType getCanonicalTagType(const TagDecl *TD) const

static bool hasSameUnqualifiedType(QualType T1, QualType T2)

Determine whether the given types are equivalent after cvr-qualifiers have been removed.

const Stmt ** const_iterator

QualType getElementType() const

Return the effective 'element' type of this array section.

Definition Expr.cpp:5297

Expr * getBase()

Get base of the array section.

static QualType getBaseOriginalType(const Expr *Base)

Return original type of the base expression for array section.

Definition Expr.cpp:5269

QualType getBaseType() const

Returns the effective 'type' of the base of this array section.

Definition Expr.cpp:5315

ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.

Represents an array type, per C99 6.7.5.2 - Array Declarators.

QualType getElementType() const

static unsigned getNumSubExprs(AtomicOp Op)

Determine the number of arguments the specified atomic builtin should have.

Definition Expr.cpp:5155

QualType getValueType() const

Definition Expr.cpp:5262

AtomicExpr(SourceLocation BLoc, ArrayRef< Expr * > args, QualType t, AtomicOp op, SourceLocation RP)

Definition Expr.cpp:5145

unsigned getNumSubExprs() const

A builtin binary operation expression such as "x + y" or "x <= y".

static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)

Retrieve the overloaded operator kind that corresponds to the given binary opcode.

Definition Expr.cpp:2179

StringRef getOpcodeStr() const

SourceLocation getOperatorLoc() const

bool hasStoredFPFeatures() const

bool isCompoundAssignmentOp() const

static unsigned sizeOfTrailingObjects(bool HasFPFeatures)

Return the size in bytes needed for the trailing objects.

static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)

Definition Expr.cpp:4981

static BinaryOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)

Definition Expr.cpp:4973

static bool isAssignmentOp(Opcode Opc)

static bool isNullPointerArithmeticExtension(ASTContext &Ctx, Opcode Opc, const Expr *LHS, const Expr *RHS)

Return true if a binary operator using the specified opcode and operands would match the 'p = (i8*)nu...

Definition Expr.cpp:2204

void setStoredFPFeatures(FPOptionsOverride F)

Set FPFeatures in trailing storage, used only by Serialization.

static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)

Retrieve the binary opcode that corresponds to the given overloaded operator.

Definition Expr.cpp:2141

BinaryOperator(const ASTContext &Ctx, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)

Build a binary operator, assuming that appropriate storage has been allocated for the trailing object...

Definition Expr.cpp:4936

BinaryOperatorKind Opcode

A binding in a decomposition declaration.

SourceLocation getCaretLocation() const

Definition Expr.cpp:2537

const Stmt * getBody() const

Definition Expr.cpp:2540

const FunctionProtoType * getFunctionType() const

getFunctionType - Return the underlying function type for this block.

Definition Expr.cpp:2531

bool isUnevaluated(unsigned ID) const

Returns true if this builtin does not perform the side-effects of its arguments.

CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....

static CStyleCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)

Definition Expr.cpp:2121

static CStyleCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *BasePath, FPOptionsOverride FPO, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R)

Definition Expr.cpp:2103

SourceLocation getLParenLoc() const

Represents a call to a CUDA kernel function.

Represents a base class of a C++ class.

Represents binding an expression to a temporary.

CXXTemporary * getTemporary()

Represents a call to a C++ constructor.

Expr * getArg(unsigned Arg)

Return the specified argument.

CXXConstructorDecl * getConstructor() const

Get the constructor that this expression will (ultimately) call.

unsigned getNumArgs() const

Return the number of arguments to the constructor call.

Represents a C++ constructor within a class.

A default argument (C++ [dcl.fct.default]).

A use of a default initializer in a constructor or in aggregate initialization.

Represents a C++ destructor within a class.

A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).

Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....

Represents a call to a member function that may be written either with member call syntax (e....

Represents a static or instance method of a struct/union/class.

const CXXRecordDecl * getParent() const

Return the parent of this method declaration, which is the class in which this method is defined.

A call to an overloaded operator written using operator syntax.

SourceLocation getOperatorLoc() const

Returns the location of the operator symbol in the expression.

OverloadedOperatorKind getOperator() const

Returns the kind of overloaded operator that this expression refers to.

SourceRange getSourceRange() const

Represents a C++ struct/union/class.

bool hasTrivialDestructor() const

Determine whether this class has a trivial destructor (C++ [class.dtor]p3)

A C++ static_cast expression (C++ [expr.static.cast]).

const CXXDestructorDecl * getDestructor() const

Represents the this expression in C++.

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

Expr * getArg(unsigned Arg)

getArg - Return the specified argument.

bool hasStoredFPFeatures() const

std::optional< llvm::APInt > evaluateBytesReturnedByAllocSizeCall(const ASTContext &Ctx) const

Evaluates the total size in bytes allocated by calling a function decorated with alloc_size.

Definition Expr.cpp:3582

static unsigned sizeOfTrailingObjects(unsigned NumPreArgs, unsigned NumArgs, bool HasFPFeatures)

Return the size in bytes needed for the trailing objects.

void setArg(unsigned Arg, Expr *ArgExpr)

setArg - Set the specified argument.

static CallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0, ADLCallKind UsesADL=NotADL)

Create a call expression.

Definition Expr.cpp:1516

const AllocSizeAttr * getCalleeAllocSizeAttr() const

Try to get the alloc_size attribute of the callee. May return null.

Definition Expr.cpp:3573

unsigned getBuiltinCallee() const

getBuiltinCallee - If this is a call to a builtin, return the builtin ID of the callee.

Definition Expr.cpp:1591

FunctionDecl * getDirectCallee()

If the callee is a FunctionDecl, return it. Otherwise return null.

static CallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)

Create an empty call expression, for deserialization.

Definition Expr.cpp:1534

bool isCallToStdMove() const

Definition Expr.cpp:3623

void setPreArg(unsigned I, Stmt *PreArg)

static constexpr unsigned OffsetToTrailingObjects

void computeDependence()

Compute and set dependence bits.

void setStoredFPFeatures(FPOptionsOverride F)

Set FPOptionsOverride in trailing storage. Used only by Serialization.

unsigned getNumArgs() const

getNumArgs - Return the number of actual arguments to this call.

CallExpr(StmtClass SC, Expr *Fn, ArrayRef< Expr * > PreArgs, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, FPOptionsOverride FPFeatures, unsigned MinNumArgs, ADLCallKind UsesADL)

Build a call expression, assuming that appropriate storage has been allocated for the trailing object...

Definition Expr.cpp:1472

static constexpr unsigned sizeToAllocateForCallExprSubclass(unsigned SizeOfTrailingObjects)

static constexpr ADLCallKind UsesADL

bool isBuiltinAssumeFalse(const ASTContext &Ctx) const

Return true if this is a call to __assume() or __builtin_assume() with a non-value-dependent constant...

Definition Expr.cpp:3561

QualType getCallReturnType(const ASTContext &Ctx) const

getCallReturnType - Get the return type of the call expr.

Definition Expr.cpp:1602

bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const

Returns true if this is a call to a builtin which does not evaluate side-effects within its arguments...

Definition Expr.cpp:1596

unsigned getNumPreArgs() const

bool hasUnusedResultAttr(const ASTContext &Ctx) const

Returns true if this call expression should warn on unused results.

QualType withConst() const

Retrieves a version of this type with const applied.

bool isVolatileQualified() const

Represents the body of a CapturedStmt, and serves as its DeclContext.

CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...

FPOptionsOverride * getTrailingFPFeatures()

Return a pointer to the trailing FPOptions.

Definition Expr.cpp:2052

NamedDecl * getConversionFunction() const

If this cast applies a user-defined conversion, retrieve the conversion function that it invokes.

Definition Expr.cpp:2001

Expr * getSubExprAsWritten()

Retrieve the cast subexpression as it was written in the source code, looking through any implicit ca...

Definition Expr.cpp:1979

CastKind getCastKind() const

bool hasStoredFPFeatures() const

static const FieldDecl * getTargetFieldForToUnionCast(QualType unionType, QualType opType)

Definition Expr.cpp:2033

CastExpr(StmtClass SC, QualType ty, ExprValueKind VK, const CastKind kind, Expr *op, unsigned BasePathSize, bool HasFPFeatures)

const char * getCastKindName() const

SourceLocation getEnd() const

static CharUnits Zero()

Zero - Construct a CharUnits quantity of zero.

void setValue(unsigned Val)

static void print(unsigned val, CharacterLiteralKind Kind, raw_ostream &OS)

Definition Expr.cpp:1019

ChooseExpr - GNU builtin-in function __builtin_choose_expr.

Represents a class template specialization, which refers to a class template with a given set of temp...

bool isExplicitSpecialization() const

CompoundAssignOperator - For compound assignments (e.g.

static CompoundAssignOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)

Definition Expr.cpp:4995

static CompoundAssignOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures, QualType CompLHSType=QualType(), QualType CompResultType=QualType())

Definition Expr.cpp:5003

CompoundLiteralExpr - [C99 6.5.2.5].

bool hasStaticStorage() const

APValue & getStaticValue() const

Definition Expr.cpp:5578

APValue & getOrCreateStaticValue(ASTContext &Ctx) const

Definition Expr.cpp:5569

CompoundStmt - This represents a group of statements like { stmt stmt }.

ConditionalOperator - The ?

ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.

APValue getAPValueResult() const

Definition Expr.cpp:412

static ConstantResultStorageKind getStorageKind(const APValue &Value)

Definition Expr.cpp:301

void MoveIntoResult(APValue &Value, const ASTContext &Context)

Definition Expr.cpp:377

llvm::APSInt getResultAsAPSInt() const

Definition Expr.cpp:400

ConstantResultStorageKind getResultStorageKind() const

static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)

Definition Expr.cpp:349

static ConstantExpr * CreateEmpty(const ASTContext &Context, ConstantResultStorageKind StorageKind)

Definition Expr.cpp:366

static ConvertVectorExpr * Create(const ASTContext &C, Expr *SrcExpr, TypeSourceInfo *TI, QualType DstType, ExprValueKind VK, ExprObjectKind OK, SourceLocation BuiltinLoc, SourceLocation RParenLoc, FPOptionsOverride FPFeatures)

Definition Expr.cpp:5558

static ConvertVectorExpr * CreateEmpty(const ASTContext &C, bool hasFPFeatures)

Definition Expr.cpp:5551

A POD class for pairing a NamedDecl* with an access specifier.

NamedDecl * getDecl() const

AccessSpecifier getAccess() const

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

DeclContext * getParent()

getParent - Returns the containing DeclContext.

A reference to a declared variable, function, enum, etc.

bool hasExplicitTemplateArgs() const

Determines whether this declaration reference was followed by an explicit template argument list.

void setDecl(ValueDecl *NewD)

Definition Expr.cpp:543

static DeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)

Construct an empty declaration reference expression.

Definition Expr.cpp:528

DeclarationNameInfo getNameInfo() const

static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)

Definition Expr.cpp:487

SourceLocation getEndLoc() const LLVM_READONLY

Definition Expr.cpp:550

SourceLocation getRAngleLoc() const

Retrieve the location of the right angle bracket ending the explicit template argument list following...

Decl - This represents one declaration (or definition), e.g.

static bool isFlexibleArrayMemberLike(const ASTContext &Context, const Decl *D, QualType Ty, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution)

Whether it resembles a flexible array member.

ASTContext & getASTContext() const LLVM_READONLY

static Decl * castFromDeclContext(const DeclContext *)

DeclContext * getDeclContext()

AccessSpecifier getAccess() const

DeclarationNameLoc - Additional source/type location info for a declaration name.

Represents a single C99 designator.

unsigned getArrayIndex() const

SourceRange getSourceRange() const LLVM_READONLY

bool isFieldDesignator() const

SourceLocation getBeginLoc() const LLVM_READONLY

struct FieldDesignatorInfo FieldInfo

A field designator, e.g., ".x".

bool isArrayRangeDesignator() const

FieldDecl * getFieldDecl() const

bool isArrayDesignator() const

SourceLocation getFieldLoc() const

const IdentifierInfo * getFieldName() const

Definition Expr.cpp:4673

SourceLocation getDotLoc() const

static DesignatedInitExpr * CreateEmpty(const ASTContext &C, unsigned NumIndexExprs)

Definition Expr.cpp:4727

Expr * getArrayRangeEnd(const Designator &D) const

Definition Expr.cpp:4782

Expr * getSubExpr(unsigned Idx) const

SourceRange getDesignatorsSourceRange() const

Definition Expr.cpp:4743

Expr * getArrayRangeStart(const Designator &D) const

Definition Expr.cpp:4777

void ExpandDesignator(const ASTContext &C, unsigned Idx, const Designator *First, const Designator *Last)

Replaces the designator at index Idx with the series of designators in [First, Last).

Definition Expr.cpp:4789

Expr * getArrayIndex(const Designator &D) const

Definition Expr.cpp:4772

Designator * getDesignator(unsigned Idx)

Expr * getInit() const

Retrieve the initializer value.

unsigned size() const

Returns the number of designators in this initializer.

SourceLocation getBeginLoc() const LLVM_READONLY

Definition Expr.cpp:4751

void setDesignators(const ASTContext &C, const Designator *Desigs, unsigned NumDesigs)

Definition Expr.cpp:4734

SourceLocation getEndLoc() const LLVM_READONLY

Definition Expr.cpp:4768

static DesignatedInitExpr * Create(const ASTContext &C, ArrayRef< Designator > Designators, ArrayRef< Expr * > IndexExprs, SourceLocation EqualOrColonLoc, bool GNUSyntax, Expr *Init)

Definition Expr.cpp:4714

SourceLocation getBeginLoc() const LLVM_READONLY

Definition Expr.cpp:4831

DesignatedInitUpdateExpr(const ASTContext &C, SourceLocation lBraceLoc, Expr *baseExprs, SourceLocation rBraceLoc)

Definition Expr.cpp:4815

SourceLocation getEndLoc() const LLVM_READONLY

Definition Expr.cpp:4835

InitListExpr * getUpdater() const

EmbedExpr(const ASTContext &Ctx, SourceLocation Loc, EmbedDataStorage *Data, unsigned Begin, unsigned NumOfElements)

Definition Expr.cpp:2393

An instance of this object exists for each enum constant that is defined.

ExplicitCastExpr - An explicit cast written in the source code.

QualType getTypeAsWritten() const

getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...

Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...

This represents one expression.

bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const

EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...

EnumConstantDecl * getEnumConstantDecl()

If this expression refers to an enum constant, retrieve its declaration.

Definition Expr.cpp:4254

bool isReadIfDiscardedInCPlusPlus11() const

Determine whether an lvalue-to-rvalue conversion should implicitly be applied to this expression if i...

Definition Expr.cpp:2564

bool isIntegerConstantExpr(const ASTContext &Ctx) const

Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY

Skip past any parentheses and casts which do not change the value (including ptr->int casts of the sa...

Definition Expr.cpp:3116

@ SE_AllowSideEffects

Allow any unmodeled side effect.

@ SE_AllowUndefinedBehavior

Allow UB that we can give a value, but not arbitrary unmodeled side effects.

static QualType findBoundMemberType(const Expr *expr)

Given an expression of bound-member type, find the type of the member.

Definition Expr.cpp:3045

static std::pair< const NamedDecl *, const WarnUnusedResultAttr * > getUnusedResultAttrImpl(const Decl *Callee, QualType ReturnType)

Returns the WarnUnusedResultAttr that is declared on the callee or its return type declaration,...

Definition Expr.cpp:1633

bool isImplicitCXXThis() const

Whether this expression is an implicit reference to 'this' in C++.

Definition Expr.cpp:3294

Expr * IgnoreParenCasts() LLVM_READONLY

Skip past any parentheses and casts which might surround this expression until reaching a fixed point...

Definition Expr.cpp:3094

bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc, SourceRange &R1, SourceRange &R2, ASTContext &Ctx) const

isUnusedResultAWarning - Return true if this immediate expression should be warned about if the resul...

Definition Expr.cpp:2630

LValueClassification ClassifyLValue(ASTContext &Ctx) const

Reasons why an expression might not be an l-value.

bool isValueDependent() const

Determines whether the value of this expression depends on.

ExprValueKind getValueKind() const

getValueKind - The value kind that this expression produces.

bool refersToVectorElement() const

Returns whether this expression refers to a vector element.

Definition Expr.cpp:4261

bool isTypeDependent() const

Determines whether the type of this expression depends on.

llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx) const

EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.

Expr * IgnoreParenLValueCasts() LLVM_READONLY

Skip past any parentheses and lvalue casts which might surround this expression until reaching a fixe...

Definition Expr.cpp:3106

FPOptions getFPFeaturesInEffect(const LangOptions &LO) const

Returns the set of floating point options that apply to this expression.

Definition Expr.cpp:3967

const CXXRecordDecl * getBestDynamicClassType() const

For an expression of class type or pointer to class type, return the most derived class decl the expr...

Definition Expr.cpp:68

Expr * IgnoreParenImpCasts() LLVM_READONLY

Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...

Definition Expr.cpp:3089

Expr * IgnoreImplicit() LLVM_READONLY

Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.

Definition Expr.cpp:3077

Expr * IgnoreConversionOperatorSingleStep() LLVM_READONLY

Skip conversion operators.

Definition Expr.cpp:3098

bool containsErrors() const

Whether this expression contains subexpressions which had errors.

bool isObjCSelfExpr() const

Check if this expression is the ObjC 'self' implicit parameter.

Definition Expr.cpp:4189

Expr * IgnoreParens() LLVM_READONLY

Skip past any parentheses which might surround this expression until reaching a fixed point.

Definition Expr.cpp:3085

bool isFlexibleArrayMemberLike(const ASTContext &Context, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution=false) const

Check whether this array fits the idiom of a flexible array member, depending on the value of -fstric...

Definition Expr.cpp:205

bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const

EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known ...

bool isEvaluatable(const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const

isEvaluatable - Call EvaluateAsRValue to see if this expression can be constant folded without side-e...

Expr * IgnoreParenBaseCasts() LLVM_READONLY

Skip past any parentheses and derived-to-base casts until reaching a fixed point.

Definition Expr.cpp:3111

bool isLValue() const

isLValue - True if this expression is an "l-value" according to the rules of the current language.

static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)

hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.

Definition Expr.cpp:3338

FieldDecl * getSourceBitField()

If this expression refers to a bit-field, retrieve the declaration of that bit-field.

Definition Expr.cpp:4207

NullPointerConstantValueDependence

Enumeration used to describe how isNullPointerConstant() should cope with value-dependent expressions...

@ NPC_ValueDependentIsNull

Specifies that a value-dependent expression of integral or dependent type should be considered a null...

@ NPC_NeverValueDependent

Specifies that the expression should never be value-dependent.

@ NPC_ValueDependentIsNotNull

Specifies that a value-dependent expression should be considered to never be a null pointer constant.

Expr * IgnoreUnlessSpelledInSource()

Skip past any invisible AST nodes which might surround this statement, such as ExprWithCleanups or Im...

Definition Expr.cpp:3142

ExprObjectKind getObjectKind() const

getObjectKind - The object kind that this expression produces.

Expr * IgnoreCasts() LLVM_READONLY

Skip past any casts which might surround this expression until reaching a fixed point.

Definition Expr.cpp:3073

Decl * getReferencedDeclOfCallee()

Definition Expr.cpp:1545

Expr * IgnoreImplicitAsWritten() LLVM_READONLY

Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.

Definition Expr.cpp:3081

bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const

HasSideEffects - This routine returns true for all those expressions which have any effect other than...

Definition Expr.cpp:3669

bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const

Evaluate an expression that is required to be a constant expression.

const Expr * getBestDynamicClassTypeExpr() const

Get the inner expression that determines the best dynamic class.

Definition Expr.cpp:43

Expr * IgnoreImpCasts() LLVM_READONLY

Skip past any implicit casts which might surround this expression until reaching a fixed point.

Definition Expr.cpp:3069

NullPointerConstantKind

Enumeration used to describe the kind of Null pointer constant returned from isNullPointerConstant().

@ NPCK_ZeroExpression

Expression is a Null pointer constant built from a zero integer expression that is not a simple,...

@ NPCK_ZeroLiteral

Expression is a Null pointer constant built from a literal zero.

@ NPCK_CXX11_nullptr

Expression is a C++11 nullptr.

@ NPCK_GNUNull

Expression is a GNU-style __null constant.

@ NPCK_NotNull

Expression is not a Null pointer constant.

bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx, bool InConstantContext=false) const

EvaluateAsBooleanCondition - Return true if this is a constant which we can fold and convert to a boo...

bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const

Determine whether the result of this expression is a temporary object of the given class type.

Definition Expr.cpp:3252

NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const

isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.

Definition Expr.cpp:4046

QualType getEnumCoercedType(const ASTContext &Ctx) const

If this expression is an enumeration constant, return the enumeration type under which said constant ...

Definition Expr.cpp:265

bool isBoundMemberFunction(ASTContext &Ctx) const

Returns true if this expression is a bound member function.

Definition Expr.cpp:3039

bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const

isConstantInitializer - Returns true if this expression can be emitted to IR as a constant,...

Definition Expr.cpp:3346

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

Definition Expr.cpp:276

static bool isSameComparisonOperand(const Expr *E1, const Expr *E2)

Checks that the two Expr's will refer to the same value as a comparison operand.

Definition Expr.cpp:4298

bool isDefaultArgument() const

Determine whether this expression is a default function argument.

Definition Expr.cpp:3213

Classification Classify(ASTContext &Ctx) const

Classify - Classify this expression according to the C++11 expression taxonomy.

bool hasNonTrivialCall(const ASTContext &Ctx) const

Determine whether this expression involves a call to any function that is not trivial.

Definition Expr.cpp:4034

bool refersToGlobalRegisterVar() const

Returns whether this expression refers to a global register variable.

Definition Expr.cpp:4286

bool isCXX98IntegralConstantExpr(const ASTContext &Ctx) const

isCXX98IntegralConstantExpr - Return true if this expression is an integral constant expression in C+...

const ValueDecl * getAsBuiltinConstantDeclRef(const ASTContext &Context) const

If this expression is an unambiguous reference to a single declaration, in the style of __builtin_fun...

Definition Expr.cpp:225

bool isOBJCGCCandidate(ASTContext &Ctx) const

isOBJCGCCandidate - Return true if this expression may be used in a read/ write barrier.

Definition Expr.cpp:3000

static ExprValueKind getValueKindForType(QualType T)

getValueKindForType - Given a formal return or parameter type, give its value kind.

const Expr * skipRValueSubobjectAdjustments() const

bool isKnownToHaveBooleanValue(bool Semantic=true) const

isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...

Definition Expr.cpp:136

void setDependence(ExprDependence Deps)

Each concrete expr subclass is expected to compute its dependence and call this in the constructor.

const ObjCPropertyRefExpr * getObjCProperty() const

If this expression is an l-value for an Objective C property, find the underlying property reference ...

Definition Expr.cpp:4170

bool containsDuplicateElements() const

containsDuplicateElements - Return true if any element access is repeated.

Definition Expr.cpp:4425

bool isArrow() const

isArrow - Return true if the base expression is a pointer to vector, return false if the base express...

Definition Expr.cpp:4414

void getEncodedElementAccess(SmallVectorImpl< uint32_t > &Elts) const

getEncodedElementAccess - Encode the elements accessed into an llvm aggregate Constant of ConstantInt...

Definition Expr.cpp:4446

const Expr * getBase() const

unsigned getNumElements() const

getNumElements - Get the number of components being selected.

Definition Expr.cpp:4418

static int getAccessorIdx(char c, bool isNumericAccessor)

Represents difference between two FPOptions values.

bool requiresTrailingStorage() const

static FPOptions defaultWithoutTrailingStorage(const LangOptions &LO)

Return the default value of FPOptions that's used when trailing storage isn't required.

Represents a member of a struct/union/class.

Expr * getInClassInitializer() const

Get the C++11 default member initializer for this member, or null if one has not been set.

bool isBitField() const

Determines whether this field is a bitfield.

static FixedPointLiteral * Create(const ASTContext &C, EmptyShell Empty)

Returns an empty fixed-point literal.

Definition Expr.cpp:1004

std::string getValueAsString(unsigned Radix) const

Definition Expr.cpp:1009

llvm::APInt getValue() const

Returns an internal integer representation of the literal.

static FixedPointLiteral * CreateFromRawInt(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l, unsigned Scale)

Definition Expr.cpp:996

static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)

Definition Expr.cpp:1075

double getValueAsApproximateDouble() const

getValueAsApproximateDouble - This returns the value as an inaccurate double.

Definition Expr.cpp:1088

llvm::APFloat getValue() const

FullExpr - Represents a "full-expression" node.

Represents a function declaration or definition.

FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const

Retrieve the function declaration from which this function could be instantiated, if it is an instant...

bool isTrivial() const

Whether this function is "trivial" in some specialized C++ senses.

Represents a prototype with parameter type info, e.g.

Provides information about a function template specialization, which is a FunctionDecl that has been ...

bool isExplicitSpecialization() const

TemplateArgumentList * TemplateArguments

The template arguments used to produce the function template specialization from the function templat...

FunctionTemplateDecl * getTemplate() const

Retrieve the template from which this function was specialized.

FunctionType - C99 6.7.5.3 - Function Declarators.

CallingConv getCallConv() const

QualType getReturnType() const

Represents a C11 generic selection.

static GenericSelectionExpr * Create(const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr, ArrayRef< TypeSourceInfo * > AssocTypes, ArrayRef< Expr * > AssocExprs, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack, unsigned ResultIndex)

Create a non-result-dependent generic selection expression accepting an expression predicate.

Definition Expr.cpp:4603

static GenericSelectionExpr * CreateEmpty(const ASTContext &Context, unsigned NumAssocs)

Create an empty generic selection expression for deserialization.

Definition Expr.cpp:4661

GlobalDecl - represents a global declaration.

static HLSLOutArgExpr * CreateEmpty(const ASTContext &Ctx)

Definition Expr.cpp:5537

static HLSLOutArgExpr * Create(const ASTContext &C, QualType Ty, OpaqueValueExpr *Base, OpaqueValueExpr *OpV, Expr *WB, bool IsInOut)

Definition Expr.cpp:5530

One of these records is kept for each identifier that is lexed.

ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...

static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)

Definition Expr.cpp:2072

static ImplicitCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)

Definition Expr.cpp:2094

Describes an C or C++ initializer list.

bool hasArrayFiller() const

Return true if this is an array initializer and its array "filler" has been set.

InitListExpr(const ASTContext &C, SourceLocation lbraceloc, ArrayRef< Expr * > initExprs, SourceLocation rbraceloc)

Definition Expr.cpp:2405

bool isTransparent() const

Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic,...

Definition Expr.cpp:2461

void resizeInits(const ASTContext &Context, unsigned NumInits)

Specify the number of initializers.

Definition Expr.cpp:2421

bool isStringLiteralInit() const

Is this an initializer for an array of characters, initialized by a string literal or an @encode?

Definition Expr.cpp:2447

FieldDecl * getInitializedFieldInUnion()

If this initializes a union, specifies which field in the union to initialize.

unsigned getNumInits() const

SourceLocation getBeginLoc() const LLVM_READONLY

Definition Expr.cpp:2495

bool isSemanticForm() const

void setInit(unsigned Init, Expr *expr)

Expr * updateInit(const ASTContext &C, unsigned Init, Expr *expr)

Updates the initializer at index Init with the new expression expr, and returns the old expression at...

Definition Expr.cpp:2425

void setArrayFiller(Expr *filler)

Definition Expr.cpp:2437

InitListExpr * getSyntacticForm() const

const Expr * getInit(unsigned Init) const

bool isIdiomaticZeroInitializer(const LangOptions &LangOpts) const

Is this the zero initializer {0} in a language which considers it idiomatic?

Definition Expr.cpp:2484

SourceLocation getEndLoc() const LLVM_READONLY

Definition Expr.cpp:2513

bool isSyntacticForm() const

ArrayRef< Expr * > inits()

void sawArrayRangeDesignator(bool ARD=true)

Expr ** getInits()

Retrieve the set of initializers.

void reserveInits(const ASTContext &C, unsigned NumInits)

Reserve space for some number of initializers.

Definition Expr.cpp:2416

static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)

Returns a new integer literal with value 'V' and type 'type'.

Definition Expr.cpp:974

static ItaniumMangleContext * create(ASTContext &Context, DiagnosticsEngine &Diags, bool IsAux=false)

LabelStmt - Represents a label, which has a substatement.

A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...

StrictFlexArraysLevelKind

@ AddUnsignedOverflowTest

if (a + b < a)

@ AddSignedOverflowTest

if (a + b < a)

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

bool isOverflowPatternExcluded(OverflowPatternExclusionKind Kind) const

void remapPathPrefix(SmallVectorImpl< char > &Path) const

Remap path prefix according to -fmacro-prefix-path option.

Lexer - This provides a simple interface that turns a text buffer into a stream of tokens.

bool LexFromRawLexer(Token &Result)

LexFromRawLexer - Lex a token from a designated raw lexer (one with no associated preprocessor object...

static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Characters, const SourceManager &SM, const LangOptions &LangOpts)

AdvanceToTokenCharacter - If the current SourceLocation specifies a location at the start of a token,...

Represents a prvalue temporary that is written into memory so that a reference can bind to it.

MemberExpr - [C99 6.5.2.3] Structure and Union Members.

static MemberExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)

Definition Expr.cpp:1771

void setMemberDecl(ValueDecl *D)

Definition Expr.cpp:1786

NestedNameSpecifierLoc getQualifierLoc() const

If the member name was qualified, retrieves the nested-name-specifier that precedes the member name,...

bool hasExplicitTemplateArgs() const

Determines whether the member name was followed by an explicit template argument list.

bool hasQualifier() const

Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...

static MemberExpr * Create(const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *MemberDecl, DeclAccessPair FoundDecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR)

Definition Expr.cpp:1749

bool isImplicitAccess() const

Determine whether the base of this explicit is implicit.

SourceLocation getRAngleLoc() const

Retrieve the location of the right angle bracket ending the explicit template argument list following...

SourceLocation getEndLoc() const LLVM_READONLY

Definition Expr.cpp:1807

SourceLocation getBeginLoc() const LLVM_READONLY

Definition Expr.cpp:1793

DeclarationNameInfo getMemberNameInfo() const

Retrieve the member declaration name info.

A pointer to member type per C++ 8.3.3 - Pointers to members.

This represents a decl that may have a name.

IdentifierInfo * getIdentifier() const

Get the identifier that names this declaration, if there is one.

StringRef getName() const

Get the name of identifier for this declaration as a StringRef.

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

A C++ nested-name-specifier augmented with source location information.

SourceLocation getBeginLoc() const

Retrieve the location of the beginning of this nested-name-specifier.

bool hasQualifier() const

Evaluates true when this nested-name-specifier location is non-empty.

An explicit cast in C or a C-style cast in C++, which uses the syntax ([s1][s2]......

static OMPArrayShapingExpr * CreateEmpty(const ASTContext &Context, unsigned NumDims)

Definition Expr.cpp:5391

static OMPArrayShapingExpr * Create(const ASTContext &Context, QualType T, Expr *Op, SourceLocation L, SourceLocation R, ArrayRef< Expr * > Dims, ArrayRef< SourceRange > BracketRanges)

Definition Expr.cpp:5377

OpenMP 5.0 [2.1.6 Iterators] Iterators are identifiers that expand to multiple values in the clause o...

static OMPIteratorExpr * Create(const ASTContext &Context, QualType T, SourceLocation IteratorKwLoc, SourceLocation L, SourceLocation R, ArrayRef< IteratorDefinition > Data, ArrayRef< OMPIteratorHelperData > Helpers)

Definition Expr.cpp:5504

static OMPIteratorExpr * CreateEmpty(const ASTContext &Context, unsigned NumIterators)

Definition Expr.cpp:5520

SourceLocation getSecondColonLoc(unsigned I) const

Gets the location of the second ':' (if any) in the range for the given iteratori definition.

Definition Expr.cpp:5467

SourceLocation getColonLoc(unsigned I) const

Gets the location of the first ':' in the range for the given iterator definition.

Definition Expr.cpp:5461

IteratorRange getIteratorRange(unsigned I)

Gets the iterator range for the given iterator.

Definition Expr.cpp:5438

OMPIteratorHelperData & getHelper(unsigned I)

Fetches helper data for the specified iteration space.

Definition Expr.cpp:5477

SourceLocation getAssignLoc(unsigned I) const

Gets the location of '=' for the given iterator definition.

Definition Expr.cpp:5455

Decl * getIteratorDecl(unsigned I)

Gets the iterator declaration for the given iterator.

Definition Expr.cpp:5434

ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.

Represents an ObjC class declaration.

ObjCIvarRefExpr - A reference to an ObjC instance variable.

An expression that sends a message to the given Objective-C object or class.

ObjCMethodFamily getMethodFamily() const

bool isInstanceMessage() const

Determine whether this is an instance message to either a computed object or to super.

bool hasUnusedResultAttr(ASTContext &Ctx) const

Returns true if this message send should warn on unused results.

ObjCMethodDecl - Represents an instance or class method declaration.

ImplicitParamDecl * getSelfDecl() const

ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.

static OffsetOfExpr * CreateEmpty(const ASTContext &C, unsigned NumComps, unsigned NumExprs)

Definition Expr.cpp:1665

static OffsetOfExpr * Create(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, ArrayRef< OffsetOfNode > comps, ArrayRef< Expr * > exprs, SourceLocation RParenLoc)

Definition Expr.cpp:1652

void setIndexExpr(unsigned Idx, Expr *E)

void setComponent(unsigned Idx, OffsetOfNode ON)

FieldDecl * getField() const

For a field offsetof node, returns the field.

IdentifierInfo * getFieldName() const

For a field or identifier offsetof node, returns the name of the field.

Definition Expr.cpp:1687

@ Identifier

A field in a dependent type, known only by its name.

Kind getKind() const

Determine what kind of offsetof node this is.

OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.

static const OpaqueValueExpr * findInCopyConstruct(const Expr *expr)

Given an expression which invokes a copy constructor — i.e.

Definition Expr.cpp:5050

OpaqueValueExpr(SourceLocation Loc, QualType T, ExprValueKind VK, ExprObjectKind OK=OK_Ordinary, Expr *SourceExpr=nullptr)

This expression type represents an asterisk in an OpenACC Size-Expr, used in the 'tile' and 'gang' cl...

static OpenACCAsteriskSizeExpr * Create(const ASTContext &C, SourceLocation Loc)

Definition Expr.cpp:5541

static OpenACCAsteriskSizeExpr * CreateEmpty(const ASTContext &C)

Definition Expr.cpp:5547

ParenExpr - This represents a parenthesized expression, e.g.

static ParenListExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumExprs)

Create an empty paren list.

Definition Expr.cpp:4862

static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc)

Create a paren list.

Definition Expr.cpp:4853

PointerType - C99 6.7.5.1 - Pointer Declarators.

QualType getPointeeType() const

static PredefinedExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType FNTy, PredefinedIdentKind IK, bool IsTransparent, StringLiteral *SL)

Create a PredefinedExpr.

Definition Expr.cpp:632

StringRef getIdentKindName() const

static PredefinedExpr * CreateEmpty(const ASTContext &Ctx, bool HasFunctionName)

Create an empty PredefinedExpr.

Definition Expr.cpp:641

static std::string ComputeName(PredefinedIdentKind IK, const Decl *CurrentDecl, bool ForceElaboratedPrinting=false)

Definition Expr.cpp:672

static void processPathToFileName(SmallVectorImpl< char > &FileName, const PresumedLoc &PLoc, const LangOptions &LangOpts, const TargetInfo &TI)

static void processPathForFileMacro(SmallVectorImpl< char > &Path, const LangOptions &LangOpts, const TargetInfo &TI)

Represents an unpacked "presumed" location which can be presented to the user.

unsigned getColumn() const

Return the presumed column number of this location.

const char * getFilename() const

Return the presumed filename of this location.

unsigned getLine() const

Return the presumed line number of this location.

Callbacks to use to customize the behavior of the pretty-printer.

PseudoObjectExpr - An expression which accesses a pseudo-object l-value.

semantics_iterator semantics_end()

semantics_iterator semantics_begin()

const Expr *const * const_semantics_iterator

static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr * > semantic, unsigned resultIndex)

Definition Expr.cpp:5075

ArrayRef< Expr * > semantics()

A (possibly-)qualified type.

bool isVolatileQualified() const

Determine whether this type is volatile-qualified.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

LangAS getAddressSpace() const

Return the address space of this type.

Qualifiers getQualifiers() const

Retrieve the set of qualifiers applied to this type.

void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const

QualType getCanonicalType() const

The collection of all-type qualifiers we support.

void removeAddressSpace()

Represents a struct/union/class.

field_iterator field_end() const

field_range fields() const

specific_decl_iterator< FieldDecl > field_iterator

field_iterator field_begin() const

static RecoveryExpr * Create(ASTContext &Ctx, QualType T, SourceLocation BeginLoc, SourceLocation EndLoc, ArrayRef< Expr * > SubExprs)

Definition Expr.cpp:5337

static RecoveryExpr * CreateEmpty(ASTContext &Ctx, unsigned NumSubExprs)

Definition Expr.cpp:5346

TypeSourceInfo * getTypeSourceInfo()

static SYCLUniqueStableNameExpr * Create(const ASTContext &Ctx, SourceLocation OpLoc, SourceLocation LParen, SourceLocation RParen, TypeSourceInfo *TSI)

Definition Expr.cpp:572

std::string ComputeName(ASTContext &Context) const

Definition Expr.cpp:586

static SYCLUniqueStableNameExpr * CreateEmpty(const ASTContext &Ctx)

Definition Expr.cpp:581

void setExprs(const ASTContext &C, ArrayRef< Expr * > Exprs)

Definition Expr.cpp:4491

ShuffleVectorExpr(const ASTContext &C, ArrayRef< Expr * > args, QualType Type, SourceLocation BLoc, SourceLocation RP)

Definition Expr.cpp:4478

APValue EvaluateInContext(const ASTContext &Ctx, const Expr *DefaultExpr) const

Return the result of evaluating this SourceLocExpr in the specified (and possibly null) default argum...

Definition Expr.cpp:2281

SourceLocExpr(const ASTContext &Ctx, SourceLocIdentKind Type, QualType ResultTy, SourceLocation BLoc, SourceLocation RParenLoc, DeclContext *Context)

Definition Expr.cpp:2248

SourceLocation getLocation() const

const DeclContext * getParentContext() const

If the SourceLocExpr has been resolved return the subexpression representing the resolved value.

StringRef getBuiltinStr() const

Return a string representing the name of the specific builtin function.

Definition Expr.cpp:2261

static bool MayBeDependent(SourceLocIdentKind Kind)

SourceLocIdentKind getIdentKind() const

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

This class handles loading and caching of source files into memory.

PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const

Returns the "presumed" location of a SourceLocation specifies.

CharSourceRange getExpansionRange(SourceLocation Loc) const

Given a SourceLocation object, return the range of tokens covered by the expansion in the ultimate fi...

A trivial tuple used to represent a source range.

Stmt - This represents one statement.

SourceLocation getEndLoc() const LLVM_READONLY

UnaryExprOrTypeTraitExprBitfields UnaryExprOrTypeTraitExprBits

GenericSelectionExprBitfields GenericSelectionExprBits

ParenListExprBitfields ParenListExprBits

StmtIterator child_iterator

Child Iterators: All subclasses must implement 'children' to permit easy iteration over the substatem...

CallExprBitfields CallExprBits

ShuffleVectorExprBitfields ShuffleVectorExprBits

FloatingLiteralBitfields FloatingLiteralBits

child_iterator child_begin()

StmtClass getStmtClass() const

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

UnaryOperatorBitfields UnaryOperatorBits

SourceLocExprBitfields SourceLocExprBits

ConstantExprBitfields ConstantExprBits

llvm::iterator_range< child_iterator > child_range

StringLiteralBitfields StringLiteralBits

MemberExprBitfields MemberExprBits

DeclRefExprBitfields DeclRefExprBits

ConstStmtIterator const_child_iterator

PredefinedExprBitfields PredefinedExprBits

SourceLocation getBeginLoc() const LLVM_READONLY

BinaryOperatorBitfields BinaryOperatorBits

PseudoObjectExprBitfields PseudoObjectExprBits

llvm::iterator_range< const_child_iterator > const_child_range

StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...

unsigned getOffsetOfStringByte(const Token &TheTok, unsigned ByteNo) const

getOffsetOfStringByte - This function returns the offset of the specified byte of the string data rep...

unsigned GetStringLength() const

StringLiteral - This represents a string literal expression, e.g.

SourceLocation getStrTokenLoc(unsigned TokNum) const

Get one of the string literal token.

unsigned getLength() const

StringLiteralKind getKind() const

static StringLiteral * Create(const ASTContext &Ctx, StringRef Str, StringLiteralKind Kind, bool Pascal, QualType Ty, ArrayRef< SourceLocation > Locs)

This is the "fully general" constructor that allows representation of strings formed from one or more...

Definition Expr.cpp:1187

SourceLocation getLocationOfByte(unsigned ByteNo, const SourceManager &SM, const LangOptions &Features, const TargetInfo &Target, unsigned *StartToken=nullptr, unsigned *StartTokenByteOffset=nullptr) const

getLocationOfByte - Return a source location that points to the specified byte of this string literal...

Definition Expr.cpp:1325

uint32_t getCodeUnit(size_t i) const

void outputString(raw_ostream &OS) const

Definition Expr.cpp:1208

static StringLiteral * CreateEmpty(const ASTContext &Ctx, unsigned NumConcatenated, unsigned Length, unsigned CharByteWidth)

Construct an empty string literal.

Definition Expr.cpp:1197

unsigned getNumConcatenated() const

getNumConcatenated - Get the number of string literal tokens that were concatenated in translation ph...

Represents the declaration of a struct/union/class/enum.

Exposes information about the current target.

A convenient class for passing around template argument information.

A template argument list.

unsigned size() const

Retrieve the number of template arguments in this template argument list.

const TemplateArgument & get(unsigned Idx) const

Retrieve the template argument at a given index.

Location wrapper for a TemplateArgument.

void print(const PrintingPolicy &Policy, raw_ostream &Out, bool IncludeType) const

Print this template argument to the given output stream.

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

Stores a list of template parameters for a TemplateDecl and its derived classes.

NamedDecl * getParam(unsigned Idx)

static bool shouldIncludeTypeForArgument(const PrintingPolicy &Policy, const TemplateParameterList *TPL, unsigned Idx)

Token - This structure provides full information about a lexed token.

A container of type source information.

The base class of the type hierarchy.

bool isBooleanType() const

bool hasAttr(attr::Kind AK) const

Determine whether this type had the specified attribute applied to it (looking through top-level type...

bool isSignedIntegerType() const

Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char,...

const ArrayType * castAsArrayTypeUnsafe() const

A variant of castAs<> for array type which silently discards qualifiers from the outermost type.

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

CXXRecordDecl * castAsCXXRecordDecl() const

bool isPointerType() const

bool isIntegerType() const

isIntegerType() does not include complex integers (a GCC extension).

const T * castAs() const

Member-template castAs.

bool isSpecificPlaceholderType(unsigned K) const

Test for a specific placeholder type.

bool isReferenceType() const

const CXXRecordDecl * getPointeeCXXRecordDecl() const

If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to.

bool isIntegralType(const ASTContext &Ctx) const

Determine whether this type is an integral type.

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

TagDecl * getAsTagDecl() const

Retrieves the TagDecl that this type refers to, either because the type is a TagType or because it is...

bool isInstantiationDependentType() const

Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...

bool isDependentType() const

Whether this type is a dependent type, meaning that its definition somehow depends on a template para...

RecordDecl * castAsRecordDecl() const

const ArrayType * getAsArrayTypeUnsafe() const

A variant of getAs<> for array types which silently discards qualifiers from the outermost type.

bool isUnsignedIntegerType() const

Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...

bool isAnyPointerType() const

const T * getAs() const

Member-template getAs'.

bool isRecordType() const

QualType getArgumentType() const

child_range children()

Definition Expr.cpp:5126

bool isArgumentType() const

UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, TypeSourceInfo *TInfo, QualType resultType, SourceLocation op, SourceLocation rp)

UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...

SourceLocation getOperatorLoc() const

getOperatorLoc - Return the location of the operator.

Expr * getSubExpr() const

bool hasStoredFPFeatures() const

Is FPFeatures in Trailing Storage?

static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)

Retrieve the overloaded operator kind that corresponds to the given unary opcode.

Definition Expr.cpp:1429

static UnaryOperator * Create(const ASTContext &C, Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow, FPOptionsOverride FPFeatures)

Definition Expr.cpp:5038

static Opcode getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix)

Retrieve the unary opcode that corresponds to the given overloaded operator.

Definition Expr.cpp:1414

void setStoredFPFeatures(FPOptionsOverride F)

Set FPFeatures in trailing storage, used by Serialization & ASTImporter.

UnaryOperator(const ASTContext &Ctx, Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow, FPOptionsOverride FPFeatures)

Definition Expr.cpp:5024

static UnaryOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)

Definition Expr.cpp:5017

static StringRef getOpcodeStr(Opcode Op)

getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...

Definition Expr.cpp:1405

An artificial decl, representing a global anonymous constant value which is uniquified by value withi...

A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

Stmt(StmtClass SC, EmptyShell)

Construct an empty statement.

Represents a variable declaration or definition.

Represents a C array with a specified size that is not an integer-constant-expression.

Represents a GCC generic vector type.

Defines the clang::TargetInfo interface.

const internal::VariadicAllOfMatcher< Type > type

Matches Types in the clang AST.

const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr

Matches expressions.

The JSON file list parser is used to communicate input to InstallAPI.

OverloadedOperatorKind

Enumeration specifying the different kinds of C++ overloaded operators.

@ OO_None

Not an overloaded operator.

ConstantResultStorageKind

Describes the kind of result that can be tail-allocated.

@ Ctor_Base

Base object ctor.

bool isa(CodeGen::Address addr)

LLVM_READONLY bool isPrintable(unsigned char c)

Return true if this character is an ASCII printable character; that is, a character that should take ...

LLVM_READONLY auto escapeCStyle(CharT Ch) -> StringRef

Return C-style escaped string for special characters, or an empty string if there is no such mapping.

Expr * IgnoreExprNodes(Expr *E, FnTys &&... Fns)

Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, Recursively apply each of the f...

RefQualifierKind

The kind of C++11 ref-qualifier associated with a function type.

@ RQ_LValue

An lvalue ref-qualifier was provided (&).

@ RQ_RValue

An rvalue ref-qualifier was provided (&&).

StmtIterator cast_away_const(const ConstStmtIterator &RHS)

ExprObjectKind

A further classification of the kind of object referenced by an l-value or x-value.

@ OK_ObjCProperty

An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...

@ OK_Ordinary

An ordinary object is located at an address in memory.

std::pair< FileID, unsigned > FileIDAndOffset

ExprDependence computeDependence(FullExpr *E)

@ Create

'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...

@ Self

'self' clause, allowed on Compute and Combined Constructs, plus 'update'.

nullptr

This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...

UnaryExprOrTypeTrait

Names for the "expression or type" traits.

Expr * IgnoreImplicitCastsExtraSingleStep(Expr *E)

bool isLambdaCallOperator(const CXXMethodDecl *MD)

@ Result

The result type of a method or function.

const FunctionProtoType * T

Expr * IgnoreImplicitCastsSingleStep(Expr *E)

@ Dtor_Base

Base object dtor.

CastKind

CastKind - The kind of operation required for a conversion.

void FixedPointValueToString(SmallVectorImpl< char > &Str, llvm::APSInt Val, unsigned Scale)

Expr * IgnoreImplicitSingleStep(Expr *E)

ExprValueKind

The categorization of expression values, currently following the C++11 scheme.

@ VK_PRValue

A pr-value expression (in the C++11 taxonomy) produces a temporary value.

@ VK_LValue

An l-value expression is a reference to an object with independent storage.

Expr * IgnoreParensSingleStep(Expr *E)

SmallVector< CXXBaseSpecifier *, 4 > CXXCastPath

A simple array of base specifiers.

Expr * IgnoreImplicitAsWrittenSingleStep(Expr *E)

Expr * IgnoreCastsSingleStep(Expr *E)

bool declaresSameEntity(const Decl *D1, const Decl *D2)

Determine whether two declarations declare the same entity.

U cast(CodeGen::Address addr)

Expr * IgnoreLValueCastsSingleStep(Expr *E)

bool isLambdaMethod(const DeclContext *DC)

ActionResult< Expr * > ExprResult

Expr * IgnoreParensOnlySingleStep(Expr *E)

@ PrettyFunctionNoVirtual

The same as PrettyFunction, except that the 'virtual' keyword is omitted for virtual member functions...

Expr * IgnoreBaseCastsSingleStep(Expr *E)

NonOdrUseReason

The reason why a DeclRefExpr does not constitute an odr-use.

__UINTPTR_TYPE__ uintptr_t

An unsigned integer type with the property that any valid pointer to void can be converted to this ty...

Represents an explicit template argument list in C++, e.g., the "" in "sort".

DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...

SourceLocation getLoc() const

getLoc - Returns the main location of the declaration name.

DeclarationName getName() const

getName - Returns the embedded declaration name.

SourceLocation getEndLoc() const LLVM_READONLY

Stores data related to a single embed directive.

EvalResult is a struct with detailed info about an evaluated expression.

APValue Val

Val - This is the value the expression can be folded to.

Iterator range representation begin:end[:step].

Helper expressions and declaration for OMPIteratorExpr class for each iteration space.

Describes how types, statements, expressions, and declarations should be printed.

unsigned SuppressTagKeyword

Whether type printing should skip printing the tag keyword.

const PrintingCallbacks * Callbacks

Callbacks to use to allow the behavior of printing to be customized.

A placeholder type used to construct an empty shell of a type, that will be filled in later (e....

An adjustment to be made to the temporary created when emitting a reference binding,...