RetroSearch Browse

->InitializingDecl) {

34 Ctx

->InitializingDecl = VD;

43

this->

->InitializingDecl = OldInitializingDecl;

44

this->

->InitStack.pop_back();

58

: Ctx(Ctx), OldDiscardResult(Ctx->DiscardResult),

60

Ctx->DiscardResult = NewDiscardResult;

61

Ctx->Initializing = NewInitializing;

65

Ctx->DiscardResult = OldDiscardResult;

66

Ctx->Initializing = OldInitializing;

73 bool

OldDiscardResult;

77template

class

Emitter>

81 return

Ctx->emitThis(

);

84 return

Ctx->emitGetPtrFieldPop(

);

86 return

Ctx->emitGetPtrLocal(

);

88 return

Ctx->visitDeclRef(

);

90 if

(!Ctx->emitConstUint32(

))

92 return

Ctx->emitArrayElemPtrPopUint32(

);

94 return

Ctx->emitRVOPtr(

);

98

llvm_unreachable(

"Unhandled InitLink kind"

);

122

OldContinueLabel(

->ContinueLabel),

123

OldBreakVarScope(

->BreakVarScope),

124

OldContinueVarScope(

->ContinueVarScope) {

132

this->

->BreakLabel = OldBreakLabel;

133

this->

->ContinueLabel = OldContinueLabel;

134

this->

->ContinueVarScope = OldContinueVarScope;

135

this->

->BreakVarScope = OldBreakVarScope;

155

OldDefaultLabel(this->

->DefaultLabel),

156

OldCaseLabels(

std

::move(this->

->CaseLabels)),

157

OldLabelVarScope(

->BreakVarScope) {

160

this->Ctx->

CaseLabels

= std::move(CaseLabels);

165

this->

->BreakLabel = OldBreakLabel;

166

this->

->DefaultLabel = OldDefaultLabel;

167

this->

->CaseLabels = std::move(OldCaseLabels);

168

this->

->BreakVarScope = OldLabelVarScope;

181

Ctx->InStmtExpr =

true

;

194template

class

Emitter>

199 case

CK_LValueToRValue: {

201 return

this->discard(SubExpr);

203

std::optional<PrimType> SubExprT = classify(SubExpr->

());

206

std::optional<unsigned> LocalIndex = allocateLocal(SubExpr);

209 if

(!this->emitGetPtrLocal(*LocalIndex, CE))

213 if

(!this->visit(SubExpr))

217 return

this->emitLoadPop(*SubExprT, CE);

222 return

this->emitMemcpy(CE);

225 case

CK_DerivedToBaseMemberPointer: {

231 unsigned

DerivedOffset = collectBaseOffset(

QualType

(ToMP->

getClass

(), 0),

234 if

(!this->delegate(SubExpr))

237 return

this->emitGetMemberPtrBasePop(DerivedOffset, CE);

240 case

CK_BaseToDerivedMemberPointer: {

246 unsigned

DerivedOffset = collectBaseOffset(

QualType

(FromMP->getClass(), 0),

249 if

(!this->delegate(SubExpr))

251 return

this->emitGetMemberPtrBasePop(-DerivedOffset, CE);

254 case

CK_UncheckedDerivedToBase:

255 case

CK_DerivedToBase: {

257 return

this->discard(SubExpr);

259 if

(!this->delegate(SubExpr))

263 if

(

const auto

*PT = dyn_cast<PointerType>(Ty))

264 return

PT->getPointeeType()->getAsCXXRecordDecl();

265 return

Ty->getAsCXXRecordDecl();

272 if

(B->isVirtual()) {

273 if

(!this->emitGetPtrVirtBasePop(extractRecordDecl(B->getType()), CE))

275

CurType = B->getType();

277 unsigned

DerivedOffset = collectBaseOffset(B->getType(), CurType);

278 if

(!this->emitGetPtrBasePop(DerivedOffset, CE))

280

CurType = B->getType();

287 case

CK_BaseToDerived: {

289 return

this->discard(SubExpr);

291 if

(!this->delegate(SubExpr))

294 unsigned

DerivedOffset =

297 return

this->emitGetPtrDerivedPop(DerivedOffset, CE);

300 case

CK_FloatingCast: {

306 return

this->discard(SubExpr);

307 if

(!this->visit(SubExpr))

309 const auto

*TargetSemantics = &Ctx.getFloatSemantics(CE->

());

313 case

CK_IntegralToFloating: {

315 return

this->discard(SubExpr);

316

std::optional<PrimType> FromT = classify(SubExpr->

());

320 if

(!this->visit(SubExpr))

323 const auto

*TargetSemantics = &Ctx.getFloatSemantics(CE->

());

324 return

this->emitCastIntegralFloating(*FromT, TargetSemantics,

325

getFPOptions(CE), CE);

328 case

CK_FloatingToBoolean:

329 case

CK_FloatingToIntegral: {

331 return

this->discard(SubExpr);

333

std::optional<PrimType> ToT = classify(CE->

());

338 if

(!this->visit(SubExpr))

342 return

this->emitCastFloatingIntegralAP(Ctx.getBitWidth(CE->

()),

343

getFPOptions(CE), CE);

345 return

this->emitCastFloatingIntegralAPS(Ctx.getBitWidth(CE->

()),

346

getFPOptions(CE), CE);

348 return

this->emitCastFloatingIntegral(*ToT, getFPOptions(CE), CE);

351 case

CK_NullToPointer:

352 case

CK_NullToMemberPointer: {

353 if

(!this->discard(SubExpr))

360 if

(!PointeeType.

isNull

()) {

361 if

(std::optional<PrimType>

= classify(PointeeType))

362

Desc =

.createDescriptor(SubExpr, *

);

364

Desc =

.createDescriptor(SubExpr, PointeeType.

getTypePtr

(),

365

std::nullopt,

true

false

370 return

this->emitNull(classifyPrim(CE->

()), Val, Desc, CE);

373 case

CK_PointerToIntegral: {

375 return

this->discard(SubExpr);

377 if

(!this->visit(SubExpr))

383 if

(!this->emitDecayPtr(FromT,

, CE))

389 return

this->emitCastPointerIntegralAP(Ctx.getBitWidth(CE->

()),

392 return

this->emitCastPointerIntegralAPS(Ctx.getBitWidth(CE->

()),

394 return

this->emitCastPointerIntegral(

, CE);

397 case

CK_ArrayToPointerDecay: {

398 if

(!this->visit(SubExpr))

400 if

(!this->emitArrayDecay(CE))

403 return

this->emitPopPtr(CE);

407 case

CK_IntegralToPointer: {

410 if

(!this->visit(SubExpr))

416 return

this->emitPop(

, CE);

421

Desc =

.createDescriptor(SubExpr, *

);

429 if

(!this->emitGetIntPtr(

, Desc, CE))

432 PrimType

DestPtrT = classifyPrim(PtrType);

437 return

this->emitDecayPtr(

, DestPtrT, CE);

440 case

CK_AtomicToNonAtomic:

441 case

CK_ConstructorConversion:

442 case

CK_FunctionToPointerDecay:

443 case

CK_NonAtomicToAtomic:

445 case

CK_UserDefinedConversion:

446 case

CK_AddressSpaceConversion:

447 case

CK_CPointerToObjCPointerCast:

448 return

this->delegate(SubExpr);

453 if

(!this->discard(SubExpr))

455 return

this->emitInvalidCast(CastKind::Reinterpret,

true

, CE);

459 return

this->discard(SubExpr);

462

std::optional<PrimType> FromT = classify(SubExprTy);

465 return

this->emitBuiltinBitCast(CE);

467

std::optional<PrimType> ToT = classify(CE->

());

475 return

this->delegate(SubExpr);

477 if

(!this->visit(SubExpr))

484 if

(!this->visit(SubExpr))

486 return

this->emitDecayPtr(*FromT, *ToT, CE);

489 case

CK_LValueToRValueBitCast:

490 return

this->emitBuiltinBitCast(CE);

492 case

CK_IntegralToBoolean:

493 case

CK_FixedPointToBoolean:

494 case

CK_BooleanToSignedIntegral:

495 case

CK_IntegralCast: {

497 return

this->discard(SubExpr);

498

std::optional<PrimType> FromT = classify(SubExpr->

());

499

std::optional<PrimType> ToT = classify(CE->

());

504 if

(!this->visit(SubExpr))

512 if

(!this->emitCheckEnumValue(*FromT, ET->getDecl(), CE))

517 auto

maybeNegate = [&]() ->

bool

{

518 if

(CE->

getCastKind

() == CK_BooleanToSignedIntegral)

519 return

this->emitNeg(*ToT, CE);

524 return

this->emitCastAP(*FromT, Ctx.getBitWidth(CE->

()), CE) &&

527 return

this->emitCastAPS(*FromT, Ctx.getBitWidth(CE->

()), CE) &&

532 if

(!this->emitCast(*FromT, *ToT, CE))

535 return

maybeNegate();

538 case

CK_PointerToBoolean:

539 case

CK_MemberPointerToBoolean: {

542 if

(!this->visit(SubExpr))

544 return

this->emitIsNonNull(PtrT, CE);

547 case

CK_IntegralComplexToBoolean:

548 case

CK_FloatingComplexToBoolean: {

550 return

this->discard(SubExpr);

551 if

(!this->visit(SubExpr))

553 return

this->emitComplexBoolCast(SubExpr);

556 case

CK_IntegralComplexToReal:

557 case

CK_FloatingComplexToReal:

558 return

this->emitComplexReal(SubExpr);

560 case

CK_IntegralRealToComplex:

561 case

CK_FloatingRealToComplex: {

565

std::optional<unsigned> LocalIndex = allocateTemporary(CE);

568 if

(!this->emitGetPtrLocal(*LocalIndex, CE))

573 if

(!this->visitArrayElemInit(0, SubExpr))

577 if

(!this->visitZeroInitializer(

, SubExpr->

(), SubExpr))

579 return

this->emitInitElem(

, 1, SubExpr);

582 case

CK_IntegralComplexCast:

583 case

CK_FloatingComplexCast:

584 case

CK_IntegralComplexToFloatingComplex:

585 case

CK_FloatingComplexToIntegralComplex: {

589 return

this->discard(SubExpr);

592

std::optional<unsigned> LocalIndex = allocateLocal(CE);

595 if

(!this->emitGetPtrLocal(*LocalIndex, CE))

602 unsigned

SubExprOffset = allocateLocalPrimitive(

603

SubExpr,

true

false

);

604 if

(!this->visit(SubExpr))

606 if

(!this->emitSetLocal(

, SubExprOffset, CE))

609 PrimType

SourceElemT = classifyComplexElementType(SubExpr->

());

612 PrimType

DestElemT = classifyPrim(DestElemType);

614 for

(

unsigned

I = 0; I != 2; ++I) {

615 if

(!this->emitGetLocal(

, SubExprOffset, CE))

617 if

(!this->emitArrayElemPop(SourceElemT, I, CE))

621 if

(!this->emitPrimCast(SourceElemT, DestElemT, DestElemType, CE))

625 if

(!this->emitInitElem(DestElemT, I, CE))

631 case

CK_VectorSplat: {

632

assert(!classify(CE->

()));

633

assert(classify(SubExpr->

()));

637 return

this->discard(SubExpr);

640

std::optional<unsigned> LocalIndex = allocateLocal(CE);

643 if

(!this->emitGetPtrLocal(*LocalIndex, CE))

649 unsigned

ElemOffset = allocateLocalPrimitive(

650

SubExpr, ElemT,

true

false

);

653 if

(!this->visit(SubExpr))

655 if

(classifyPrim(SubExpr) ==

&& !this->emitLoadPop(ElemT, CE))

658 if

(!this->emitSetLocal(ElemT, ElemOffset, CE))

661 for

(

unsigned

I = 0; I != VT->getNumElements(); ++I) {

662 if

(!this->emitGetLocal(ElemT, ElemOffset, CE))

664 if

(!this->emitInitElem(ElemT, I, CE))

671 case

CK_HLSLVectorTruncation: {

673 if

(std::optional<PrimType> ResultT = classify(CE)) {

674

assert(!DiscardResult);

676 if

(!this->visit(SubExpr))

678 return

this->emitArrayElemPop(*ResultT, 0, CE);

684

std::optional<unsigned> LocalIndex = allocateTemporary(CE);

687 if

(!this->emitGetPtrLocal(*LocalIndex, CE))

692 if

(!this->visit(SubExpr))

694 return

this->emitCopyArray(classifyVectorElementType(CE->

()), 0, 0,

698 case

CK_IntegralToFixedPoint: {

699 if

(!this->visit(SubExpr))

704 return

this->emitCastIntegralFixedPoint(classifyPrim(SubExpr->

()),

707 case

CK_FloatingToFixedPoint: {

708 if

(!this->visit(SubExpr))

713 return

this->emitCastFloatingFixedPoint(Sem, CE);

715 case

CK_FixedPointToFloating: {

716 if

(!this->visit(SubExpr))

718 const auto

*TargetSemantics = &Ctx.getFloatSemantics(CE->

());

719 return

this->emitCastFixedPointFloating(TargetSemantics, CE);

721 case

CK_FixedPointToIntegral: {

722 if

(!this->visit(SubExpr))

724 return

this->emitCastFixedPointIntegral(classifyPrim(CE->

()), CE);

726 case

CK_FixedPointCast: {

727 if

(!this->visit(SubExpr))

731 return

this->emitCastFixedPoint(Sem, CE);

735 return

discard(SubExpr);

738 return

this->emitInvalid(CE);

740

llvm_unreachable(

"Unhandled clang::CastKind enum"

);

743template

class

Emitter>

748 return

this->emitConst(

->getValue(),

);

751template

class

Emitter>

756 return

this->emitConstFloat(

->getValue(),

);

759template

class

Emitter>

766

std::optional<unsigned> LocalIndex = allocateTemporary(

);

769 if

(!this->emitGetPtrLocal(*LocalIndex,

))

773 const Expr

*SubExpr =

->getSubExpr();

776 if

(!this->visitZeroInitializer(SubExprT, SubExpr->

(), SubExpr))

778 if

(!this->emitInitElem(SubExprT, 0, SubExpr))

780 return

this->visitArrayElemInit(1, SubExpr);

783template

class

Emitter>

796template

class

Emitter>

798 return

this->delegate(

->getSubExpr());

801template

class

Emitter>

805 return

this->VisitLogicalBinOp(BO);

813 if

(!this->discard(LHS))

816 return

this->discard(RHS);

818 return

this->delegate(RHS);

822 return

this->VisitComplexBinOp(BO);

824 return

this->VisitVectorBinOp(BO);

828 return

this->emitComplexComparison(LHS, RHS, BO);

830 return

this->VisitFixedPointBinOp(BO);

833 if

(!this->visit(LHS))

836 if

(!this->visit(RHS))

839 if

(!this->emitToMemberPtr(BO))

845 if

(!this->emitCastMemberPtrPtr(BO))

847 return

DiscardResult ? this->emitPopPtr(BO) :

true

;

851

std::optional<PrimType>

= classify(LHS);

852

std::optional<PrimType> RT = classify(RHS);

853

std::optional<PrimType>

= classify(BO->

());

867

std::optional<unsigned> ResultIndex = this->allocateLocal(BO);

868 if

(!this->emitGetPtrLocal(*ResultIndex, BO))

872 if

(!visit(LHS) || !visit(RHS))

875 return

this->emitCMP3(*

, CmpInfo, BO);

878 if

|| !RT || !

)

884 return

this->VisitPointerArithBinOp(BO);

889 if

(!visit(RHS) || !visit(LHS))

891 if

(!this->emitFlip(*

, *RT, BO))

894 if

(!visit(LHS) || !visit(RHS))

900 auto

MaybeCastToBool = [

this

, BO](

bool

Result) {

904 return

this->emitPop(*

, BO);

906 return

this->emitCast(

, *

, BO);

910 auto

Discard = [

this

, BO](

bool

Result) {

913 return

DiscardResult ? this->emitPop(*

, BO) :

true

;

918 return

MaybeCastToBool(this->emitEQ(*

, BO));

920 return

MaybeCastToBool(this->emitNE(*

, BO));

922 return

MaybeCastToBool(this->emitLT(*

, BO));

924 return

MaybeCastToBool(this->emitLE(*

, BO));

926 return

MaybeCastToBool(this->emitGT(*

, BO));

928 return

MaybeCastToBool(this->emitGE(*

, BO));

931 return

Discard(this->emitSubf(getFPOptions(BO), BO));

932 return

Discard(this->emitSub(*

, BO));

935 return

Discard(this->emitAddf(getFPOptions(BO), BO));

936 return

Discard(this->emitAdd(*

, BO));

939 return

Discard(this->emitMulf(getFPOptions(BO), BO));

940 return

Discard(this->emitMul(*

, BO));

942 return

Discard(this->emitRem(*

, BO));

945 return

Discard(this->emitDivf(getFPOptions(BO), BO));

946 return

Discard(this->emitDiv(*

, BO));

950

: this->emitStorePop(*

, BO);

952 if

(!this->emitStoreBitField(*

, BO))

955 if

(!this->emitStore(*

, BO))

961 return

this->emitLoadPop(*

, BO);

964 return

Discard(this->emitBitAnd(*

, BO));

966 return

Discard(this->emitBitOr(*

, BO));

968 return

Discard(this->emitShl(*

, *RT, BO));

970 return

Discard(this->emitShr(*

, *RT, BO));

972 return

Discard(this->emitBitXor(*

, BO));

975

llvm_unreachable(

"Already handled earlier"

);

980

llvm_unreachable(

"Unhandled binary op"

);

985template

class

Emitter>

988 const Expr

*LHS =

->getLHS();

989 const Expr

*RHS =

->getRHS();

991 if

((Op != BO_Add && Op != BO_Sub) ||

995

std::optional<PrimType>

= classify(LHS);

996

std::optional<PrimType> RT = classify(RHS);

1002 auto

visitAsPointer = [&](

const Expr

PrimType T

) ->

bool

{

1003 if

(!this->visit(

))

1006 return

this->emitDecayPtr(

);

1015 if

(!visitAsPointer(RHS, *RT) || !visitAsPointer(LHS, *

))

1019 if

(!this->emitSubPtr(IntT,

))

1021 return

DiscardResult ? this->emitPop(IntT,

) :

true

;

1026 if

(!visitAsPointer(RHS, *RT))

1028 if

(!this->visit(LHS))

1032 if

(!visitAsPointer(LHS, *

))

1034 if

(!this->visit(RHS))

1044 if

(!this->emitAddOffset(OffsetType,

))

1047 if

(classifyPrim(

) !=

)

1048 return

this->emitDecayPtr(

, classifyPrim(

);

1050

}

else if

(Op == BO_Sub) {

1051 if

(!this->emitSubOffset(OffsetType,

))

1054 if

(classifyPrim(

) !=

)

1055 return

this->emitDecayPtr(

, classifyPrim(

);

1062template

class

Emitter>

1064

assert(

->isLogicalOp());

1066 const Expr

*LHS =

->getLHS();

1067 const Expr

*RHS =

->getRHS();

1068

std::optional<PrimType>

= classify(

());

1072 LabelTy

LabelTrue = this->getLabel();

1073 LabelTy

LabelEnd = this->getLabel();

1075 if

(!this->visitBool(LHS))

1077 if

(!this->jumpTrue(LabelTrue))

1080 if

(!this->visitBool(RHS))

1082 if

(!this->jump(LabelEnd))

1085

this->emitLabel(LabelTrue);

1086

this->emitConstBool(

true

);

1087

this->fallthrough(LabelEnd);

1088

this->emitLabel(LabelEnd);

1091

assert(Op == BO_LAnd);

1094 LabelTy

LabelFalse = this->getLabel();

1095 LabelTy

LabelEnd = this->getLabel();

1097 if

(!this->visitBool(LHS))

1099 if

(!this->jumpFalse(LabelFalse))

1102 if

(!this->visitBool(RHS))

1104 if

(!this->jump(LabelEnd))

1107

this->emitLabel(LabelFalse);

1108

this->emitConstBool(

false

);

1109

this->fallthrough(LabelEnd);

1110

this->emitLabel(LabelEnd);

1114 return

this->emitPopBool(

);

1119 return

this->emitCast(

, *

);

1123template

class

Emitter>

1127

std::optional<unsigned> LocalIndex = allocateTemporary(

);

1130 if

(!this->emitGetPtrLocal(*LocalIndex,

))

1136 const Expr

*LHS =

->getLHS();

1137 const Expr

*RHS =

->getRHS();

1140 unsigned

ResultOffset = ~0u;

1142

ResultOffset = this->allocateLocalPrimitive(

true

false

);

1145 if

(!this->DiscardResult) {

1146 if

(!this->emitDupPtr(

))

1148 if

(!this->emitSetLocal(

, ResultOffset,

))

1153

LHSType = AT->getValueType();

1156

RHSType = AT->getValueType();

1165 if

(Op == BO_Mul && LHSIsComplex && RHSIsComplex) {

1170 if

(!this->visit(LHS))

1172 if

(!this->visit(RHS))

1174 return

this->emitMulc(ElemT,

);

1177 if

(Op == BO_Div && RHSIsComplex) {

1179 PrimType

ElemT = classifyPrim(ElemQT);

1184 if

(!LHSIsComplex) {

1186

std::optional<unsigned> LocalIndex = allocateTemporary(RHS);

1189

LHSOffset = *LocalIndex;

1191 if

(!this->emitGetPtrLocal(LHSOffset,

))

1194 if

(!this->visit(LHS))

1197 if

(!this->emitInitElem(ElemT, 0,

))

1200 if

(!this->visitZeroInitializer(ElemT, ElemQT,

))

1202 if

(!this->emitInitElem(ElemT, 1,

))

1205 if

(!this->visit(LHS))

1209 if

(!this->visit(RHS))

1211 return

this->emitDivc(ElemT,

);

1216

LHSOffset = this->allocateLocalPrimitive(LHS,

true

false

);

1217 if

(!this->visit(LHS))

1219 if

(!this->emitSetLocal(

, LHSOffset,

))

1222 PrimType

LHST = classifyPrim(LHSType);

1223

LHSOffset = this->allocateLocalPrimitive(LHS, LHST,

true

false

);

1224 if

(!this->visit(LHS))

1226 if

(!this->emitSetLocal(LHST, LHSOffset,

))

1233

RHSOffset = this->allocateLocalPrimitive(RHS,

true

false

);

1234 if

(!this->visit(RHS))

1236 if

(!this->emitSetLocal(

, RHSOffset,

))

1239 PrimType

RHST = classifyPrim(RHSType);

1240

RHSOffset = this->allocateLocalPrimitive(RHS, RHST,

true

false

);

1241 if

(!this->visit(RHS))

1243 if

(!this->emitSetLocal(RHST, RHSOffset,

))

1250 auto

loadComplexValue = [

this

](

bool

IsComplex,

bool

LoadZero,

1251 unsigned

ElemIndex,

unsigned

Offset,

1252 const Expr

) ->

bool

{

1254 if

(!this->emitGetLocal(

, Offset,

))

1256 return

this->emitArrayElemPop(classifyComplexElementType(

()),

1259 if

(ElemIndex == 0 || !LoadZero)

1260 return

this->emitGetLocal(classifyPrim(

()), Offset,

);

1261 return

this->visitZeroInitializer(classifyPrim(

()),

(),

1266 for

(

unsigned

ElemIndex = 0; ElemIndex != 2; ++ElemIndex) {

1268 if

(!this->DiscardResult) {

1269 if

(!this->emitGetLocal(

, ResultOffset,

))

1276 if

(!loadComplexValue(LHSIsComplex,

true

, ElemIndex, LHSOffset, LHS))

1279 if

(!loadComplexValue(RHSIsComplex,

true

, ElemIndex, RHSOffset, RHS))

1282 if

(!this->emitAddf(getFPOptions(

))

1285 if

(!this->emitAdd(ResultElemT,

))

1290 if

(!loadComplexValue(LHSIsComplex,

true

, ElemIndex, LHSOffset, LHS))

1293 if

(!loadComplexValue(RHSIsComplex,

true

, ElemIndex, RHSOffset, RHS))

1296 if

(!this->emitSubf(getFPOptions(

))

1299 if

(!this->emitSub(ResultElemT,

))

1304 if

(!loadComplexValue(LHSIsComplex,

false

, ElemIndex, LHSOffset, LHS))

1307 if

(!loadComplexValue(RHSIsComplex,

false

, ElemIndex, RHSOffset, RHS))

1311 if

(!this->emitMulf(getFPOptions(

))

1314 if

(!this->emitMul(ResultElemT,

))

1319

assert(!RHSIsComplex);

1320 if

(!loadComplexValue(LHSIsComplex,

false

, ElemIndex, LHSOffset, LHS))

1323 if

(!loadComplexValue(RHSIsComplex,

false

, ElemIndex, RHSOffset, RHS))

1327 if

(!this->emitDivf(getFPOptions(

))

1330 if

(!this->emitDiv(ResultElemT,

))

1339 if

(!this->DiscardResult) {

1341 if

(!this->emitInitElemPop(ResultElemT, ElemIndex,

))

1344 if

(!this->emitPop(ResultElemT,

))

1351template

class

Emitter>

1353

assert(!

->isCommaOp() &&

1354 "Comma op should be handled in VisitBinaryOperator"

);

1361

std::optional<unsigned> LocalIndex = allocateTemporary(

);

1364 if

(!this->emitGetPtrLocal(*LocalIndex,

))

1368 const Expr

*LHS =

->getLHS();

1369 const Expr

*RHS =

->getRHS();

1371 auto

Op =

->isCompoundAssignmentOp()

1376 PrimType

RHSElemT = this->classifyVectorElementType(RHS->

());

1380 unsigned

LHSOffset = this->allocateLocalPrimitive(LHS,

true

false

);

1381 if

(!this->visit(LHS))

1383 if

(!this->emitSetLocal(

, LHSOffset,

))

1387 unsigned

RHSOffset = this->allocateLocalPrimitive(RHS,

true

false

);

1388 if

(!this->visit(RHS))

1390 if

(!this->emitSetLocal(

, RHSOffset,

))

1393 if

(

->isCompoundAssignmentOp() && !this->emitGetLocal(

, LHSOffset,

))

1398 bool

NeedIntPromot = ElemT ==

&& (

->isBitwiseOp() ||

->isShiftOp());

1401 PrimType

PromotT = classifyPrim(PromotTy);

1402 PrimType

OpT = NeedIntPromot ? PromotT : ElemT;

1404 auto

getElem = [=](

unsigned

Offset,

PrimType

ElemT,

unsigned

Index) {

1405 if

(!this->emitGetLocal(

, Offset,

))

1407 if

(!this->emitArrayElemPop(ElemT, Index,

))

1409 if

(

->isLogicalOp()) {

1410 if

(!this->emitPrimCast(ElemT,

, Ctx.getASTContext().

BoolTy

))

1412 if

(!this->emitPrimCast(

, ResultElemT, VecTy->getElementType(),

))

1414

}

else if

(NeedIntPromot) {

1415 if

(!this->emitPrimCast(ElemT, PromotT, PromotTy,

))

1421#define EMIT_ARITH_OP(OP) \ 1423 if (ElemT == PT_Float) { \ 1424 if (!this->emit##OP##f(getFPOptions(E), E)) \ 1427 if (!this->emit##OP(ElemT, E)) \ 1433 for

(

unsigned

I = 0; I != VecTy->getNumElements(); ++I) {

1434 if

(!getElem(LHSOffset, ElemT, I))

1436 if

(!getElem(RHSOffset, RHSElemT, I))

1448 if

(!this->emitRem(ElemT,

))

1452 if

(!this->emitBitAnd(OpT,

))

1456 if

(!this->emitBitOr(OpT,

))

1460 if

(!this->emitBitXor(OpT,

))

1464 if

(!this->emitShl(OpT, RHSElemT,

))

1468 if

(!this->emitShr(OpT, RHSElemT,

))

1472 if

(!this->emitEQ(ElemT,

))

1476 if

(!this->emitNE(ElemT,

))

1480 if

(!this->emitLE(ElemT,

))

1484 if

(!this->emitLT(ElemT,

))

1488 if

(!this->emitGE(ElemT,

))

1492 if

(!this->emitGT(ElemT,

))

1497 if

(!this->emitBitAnd(ResultElemT,

))

1502 if

(!this->emitBitOr(ResultElemT,

))

1506 return

this->emitInvalid(

);

1514 if

(

->isComparisonOp()) {

1515 if

(!this->emitPrimCast(

, ResultElemT, VecTy->getElementType(),

))

1517 if

(!this->emitNeg(ResultElemT,

))

1523 if

(NeedIntPromot &&

1524

!this->emitPrimCast(PromotT, ResultElemT, VecTy->getElementType(),

))

1528 if

(!this->emitInitElem(ResultElemT, I,

))

1532 if

(DiscardResult &&

->isCompoundAssignmentOp() && !this->emitPopPtr(

))

1537template

class

Emitter>

1539 const Expr

*LHS =

->getLHS();

1540 const Expr

*RHS =

->getRHS();

1541 const ASTContext

&ASTCtx = Ctx.getASTContext();

1547 auto

LHSSemaInt = LHSSema.toOpaqueInt();

1549 auto

RHSSemaInt = RHSSema.toOpaqueInt();

1551 if

(!this->visit(LHS))

1554 if

(!this->emitCastIntegralFixedPoint(classifyPrim(LHS->

()),

1559 if

(!this->visit(RHS))

1562 if

(!this->emitCastIntegralFixedPoint(classifyPrim(RHS->

()),

1568 auto

ConvertResult = [&](

bool

R) ->

bool

{

1572 auto

CommonSema = LHSSema.getCommonSemantics(RHSSema).toOpaqueInt();

1573 if

(ResultSema != CommonSema)

1574 return

this->emitCastFixedPoint(ResultSema,

);

1578 auto

MaybeCastToBool = [&](

bool

Result) {

1583 return

this->emitPop(

);

1585 return

this->emitCast(

);

1589 switch

(

->getOpcode()) {

1591 return

MaybeCastToBool(this->emitEQFixedPoint(

));

1593 return

MaybeCastToBool(this->emitNEFixedPoint(

));

1595 return

MaybeCastToBool(this->emitLTFixedPoint(

));

1597 return

MaybeCastToBool(this->emitLEFixedPoint(

));

1599 return

MaybeCastToBool(this->emitGTFixedPoint(

));

1601 return

MaybeCastToBool(this->emitGEFixedPoint(

));

1603 return

ConvertResult(this->emitAddFixedPoint(

));

1605 return

ConvertResult(this->emitSubFixedPoint(

));

1607 return

ConvertResult(this->emitMulFixedPoint(

));

1609 return

ConvertResult(this->emitDivFixedPoint(

));

1611 return

ConvertResult(this->emitShiftFixedPoint(

true

));

1613 return

ConvertResult(this->emitShiftFixedPoint(

false

));

1616 return

this->emitInvalid(

);

1619

llvm_unreachable(

"unhandled binop opcode"

);

1622template

class

Emitter>

1624 const Expr

*SubExpr =

->getSubExpr();

1627 switch

(

->getOpcode()) {

1629 return

this->delegate(SubExpr);

1631 if

(!this->visit(SubExpr))

1633 return

this->emitNegFixedPoint(

);

1638

llvm_unreachable(

"Unhandled unary opcode"

);

1641template

class

Emitter>

1646 if

(std::optional<PrimType>

= classify(QT))

1647 return

this->visitZeroInitializer(*

, QT,

);

1655 if

(

const auto

*CXXRD = dyn_cast<CXXRecordDecl>(RD);

1656

CXXRD && CXXRD->getNumVBases() > 0) {

1661 const Record

*R = getRecord(QT);

1666 return

this->visitZeroRecordInitializer(R,

);

1673 return

this->visitZeroArrayInitializer(QT,

);

1677 QualType

ElemQT = ComplexTy->getElementType();

1678 PrimType

ElemT = classifyPrim(ElemQT);

1679 for

(

unsigned

I = 0; I < 2; ++I) {

1680 if

(!this->visitZeroInitializer(ElemT, ElemQT,

))

1682 if

(!this->emitInitElem(ElemT, I,

))

1689 unsigned

NumVecElements = VecT->getNumElements();

1690 QualType

ElemQT = VecT->getElementType();

1691 PrimType

ElemT = classifyPrim(ElemQT);

1693 for

(

unsigned

I = 0; I < NumVecElements; ++I) {

1694 if

(!this->visitZeroInitializer(ElemT, ElemQT,

))

1696 if

(!this->emitInitElem(ElemT, I,

))

1705template

class

Emitter>

1707 const Expr

*LHS =

->getLHS();

1708 const Expr

*RHS =

->getRHS();

1709 const Expr

*Index =

->getIdx();

1712 return

this->discard(LHS) && this->discard(RHS);

1717 for

(

const Expr

*SubExpr : {LHS, RHS}) {

1718 if

(!this->visit(SubExpr))

1725 PrimType

IndexT = classifyPrim(Index->getType());

1728 if

(!this->emitFlip(

, IndexT,

))

1732 return

this->emitArrayElemPtrPop(IndexT,

);

1735template

class

Emitter>

1737 const Expr

*ArrayFiller,

const Expr

) {

1742

QT = AT->getValueType();

1745 if

(Inits.size() == 0)

1747 return

this->emitInvalid(

);

1751 if

(DiscardResult) {

1753 if

(!this->discard(

))

1760 if

(std::optional<PrimType>

= classify(QT)) {

1761

assert(!DiscardResult);

1762 if

(Inits.size() == 0)

1763 return

this->visitZeroInitializer(*

, QT,

);

1764

assert(Inits.size() == 1);

1765 return

this->delegate(Inits[0]);

1769 const Record

*R = getRecord(QT);

1771 if

(Inits.size() == 1 &&

() == Inits[0]->getType())

1772 return

this->delegate(Inits[0]);

1774 auto

initPrimitiveField = [=](

const

Record::Field *FieldToInit,

1778 if

(!this->visit(

))

1781 if

(FieldToInit->isBitField())

1782 return

this->emitInitBitField(

, FieldToInit,

);

1783 return

this->emitInitField(

, FieldToInit->Offset,

);

1786 auto

initCompositeField = [=](

const

Record::Field *FieldToInit,

1793 if

(!this->emitGetPtrField(FieldToInit->Offset,

))

1795 if

(!this->visitInitializer(

))

1797 return

this->emitPopPtr(

);

1801 if

(Inits.size() == 0) {

1802 if

(!this->visitZeroRecordInitializer(R,

))

1807 if

(

const auto

*ILE = dyn_cast<InitListExpr>(

))

1808

FToInit = ILE->getInitializedFieldInUnion();

1810

FToInit = cast<CXXParenListInitExpr>(

)->getInitializedFieldInUnion();

1812 const

Record::Field *FieldToInit = R->

(FToInit);

1813 if

(std::optional<PrimType>

= classify(

)) {

1814 if

(!initPrimitiveField(FieldToInit,

, *

))

1817 if

(!initCompositeField(FieldToInit,

))

1821 return

this->emitFinishInit(

);

1825 unsigned

InitIndex = 0;

1828 while

(InitIndex < R->getNumFields() &&

1832 if

(std::optional<PrimType>

= classify(

)) {

1833 const

Record::Field *FieldToInit = R->

(InitIndex);

1834 if

(!initPrimitiveField(FieldToInit,

, *

))

1839 if

(

const

Record::Base *B = R->

getBase

(

->getType())) {

1840 if

(!this->emitGetPtrBase(B->Offset,

))

1843 if

(!this->visitInitializer(

))

1846 if

(!this->emitFinishInitPop(

))

1851 const

Record::Field *FieldToInit = R->

(InitIndex);

1852 if

(!initCompositeField(FieldToInit,

))

1858 return

this->emitFinishInit(

);

1862 if

(Inits.size() == 1 && QT == Inits[0]->getType())

1863 return

this->delegate(Inits[0]);

1865 unsigned

ElementIndex = 0;

1867 if

(

const auto

*EmbedS =

1868

dyn_cast<EmbedExpr>(

->IgnoreParenImpCasts())) {

1871 auto

Eval = [&](

const Expr

unsigned

ElemIndex) {

1873 if

(!this->visit(

))

1875 if

(InitT != TargetT) {

1876 if

(!this->emitCast(InitT, TargetT,

))

1879 return

this->emitInitElem(TargetT, ElemIndex,

);

1881 if

(!EmbedS->doForEachDataElement(Eval, ElementIndex))

1884 if

(!this->visitArrayElemInit(ElementIndex,

))

1897 for

(; ElementIndex != NumElems; ++ElementIndex) {

1898 if

(!this->visitArrayElemInit(ElementIndex, ArrayFiller))

1903 return

this->emitFinishInit(

);

1907 unsigned

NumInits = Inits.size();

1910 return

this->delegate(Inits[0]);

1912 QualType

ElemQT = ComplexTy->getElementType();

1913 PrimType

ElemT = classifyPrim(ElemQT);

1914 if

(NumInits == 0) {

1916 for

(

unsigned

I = 0; I < 2; ++I) {

1917 if

(!this->visitZeroInitializer(ElemT, ElemQT,

))

1919 if

(!this->emitInitElem(ElemT, I,

))

1922

}

else if

(NumInits == 2) {

1923 unsigned

InitIndex = 0;

1925 if

(!this->visit(

))

1928 if

(!this->emitInitElem(ElemT, InitIndex,

))

1937 unsigned

NumVecElements = VecT->getNumElements();

1938

assert(NumVecElements >= Inits.size());

1940 QualType

ElemQT = VecT->getElementType();

1941 PrimType

ElemT = classifyPrim(ElemQT);

1944 unsigned

InitIndex = 0;

1946 if

(!this->visit(

))

1951 if

(

const auto

*InitVecT =

->getType()->getAs<

VectorType

>()) {

1952 if

(!this->emitCopyArray(ElemT, 0, InitIndex,

1953

InitVecT->getNumElements(),

))

1955

InitIndex += InitVecT->getNumElements();

1957 if

(!this->emitInitElem(ElemT, InitIndex,

))

1963

assert(InitIndex <= NumVecElements);

1966 for

(; InitIndex != NumVecElements; ++InitIndex) {

1967 if

(!this->visitZeroInitializer(ElemT, ElemQT,

))

1969 if

(!this->emitInitElem(ElemT, InitIndex,

))

1980template

class

Emitter>

1983 if

(std::optional<PrimType>

= classify(

->getType())) {

1985 if

(!this->visit(

))

1987 return

this->emitInitElem(*

, ElemIndex,

);

1993 if

(!this->emitConstUint32(ElemIndex,

))

1995 if

(!this->emitArrayElemPtrUint32(

))

1997 if

(!this->visitInitializer(

))

1999 return

this->emitFinishInitPop(

);

2002template

class

Emitter>

2004 return

this->visitInitList(

->inits(),

->getArrayFiller(),

);

2007template

class

Emitter>

2010 return

this->visitInitList(

->getInitExprs(),

->getArrayFiller(),

);

2013template

class

Emitter>

2016 return

this->delegate(

->getReplacement());

2019template

class

Emitter>

2021

std::optional<PrimType>

= classify(

());

2022 if

(

->hasAPValueResult()) {

2029 if

(this->visitAPValue(

->getAPValueResult(), *

))

2032 return

this->delegate(

->getSubExpr());

2035template

class

Emitter>

2037 auto

It =

->begin();

2038 return

this->visit(*It);

2043 bool

AlignOfReturnsPreferred =

2044

ASTCtx.

getLangOpts

().getClangABICompat() <= LangOptions::ClangABI::Ver7;

2052 if

(

.getQualifiers().hasUnaligned())

2058 if

(Kind == UETT_PreferredAlignOf || AlignOfReturnsPreferred)

2064template

class

Emitter>

2068 const ASTContext

&ASTCtx = Ctx.getASTContext();

2070 if

(Kind == UETT_SizeOf || Kind == UETT_DataSizeOf) {

2071 QualType

ArgType =

->getTypeOfArgument();

2083 return

this->emitInvalid(

);

2085 if

(Kind == UETT_SizeOf)

2094 return

this->emitConst(Size.getQuantity(),

);

2097 if

(Kind == UETT_AlignOf || Kind == UETT_PreferredAlignOf) {

2100 if

(

->isArgumentType()) {

2101 QualType

ArgType =

->getTypeOfArgument();

2114 if

(

const auto

*DRE = dyn_cast<DeclRefExpr>(Arg))

2117 else if

(

const auto

*ME = dyn_cast<MemberExpr>(Arg))

2127 return

this->emitConst(Size.getQuantity(),

);

2130 if

(Kind == UETT_VectorElements) {

2131 if

(

const auto

*VT =

->getTypeOfArgument()->getAs<

VectorType

>())

2132 return

this->emitConst(VT->getNumElements(),

);

2133

assert(

->getTypeOfArgument()->isSizelessVectorType());

2134 return

this->emitSizelessVectorElementSize(

);

2137 if

(Kind == UETT_VecStep) {

2138 if

(

const auto

*VT =

->getTypeOfArgument()->getAs<

VectorType

>()) {

2139 unsigned

N = VT->getNumElements();

2146 return

this->emitConst(N,

);

2148 return

this->emitConst(1,

);

2151 if

(Kind == UETT_OpenMPRequiredSimdAlign) {

2152

assert(

->isArgumentType());

2158 if

(Kind == UETT_PtrAuthTypeDiscriminator) {

2159 if

(

->getArgumentType()->isDependentType())

2160 return

this->emitInvalid(

);

2162 return

this->emitConst(

2163 const_cast<ASTContext

>

(ASTCtx).getPointerAuthTypeDiscriminator(

2164 E

->getArgumentType()),

2171template

class

Emitter>

2178 return

this->discard(

);

2182 const auto

maybeLoadValue = [&]() ->

bool

{

2185 if

(std::optional<PrimType>

= classify(

))

2186 return

this->emitLoadPop(*

);

2190 if

(

const auto

*VD = dyn_cast<VarDecl>(

)) {

2194 if

(

auto

GlobalIndex =

.getGlobal(VD))

2195 return

this->emitGetPtrGlobal(*GlobalIndex,

) && maybeLoadValue();

2199 if

(!isa<FieldDecl>(

)) {

2200 if

(!this->discard(

) && !this->emitSideEffect(

))

2203 return

this->visitDeclRef(

);

2207 if

(!this->delegate(

))

2210 if

(!this->visit(

))

2215 const auto

*FD = cast<FieldDecl>(

);

2217 const Record

*R = getRecord(RD);

2220 const

Record::Field *F = R->

(FD);

2222 if

(F->Decl->getType()->isReferenceType())

2223 return

this->emitGetFieldPop(

, F->Offset,

) && maybeLoadValue();

2224 return

this->emitGetPtrFieldPop(F->Offset,

) && maybeLoadValue();

2227template

class

Emitter>

2233 return

this->emitConst(*ArrayIndex,

);

2236template

class

Emitter>

2239

assert(!DiscardResult);

2243 if

(!this->discard(

->getCommonExpr()))

2248 const Expr

*SubExpr =

->getSubExpr();

2249 size_t

Size =

->getArraySize().getZExtValue();

2254 for

(

size_t

I = 0; I != Size; ++I) {

2258 if

(!this->visitArrayElemInit(I, SubExpr))

2266template

class

Emitter>

2268 const Expr

*SourceExpr =

->getSourceExpr();

2273 return

this->visitInitializer(SourceExpr);

2276 if

(

auto

It = OpaqueExprs.find(

); It != OpaqueExprs.end())

2277 return

this->emitGetLocal(SubExprT, It->second,

);

2279 if

(!this->visit(SourceExpr))

2285 unsigned

LocalIndex = allocateLocalPrimitive(

, SubExprT,

true

);

2286 if

(!this->emitSetLocal(SubExprT, LocalIndex,

))

2291 if

(!DiscardResult) {

2292 if

(!this->emitGetLocal(SubExprT, LocalIndex,

))

2297

OpaqueExprs.insert({

, LocalIndex});

2302template

class

Emitter>

2306 const Expr

*TrueExpr =

->getTrueExpr();

2307 const Expr

*FalseExpr =

->getFalseExpr();

2309 LabelTy

LabelEnd = this->getLabel();

2310 LabelTy

LabelFalse = this->getLabel();

2315 if

(!this->jumpFalse(LabelFalse))

2320 if

(!this->delegate(TrueExpr))

2322 if

(!S.destroyLocals())

2326 if

(!this->jump(LabelEnd))

2329

this->emitLabel(LabelFalse);

2333 if

(!this->delegate(FalseExpr))

2335 if

(!S.destroyLocals())

2339

this->fallthrough(LabelEnd);

2340

this->emitLabel(LabelEnd);

2345template

class

Emitter>

2351 unsigned

StringIndex =

.createGlobalString(

);

2352 return

this->emitGetPtrGlobal(StringIndex,

);

2358

assert(CAT &&

"a string literal that's not a constant array?"

);

2363 unsigned

N = std::min(ArraySize,

->getLength());

2364 size_t

CharWidth =

->getCharByteWidth();

2366 for

(

unsigned

I = 0; I != N; ++I) {

2367

uint32_t CodeUnit =

->getCodeUnit(I);

2369 if

(CharWidth == 1) {

2370

this->emitConstSint8(CodeUnit,

);

2371

this->emitInitElemSint8(I,

);

2372

}

else if

(CharWidth == 2) {

2373

this->emitConstUint16(CodeUnit,

);

2374

this->emitInitElemUint16(I,

);

2375

}

else if

(CharWidth == 4) {

2376

this->emitConstUint32(CodeUnit,

);

2377

this->emitInitElemUint32(I,

);

2379

llvm_unreachable(

"unsupported character width"

);

2384 for

(

unsigned

I = N; I != ArraySize; ++I) {

2385 if

(CharWidth == 1) {

2386

this->emitConstSint8(0,

);

2387

this->emitInitElemSint8(I,

);

2388

}

else if

(CharWidth == 2) {

2389

this->emitConstUint16(0,

);

2390

this->emitInitElemUint16(I,

);

2391

}

else if

(CharWidth == 4) {

2392

this->emitConstUint32(0,

);

2393

this->emitInitElemUint32(I,

);

2395

llvm_unreachable(

"unsupported character width"

);

2402template

class

Emitter>

2406 return

this->emitDummyPtr(

);

2409template

class

Emitter>

2411 auto

&A = Ctx.getASTContext();

2416 false

(),

->getAtLoc());

2417 return

this->delegate(SL);

2420template

class

Emitter>

2428 auto

&A = Ctx.getASTContext();

2429

std::string ResultStr =

->ComputeName(A);

2432 APInt

Size(A.getTypeSize(A.getSizeType()), ResultStr.size() + 1);

2433 QualType

ArrayTy = A.getConstantArrayType(CharTy, Size,

nullptr

2434

ArraySizeModifier::Normal, 0);

2438 false

, ArrayTy,

->getLocation());

2440 unsigned

StringIndex =

.createGlobalString(SL);

2441 return

this->emitGetPtrGlobal(StringIndex,

);

2444template

class

Emitter>

2448 return

this->emitConst(

->getValue(),

);

2451template

class

Emitter>

2455 const Expr

*LHS =

->getLHS();

2456 const Expr

*RHS =

->getRHS();

2458 QualType

LHSComputationType =

->getComputationLHSType();

2459 QualType

ResultType =

->getComputationResultType();

2460

std::optional<PrimType>

= classify(LHSComputationType);

2461

std::optional<PrimType> RT = classify(ResultType);

2468 PrimType

LHST = classifyPrim(LHSType);

2476 unsigned

TempOffset = this->allocateLocalPrimitive(

, *RT,

true

);

2477 if

(!this->emitSetLocal(*RT, TempOffset,

))

2483 if

(!this->emitLoad(LHST,

))

2487 if

(!this->emitPrimCast(LHST, classifyPrim(LHSComputationType),

2488

LHSComputationType,

))

2492 if

(!this->emitGetLocal(*RT, TempOffset,

))

2495 switch

(

->getOpcode()) {

2497 if

(!this->emitAddf(getFPOptions(

))

2501 if

(!this->emitSubf(getFPOptions(

))

2505 if

(!this->emitMulf(getFPOptions(

))

2509 if

(!this->emitDivf(getFPOptions(

))

2516 if

(!this->emitPrimCast(classifyPrim(ResultType), LHST, LHS->

(),

))

2520 return

this->emitStorePop(LHST,

);

2521 return

this->emitStore(LHST,

);

2524template

class

Emitter>

2528 const Expr

*LHS =

->getLHS();

2529 const Expr

*RHS =

->getRHS();

2530

std::optional<PrimType>

= classify(LHS->

());

2531

std::optional<PrimType> RT = classify(RHS->

());

2533 if

(Op != BO_AddAssign && Op != BO_SubAssign)

2542 if

(!this->emitLoad(*

, LHS))

2548 if

(Op == BO_AddAssign) {

2549 if

(!this->emitAddOffset(*RT,

))

2552 if

(!this->emitSubOffset(*RT,

))

2557 return

this->emitStorePopPtr(

);

2558 return

this->emitStorePtr(

);

2561template

class

Emitter>

2565 return

VisitVectorBinOp(

);

2567 const Expr

*LHS =

->getLHS();

2568 const Expr

*RHS =

->getRHS();

2569

std::optional<PrimType> LHSComputationT =

2570

classify(

->getComputationLHSType());

2571

std::optional<PrimType>

= classify(LHS->

());

2572

std::optional<PrimType> RT = classify(RHS->

());

2573

std::optional<PrimType> ResultT = classify(

());

2576 return

this->visit(RHS) && this->visit(LHS) && this->emitError(

);

2578 if

|| !RT || !ResultT || !LHSComputationT)

2585 return

VisitFloatCompoundAssignOperator(

);

2588 return

VisitPointerCompoundAssignOperator(

);

2601 unsigned

TempOffset = this->allocateLocalPrimitive(

, *RT,

true

);

2603 if

(!this->emitSetLocal(*RT, TempOffset,

))

2610 if

(!this->emitLoad(*

))

2612 if

(

!= LHSComputationT) {

2613 if

(!this->emitCast(*

, *LHSComputationT,

))

2618 if

(!this->emitGetLocal(*RT, TempOffset,

))

2622 switch

(

->getOpcode()) {

2624 if

(!this->emitAdd(*LHSComputationT,

))

2628 if

(!this->emitSub(*LHSComputationT,

))

2632 if

(!this->emitMul(*LHSComputationT,

))

2636 if

(!this->emitDiv(*LHSComputationT,

))

2640 if

(!this->emitRem(*LHSComputationT,

))

2644 if

(!this->emitShl(*LHSComputationT, *RT,

))

2648 if

(!this->emitShr(*LHSComputationT, *RT,

))

2652 if

(!this->emitBitAnd(*LHSComputationT,

))

2656 if

(!this->emitBitXor(*LHSComputationT,

))

2660 if

(!this->emitBitOr(*LHSComputationT,

))

2664

llvm_unreachable(

"Unimplemented compound assign operator"

);

2668 if

(ResultT != LHSComputationT) {

2669 if

(!this->emitCast(*LHSComputationT, *ResultT,

))

2674 if

(DiscardResult) {

2676 return

this->emitStoreBitFieldPop(*ResultT,

);

2677 return

this->emitStorePop(*ResultT,

);

2680 return

this->emitStoreBitField(*ResultT,

);

2681 return

this->emitStore(*ResultT,

);

2684template

class

Emitter>

2687 const Expr

*SubExpr =

->getSubExpr();

2692template

class

Emitter>

2695 const Expr

*SubExpr =

->getSubExpr();

2699 return

this->delegate(SubExpr);

2704 return

this->discard(SubExpr);

2708

std::optional<PrimType> SubExprT = classify(SubExpr);

2711

std::optional<unsigned> GlobalIndex =

.createGlobal(

);

2716 E

->getLifetimeExtendedTemporaryDecl();

2721 if

(!this->visit(SubExpr))

2724 if

(!this->emitInitGlobalTemp(*SubExprT, *GlobalIndex, TempDecl,

))

2727 if

(!this->emitInitGlobal(*SubExprT, *GlobalIndex,

))

2730 return

this->emitGetPtrGlobal(*GlobalIndex,

);

2733 if

(!this->checkLiteralType(SubExpr))

2736 if

(!this->emitGetPtrGlobal(*GlobalIndex,

))

2738 if

(!this->visitInitializer(SubExpr))

2741 return

this->emitInitGlobalTempComp(TempDecl,

);

2747 unsigned

LocalIndex = allocateLocalPrimitive(

, *SubExprT,

true

2749 if

(!this->visit(SubExpr))

2751 if

(!this->emitSetLocal(*SubExprT, LocalIndex,

))

2753 return

this->emitGetPtrLocal(LocalIndex,

);

2756 if

(!this->checkLiteralType(SubExpr))

2760 if

(std::optional<unsigned> LocalIndex =

2761

allocateLocal(

, Inner->getType(),

->getExtendingDecl())) {

2763 if

(!this->emitGetPtrLocal(*LocalIndex,

))

2765 return

this->visitInitializer(SubExpr) && this->emitFinishInit(

);

2771template

class

Emitter>

2774 return

this->delegate(

->getSubExpr());

2777template

class

Emitter>

2779 const Expr

->getInitializer();

2781 return

this->discard(

);

2785 return

this->visitInitializer(

) && this->emitFinishInit(

);

2788

std::optional<PrimType>

= classify(

());

2789 if

(

->isFileScope()) {

2792 return

this->delegate(

);

2794 if

(std::optional<unsigned> GlobalIndex =

.createGlobal(

)) {

2795 if

(!this->emitGetPtrGlobal(*GlobalIndex,

))

2799 if

(!this->visit(

))

2801 return

this->emitInitGlobal(*

, *GlobalIndex,

);

2804 return

this->visitInitializer(

) && this->emitFinishInit(

);

2813 return

this->delegate(

);

2815 unsigned

LocalIndex;

2818

LocalIndex = this->allocateLocalPrimitive(

, *

false

);

2819 else if

(std::optional<unsigned> MaybeIndex = this->allocateLocal(

))

2820

LocalIndex = *MaybeIndex;

2824 if

(!this->emitGetPtrLocal(LocalIndex,

))

2828 if

(!this->visit(

)) {

2831 return

this->emitInit(*

);

2833 if

(!this->visitInitializer(

) || !this->emitFinishInit(

))

2842template

class

Emitter>

2847 return

this->emitConstBool(

->getValue(),

);

2848 return

this->emitConst(

->getValue(),

);

2851template

class

Emitter>

2855 return

this->emitConst(

->getValue(),

);

2858template

class

Emitter>

2864 const Record

*R =

.getOrCreateRecord(

->getLambdaClass());

2866 auto

*CaptureInitIt =

->capture_init_begin();

2869 for

(

const

Record::Field &F : R->

fields

()) {

2870 const Expr

= *CaptureInitIt;

2876 if

(std::optional<PrimType>

= classify(

)) {

2877 if

(!this->visit(

))

2880 if

(!this->emitInitField(*

, F.Offset,

))

2883 if

(!this->emitGetPtrField(F.Offset,

))

2886 if

(!this->visitInitializer(

))

2889 if

(!this->emitPopPtr(

))

2897template

class

Emitter>

2903 unsigned

StringIndex =

.createGlobalString(

->getFunctionName(),

);

2904 return

this->emitGetPtrGlobal(StringIndex,

);

2907 return

this->delegate(

->getFunctionName());

2910template

class

Emitter>

2912 if

(

->getSubExpr() && !this->discard(

->getSubExpr()))

2915 return

this->emitInvalid(

);

2918template

class

Emitter>

2921 const Expr

*SubExpr =

->getSubExpr();

2923

std::optional<PrimType> FromT = classify(SubExpr);

2924

std::optional<PrimType> ToT = classify(

);

2927 return

this->emitInvalidCast(CastKind::Reinterpret,

true

);

2931

std::optional<PrimType> PointeeFromT;

2935

PointeeFromT = classify(SubExpr->

());

2937

std::optional<PrimType> PointeeToT;

2941

PointeeToT = classify(

());

2944 if

(PointeeToT && PointeeFromT) {

2949 if

(!this->emitInvalidCast(CastKind::Reinterpret, Fatal,

))

2952 if

(

->getCastKind() == CK_LValueBitCast)

2953 return

this->delegate(SubExpr);

2954 return

this->VisitCastExpr(

);

2958 bool

Fatal = (ToT != FromT);

2959 if

(!this->emitInvalidCast(CastKind::Reinterpret, Fatal,

))

2962 return

this->VisitCastExpr(

);

2965template

class

Emitter>

2971 return

this->emitConstBool(

->getValue(),

);

2974template

class

Emitter>

2977

assert(!classify(

));

2987 return

this->visitInitializer(

->getArg(0));

2991 if

(DiscardResult) {

2995

std::optional<unsigned> LocalIndex = allocateLocal(

);

3000 if

(!this->emitGetPtrLocal(*LocalIndex,

))

3005 if

(

->requiresZeroInitialization()) {

3008 if

(!this->visitZeroRecordInitializer(R,

))

3021

assert(

->hasThisPointer());

3022

assert(!

->hasRVO());

3026 if

(!this->emitDupPtr(

))

3030 for

(

const auto

*Arg :

->arguments()) {

3031 if

(!this->visit(Arg))

3035 if

(

->isVariadic()) {

3036

uint32_t VarArgSize = 0;

3037 unsigned

NumParams =

->getNumWrittenParams();

3038 for

(

unsigned

I = NumParams, N =

->getNumArgs(); I != N; ++I) {

3042 if

(!this->emitCallVar(

, VarArgSize,

))

3045 if

(!this->emitCall(

, 0,

)) {

3050

(void)this->emitPopPtr(

);

3056 return

this->emitPopPtr(

);

3057 return

this->emitFinishInit(

);

3068 if

|| !

->isConstexpr())

3073 for

(

size_t

I = 0; I != NumElems; ++I) {

3074 if

(!this->emitConstUint64(I,

))

3076 if

(!this->emitArrayElemPtrUint64(

))

3080 for

(

const auto

*Arg :

->arguments()) {

3081 if

(!this->visit(Arg))

3085 if

(!this->emitCall(

, 0,

))

3094template

class

Emitter>

3100 E

->EvaluateInContext(Ctx.getASTContext(), SourceLocDefaultExpr);

3104

assert(Val.

isInt

());

3106 return

this->emitConst(I,

);

3113 if

(

const Expr

*LValueExpr =

.dyn_cast<

const Expr

*>())

3114 return

this->visit(LValueExpr);

3120 const auto

*BaseDecl =

.dyn_cast<

const ValueDecl

*>();

3123 auto

*UGCD = cast<UnnamedGlobalConstantDecl>(BaseDecl);

3125

std::optional<unsigned> GlobalIndex =

.getOrCreateGlobal(UGCD);

3129 if

(!this->emitGetPtrGlobal(*GlobalIndex,

))

3133 const APValue

= UGCD->getValue();

3134 for

(

unsigned

I = 0, N = R->

getNumFields

(); I != N; ++I) {

3135 const

Record::Field *F = R->

(I);

3136 const APValue

&FieldValue =

.getStructField(I);

3138 PrimType

FieldT = classifyPrim(F->Decl->getType());

3140 if

(!this->visitAPValue(FieldValue, FieldT,

))

3142 if

(!this->emitInitField(FieldT, F->Offset,

))

3150template

class

Emitter>

3152 unsigned

N =

->getNumComponents();

3156 for

(

unsigned

I = 0; I != N; ++I) {

3159 const Expr

*ArrayIndexExpr =

->getIndexExpr(

Node

.getArrayExprIndex());

3162 if

(DiscardResult) {

3163 if

(!this->discard(ArrayIndexExpr))

3168 if

(!this->visit(ArrayIndexExpr))

3182 return

this->emitOffsetOf(

);

3185template

class

Emitter>

3193 if

(std::optional<PrimType>

= classify(Ty))

3194 return

this->visitZeroInitializer(*

, Ty,

);

3198

std::optional<unsigned> LocalIndex = allocateLocal(

);

3201 if

(!this->emitGetPtrLocal(*LocalIndex,

))

3206 QualType

ElemQT = CT->getElementType();

3207 PrimType

ElemT = classifyPrim(ElemQT);

3209 for

(

unsigned

I = 0; I != 2; ++I) {

3210 if

(!this->visitZeroInitializer(ElemT, ElemQT,

))

3212 if

(!this->emitInitElem(ElemT, I,

))

3221

std::optional<unsigned> LocalIndex = allocateLocal(

);

3224 if

(!this->emitGetPtrLocal(*LocalIndex,

))

3229 QualType

ElemQT = VT->getElementType();

3230 PrimType

ElemT = classifyPrim(ElemQT);

3232 for

(

unsigned

I = 0, N = VT->getNumElements(); I != N; ++I) {

3233 if

(!this->visitZeroInitializer(ElemT, ElemQT,

))

3235 if

(!this->emitInitElem(ElemT, I,

))

3244template

class

Emitter>

3246 return

this->emitConst(

->getPackLength(),

);

3249template

class

Emitter>

3252 return

this->delegate(

->getResultExpr());

3255template

class

Emitter>

3257 return

this->delegate(

->getChosenSubExpr());

3260template

class

Emitter>

3265 return

this->emitConst(

->getValue(),

);

3268template

class

Emitter>

3273 "Trivial CXXInheritedCtorInitExpr, implement. (possible?)"

);

3274 const Function

*F = this->getFunction(Ctor);

3291 if

(!this->emitGetParam(PT, Offset,

))

3296 return

this->emitCall(F, 0,

);

3299template

class

Emitter>

3302 const Expr

->getInitializer();

3303 QualType

ElementType =

->getAllocatedType();

3304

std::optional<PrimType> ElemT = classify(ElementType);

3305 unsigned

PlacementArgs =

->getNumPlacementArgs();

3307 const Expr

*PlacementDest =

nullptr

;

3308 bool

IsNoThrow =

false

;

3310 if

(PlacementArgs != 0) {

3319 if

(PlacementArgs == 1) {

3320 const Expr

*Arg1 =

->getPlacementArg(0);

3322 if

(!this->discard(Arg1))

3327 if

(!this->emitInvalidNewDeleteExpr(

))

3332 if

(OperatorNew->isReservedGlobalPlacementOperator())

3333

PlacementDest = Arg1;

3337 return

this->emitInvalid(

);

3339

}

else if

(!OperatorNew->isReplaceableGlobalAllocationFunction())

3340 return

this->emitInvalidNewDeleteExpr(

);

3343 if

(!PlacementDest) {

3352

Desc =

.createDescriptor(

3355 false

false

);

3359 if

(

->isArray()) {

3360

std::optional<const Expr *> ArraySizeExpr =

->getArraySize();

3364 const Expr

*Stripped = *ArraySizeExpr;

3365 for

(;

auto

*ICE = dyn_cast<ImplicitCastExpr>(Stripped);

3366

Stripped = ICE->getSubExpr())

3367 if

(ICE->getCastKind() != CK_NoOp &&

3368

ICE->getCastKind() != CK_IntegralCast)

3373 if

(PlacementDest) {

3374 if

(!this->visit(PlacementDest))

3376 if

(!this->visit(Stripped))

3378 if

(!this->emitCheckNewTypeMismatchArray(SizeT,

))

3381 if

(!this->visit(Stripped))

3386 if

(!this->emitAllocN(SizeT, *ElemT,

, IsNoThrow,

))

3390 if

(!this->emitAllocCN(SizeT, Desc, IsNoThrow,

))

3395 if

(

&& !this->visitInitializer(

))

3399 if

(PlacementDest) {

3400 if

(!this->visit(PlacementDest))

3402 if

(!this->emitCheckNewTypeMismatch(

))

3406 if

(!this->emitAlloc(Desc,

))

3412 if

(!this->visit(

))

3415 if

(!this->emitInit(*ElemT,

))

3419 if

(!this->visitInitializer(

))

3426 return

this->emitPopPtr(

);

3431template

class

Emitter>

3433 const Expr

*Arg =

->getArgument();

3435 const FunctionDecl

*OperatorDelete =

->getOperatorDelete();

3437 if

(!OperatorDelete->isReplaceableGlobalAllocationFunction())

3438 return

this->emitInvalidNewDeleteExpr(

);

3441 if

(!this->visit(Arg))

3444 return

this->emitFree(

->isArrayForm(),

->isGlobalDelete(),

);

3447template

class

Emitter>

3458 return

this->emitGetFnPtr(

);

3461template

class

Emitter>

3465 if

->isPotentiallyEvaluated()) {

3469 if

(

->isTypeOperand())

3470 return

this->emitGetTypeid(

3471 E

->getTypeOperand(Ctx.getASTContext()).getTypePtr(), TypeInfoType,

);

3477

assert(

->getExprOperand());

3478

assert(

->getExprOperand()->

isLValue

());

3480 if

(!Ctx.

getLangOpts

().CPlusPlus20 && !this->emitDiagTypeid(

))

3483 if

(!this->visit(

->getExprOperand()))

3486 if

(!this->emitGetTypeidPtr(TypeInfoType,

))

3489 return

this->emitPopPtr(

);

3493template

class

Emitter>

3496 return

this->emitConstBool(

->getValue(),

);

3499template

class

Emitter>

3511 return

this->emitDummyPtr(GuidDecl,

);

3513

std::optional<unsigned> GlobalIndex =

.getOrCreateGlobal(GuidDecl);

3516 if

(!this->emitGetPtrGlobal(*GlobalIndex,

))

3519

assert(this->getRecord(

()));

3525

assert(

.isStruct());

3526

assert(

.getStructNumBases() == 0);

3527 if

(!this->visitAPValueInitializer(

))

3530 return

this->emitFinishInit(

);

3533template

class

Emitter>

3538 return

this->emitConstBool(

->isSatisfied(),

);

3541template

class

Emitter>

3547 return

this->emitConstBool(

->isSatisfied(),

);

3550template

class

Emitter>

3553 return

this->delegate(

->getSemanticForm());

3556template

class

Emitter>

3559 for

(

const Expr

*SemE :

->semantics()) {

3560 if

(

auto

*OVE = dyn_cast<OpaqueValueExpr>(SemE)) {

3561 if

(SemE ==

->getResultExpr())

3564 if

(OVE->isUnique())

3567 if

(!this->discard(OVE))

3569

}

else if

(SemE ==

->getResultExpr()) {

3570 if

(!this->delegate(SemE))

3573 if

(!this->discard(SemE))

3580template

class

Emitter>

3582 return

this->delegate(

->getSelectedExpr());

3585template

class

Emitter>

3587 return

this->emitError(

);

3590template

class

Emitter>

3594 unsigned

Offset = allocateLocalPrimitive(

3595 E

->getLabel(),

true

false

);

3597 return

this->emitGetLocal(

, Offset,

);

3600template

class

Emitter>

3604 QualType

ElemType = VT->getElementType();

3605 PrimType

ElemT = classifyPrim(ElemType);

3606 const Expr

*Src =

->getSrcExpr();

3608 PrimType

SrcElemT = classifyVectorElementType(SrcType);

3610 unsigned

SrcOffset = this->allocateLocalPrimitive(Src,

true

false

);

3611 if

(!this->visit(Src))

3613 if

(!this->emitSetLocal(

, SrcOffset,

))

3616 for

(

unsigned

I = 0; I != VT->getNumElements(); ++I) {

3617 if

(!this->emitGetLocal(

, SrcOffset,

))

3619 if

(!this->emitArrayElemPop(SrcElemT, I,

))

3623 if

(SrcElemT != ElemT) {

3624 if

(!this->emitPrimCast(SrcElemT, ElemT, ElemType,

))

3626

}

else if

(ElemType->isFloatingType() && SrcType != ElemType) {

3627 const auto

*TargetSemantics = &Ctx.getFloatSemantics(ElemType);

3631 if

(!this->emitInitElem(ElemT, I,

))

3638template

class

Emitter>

3641

assert(

->getNumSubExprs() > 2);

3643 const Expr

*Vecs[] = {

->getExpr(0),

->getExpr(1)};

3647 unsigned

NumOutputElems =

->getNumSubExprs() - 2;

3648

assert(NumOutputElems > 0);

3651 unsigned

VectorOffsets[2];

3652 for

(

unsigned

I = 0; I != 2; ++I) {

3653

VectorOffsets[I] = this->allocateLocalPrimitive(

3654

Vecs[I],

true

false

);

3655 if

(!this->visit(Vecs[I]))

3657 if

(!this->emitSetLocal(

, VectorOffsets[I],

))

3660 for

(

unsigned

I = 0; I != NumOutputElems; ++I) {

3661 APSInt

ShuffleIndex =

->getShuffleMaskIdx(Ctx.getASTContext(), I);

3662

assert(ShuffleIndex >= -1);

3663 if

(ShuffleIndex == -1)

3664 return

this->emitInvalidShuffleVectorIndex(I,

);

3666

assert(ShuffleIndex < (NumInputElems * 2));

3667 if

(!this->emitGetLocal(

3668

VectorOffsets[ShuffleIndex >= NumInputElems],

))

3670 unsigned

InputVectorIndex = ShuffleIndex.getZExtValue() % NumInputElems;

3671 if

(!this->emitArrayElemPop(ElemT, InputVectorIndex,

))

3674 if

(!this->emitInitElem(ElemT, I,

))

3681template

class

Emitter>

3686 Base

->getType()->isVectorType() ||

3690 E

->getEncodedElementAccess(Indices);

3692 if

(Indices.size() == 1) {

3693 if

(!this->visit(

))

3697 if

(!this->emitConstUint32(Indices[0],

))

3699 return

this->emitArrayElemPtrPop(

PT_Uint32

);

3702 return

this->emitArrayElemPop(classifyPrim(

()), Indices[0],

);

3706 unsigned

BaseOffset = allocateLocalPrimitive(

true

3708 if

(!this->visit(

))

3710 if

(!this->emitSetLocal(

, BaseOffset,

))

3715

std::optional<unsigned> ResultIndex;

3716

ResultIndex = allocateLocal(

);

3719 if

(!this->emitGetPtrLocal(*ResultIndex,

))

3727

uint32_t DstIndex = 0;

3728 for

(uint32_t I : Indices) {

3729 if

(!this->emitGetLocal(

, BaseOffset,

))

3731 if

(!this->emitArrayElemPop(ElemT, I,

))

3733 if

(!this->emitInitElem(ElemT, DstIndex,

))

3739

assert(!DiscardResult);

3743template

class

Emitter>

3745 const Expr

*SubExpr =

->getSubExpr();

3746 if

->isExpressibleAsConstantInitializer())

3747 return

this->discard(SubExpr) && this->emitInvalid(

);

3752

assert(classifyPrim(

) ==

);

3753 return

this->emitDummyPtr(

);

3756template

class

Emitter>

3759 const Expr

*SubExpr =

->getSubExpr();

3766 if

(!this->visit(SubExpr))

3768 if

(!this->emitConstUint8(0,

))

3770 if

(!this->emitArrayElemPtrPopUint8(

))

3780 return

this->emitInitField(SecondFieldT, R->

(1u)->

);

3782

assert(SecondFieldT ==

);

3786 if

(!this->emitExpandPtr(

))

3790 if

(!this->emitArrayElemPtrPop(

PT_Uint64

))

3795template

class

Emitter>

3802 for

(

const Stmt

*S : CS->

body

()) {

3804 if

(!this->visitStmt(S))

3809

assert(S == Result);

3810 if

(

const Expr

*ResultExpr = dyn_cast<Expr>(S))

3811 return

this->delegate(ResultExpr);

3812 return

this->emitUnsupported(

);

3821 return

this->Visit(

);

3828 return

this->Visit(

);

3836 return

this->discard(

);

3841

std::optional<unsigned> LocalIndex = allocateLocal(

);

3845 if

(!this->emitGetPtrLocal(*LocalIndex,

))

3848 return

this->visitInitializer(

);

3855 return

this->Visit(

);

3858template

class

Emitter>

3860

assert(!classify(

()));

3864 return

this->Visit(

);

3868

std::optional<PrimType>

= classify(

());

3872 if

(!this->visit(

))

3874 return

this->emitComplexBoolCast(

);

3879 if

(!this->visit(

))

3887 if

(!this->emitNull(*

, 0,

nullptr

))

3889 return

this->emitNE(*

);

3894 return

this->emitCastFloatingIntegralBool(getFPOptions(

);

3897 return

this->emitCast(*

);

3900template

class

Emitter>

3905 return

this->emitZeroBool(

);

3907 return

this->emitZeroSint8(

);

3909 return

this->emitZeroUint8(

);

3911 return

this->emitZeroSint16(

);

3913 return

this->emitZeroUint16(

);

3915 return

this->emitZeroSint32(

);

3917 return

this->emitZeroUint32(

);

3919 return

this->emitZeroSint64(

);

3921 return

this->emitZeroUint64(

);

3923 return

this->emitZeroIntAP(Ctx.getBitWidth(QT),

);

3925 return

this->emitZeroIntAPS(Ctx.getBitWidth(QT),

);

3930 return

this->emitNullFnPtr(0,

nullptr

);

3932 return

this->emitNullMemberPtr(0,

nullptr

);

3934 return

this->emitConstFloat(APFloat::getZero(Ctx.getFloatSemantics(QT)),

);

3939

llvm_unreachable(

"Implement"

);

3941

llvm_unreachable(

"unknown primitive type"

);

3944template

class

Emitter>

3950 for

(

const

Record::Field &Field : R->

fields

()) {

3951 if

(

Field

.Decl->isUnnamedBitField())

3955 if

(

->isPrimitive()) {

3958 if

(!this->visitZeroInitializer(

, QT,

))

3960 if

(!this->emitInitField(

Field

.Offset,

))

3967 if

(!this->emitGetPtrField(

Field

.Offset,

))

3970 if

(

->isPrimitiveArray()) {

3973 for

(uint32_t I = 0, N =

->getNumElems(); I != N; ++I) {

3974 if

(!this->visitZeroInitializer(

, ET,

))

3976 if

(!this->emitInitElem(

, I,

))

3979

}

else if

(

->isCompositeArray()) {

3981 if

(!this->visitZeroArrayInitializer(

->getType(),

))

3983

}

else if

(

->isRecord()) {

3984 if

(!this->visitZeroRecordInitializer(

->ElemRecord,

))

3990 if

(!this->emitFinishInitPop(

))

3999 for

(

const

Record::Base &B : R->

bases

()) {

4000 if

(!this->emitGetPtrBase(B.Offset,

))

4002 if

(!this->visitZeroRecordInitializer(B.R,

))

4004 if

(!this->emitFinishInitPop(

))

4013template

class

Emitter>

4018 size_t

NumElems = cast<ConstantArrayType>(AT)->getZExtSize();

4020 if

(std::optional<PrimType> ElemT = classify(ElemType)) {

4021 for

(

size_t

I = 0; I != NumElems; ++I) {

4022 if

(!this->visitZeroInitializer(*ElemT, ElemType,

))

4024 if

(!this->emitInitElem(*ElemT, I,

))

4029 const Record

*R = getRecord(ElemType);

4031 for

(

size_t

I = 0; I != NumElems; ++I) {

4032 if

(!this->emitConstUint32(I,

))

4034 if

(!this->emitArrayElemPtr(

PT_Uint32

))

4036 if

(!this->visitZeroRecordInitializer(R,

))

4038 if

(!this->emitPopPtr(

))

4043 for

(

size_t

I = 0; I != NumElems; ++I) {

4044 if

(!this->emitConstUint32(I,

))

4046 if

(!this->emitArrayElemPtr(

PT_Uint32

))

4048 if

(!this->visitZeroArrayInitializer(ElemType,

))

4050 if

(!this->emitPopPtr(

))

4059template

class

Emitter>

4060template

typename

4064 return

this->emitConstSint8(

);

4066 return

this->emitConstUint8(

);

4068 return

this->emitConstSint16(

);

4070 return

this->emitConstUint16(

);

4072 return

this->emitConstSint32(

);

4074 return

this->emitConstUint32(

);

4076 return

this->emitConstSint64(

);

4078 return

this->emitConstUint64(

);

4080 return

this->emitConstBool(

);

4088

llvm_unreachable(

"Invalid integral type"

);

4091

llvm_unreachable(

"unknown primitive type"

);

4094template

class

Emitter>

4095template

typename

4097 return

this->emitConst(

, classifyPrim(

()),

);

4100template

class

Emitter>

4104 return

this->emitConstIntAPS(

);

4106 return

this->emitConstIntAP(

);

4108 if

(

.isSigned())

4109 return

this->emitConst(

.getSExtValue(), Ty,

);

4110 return

this->emitConst(

.getZExtValue(), Ty,

);

4113template

class

Emitter>

4115 return

this->emitConst(

, classifyPrim(

()),

);

4118template

class

Emitter>

4123 if

(

const auto

*VD =

4124

dyn_cast_if_present<ValueDecl>(Src.dyn_cast<

const Decl

*>())) {

4125

assert(!

.getGlobal(VD));

4126

assert(!Locals.contains(VD));

4134

isa<const Expr *>(Src));

4136 if

(

auto

*VD = dyn_cast_if_present<ValueDecl>(Src.dyn_cast<

const Decl

*>()))

4137

Locals.insert({VD, Local});

4138

VarScope->add(Local, IsExtended);

4139 return

Local.Offset;

4142template

class

Emitter>

4143

std::optional<unsigned>

4147 if

([[maybe_unused]]

const auto

*VD =

4148

dyn_cast_if_present<ValueDecl>(Src.dyn_cast<

const Decl

*>())) {

4149

assert(!

.getGlobal(VD));

4150

assert(!Locals.contains(VD));

4155 bool

IsTemporary =

false

;

4156 if

(

auto

*VD = dyn_cast_if_present<ValueDecl>(Src.dyn_cast<

const Decl

*>())) {

4160 if

(

const auto

*VarD = dyn_cast<VarDecl>(VD))

4161 Init

= VarD->getInit();

4163 if

(

auto

= Src.dyn_cast<

const Expr

*>()) {

4164

IsTemporary =

true

;

4171

IsTemporary,

false

);

4173 return

std::nullopt;

4177

Locals.insert({Key, Local});

4179

VarScope->addExtended(Local, ExtendingDecl);

4181

VarScope->add(Local,

false

);

4182 return

Local.Offset;

4185template

class

Emitter>

4192 true

false

nullptr

);

4195 return

std::nullopt;

4201 while

(S->getParent())

4203

assert(S && !S->getParent());

4205 return

Local.Offset;

4208template

class

Emitter>

4210 if

(

const PointerType

*PT = dyn_cast<PointerType>(Ty))

4216 if

(

const auto

*RecordTy = getRecordTy(Ty))

4217 return

getRecord(RecordTy->getDecl());

4221template

class

Emitter>

4223 return P

.getOrCreateRecord(RD);

4226template

class

Emitter>

4228 return

Ctx.getOrCreateFunction(FD);

4231template

class

Emitter>

4236 if

(!DestroyToplevelScope) {

4237 if

(!this->emitCheckAllocations(

))

4241 auto

maybeDestroyLocals = [&]() ->

bool

{

4242 if

(DestroyToplevelScope)

4243 return

RootScope.

destroyLocals

() && this->emitCheckAllocations(

);

4244 return

this->emitCheckAllocations(

);

4251 return

this->emitRetVoid(

) && maybeDestroyLocals();

4255 if

(std::optional<PrimType>

= classify(

)) {

4259 return

this->emitRet(*

) && maybeDestroyLocals();

4265 if

(std::optional<unsigned> LocalOffset = this->allocateLocal(

)) {

4267 if

(!this->emitGetPtrLocal(*LocalOffset,

))

4270 if

(!visitInitializer(

))

4273 if

(!this->emitFinishInit(

))

4278 return

this->emitRetValue(

) && maybeDestroyLocals();

4281 return

maybeDestroyLocals() && this->emitCheckAllocations(

) &&

false

;

4284template

class

Emitter>

4287 auto

R = this->visitVarDecl(VD,

true

);

4296 if

(

auto

GlobalIndex =

.getGlobal(VD)) {

4297 Block

*GlobalBlock =

.getGlobal(*GlobalIndex);

4301

GD.

InitState

= GlobalInitState::InitializerFailed;

4312template

class

Emitter>

4314 bool

ConstantContext) {

4315

std::optional<PrimType> VarT = classify(VD->

());

4319 if

(!ConstantContext) {

4324

this->emitCheckAllocations(VD);

4328 if

(!this->visitVarDecl(VD,

true

))

4332 auto

GlobalIndex =

.getGlobal(VD);

4333

assert(GlobalIndex);

4335 if

(!this->emitGetGlobalUnchecked(*VarT, *GlobalIndex, VD))

4338 if

(!this->emitGetPtrGlobal(*GlobalIndex, VD))

4342 auto

Local = Locals.find(VD);

4343

assert(Local != Locals.end());

4345 if

(!this->emitGetLocal(*VarT, Local->second.Offset, VD))

4348 if

(!this->emitGetPtrLocal(Local->second.Offset, VD))

4354 if

(!this->emitRet(VarT.value_or(

), VD)) {

4358 auto

GlobalIndex =

.getGlobal(VD);

4359

assert(GlobalIndex);

4360 Block

*GlobalBlock =

.getGlobal(*GlobalIndex);

4364

GD.

InitState

= GlobalInitState::InitializerFailed;

4370 return

VDScope.

destroyLocals

() && this->emitCheckAllocations(VD);

4373template

class

Emitter>

4382 if

(!this->isActive())

4386

std::optional<PrimType> VarT = classify(VD->

());

4388 if

(

->isValueDependent())

4392 auto

checkDecl = [&]() ->

bool

{

4394 return

!NeedsOp || this->emitCheckDecl(VD, VD);

4397 auto

initGlobal = [&](

unsigned

GlobalIndex) ->

bool

{

4401 if

(!this->visit(

))

4402 return

checkDecl() &&

false

;

4404 return

checkDecl() && this->emitInitGlobal(*VarT, GlobalIndex, VD);

4410 if

(!this->emitGetPtrGlobal(GlobalIndex,

))

4413 if

(!visitInitializer(

))

4416 if

(!this->emitFinishInit(

))

4419 return

this->emitPopPtr(

);

4425 if

(std::optional<unsigned> GlobalIndex =

.getGlobal(VD)) {

4426 if

(

.getPtrGlobal(*GlobalIndex).isInitialized())

4431 return Init

&& checkDecl() && initGlobal(*GlobalIndex);

4434

std::optional<unsigned> GlobalIndex =

.createGlobal(VD,

);

4439 return

|| (checkDecl() && initGlobal(*GlobalIndex));

4444 unsigned

Offset = this->allocateLocalPrimitive(

4451 if

(!this->visit(

))

4453 return

this->emitSetLocal(*VarT, Offset, VD) &&

Scope

.destroyLocals();

4455 if

(!this->visit(

))

4457 return

this->emitSetLocal(*VarT, Offset, VD);

4461 if

(std::optional<unsigned> Offset = this->allocateLocal(VD)) {

4465 if

(!this->emitGetPtrLocal(*Offset,

))

4468 if

(!visitInitializer(

))

4471 if

(!this->emitFinishInit(

))

4474 return

this->emitPopPtr(

);

4484template

class

Emitter>

4487

assert(!DiscardResult);

4489 return

this->emitConst(Val.

getInt

(), ValType,

);

4491 return

this->emitConstFloat(Val.

getFloat

(),

);

4495 return

this->emitNull(ValType, 0,

nullptr

);

4497 if

(

const Expr

*BaseExpr =

.dyn_cast<

const Expr

*>())

4498 return

this->visit(BaseExpr);

4499 else if

(

const auto

*VD =

.dyn_cast<

const ValueDecl

*>()) {

4500 return

this->visitDeclRef(VD,

);

4504 return

this->emitGetMemberPtr(MemberDecl,

);

4505 return

this->emitNullMemberPtr(0,

nullptr

);

4511template

class

Emitter>

4520 const

Record::Field *RF = R->

(I);

4523 PrimType T

= classifyPrim(RF->Decl->getType());

4524 if

(!this->visitAPValue(F,

))

4526 if

(!this->emitInitField(

, RF->Offset,

))

4529

assert(RF->Desc->isPrimitiveArray());

4530 const auto

*ArrType = RF->Decl->getType()->getAsArrayTypeUnsafe();

4531 PrimType

ElemT = classifyPrim(ArrType->getElementType());

4534 if

(!this->emitGetPtrField(RF->Offset,

))

4537 for

(

unsigned

A = 0, AN = F.

getArraySize

(); A != AN; ++A) {

4540 if

(!this->emitInitElem(ElemT, A,

))

4544 if

(!this->emitPopPtr(

))

4547 if

(!this->emitGetPtrField(RF->Offset,

))

4549 if

(!this->visitAPValueInitializer(F,

))

4551 if

(!this->emitPopPtr(

))

4554

assert(

false

"I don't think this should be possible"

);

4563 const

Record::Field *RF = R->

(UnionField);

4564 PrimType T

= classifyPrim(RF->Decl->getType());

4565 if

(!this->visitAPValue(F,

))

4567 return

this->emitInitField(

, RF->Offset,

);

4574template

class

Emitter>

4576 unsigned

BuiltinID) {

4577 const Function

= getFunction(

->getDirectCallee());

4583 if

(BuiltinID == Builtin::BI__builtin___CFStringMakeConstantString ||

4584

BuiltinID == Builtin::BI__builtin___NSStringMakeConstantString ||

4585

BuiltinID == Builtin::BI__builtin_ptrauth_sign_constant ||

4586

BuiltinID == Builtin::BI__builtin_function_start) {

4589 return

this->emitDummyPtr(

);

4593

std::optional<PrimType> ReturnT = classify(

);

4597

std::optional<unsigned> LocalIndex = allocateLocal(

);

4600 if

(!this->emitGetPtrLocal(*LocalIndex,

))

4604 if

->isUnevaluatedBuiltin()) {

4606 for

(

const auto

*Arg :

->arguments()) {

4607 if

(!this->visit(Arg))

4612 if

(!this->emitCallBI(

, BuiltinID,

))

4615 if

(DiscardResult && !ReturnType->

isVoidType

()) {

4617 return

this->emitPop(*ReturnT,

);

4623template

class

Emitter>

4625 if

(

unsigned

BuiltinID =

->getBuiltinCallee())

4626 return

VisitBuiltinCallExpr(

, BuiltinID);

4633 return

VisitBuiltinCallExpr(

, Builtin::BI__builtin_operator_new);

4636 return

VisitBuiltinCallExpr(

, Builtin::BI__builtin_operator_delete);

4640 if

(

const auto

*DD = dyn_cast_if_present<CXXDestructorDecl>(FuncDecl);

4641

DD && DD->isTrivial())

4644 QualType

ReturnType =

->getCallReturnType(Ctx.getASTContext());

4645

std::optional<PrimType>

= classify(ReturnType);

4646 bool

HasRVO = !ReturnType->

isVoidType

() && !

;

4649 if

(DiscardResult) {

4653 if

(std::optional<unsigned> LocalIndex = allocateLocal(

)) {

4654 if

(!this->emitGetPtrLocal(*LocalIndex,

))

4661 if

(std::optional<unsigned> LocalIndex = allocateLocal(

)) {

4662 if

(!this->emitGetPtrLocal(*LocalIndex,

))

4666 if

(!this->emitDupPtr(

))

4674 bool

IsAssignmentOperatorCall =

false

;

4675 if

(

const auto

*OCE = dyn_cast<CXXOperatorCallExpr>(

);

4676

OCE && OCE->isAssignmentOp()) {

4680

assert(Args.size() == 2);

4681

IsAssignmentOperatorCall =

true

;

4682

std::reverse(Args.begin(), Args.end());

4687 if

(isa<CXXOperatorCallExpr>(

)) {

4688 if

(

const auto

*MD = dyn_cast_if_present<CXXMethodDecl>(FuncDecl);

4689

MD && MD->isStatic()) {

4690 if

(!this->discard(

->getArg(0)))

4693

Args.erase(Args.begin());

4697

std::optional<unsigned> CalleeOffset;

4699 if

(

const auto

*MC = dyn_cast<CXXMemberCallExpr>(

)) {

4700 if

(!FuncDecl && classifyPrim(

->getCallee()) ==

PT_MemberPtr

) {

4704 const Expr

*Callee =

->getCallee();

4706

this->allocateLocalPrimitive(Callee,

PT_MemberPtr

true

false

);

4707 if

(!this->visit(Callee))

4713 if

(!this->emitGetMemberPtrBase(

))

4715

}

else if

(!this->visit(MC->getImplicitObjectArgument())) {

4718

}

else if

(!FuncDecl) {

4719 const Expr

*Callee =

->getCallee();

4720

CalleeOffset = this->allocateLocalPrimitive(Callee,

PT_FnPtr

true

false

);

4721 if

(!this->visit(Callee))

4723 if

(!this->emitSetLocal(

PT_FnPtr

, *CalleeOffset,

))

4729 unsigned

ArgIndex = 0;

4730 for

(

const auto

*Arg : Args) {

4731 if

(!this->visit(Arg))

4735 if

(FuncDecl && NonNullArgs[ArgIndex]) {

4738 if

(!this->emitCheckNonNullArg(ArgT, Arg))

4746 if

(IsAssignmentOperatorCall) {

4747

assert(Args.size() == 2);

4750 if

(!this->emitFlip(Arg2T, Arg1T,

))

4758

assert(HasRVO ==

->hasRVO());

4760 bool

HasQualifier =

false

;

4761 if

(

const auto

*ME = dyn_cast<MemberExpr>(

->getCallee()))

4762

HasQualifier = ME->hasQualifier();

4764 bool

IsVirtual =

false

;

4765 if

(

const auto

*MD = dyn_cast<CXXMethodDecl>(FuncDecl))

4766

IsVirtual = MD->isVirtual();

4771 if

(IsVirtual && !HasQualifier) {

4772

uint32_t VarArgSize = 0;

4773 unsigned

NumParams =

4774 Func

->getNumWrittenParams() + isa<CXXOperatorCallExpr>(

);

4775 for

(

unsigned

I = NumParams, N =

->getNumArgs(); I != N; ++I)

4778 if

(!this->emitCallVirt(

, VarArgSize,

))

4780

}

else if

(

->isVariadic()) {

4781

uint32_t VarArgSize = 0;

4782 unsigned

NumParams =

4783 Func

->getNumWrittenParams() + isa<CXXOperatorCallExpr>(

);

4784 for

(

unsigned

I = NumParams, N =

->getNumArgs(); I != N; ++I)

4786 if

(!this->emitCallVar(

, VarArgSize,

))

4789 if

(!this->emitCall(

, 0,

))

4798

uint32_t ArgSize = 0;

4799 for

(

unsigned

I = 0, N =

->getNumArgs(); I != N; ++I)

4804 if

(isa<CXXMemberCallExpr>(

) && CalleeOffset) {

4807 if

(!this->emitGetMemberPtrDecl(

))

4810 if

(!this->emitGetLocal(

PT_FnPtr

, *CalleeOffset,

))

4813 if

(!this->emitCallPtr(ArgSize,

))

4818 if

(DiscardResult && !ReturnType->

isVoidType

() &&

)

4819 return

this->emitPop(*

);

4824template

class

Emitter>

4828 return

this->delegate(

->getExpr());

4831template

class

Emitter>

4835 return

this->delegate(

->getExpr());

4838template

class

Emitter>

4843 return

this->emitConstBool(

->getValue(),

);

4846template

class

Emitter>

4853 return

this->emitNullPtr(Val,

nullptr

);

4856template

class

Emitter>

4864 return

this->emitZero(

);

4867template

class

Emitter>

4872 if

(this->LambdaThisCapture.Offset > 0) {

4873 if

(this->LambdaThisCapture.IsPtr)

4874 return

this->emitGetThisFieldPtr(this->LambdaThisCapture.Offset,

);

4875 return

this->emitGetPtrThisField(this->LambdaThisCapture.Offset,

);

4882 if

(!InitStackActive)

4883 return

this->emitThis(

);

4885 if

(!InitStack.empty()) {

4899 unsigned

StartIndex = 0;

4900 unsigned

EndIndex = 0;

4902 for

(StartIndex = InitStack.size() - 1; StartIndex > 0; --StartIndex) {

4905

EndIndex = StartIndex;

4912 for

(; StartIndex > 0; --StartIndex) {

4922 for

(

unsigned

I = StartIndex; I != EndIndex; ++I) {

4925 if

(!InitStack[I].

template

emit<Emitter>(

this

))

4930 return

this->emitThis(

);

4934 switch

(S->getStmtClass()) {

4935 case

Stmt::CompoundStmtClass:

4936 return

visitCompoundStmt(cast<CompoundStmt>(S));

4937 case

Stmt::DeclStmtClass:

4938 return

visitDeclStmt(cast<DeclStmt>(S));

4939 case

Stmt::ReturnStmtClass:

4940 return

visitReturnStmt(cast<ReturnStmt>(S));

4941 case

Stmt::IfStmtClass:

4942 return

visitIfStmt(cast<IfStmt>(S));

4943 case

Stmt::WhileStmtClass:

4944 return

visitWhileStmt(cast<WhileStmt>(S));

4945 case

Stmt::DoStmtClass:

4946 return

visitDoStmt(cast<DoStmt>(S));

4947 case

Stmt::ForStmtClass:

4948 return

visitForStmt(cast<ForStmt>(S));

4949 case

Stmt::CXXForRangeStmtClass:

4950 return

visitCXXForRangeStmt(cast<CXXForRangeStmt>(S));

4951 case

Stmt::BreakStmtClass:

4952 return

visitBreakStmt(cast<BreakStmt>(S));

4953 case

Stmt::ContinueStmtClass:

4954 return

visitContinueStmt(cast<ContinueStmt>(S));

4955 case

Stmt::SwitchStmtClass:

4956 return

visitSwitchStmt(cast<SwitchStmt>(S));

4957 case

Stmt::CaseStmtClass:

4958 return

visitCaseStmt(cast<CaseStmt>(S));

4959 case

Stmt::DefaultStmtClass:

4960 return

visitDefaultStmt(cast<DefaultStmt>(S));

4961 case

Stmt::AttributedStmtClass:

4962 return

visitAttributedStmt(cast<AttributedStmt>(S));

4963 case

Stmt::CXXTryStmtClass:

4964 return

visitCXXTryStmt(cast<CXXTryStmt>(S));

4965 case

Stmt::NullStmtClass:

4968 case

Stmt::GCCAsmStmtClass:

4969 case

Stmt::MSAsmStmtClass:

4970 case

Stmt::GotoStmtClass:

4971 return

this->emitInvalid(S);

4972 case

Stmt::LabelStmtClass:

4973 return

this->visitStmt(cast<LabelStmt>(S)->getSubStmt());

4975 if

(

const auto

= dyn_cast<Expr>(S))

4976 return

this->discard(

);

4982template

class

Emitter>

4985 for

(

const auto

*InnerStmt : S->body())

4986 if

(!visitStmt(InnerStmt))

4988 return Scope

.destroyLocals();

4991template

class

Emitter>

4993 for

(

const auto

: DS->

decls

()) {

4998 const auto

*VD = dyn_cast<VarDecl>(

);

5001 if

(!this->visitVarDecl(VD))

5005 if

(

const auto

*DD = dyn_cast<DecompositionDecl>(VD)) {

5006 for

(

auto

*BD : DD->bindings())

5007 if

(

auto

*KD = BD->getHoldingVar()) {

5008 if

(!this->visitVarDecl(KD))

5017template

class

Emitter>

5019 if

(this->InStmtExpr)

5020 return

this->emitUnsupported(RS);

5026 if

(!this->visit(RE))

5028

this->emitCleanup();

5029 return

this->emitRet(*ReturnType, RS);

5030

}

else if

(RE->getType()->isVoidType()) {

5031 if

(!this->visit(RE))

5036 if

(!this->emitRVOPtr(RE))

5038 if

(!this->visitInitializer(RE))

5040 if

(!this->emitPopPtr(RE))

5043

this->emitCleanup();

5044 return

this->emitRetVoid(RS);

5049

this->emitCleanup();

5050 return

this->emitRetVoid(RS);

5054 if

(

auto

*CondInit = IS->

getInit

())

5055 if

(!visitStmt(CondInit))

5059 if

(!visitDeclStmt(CondDecl))

5064 if

(!this->emitIsConstantContext(IS))

5067 if

(!this->emitIsConstantContext(IS))

5069 if

(!this->emitInv(IS))

5072 if

(!this->visitBool(IS->

getCond

()))

5077 LabelTy

LabelElse = this->getLabel();

5078 LabelTy

LabelEnd = this->getLabel();

5079 if

(!this->jumpFalse(LabelElse))

5083 if

(!visitStmt(IS->

getThen

()))

5088 if

(!this->jump(LabelEnd))

5090

this->emitLabel(LabelElse);

5093 if

(!visitStmt(Else))

5098

this->emitLabel(LabelEnd);

5100 LabelTy

LabelEnd = this->getLabel();

5101 if

(!this->jumpFalse(LabelEnd))

5105 if

(!visitStmt(IS->

getThen

()))

5110

this->emitLabel(LabelEnd);

5116template

class

Emitter>

5118 const Expr

*Cond = S->getCond();

5119 const Stmt

*Body = S->getBody();

5121 LabelTy

CondLabel = this->getLabel();

5122 LabelTy

EndLabel = this->getLabel();

5125

this->fallthrough(CondLabel);

5126

this->emitLabel(CondLabel);

5130 if

(

const DeclStmt

*CondDecl = S->getConditionVariableDeclStmt())

5131 if

(!visitDeclStmt(CondDecl))

5134 if

(!this->visitBool(Cond))

5136 if

(!this->jumpFalse(EndLabel))

5139 if

(!this->visitStmt(Body))

5145 if

(!this->jump(CondLabel))

5147

this->fallthrough(EndLabel);

5148

this->emitLabel(EndLabel);

5154 const Expr

*Cond = S->getCond();

5155 const Stmt

*Body = S->getBody();

5157 LabelTy

StartLabel = this->getLabel();

5158 LabelTy

EndLabel = this->getLabel();

5159 LabelTy

CondLabel = this->getLabel();

5162

this->fallthrough(StartLabel);

5163

this->emitLabel(StartLabel);

5167 if

(!this->visitStmt(Body))

5169

this->fallthrough(CondLabel);

5170

this->emitLabel(CondLabel);

5171 if

(!this->visitBool(Cond))

5177 if

(!this->jumpTrue(StartLabel))

5180

this->fallthrough(EndLabel);

5181

this->emitLabel(EndLabel);

5185template

class

Emitter>

5189 const Expr

*Cond = S->getCond();

5190 const Expr

= S->getInc();

5191 const Stmt

*Body = S->getBody();

5193 LabelTy

EndLabel = this->getLabel();

5194 LabelTy

CondLabel = this->getLabel();

5195 LabelTy

IncLabel = this->getLabel();

5198 if

(

&& !this->visitStmt(

))

5201

this->fallthrough(CondLabel);

5202

this->emitLabel(CondLabel);

5206 if

(

const DeclStmt

*CondDecl = S->getConditionVariableDeclStmt())

5207 if

(!visitDeclStmt(CondDecl))

5211 if

(!this->visitBool(Cond))

5213 if

(!this->jumpFalse(EndLabel))

5217 if

(Body && !this->visitStmt(Body))

5220

this->fallthrough(IncLabel);

5221

this->emitLabel(IncLabel);

5222 if

(

&& !this->discard(

))

5228 if

(!this->jump(CondLabel))

5231

this->fallthrough(EndLabel);

5232

this->emitLabel(EndLabel);

5236template

class

Emitter>

5239 const Expr

*Cond = S->getCond();

5240 const Expr

= S->getInc();

5241 const Stmt

*Body = S->getBody();

5242 const Stmt

*BeginStmt = S->getBeginStmt();

5243 const Stmt

*RangeStmt = S->getRangeStmt();

5244 const Stmt

*EndStmt = S->getEndStmt();

5245 const VarDecl

*LoopVar = S->getLoopVariable();

5247 LabelTy

EndLabel = this->getLabel();

5248 LabelTy

CondLabel = this->getLabel();

5249 LabelTy

IncLabel = this->getLabel();

5253 if

(

&& !this->visitStmt(

))

5255 if

(!this->visitStmt(RangeStmt))

5257 if

(!this->visitStmt(BeginStmt))

5259 if

(!this->visitStmt(EndStmt))

5263

this->fallthrough(CondLabel);

5264

this->emitLabel(CondLabel);

5265 if

(!this->visitBool(Cond))

5267 if

(!this->jumpFalse(EndLabel))

5270 if

(!this->visitVarDecl(LoopVar))

5275 if

(!this->visitStmt(Body))

5278

this->fallthrough(IncLabel);

5279

this->emitLabel(IncLabel);

5280 if

(!this->discard(

))

5284 if

(!this->jump(CondLabel))

5287

this->fallthrough(EndLabel);

5288

this->emitLabel(EndLabel);

5292template

class

Emitter>

5298 C

->getParent())

5299 C

->emitDestruction();

5300 return

this->jump(*BreakLabel);

5303template

class

Emitter>

5309 C

->getParent() != ContinueVarScope;

->getParent())

5310 C

->emitDestruction();

5311 return

this->jump(*ContinueLabel);

5314template

class

Emitter>

5316 const Expr

*Cond = S->getCond();

5320 LabelTy

EndLabel = this->getLabel();

5322 unsigned

CondVar = this->allocateLocalPrimitive(Cond, CondT,

true

false

);

5324 if

(

const auto

*CondInit = S->getInit())

5325 if

(!visitStmt(CondInit))

5328 if

(

const DeclStmt

*CondDecl = S->getConditionVariableDeclStmt())

5329 if

(!visitDeclStmt(CondDecl))

5333 if

(!this->visit(Cond))

5335 if

(!this->emitSetLocal(CondT, CondVar, S))

5340 for

(

const SwitchCase

*SC = S->getSwitchCaseList(); SC;

5341

SC = SC->getNextSwitchCase()) {

5342 if

(

const auto

*CS = dyn_cast<CaseStmt>(SC)) {

5344 if

(CS->caseStmtIsGNURange())

5346

CaseLabels[SC] = this->getLabel();

5352 if

(!this->emitGetLocal(CondT, CondVar, CS))

5354 if

(!this->visit(

))

5358 if

(!this->emitEQ(ValueT, S))

5360 if

(!this->jumpTrue(CaseLabels[CS]))

5363

assert(!DefaultLabel);

5364

DefaultLabel = this->getLabel();

5371 if

(!this->jump(*DefaultLabel))

5374 if

(!this->jump(EndLabel))

5379 if

(!this->visitStmt(S->getBody()))

5381

this->emitLabel(EndLabel);

5386template

class

Emitter>

5388

this->emitLabel(CaseLabels[S]);

5389 return

this->visitStmt(S->getSubStmt());

5392template

class

Emitter>

5394

this->emitLabel(*DefaultLabel);

5395 return

this->visitStmt(S->getSubStmt());

5398template

class

Emitter>

5401

!this->Ctx.getLangOpts().MSVCCompat) {

5402 for

(

const Attr

*A : S->getAttrs()) {

5403 auto

*AA = dyn_cast<CXXAssumeAttr>(A);

5407

assert(isa<NullStmt>(S->getSubStmt()));

5409 const Expr

*Assumption = AA->getAssumption();

5417 if

(!this->visitBool(Assumption))

5420 if

(!this->emitAssume(Assumption))

5426 return

this->visitStmt(S->getSubStmt());

5429template

class

Emitter>

5432 return

this->visitStmt(S->getTryBlock());

5435template

class

Emitter>

5439

assert(cast<CompoundStmt>(MD->

())->body_empty());

5444 const Function

= this->getFunction(LambdaCallOp);

5447

assert(

->hasThisPointer());

5450 if

(

->hasRVO()) {

5451 if

(!this->emitRVOPtr(MD))

5459 if

(!this->emitNullPtr(0,

nullptr

, MD))

5464 auto

It = this->Params.find(PVD);

5465

assert(It != this->Params.end());

5469 PrimType

ParamType = this->classify(PVD->getType()).value_or(

);

5470 if

(!this->emitGetParam(ParamType, It->second.Offset, MD))

5474 if

(!this->emitCall(

, 0, LambdaCallOp))

5477

this->emitCleanup();

5479 return

this->emitRet(*ReturnType, MD);

5482 return

this->emitRetVoid(MD);

5485template

class

Emitter>

5496template

class

Emitter>

5498

assert(!ReturnType);

5500 auto

emitFieldInitializer = [&](

const

Record::Field *F,

unsigned

FieldOffset,

5501 const Expr

*InitExpr) ->

bool

{

5503 if

(InitExpr->getType().isNull())

5506 if

(std::optional<PrimType>

= this->classify(InitExpr)) {

5507 if

(!this->visit(InitExpr))

5510 if

(F->isBitField())

5511 return

this->emitInitThisBitField(*

, F, FieldOffset, InitExpr);

5512 return

this->emitInitThisField(*

, FieldOffset, InitExpr);

5517 if

(!this->emitGetPtrThisField(FieldOffset, InitExpr))

5520 if

(!this->visitInitializer(InitExpr))

5523 return

this->emitFinishInitPop(InitExpr);

5527 const Record

*R = this->getRecord(RD);

5533

assert(cast<CompoundStmt>(Ctor->

())->body_empty());

5534 if

(!this->emitThis(Ctor))

5543 return

this->emitMemcpy(Ctor) && this->emitPopPtr(Ctor) &&

5544

this->emitRetVoid(Ctor);

5548 for

(

const auto

: Ctor->

inits

()) {

5552 const Expr

*InitExpr =

->getInit();

5556 if

(!emitFieldInitializer(F, F->Offset, InitExpr))

5558

}

else if

(

const Type

->getBaseClass()) {

5559 const auto

*BaseDecl =

->getAsCXXRecordDecl();

5562 if

(

->isBaseVirtual()) {

5564 if

(!this->emitGetPtrThisVirtBase(BaseDecl, InitExpr))

5570 const

Record::Base *B = R->

getBase

(BaseDecl);

5572 if

(!this->emitGetPtrThisBase(B->Offset, InitExpr))

5576 if

(!this->visitInitializer(InitExpr))

5578 if

(!this->emitFinishInitPop(InitExpr))

5581

assert(IFD->getChainingSize() >= 2);

5583 unsigned

NestedFieldOffset = 0;

5584 const

Record::Field *NestedField =

nullptr

;

5585 for

(

const NamedDecl

*ND : IFD->chain()) {

5586 const auto

*FD = cast<FieldDecl>(ND);

5587 const Record

*FieldRecord = this->

.getOrCreateRecord(FD->getParent());

5588

assert(FieldRecord);

5590

NestedField = FieldRecord->

(FD);

5591

assert(NestedField);

5593

NestedFieldOffset += NestedField->Offset;

5595

assert(NestedField);

5597 if

(!emitFieldInitializer(NestedField, NestedFieldOffset, InitExpr))

5600

assert(

->isDelegatingInitializer());

5601 if

(!this->emitThis(InitExpr))

5603 if

(!this->visitInitializer(

->getInit()))

5605 if

(!this->emitPopPtr(InitExpr))

5609 if

Scope

.destroyLocals())

5613 if

(

const auto

*Body = Ctor->

())

5614 if

(!visitStmt(Body))

5620template

class

Emitter>

5623 const Record

*R = this->getRecord(RD);

5628 if

(!this->visitStmt(Dtor->

()))

5632 if

(!this->emitThis(Dtor))

5638 for

(

const

Record::Field &Field : llvm::reverse(R->

fields

())) {

5640 if

->isPrimitive() && !

->isPrimitiveArray()) {

5651 for

(

const

Record::Base &

: llvm::reverse(R->

bases

())) {

5652 if

(

.R->isAnonymousUnion())

5657 if

(!this->emitRecordDestruction(

.R, {}))

5664 return

this->emitPopPtr(Dtor) && this->emitRetVoid(Dtor);

5667template

class

Emitter>

5670 if

(!this->emitThis(MD))

5679 return

this->emitMemcpy(MD) && this->emitRet(

, MD);

5682template

class

Emitter>

5687 if

(

const auto

*Ctor = dyn_cast<CXXConstructorDecl>(F))

5688 return

this->compileConstructor(Ctor);

5689 if

(

const auto

*Dtor = dyn_cast<CXXDestructorDecl>(F))

5690 return

this->compileDestructor(Dtor);

5693 if

(

const auto

*MD = dyn_cast<CXXMethodDecl>(F)) {

5697 return

this->compileUnionCopyAssignmentOperator(MD);

5700 return

this->emitLambdaStaticInvokerBody(MD);

5704 if

(

const auto

*Body = F->

())

5705 if

(!visitStmt(Body))

5714template

class

Emitter>

5716 const Expr

*SubExpr =

->getSubExpr();

5718 return

this->VisitComplexUnaryOperator(

);

5720 return

this->VisitVectorUnaryOperator(

);

5722 return

this->VisitFixedPointUnaryOperator(

);

5723

std::optional<PrimType>

= classify(SubExpr->

());

5725 switch

(

->getOpcode()) {

5728 return

this->emitInvalid(

);

5730 return

this->emitError(

);

5732 if

(!this->visit(SubExpr))

5736 if

(!this->emitIncPtr(

))

5739 return

DiscardResult ? this->emitPopPtr(

) :

true

;

5743 return

DiscardResult ? this->emitIncfPop(getFPOptions(

)

5744

: this->emitIncf(getFPOptions(

);

5747 return

DiscardResult ? this->emitIncPop(*

) : this->emitInc(*

);

5751 return

this->emitInvalid(

);

5753 return

this->emitError(

);

5755 if

(!this->visit(SubExpr))

5759 if

(!this->emitDecPtr(

))

5762 return

DiscardResult ? this->emitPopPtr(

) :

true

;

5766 return

DiscardResult ? this->emitDecfPop(getFPOptions(

)

5767

: this->emitDecf(getFPOptions(

);

5770 return

DiscardResult ? this->emitDecPop(*

) : this->emitDec(*

);

5774 return

this->emitInvalid(

);

5776 return

this->emitError(

);

5778 if

(!this->visit(SubExpr))

5782 if

(!this->emitLoadPtr(

))

5784 if

(!this->emitConstUint8(1,

))

5786 if

(!this->emitAddOffsetUint8(

))

5788 return

DiscardResult ? this->emitStorePopPtr(

) : this->emitStorePtr(

);

5792 if

(DiscardResult) {

5794 return

this->emitIncfPop(getFPOptions(

);

5795 return

this->emitIncPop(*

);

5799 const auto

&TargetSemantics = Ctx.getFloatSemantics(

());

5800 if

(!this->emitLoadFloat(

))

5802 if

(!this->emitConstFloat(llvm::APFloat(TargetSemantics, 1),

))

5804 if

(!this->emitAddf(getFPOptions(

))

5806 if

(!this->emitStoreFloat(

))

5810 if

(!this->emitLoad(*

))

5812 if

(!this->emitConst(1,

))

5814 if

(!this->emitAdd(*

))

5816 if

(!this->emitStore(*

))

5819 return E

isGLValue

() || this->emitLoadPop(*

);

5823 return

this->emitInvalid(

);

5825 return

this->emitError(

);

5827 if

(!this->visit(SubExpr))

5831 if

(!this->emitLoadPtr(

))

5833 if

(!this->emitConstUint8(1,

))

5835 if

(!this->emitSubOffsetUint8(

))

5837 return

DiscardResult ? this->emitStorePopPtr(

) : this->emitStorePtr(

);

5841 if

(DiscardResult) {

5843 return

this->emitDecfPop(getFPOptions(

);

5844 return

this->emitDecPop(*

);

5848 const auto

&TargetSemantics = Ctx.getFloatSemantics(

());

5849 if

(!this->emitLoadFloat(

))

5851 if

(!this->emitConstFloat(llvm::APFloat(TargetSemantics, 1),

))

5853 if

(!this->emitSubf(getFPOptions(

))

5855 if

(!this->emitStoreFloat(

))

5859 if

(!this->emitLoad(*

))

5861 if

(!this->emitConst(1,

))

5863 if

(!this->emitSub(*

))

5865 if

(!this->emitStore(*

))

5868 return E

isGLValue

() || this->emitLoadPop(*

);

5872 return

this->emitError(

);

5875 return

this->discard(SubExpr);

5877 if

(!this->visitBool(SubExpr))

5880 if

(!this->emitInv(

))

5884 return

this->emitCast(

, ET,

);

5888 return

this->emitError(

);

5890 if

(!this->visit(SubExpr))

5892 return

DiscardResult ? this->emitPop(*

) : this->emitNeg(*

);

5895 return

this->emitError(

);

5897 if

(!this->visit(SubExpr))

5899 return

DiscardResult ? this->emitPop(*

) :

true

;

5904 return

this->emitGetMemberPtr(cast<DeclRefExpr>(SubExpr)->getDecl(),

);

5907 return

this->delegate(SubExpr);

5909 if

(DiscardResult) {

5911 return

this->discard(SubExpr);

5914 if

(!this->visit(SubExpr))

5916 if

(classifyPrim(SubExpr) ==

)

5917 return

this->emitNarrowPtr(

);

5922 return

this->emitError(

);

5924 if

(!this->visit(SubExpr))

5926 return

DiscardResult ? this->emitPop(*

) : this->emitComp(*

);

5929 return

this->delegate(SubExpr);

5932 if

(!this->discard(SubExpr))

5934 return

this->visitZeroInitializer(*

, SubExpr->

(), SubExpr);

5937 return

this->delegate(SubExpr);

5939

assert(

false

"Unhandled opcode"

);

5945template

class

Emitter>

5947 const Expr

*SubExpr =

->getSubExpr();

5951 return

this->discard(SubExpr);

5953

std::optional<PrimType> ResT = classify(

);

5954 auto

prepareResult = [=]() ->

bool

{

5956

std::optional<unsigned> LocalIndex = allocateLocal(SubExpr);

5959 return

this->emitGetPtrLocal(*LocalIndex,

);

5966 unsigned

SubExprOffset = ~0u;

5967 auto

createTemp = [=, &SubExprOffset]() ->

bool

{

5968

SubExprOffset = this->allocateLocalPrimitive(SubExpr,

true

false

);

5969 if

(!this->visit(SubExpr))

5971 return

this->emitSetLocal(

, SubExprOffset,

);

5975 auto

getElem = [=](

unsigned

Offset,

unsigned

Index) ->

bool

{

5976 if

(!this->emitGetLocal(

, Offset,

))

5978 return

this->emitArrayElemPop(ElemT, Index,

);

5981 switch

(

->getOpcode()) {

5983 if

(!prepareResult())

5987 for

(

unsigned

I = 0; I != 2; ++I) {

5988 if

(!getElem(SubExprOffset, I))

5990 if

(!this->emitNeg(ElemT,

))

5992 if

(!this->emitInitElem(ElemT, I,

))

6000 return

this->delegate(SubExpr);

6003 if

(!this->visit(SubExpr))

6005 if

(!this->emitComplexBoolCast(SubExpr))

6007 if

(!this->emitInv(

))

6010 return

this->emitCast(

, ET,

);

6014 return

this->emitComplexReal(SubExpr);

6017 if

(!this->visit(SubExpr))

6021 if

(!this->emitConstUint8(1,

))

6023 return

this->emitArrayElemPtrPopUint8(

);

6028 return

this->emitArrayElemPop(classifyPrim(

()), 1,

);

6031 if

(!this->visit(SubExpr))

6034 if

(!this->emitArrayElem(ElemT, 1,

))

6036 if

(!this->emitNeg(ElemT,

))

6038 if

(!this->emitInitElem(ElemT, 1,

))

6040 return

DiscardResult ? this->emitPopPtr(

) :

true

;

6043 return

this->delegate(SubExpr);

6046 return

this->emitInvalid(

);

6052template

class

Emitter>

6054 const Expr

*SubExpr =

->getSubExpr();

6058 return

this->discard(SubExpr);

6060 auto

UnaryOp =

->getOpcode();

6061 if

(UnaryOp == UO_Extension)

6062 return

this->delegate(SubExpr);

6064 if

(UnaryOp != UO_Plus && UnaryOp != UO_Minus && UnaryOp != UO_LNot &&

6065

UnaryOp != UO_Not && UnaryOp != UO_AddrOf)

6066 return

this->emitInvalid(

);

6069 if

(UnaryOp == UO_Plus || UnaryOp == UO_AddrOf)

6070 return

this->delegate(SubExpr);

6073

std::optional<unsigned> LocalIndex = allocateLocal(SubExpr);

6076 if

(!this->emitGetPtrLocal(*LocalIndex,

))

6081 unsigned

SubExprOffset =

6082

this->allocateLocalPrimitive(SubExpr,

true

false

);

6083 if

(!this->visit(SubExpr))

6085 if

(!this->emitSetLocal(

, SubExprOffset,

))

6090 auto

getElem = [=](

unsigned

Offset,

unsigned

Index) ->

bool

{

6091 if

(!this->emitGetLocal(

, Offset,

))

6093 return

this->emitArrayElemPop(ElemT, Index,

);

6098 for

(

unsigned

I = 0; I != VecTy->getNumElements(); ++I) {

6099 if

(!getElem(SubExprOffset, I))

6101 if

(!this->emitNeg(ElemT,

))

6103 if

(!this->emitInitElem(ElemT, I,

))

6118 for

(

unsigned

I = 0; I != VecTy->getNumElements(); ++I) {

6119 if

(!getElem(SubExprOffset, I))

6122 if

(!this->emitPrimCast(ElemT,

, Ctx.getASTContext().

BoolTy

))

6124 if

(!this->emitInv(

))

6126 if

(!this->emitPrimCast(

, ElemT, VecTy->getElementType(),

))

6128 if

(!this->emitNeg(ElemT,

))

6130 if

(ElemT != ResultVecElemT &&

6131

!this->emitPrimCast(ElemT, ResultVecElemT, ResultVecTy,

))

6133 if

(!this->emitInitElem(ResultVecElemT, I,

))

6139 for

(

unsigned

I = 0; I != VecTy->getNumElements(); ++I) {

6140 if

(!getElem(SubExprOffset, I))

6143 if

(!this->emitInv(

))

6146 if

(!this->emitComp(ElemT,

))

6149 if

(!this->emitInitElem(ElemT, I,

))

6154

llvm_unreachable(

"Unsupported unary operators should be handled up front"

);

6159template

class

Emitter>

6164 if

(

const auto

*ECD = dyn_cast<EnumConstantDecl>(

)) {

6165 return

this->emitConst(ECD->getInitVal(),

);

6166

}

else if

(

const auto

*BD = dyn_cast<BindingDecl>(

)) {

6167 return

this->visit(BD->getBinding());

6168

}

else if

(

const auto

*FuncDecl = dyn_cast<FunctionDecl>(

)) {

6169 const Function

*F = getFunction(FuncDecl);

6170 return

F && this->emitGetFnPtr(F,

);

6171

}

else if

(

const auto

*TPOD = dyn_cast<TemplateParamObjectDecl>(

)) {

6172 if

(std::optional<unsigned> Index =

.getOrCreateGlobal(

)) {

6173 if

(!this->emitGetPtrGlobal(*Index,

))

6175 if

(std::optional<PrimType>

= classify(

())) {

6176 if

(!this->visitAPValue(TPOD->getValue(), *

))

6178 return

this->emitInitGlobal(*

, *Index,

);

6180 return

this->visitAPValueInitializer(TPOD->getValue(),

);

6189 bool

IsReference =

->getType()->isReferenceType();

6192 if

(

auto

It = Locals.find(

); It != Locals.end()) {

6193 const unsigned

Offset = It->second.Offset;

6195 return

this->emitGetLocal(

, Offset,

);

6196 return

this->emitGetPtrLocal(Offset,

);

6197

}

else if

(

auto

GlobalIndex =

.getGlobal(

)) {

6200 return

this->emitGetGlobal(classifyPrim(

), *GlobalIndex,

);

6201 return

this->emitGetGlobalUnchecked(classifyPrim(

), *GlobalIndex,

);

6204 return

this->emitGetPtrGlobal(*GlobalIndex,

);

6205

}

else if

(

const auto

*PVD = dyn_cast<ParmVarDecl>(

)) {

6206 if

(

auto

It = this->Params.find(PVD); It != this->Params.end()) {

6207 if

(IsReference || !It->second.IsPtr)

6208 return

this->emitGetParam(classifyPrim(

), It->second.Offset,

);

6210 return

this->emitGetPtrParam(It->second.Offset,

);

6213 if

(

->getType()->isReferenceType())

6214 return

this->emitDummyPtr(

);

6218 auto

revisit = [&](

const VarDecl

*VD) ->

bool

{

6219 auto

VarState = this->visitDecl(VD);

6221 if

(VarState.notCreated())

6226 return

this->visitDeclRef(

);

6230 if

(

auto

It = this->LambdaCaptures.find(

);

6231

It != this->LambdaCaptures.end()) {

6232 auto

[Offset, IsPtr] = It->second;

6235 return

this->emitGetThisFieldPtr(Offset,

);

6236 return

this->emitGetPtrThisField(Offset,

);

6237

}

else if

(

const auto

*DRE = dyn_cast<DeclRefExpr>(

);

6238

DRE && DRE->refersToEnclosingVariableOrCapture()) {

6239 if

(

const auto

*VD = dyn_cast<VarDecl>(

); VD && VD->isInitCapture())

6244 if

(

== InitializingDecl)

6245 return

this->emitDummyPtr(

);

6251 if

(

const auto

*VD = dyn_cast<VarDecl>(

);

6252

VD && VD->getAnyInitializer() &&

6253

VD->getType().isConstant(Ctx.getASTContext()) && !VD->isWeak())

6255 return

this->emitDummyPtr(

);

6259 const auto

*VD = dyn_cast<VarDecl>(

);

6261 return

this->emitDummyPtr(

);

6263 const auto

typeShouldBeVisited = [&](

QualType T

) ->

bool

{

6264 if

(

.isConstant(Ctx.getASTContext()))

6270 if

(isa<DecompositionDecl>(VD))

6273 if

((VD->hasGlobalStorage() || VD->isStaticDataMember()) &&

6274

typeShouldBeVisited(VD->getType())) {

6275 if

(

const Expr

= VD->getAnyInitializer();

6276 Init

&& !

->isValueDependent()) {

6282

(void)

->EvaluateAsInitializer(

, Ctx.getASTContext(), VD, Notes,

6284 return

this->visitDeclRef(

);

6293 if

(VD->isLocalVarDecl() && typeShouldBeVisited(VD->getType()) &&

6294

VD->getInit() && !VD->getInit()->isValueDependent()) {

6296 if

(VD->evaluateValue())

6299 if

->getType()->isReferenceType())

6300 return

this->emitDummyPtr(

);

6302 return

this->emitInvalidDeclRef(cast<DeclRefExpr>(

6306 return

this->emitDummyPtr(

);

6309template

class

Emitter>

6311 const auto

->getDecl();

6312 return

this->visitDeclRef(

);

6317 C

->emitDestruction();

6320template

class

Emitter>

6324 if

(

const auto

*R = Ty->getPointeeCXXRecordDecl())

6326 return

Ty->getAsCXXRecordDecl();

6328 const CXXRecordDecl

*BaseDecl = extractRecordDecl(BaseType);

6329 const CXXRecordDecl

*DerivedDecl = extractRecordDecl(DerivedType);

6331 return

Ctx.collectBaseOffset(BaseDecl, DerivedDecl);

6335template

class

Emitter>

6342 const

llvm::fltSemantics *ToSem = &Ctx.getFloatSemantics(ToQT);

6347 return

this->emitCastFloatingIntegralAP(Ctx.getBitWidth(ToQT),

6348

getFPOptions(

);

6350 return

this->emitCastFloatingIntegralAPS(Ctx.getBitWidth(ToQT),

6351

getFPOptions(

);

6355 return

this->emitCastFloatingIntegral(ToT, getFPOptions(

);

6360 return

this->emitCastAP(FromT, Ctx.getBitWidth(ToQT),

);

6362 return

this->emitCastAPS(FromT, Ctx.getBitWidth(ToQT),

);

6366 return

FromT != ToT ? this->emitCast(FromT, ToT,

) :

true

;

6370 const

llvm::fltSemantics *ToSem = &Ctx.getFloatSemantics(ToQT);

6371 return

this->emitCastIntegralFloating(FromT, ToSem, getFPOptions(

);

6379template

class

Emitter>

6384 return

this->discard(SubExpr);

6386 if

(!this->visit(SubExpr))

6389 if

(!this->emitConstUint8(0, SubExpr))

6391 return

this->emitArrayElemPtrPopUint8(SubExpr);

6395 return

this->emitArrayElemPop(classifyComplexElementType(SubExpr->

()),

6399template

class

Emitter>

6401

assert(!DiscardResult);

6405 if

(!this->emitArrayElem(ElemT, 0,

))

6408 if

(!this->emitCastFloatingIntegral(

, getFPOptions(

))

6411 if

(!this->emitCast(ElemT,

))

6416

LabelTy LabelTrue = this->getLabel();

6417 if

(!this->jumpTrue(LabelTrue))

6420 if

(!this->emitArrayElemPop(ElemT, 1,

))

6423 if

(!this->emitCastFloatingIntegral(

, getFPOptions(

))

6426 if

(!this->emitCast(ElemT,

))

6430

LabelTy EndLabel = this->getLabel();

6431

this->jump(EndLabel);

6433

this->emitLabel(LabelTrue);

6434 if

(!this->emitPopPtr(

))

6436 if

(!this->emitConstBool(

true

))

6439

this->fallthrough(EndLabel);

6440

this->emitLabel(EndLabel);

6445template

class

Emitter>

6448

assert(

->isComparisonOp());

6450

assert(!DiscardResult);

6456

LHSIsComplex =

true

;

6457

ElemT = classifyComplexElementType(LHS->

());

6458

LHSOffset = allocateLocalPrimitive(LHS,

true

6460 if

(!this->visit(LHS))

6462 if

(!this->emitSetLocal(

, LHSOffset,

))

6465

LHSIsComplex =

false

;

6467

LHSOffset = this->allocateLocalPrimitive(LHS, LHST,

true

false

);

6468 if

(!this->visit(LHS))

6470 if

(!this->emitSetLocal(LHST, LHSOffset,

))

6477

RHSIsComplex =

true

;

6478

ElemT = classifyComplexElementType(RHS->

());

6479

RHSOffset = allocateLocalPrimitive(RHS,

true

6481 if

(!this->visit(RHS))

6483 if

(!this->emitSetLocal(

, RHSOffset,

))

6486

RHSIsComplex =

false

;

6488

RHSOffset = this->allocateLocalPrimitive(RHS, RHST,

true

false

);

6489 if

(!this->visit(RHS))

6491 if

(!this->emitSetLocal(RHST, RHSOffset,

))

6495 auto

getElem = [&](

unsigned

LocalOffset,

unsigned

Index,

6496 bool

IsComplex) ->

bool

{

6498 if

(!this->emitGetLocal(

, LocalOffset,

))

6500 return

this->emitArrayElemPop(ElemT, Index,

);

6502 return

this->emitGetLocal(ElemT, LocalOffset,

);

6505 for

(

unsigned

I = 0; I != 2; ++I) {

6507 if

(!getElem(LHSOffset, I, LHSIsComplex))

6509 if

(!getElem(RHSOffset, I, RHSIsComplex))

6512 if

(!this->emitEQ(ElemT,

))

6515 if

(!this->emitCastBoolUint8(

))

6520 if

(!this->emitAddUint8(

))

6522 if

(!this->emitConstUint8(2,

))

6525 if

(

->getOpcode() == BO_EQ) {

6526 if

(!this->emitEQUint8(

))

6528

}

else if

(

->getOpcode() == BO_NE) {

6529 if

(!this->emitNEUint8(

))

6536 return

this->emitCast(

, ResT,

);

6543template

class

Emitter>

6552 const Function

*DtorFunc = getFunction(Dtor);

6557 if

(!this->emitDupPtr(

))

6559 return

this->emitCall(DtorFunc, 0,

);

6564template

class

Emitter>

6589 for

(ssize_t I = Desc->

getNumElems

() - 1; I >= 0; --I) {

6590 if

(!this->emitConstUint64(I,

))

6592 if

(!this->emitArrayElemPtrUint64(

))

6594 if

(!this->emitDestruction(ElemDesc,

))

6596 if

(!this->emitPopPtr(

))

6606 return

this->emitRecordDestruction(Desc->

ElemRecord

);

6611template

class

Emitter>

6613

assert(!DiscardResult &&

"Should've been checked before"

);

6615 unsigned

DummyID =

.getOrCreateDummy(

);

6617 if

(!this->emitGetPtrGlobal(DummyID,

))

6625 return

this->emitDecayPtr(