Skip to content

Commit f57bc64

Browse files
eecksteineeckstein
committed
Builder Bridging: some refactoring to simplify the code
NFC
1 parent 22979b9 commit f57bc64

File tree

2 files changed

+66
-63
lines changed

2 files changed

+66
-63
lines changed

‎include/swift/SIL/SILBridging.h

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,7 @@
2121

2222
#ifdef USED_IN_CPP_SOURCE
2323
#include "llvm/ADT/ArrayRef.h"
24+
#include "swift/SIL/SILBuilder.h"
2425
#include "swift/SIL/SILInstruction.h"
2526
#include "swift/SIL/SILWitnessTable.h"
2627
#endif
@@ -769,6 +770,23 @@ struct BridgedBuilder{
769770

770771
SwiftObject insertionObj;
771772
BridgedLocation loc;
773+
774+
#ifdef USED_IN_CPP_SOURCE
775+
swift::SILBuilder get() const {
776+
switch (insertAt) {
777+
case BridgedBuilder::InsertAt::beforeInst:
778+
return swift::SILBuilder(BridgedInstruction(insertionObj).get(), loc.getLoc().getScope());
779+
case BridgedBuilder::InsertAt::endOfBlock:
780+
return swift::SILBuilder(BridgedBasicBlock(insertionObj).get(), loc.getLoc().getScope());
781+
case BridgedBuilder::InsertAt::intoGlobal:
782+
return swift::SILBuilder(BridgedGlobalVar(insertionObj).getGlobal());
783+
}
784+
}
785+
swift::SILLocation regularLoc() const {
786+
return swift::RegularLocation(loc.getLoc().getLocation());
787+
}
788+
#endif
789+
772790
SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createBuiltinBinaryFunction(BridgedStringRef name,
773791
BridgedType operandType, BridgedType resultType,
774792
BridgedValueArray arguments) const;

‎include/swift/SIL/SILBridgingImpl.h

Lines changed: 48 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -1124,127 +1124,112 @@ BridgedWitnessTableEntryArray BridgedDefaultWitnessTable::getEntries() const {
11241124
// BridgedBuilder
11251125
//===----------------------------------------------------------------------===//
11261126

1127-
static swift::SILBuilder builder(const BridgedBuilder * _Nonnull b) {
1128-
switch (b->insertAt) {
1129-
case BridgedBuilder::InsertAt::beforeInst:
1130-
return swift::SILBuilder(BridgedInstruction(b->insertionObj).get(), b->loc.getLoc().getScope());
1131-
case BridgedBuilder::InsertAt::endOfBlock:
1132-
return swift::SILBuilder(BridgedBasicBlock(b->insertionObj).get(), b->loc.getLoc().getScope());
1133-
case BridgedBuilder::InsertAt::intoGlobal:
1134-
return swift::SILBuilder(BridgedGlobalVar(b->insertionObj).getGlobal());
1135-
}
1136-
}
1137-
1138-
static swift::SILLocation regularLoc(const BridgedBuilder * _Nonnull b) {
1139-
return swift::RegularLocation(b->loc.getLoc().getLocation());
1140-
}
1141-
11421127
BridgedInstruction BridgedBuilder::createBuiltinBinaryFunction(BridgedStringRef name,
11431128
BridgedType operandType, BridgedType resultType,
11441129
BridgedValueArray arguments) const {
11451130
llvm::SmallVector<swift::SILValue, 16> argValues;
1146-
return {builder(this).createBuiltinBinaryFunction(regularLoc(this),
1131+
return {get().createBuiltinBinaryFunction(regularLoc(),
11471132
name.get(),
11481133
operandType.get(), resultType.get(),
11491134
arguments.getValues(argValues))};
11501135
}
11511136

11521137
BridgedInstruction BridgedBuilder::createCondFail(BridgedValue condition, BridgedStringRef message) const {
1153-
return {builder(this).createCondFail(regularLoc(this), condition.getSILValue(), message.get())};
1138+
return {get().createCondFail(regularLoc(), condition.getSILValue(), message.get())};
11541139
}
11551140

11561141
BridgedInstruction BridgedBuilder::createIntegerLiteral(BridgedType type, SwiftInt value) const {
1157-
return {builder(this).createIntegerLiteral(regularLoc(this), type.get(), value)};
1142+
return {get().createIntegerLiteral(regularLoc(), type.get(), value)};
11581143
}
11591144

11601145
BridgedInstruction BridgedBuilder::createAllocStack(BridgedType type,
11611146
bool hasDynamicLifetime, bool isLexical, bool wasMoved) const {
1162-
return {builder(this).createAllocStack(regularLoc(this), type.get(), llvm::None,
1147+
return {get().createAllocStack(regularLoc(), type.get(), llvm::None,
11631148
hasDynamicLifetime, isLexical, wasMoved)};
11641149
}
11651150

11661151
BridgedInstruction BridgedBuilder::createDeallocStack(BridgedValue operand) const {
1167-
return {builder(this).createDeallocStack(regularLoc(this), operand.getSILValue())};
1152+
return {get().createDeallocStack(regularLoc(), operand.getSILValue())};
11681153
}
11691154

11701155
BridgedInstruction BridgedBuilder::createDeallocStackRef(BridgedValue operand) const {
1171-
return {builder(this).createDeallocStackRef(regularLoc(this), operand.getSILValue())};
1156+
return {get().createDeallocStackRef(regularLoc(), operand.getSILValue())};
11721157
}
11731158

11741159
BridgedInstruction BridgedBuilder::createUncheckedRefCast(BridgedValue op, BridgedType type) const {
1175-
return {builder(this).createUncheckedRefCast(regularLoc(this), op.getSILValue(), type.get())};
1160+
return {get().createUncheckedRefCast(regularLoc(), op.getSILValue(), type.get())};
11761161
}
11771162

11781163
BridgedInstruction BridgedBuilder::createUpcast(BridgedValue op, BridgedType type) const {
1179-
return {builder(this).createUpcast(regularLoc(this), op.getSILValue(), type.get())};
1164+
return {get().createUpcast(regularLoc(), op.getSILValue(), type.get())};
11801165
}
11811166

11821167
BridgedInstruction BridgedBuilder::createLoad(BridgedValue op, SwiftInt ownership) const {
1183-
return {builder(this).createLoad(regularLoc(this), op.getSILValue(), (swift::LoadOwnershipQualifier)ownership)};
1168+
return {get().createLoad(regularLoc(), op.getSILValue(), (swift::LoadOwnershipQualifier)ownership)};
11841169
}
11851170

11861171
BridgedInstruction BridgedBuilder::createBeginDeallocRef(BridgedValue reference, BridgedValue allocation) const {
1187-
return {builder(this).createBeginDeallocRef(regularLoc(this), reference.getSILValue(), allocation.getSILValue())};
1172+
return {get().createBeginDeallocRef(regularLoc(), reference.getSILValue(), allocation.getSILValue())};
11881173
}
11891174

11901175
BridgedInstruction BridgedBuilder::createEndInitLetRef(BridgedValue op) const {
1191-
return {builder(this).createEndInitLetRef(regularLoc(this), op.getSILValue())};
1176+
return {get().createEndInitLetRef(regularLoc(), op.getSILValue())};
11921177
}
11931178

11941179
BridgedInstruction BridgedBuilder::createStrongRetain(BridgedValue op) const {
1195-
auto b = builder(this);
1196-
return {b.createStrongRetain(regularLoc(this), op.getSILValue(), b.getDefaultAtomicity())};
1180+
auto b = get();
1181+
return {b.createStrongRetain(regularLoc(), op.getSILValue(), b.getDefaultAtomicity())};
11971182
}
11981183

11991184
BridgedInstruction BridgedBuilder::createStrongRelease(BridgedValue op) const {
1200-
auto b = builder(this);
1201-
return {b.createStrongRelease(regularLoc(this), op.getSILValue(), b.getDefaultAtomicity())};
1185+
auto b = get();
1186+
return {b.createStrongRelease(regularLoc(), op.getSILValue(), b.getDefaultAtomicity())};
12021187
}
12031188

12041189
BridgedInstruction BridgedBuilder::createUnownedRetain(BridgedValue op) const {
1205-
auto b = builder(this);
1206-
return {b.createUnownedRetain(regularLoc(this), op.getSILValue(), b.getDefaultAtomicity())};
1190+
auto b = get();
1191+
return {b.createUnownedRetain(regularLoc(), op.getSILValue(), b.getDefaultAtomicity())};
12071192
}
12081193

12091194
BridgedInstruction BridgedBuilder::createUnownedRelease(BridgedValue op) const {
1210-
auto b = builder(this);
1211-
return {b.createUnownedRelease(regularLoc(this), op.getSILValue(), b.getDefaultAtomicity())};
1195+
auto b = get();
1196+
return {b.createUnownedRelease(regularLoc(), op.getSILValue(), b.getDefaultAtomicity())};
12121197
}
12131198

12141199
BridgedInstruction BridgedBuilder::createFunctionRef(BridgedFunction function) const {
1215-
return {builder(this).createFunctionRef(regularLoc(this), function.getFunction())};
1200+
return {get().createFunctionRef(regularLoc(), function.getFunction())};
12161201
}
12171202

12181203
BridgedInstruction BridgedBuilder::createCopyValue(BridgedValue op) const {
1219-
return {builder(this).createCopyValue(regularLoc(this), op.getSILValue())};
1204+
return {get().createCopyValue(regularLoc(), op.getSILValue())};
12201205
}
12211206

12221207
BridgedInstruction BridgedBuilder::createBeginBorrow(BridgedValue op) const {
1223-
return {builder(this).createBeginBorrow(regularLoc(this), op.getSILValue())};
1208+
return {get().createBeginBorrow(regularLoc(), op.getSILValue())};
12241209
}
12251210

12261211
BridgedInstruction BridgedBuilder::createEndBorrow(BridgedValue op) const {
1227-
return {builder(this).createEndBorrow(regularLoc(this), op.getSILValue())};
1212+
return {get().createEndBorrow(regularLoc(), op.getSILValue())};
12281213
}
12291214

12301215
BridgedInstruction BridgedBuilder::createCopyAddr(BridgedValue from, BridgedValue to,
12311216
bool takeSource, bool initializeDest) const {
1232-
return {builder(this).createCopyAddr(regularLoc(this),
1217+
return {get().createCopyAddr(regularLoc(),
12331218
from.getSILValue(), to.getSILValue(),
12341219
swift::IsTake_t(takeSource),
12351220
swift::IsInitialization_t(initializeDest))};
12361221
}
12371222

12381223
BridgedInstruction BridgedBuilder::createDestroyValue(BridgedValue op) const {
1239-
return {builder(this).createDestroyValue(regularLoc(this), op.getSILValue())};
1224+
return {get().createDestroyValue(regularLoc(), op.getSILValue())};
12401225
}
12411226

12421227
BridgedInstruction BridgedBuilder::createDestroyAddr(BridgedValue op) const {
1243-
return {builder(this).createDestroyAddr(regularLoc(this), op.getSILValue())};
1228+
return {get().createDestroyAddr(regularLoc(), op.getSILValue())};
12441229
}
12451230

12461231
BridgedInstruction BridgedBuilder::createDebugStep() const {
1247-
return {builder(this).createDebugStep(regularLoc(this))};
1232+
return {get().createDebugStep(regularLoc())};
12481233
}
12491234

12501235
BridgedInstruction BridgedBuilder::createApply(BridgedValue function, BridgedSubstitutionMap subMap,
@@ -1255,7 +1240,7 @@ BridgedInstruction BridgedBuilder::createApply(BridgedValue function, BridgedSub
12551240
if (isNonThrowing) { applyOpts |= swift::ApplyFlags::DoesNotThrow; }
12561241
if (isNonAsync) { applyOpts |= swift::ApplyFlags::DoesNotAwait; }
12571242

1258-
return {builder(this).createApply(regularLoc(this),
1243+
return {get().createApply(regularLoc(),
12591244
function.getSILValue(), subMap.get(),
12601245
arguments.getValues(argValues),
12611246
applyOpts, specInfo.data)};
@@ -1277,99 +1262,99 @@ BridgedInstruction BridgedBuilder::createSwitchEnumInst(BridgedValue enumVal, Op
12771262
assert(mappedElements.count(c.first) && "wrong enum element index");
12781263
convertedCases.push_back({mappedElements[c.first], c.second.get()});
12791264
}
1280-
return {builder(this).createSwitchEnum(regularLoc(this),
1265+
return {get().createSwitchEnum(regularLoc(),
12811266
enumVal.getSILValue(),
12821267
defaultBlock.get(), convertedCases)};
12831268
}
12841269

12851270
BridgedInstruction BridgedBuilder::createUncheckedEnumData(BridgedValue enumVal, SwiftInt caseIdx,
12861271
BridgedType resultType) const {
12871272
swift::SILValue en = enumVal.getSILValue();
1288-
return {builder(this).createUncheckedEnumData(regularLoc(this), enumVal.getSILValue(),
1273+
return {get().createUncheckedEnumData(regularLoc(), enumVal.getSILValue(),
12891274
en->getType().getEnumElement(caseIdx), resultType.get())};
12901275
}
12911276

12921277
BridgedInstruction BridgedBuilder::createEnum(SwiftInt caseIdx, OptionalBridgedValue payload,
12931278
BridgedType resultType) const {
12941279
swift::EnumElementDecl *caseDecl = resultType.get().getEnumElement(caseIdx);
12951280
swift::SILValue pl = payload.getSILValue();
1296-
return {builder(this).createEnum(regularLoc(this), pl, caseDecl, resultType.get())};
1281+
return {get().createEnum(regularLoc(), pl, caseDecl, resultType.get())};
12971282
}
12981283

12991284
BridgedInstruction BridgedBuilder::createBranch(BridgedBasicBlock destBlock, BridgedValueArray arguments) const {
13001285
llvm::SmallVector<swift::SILValue, 16> argValues;
1301-
return {builder(this).createBranch(regularLoc(this), destBlock.get(), arguments.getValues(argValues))};
1286+
return {get().createBranch(regularLoc(), destBlock.get(), arguments.getValues(argValues))};
13021287
}
13031288

13041289
BridgedInstruction BridgedBuilder::createUnreachable() const {
1305-
return {builder(this).createUnreachable(regularLoc(this))};
1290+
return {get().createUnreachable(regularLoc())};
13061291
}
13071292

13081293
BridgedInstruction BridgedBuilder::createObject(BridgedType type,
13091294
BridgedValueArray arguments,
13101295
SwiftInt numBaseElements) const {
13111296
llvm::SmallVector<swift::SILValue, 16> argValues;
1312-
return {builder(this).createObject(swift::ArtificialUnreachableLocation(),
1297+
return {get().createObject(swift::ArtificialUnreachableLocation(),
13131298
type.get(), arguments.getValues(argValues), numBaseElements)};
13141299
}
13151300

13161301
BridgedInstruction BridgedBuilder::createGlobalAddr(BridgedGlobalVar global) const {
1317-
return {builder(this).createGlobalAddr(regularLoc(this), global.getGlobal())};
1302+
return {get().createGlobalAddr(regularLoc(), global.getGlobal())};
13181303
}
13191304

13201305
BridgedInstruction BridgedBuilder::createGlobalValue(BridgedGlobalVar global, bool isBare) const {
1321-
return {builder(this).createGlobalValue(regularLoc(this), global.getGlobal(), isBare)};
1306+
return {get().createGlobalValue(regularLoc(), global.getGlobal(), isBare)};
13221307
}
13231308

13241309
BridgedInstruction BridgedBuilder::createStruct(BridgedType type, BridgedValueArray elements) const {
13251310
llvm::SmallVector<swift::SILValue, 16> elementValues;
1326-
return {builder(this).createStruct(regularLoc(this), type.get(), elements.getValues(elementValues))};
1311+
return {get().createStruct(regularLoc(), type.get(), elements.getValues(elementValues))};
13271312
}
13281313

13291314
BridgedInstruction BridgedBuilder::createStructExtract(BridgedValue str, SwiftInt fieldIndex) const {
13301315
swift::SILValue v = str.getSILValue();
1331-
return {builder(this).createStructExtract(regularLoc(this), v, v->getType().getFieldDecl(fieldIndex))};
1316+
return {get().createStructExtract(regularLoc(), v, v->getType().getFieldDecl(fieldIndex))};
13321317
}
13331318

13341319
BridgedInstruction BridgedBuilder::createStructElementAddr(BridgedValue addr, SwiftInt fieldIndex) const {
13351320
swift::SILValue v = addr.getSILValue();
1336-
return {builder(this).createStructElementAddr(regularLoc(this), v, v->getType().getFieldDecl(fieldIndex))};
1321+
return {get().createStructElementAddr(regularLoc(), v, v->getType().getFieldDecl(fieldIndex))};
13371322
}
13381323

13391324
BridgedInstruction BridgedBuilder::createDestructureStruct(BridgedValue str) const {
1340-
return {builder(this).createDestructureStruct(regularLoc(this), str.getSILValue())};
1325+
return {get().createDestructureStruct(regularLoc(), str.getSILValue())};
13411326
}
13421327

13431328
BridgedInstruction BridgedBuilder::createTuple(BridgedType type, BridgedValueArray elements) const {
13441329
llvm::SmallVector<swift::SILValue, 16> elementValues;
1345-
return {builder(this).createTuple(regularLoc(this), type.get(), elements.getValues(elementValues))};
1330+
return {get().createTuple(regularLoc(), type.get(), elements.getValues(elementValues))};
13461331
}
13471332

13481333
BridgedInstruction BridgedBuilder::createTupleExtract(BridgedValue str, SwiftInt elementIndex) const {
13491334
swift::SILValue v = str.getSILValue();
1350-
return {builder(this).createTupleExtract(regularLoc(this), v, elementIndex)};
1335+
return {get().createTupleExtract(regularLoc(), v, elementIndex)};
13511336
}
13521337

13531338
BridgedInstruction BridgedBuilder::createTupleElementAddr(BridgedValue addr, SwiftInt elementIndex) const {
13541339
swift::SILValue v = addr.getSILValue();
1355-
return {builder(this).createTupleElementAddr(regularLoc(this), v, elementIndex)};
1340+
return {get().createTupleElementAddr(regularLoc(), v, elementIndex)};
13561341
}
13571342

13581343
BridgedInstruction BridgedBuilder::createDestructureTuple(BridgedValue str) const {
1359-
return {builder(this).createDestructureTuple(regularLoc(this), str.getSILValue())};
1344+
return {get().createDestructureTuple(regularLoc(), str.getSILValue())};
13601345
}
13611346

13621347
BridgedInstruction BridgedBuilder::createStore(BridgedValue src, BridgedValue dst,
13631348
SwiftInt ownership) const {
1364-
return {builder(this).createStore(regularLoc(this), src.getSILValue(), dst.getSILValue(),
1349+
return {get().createStore(regularLoc(), src.getSILValue(), dst.getSILValue(),
13651350
(swift::StoreOwnershipQualifier)ownership)};
13661351
}
13671352

13681353
BridgedInstruction BridgedBuilder::createInitExistentialRef(BridgedValue instance,
13691354
BridgedType type,
13701355
BridgedInstruction useConformancesOf) const {
13711356
auto *src = useConformancesOf.getAs<swift::InitExistentialRefInst>();
1372-
return {builder(this).createInitExistentialRef(regularLoc(this), type.get(),
1357+
return {get().createInitExistentialRef(regularLoc(), type.get(),
13731358
src->getFormalConcreteType(),
13741359
instance.getSILValue(),
13751360
src->getConformances())};
@@ -1379,11 +1364,11 @@ BridgedInstruction BridgedBuilder::createMetatype(BridgedType type,
13791364
BridgedType::MetatypeRepresentation representation) const {
13801365
auto *mt = swift::MetatypeType::get(type.get().getASTType(), (swift::MetatypeRepresentation)representation);
13811366
auto t = swift::SILType::getPrimitiveObjectType(swift::CanType(mt));
1382-
return {builder(this).createMetatype(regularLoc(this), t)};
1367+
return {get().createMetatype(regularLoc(), t)};
13831368
}
13841369

13851370
BridgedInstruction BridgedBuilder::createEndCOWMutation(BridgedValue instance, bool keepUnique) const {
1386-
return {builder(this).createEndCOWMutation(regularLoc(this), instance.getSILValue(), keepUnique)};
1371+
return {get().createEndCOWMutation(regularLoc(), instance.getSILValue(), keepUnique)};
13871372
}
13881373

13891374
//===----------------------------------------------------------------------===//

0 commit comments

Comments
 (0)