Skip to content

Commit 00b98b9

Browse files
adazem009adazem009
committed
Variable & list optimizations
* always use stack variables * pass a custom destination type variable to createValueStore() * improve list type assumption
1 parent 269e011 commit 00b98b9

File tree

9 files changed

+100
-80
lines changed

9 files changed

+100
-80
lines changed

‎src/engine/internal/llvm/instructions/functions.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ LLVMInstruction *Functions::buildFunctionCall(LLVMInstruction *ins)
3030
std::vector<llvm::Value *> args;
3131

3232
// Variables must be synchronized because the function can read them
33-
m_utils.syncVariables(m_utils.targetVariables());
33+
m_utils.syncVariables();
3434

3535
// Add execution context arg
3636
if (ins->functionCtxArg) {

‎src/engine/internal/llvm/instructions/lists.cpp‎

Lines changed: 46 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -147,15 +147,15 @@ LLVMInstruction *Lists::buildAppendToList(LLVMInstruction *ins)
147147
// If there's enough space, use the allocated memory
148148
m_builder.SetInsertPoint(ifBlock);
149149
llvm::Value *itemPtr = m_utils.getListItem(listPtr, size);
150-
m_utils.createValueStore(arg.second, itemPtr, type);
150+
m_utils.createValueStore(itemPtr, m_utils.getValueTypePtr(itemPtr), arg.second, type);
151151
m_builder.CreateStore(m_builder.CreateAdd(size, m_builder.getInt64(1)), listPtr.sizePtr); // update size stored in *sizePtr
152152
m_builder.CreateBr(nextBlock);
153153

154154
// Otherwise call appendEmpty()
155155
m_builder.SetInsertPoint(elseBlock);
156156
itemPtr = m_builder.CreateCall(m_utils.functions().resolve_list_append_empty(), listPtr.ptr);
157157
// NOTE: Items created using appendEmpty() are always numbers
158-
m_utils.createValueStore(arg.second, itemPtr, Compiler::StaticType::Number, type);
158+
m_utils.createValueStore(itemPtr, m_utils.getValueTypePtr(itemPtr), arg.second, Compiler::StaticType::Number, type);
159159
m_builder.CreateBr(nextBlock);
160160

161161
m_builder.SetInsertPoint(nextBlock);
@@ -196,7 +196,7 @@ LLVMInstruction *Lists::buildInsertToList(LLVMInstruction *ins)
196196
m_builder.SetInsertPoint(insertBlock);
197197
index = m_builder.CreateFPToUI(index, m_builder.getInt64Ty());
198198
llvm::Value *itemPtr = m_builder.CreateCall(m_utils.functions().resolve_list_insert_empty(), { listPtr.ptr, index });
199-
m_utils.createValueStore(valueArg.second, itemPtr, type);
199+
m_utils.createValueStore(itemPtr, m_utils.getValueTypePtr(itemPtr), valueArg.second, type);
200200

201201
if (listPtr.size) {
202202
// Update size
@@ -242,8 +242,13 @@ LLVMInstruction *Lists::buildListReplace(LLVMInstruction *ins)
242242
// Replace
243243
m_builder.SetInsertPoint(replaceBlock);
244244
index = m_builder.CreateFPToUI(index, m_builder.getInt64Ty());
245+
245246
llvm::Value *itemPtr = m_utils.getListItem(listPtr, index);
246-
m_utils.createValueStore(valueArg.second, itemPtr, listType, type);
247+
llvm::Value *itemType = m_builder.CreateLoad(m_builder.getInt32Ty(), m_utils.getValueTypePtr(itemPtr));
248+
llvm::Value *typeVar = createListTypeVar(listPtr, itemType);
249+
createListTypeAssumption(listPtr, itemType, typeVar);
250+
251+
m_utils.createValueStore(itemPtr, m_utils.getValueTypePtr(itemPtr), valueArg.second, listType, type);
247252
createListTypeUpdate(listPtr, valueArg.second);
248253
m_builder.CreateBr(nextBlock);
249254

@@ -279,35 +284,21 @@ LLVMInstruction *Lists::buildGetListItem(LLVMInstruction *ins)
279284
llvm::Value *size = m_utils.getListSize(listPtr);
280285
size = m_builder.CreateUIToFP(size, m_builder.getDoubleTy());
281286
llvm::Value *index = m_utils.castValue(arg.second, arg.first);
282-
llvm::Value *inRange = m_builder.CreateAnd(m_builder.CreateFCmpOGE(index, min), m_builder.CreateFCmpOLT(index, size));
287+
llvm::Value *inRange = m_builder.CreateAnd(m_builder.CreateFCmpOGE(index, min), m_builder.CreateFCmpOLT(index, size), "inRange");
283288

284289
LLVMConstantRegister nullReg(Compiler::StaticType::String, "");
285290
llvm::Value *null = m_utils.createValue(static_cast<LLVMRegister *>(&nullReg));
286291

287292
index = m_builder.CreateFPToUI(index, m_builder.getInt64Ty());
293+
288294
llvm::Value *itemPtr = m_builder.CreateSelect(inRange, m_utils.getListItem(listPtr, index), null);
295+
llvm::Value *stringType = m_builder.getInt32(static_cast<uint32_t>(ValueType::String));
296+
llvm::Value *type = m_builder.CreateSelect(inRange, m_builder.CreateLoad(m_builder.getInt32Ty(), m_utils.getValueTypePtr(itemPtr)), stringType);
297+
llvm::Value *typeVar = createListTypeVar(listPtr, type);
289298

290299
ins->functionReturnReg->value = itemPtr;
291-
292-
if (listPtr.type) {
293-
// Load the runtime list type information
294-
llvm::Value *listTypeFlags = m_builder.CreateLoad(m_builder.getInt32Ty(), listPtr.type);
295-
296-
// The result is an empty string if index is out of range
297-
llvm::Value *withString = m_builder.CreateOr(listTypeFlags, m_builder.getInt32(static_cast<uint32_t>(ValueType::String)));
298-
listTypeFlags = m_builder.CreateSelect(inRange, listTypeFlags, withString);
299-
300-
// Load the actual item type from ValueData
301-
llvm::Value *itemTypePtr = m_builder.CreateStructGEP(m_utils.compilerCtx()->valueDataType(), itemPtr, 1);
302-
llvm::Value *actualItemType = m_builder.CreateLoad(m_builder.getInt32Ty(), itemTypePtr);
303-
304-
// Create assumption that the actual type is contained in the list type flags
305-
llvm::Value *typeIsValid = m_builder.CreateICmpEQ(m_builder.CreateAnd(listTypeFlags, actualItemType), actualItemType);
306-
307-
// Tell LLVM to assume this is true
308-
llvm::Function *assumeIntrinsic = llvm::Intrinsic::getDeclaration(m_utils.module(), llvm::Intrinsic::assume);
309-
m_builder.CreateCall(assumeIntrinsic, typeIsValid);
310-
}
300+
ins->functionReturnReg->typeVar = typeVar;
301+
createListTypeAssumption(listPtr, type, typeVar, inRange);
311302

312303
return ins->next;
313304
}
@@ -365,3 +356,33 @@ void Lists::createListTypeUpdate(const LLVMListPtr &listPtr, const LLVMRegister
365356
m_builder.CreateStore(m_builder.CreateOr(currentType, newTypeFlag), listPtr.type);
366357
}
367358
}
359+
360+
llvm::Value *Lists::createListTypeVar(const LLVMListPtr &listPtr, llvm::Value *itemType)
361+
{
362+
llvm::Value *typeVar = m_utils.addAlloca(m_builder.getInt32Ty());
363+
m_builder.CreateStore(itemType, typeVar);
364+
return typeVar;
365+
}
366+
367+
void Lists::createListTypeAssumption(const LLVMListPtr &listPtr, llvm::Value *itemType, llvm::Value *typeVar, llvm::Value *inRange)
368+
{
369+
if (listPtr.type) {
370+
llvm::Function *assumeIntrinsic = llvm::Intrinsic::getDeclaration(m_utils.module(), llvm::Intrinsic::assume);
371+
372+
// Load the runtime list type information
373+
llvm::Value *listTypeFlags = m_builder.CreateLoad(m_builder.getInt32Ty(), listPtr.type);
374+
375+
// Create assumption that the item type is contained in the list type flags
376+
llvm::Value *typeIsValid = m_builder.CreateICmpEQ(m_builder.CreateAnd(listTypeFlags, itemType), itemType);
377+
378+
if (inRange) {
379+
llvm::Value *stringType = m_builder.getInt32(static_cast<uint32_t>(ValueType::String));
380+
llvm::Value *canNotBeString = m_builder.CreateICmpNE(m_builder.CreateAnd(listTypeFlags, stringType), stringType);
381+
llvm::Value *isString = m_builder.CreateICmpEQ(itemType, stringType);
382+
llvm::Value *impossible = m_builder.CreateAnd(m_builder.CreateAnd(inRange, canNotBeString), isString);
383+
typeIsValid = m_builder.CreateAnd(typeIsValid, m_builder.CreateNot(impossible));
384+
}
385+
386+
m_builder.CreateCall(assumeIntrinsic, typeIsValid);
387+
}
388+
}

‎src/engine/internal/llvm/instructions/lists.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,8 @@ class Lists : public InstructionGroup
3333
LLVMInstruction *buildListContainsItem(LLVMInstruction *ins);
3434

3535
void createListTypeUpdate(const LLVMListPtr &listPtr, const LLVMRegister *newValue);
36+
llvm::Value *createListTypeVar(const LLVMListPtr &listPtr, llvm::Value *itemType);
37+
void createListTypeAssumption(const LLVMListPtr &listPtr, llvm::Value *itemType, llvm::Value *typeVar, llvm::Value *inRange = nullptr);
3638
};
3739

3840
} // namespace llvmins

‎src/engine/internal/llvm/instructions/procedures.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -39,7 +39,7 @@ LLVMInstruction *Procedures::buildCallProcedure(LLVMInstruction *ins)
3939
assert(ins->procedurePrototype);
4040
assert(ins->args.size() == ins->procedurePrototype->argumentTypes().size());
4141
m_utils.freeScopeHeap();
42-
m_utils.syncVariables(m_utils.targetVariables());
42+
m_utils.syncVariables();
4343

4444
std::string name = m_utils.scriptFunctionName(ins->procedurePrototype);
4545
llvm::FunctionType *type = m_utils.scriptFunctionType(ins->procedurePrototype);
@@ -80,7 +80,7 @@ LLVMInstruction *Procedures::buildCallProcedure(LLVMInstruction *ins)
8080
m_builder.SetInsertPoint(nextBranch);
8181
}
8282

83-
m_utils.reloadVariables(m_utils.targetVariables());
83+
m_utils.reloadVariables();
8484
m_utils.reloadLists();
8585
return ins->next;
8686
}

‎src/engine/internal/llvm/instructions/variables.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -112,7 +112,7 @@ LLVMInstruction *Variables::buildWriteVariable(LLVMInstruction *ins)
112112
Compiler::StaticType argType = m_utils.optimizeRegisterType(arg.second);
113113
LLVMVariablePtr &varPtr = m_utils.variablePtr(ins->targetVariable);
114114

115-
m_utils.createValueStore(arg.second, varPtr.onStack ? varPtr.stackPtr : varPtr.heapPtr, ins->targetType, argType);
115+
m_utils.createValueStore(varPtr.stackPtr, m_utils.getValueTypePtr(varPtr.stackPtr), arg.second, ins->targetType, argType);
116116
return ins->next;
117117
}
118118

@@ -121,6 +121,6 @@ LLVMInstruction *Variables::buildReadVariable(LLVMInstruction *ins)
121121
assert(ins->args.size() == 0);
122122
LLVMVariablePtr &varPtr = m_utils.variablePtr(ins->targetVariable);
123123

124-
ins->functionReturnReg->value = varPtr.onStack ? varPtr.stackPtr : varPtr.heapPtr;
124+
ins->functionReturnReg->value = varPtr.stackPtr;
125125
return ins->next;
126126
}

‎src/engine/internal/llvm/llvmbuildutils.cpp‎

Lines changed: 38 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -66,16 +66,10 @@ void LLVMBuildUtils::init(llvm::Function *function, BlockPrototype *procedurePro
6666
// Create variable pointers
6767
for (auto &[var, varPtr] : m_variablePtrs) {
6868
llvm::Value *ptr = getVariablePtr(m_targetVariables, var);
69-
70-
// Direct access
7169
varPtr.heapPtr = ptr;
7270

73-
// In warp scripts, all variables are created on the stack and synced later (seems to be faster)
74-
// NOTE: Strings are NOT copied, only the pointer is copied
75-
varPtr.onStack = m_warp;
76-
77-
if (varPtr.onStack)
78-
varPtr.stackPtr = m_builder.CreateAlloca(m_valueDataType);
71+
// Store variables locally to enable optimizations
72+
varPtr.stackPtr = m_builder.CreateAlloca(m_valueDataType);
7973
}
8074

8175
// Create list pointers
@@ -101,7 +95,7 @@ void LLVMBuildUtils::init(llvm::Function *function, BlockPrototype *procedurePro
10195
}
10296
}
10397

104-
reloadVariables(m_targetVariables);
98+
reloadVariables();
10599
reloadLists();
106100

107101
// Create end branch
@@ -116,7 +110,7 @@ void LLVMBuildUtils::end(LLVMInstruction *lastInstruction, LLVMRegister *lastCon
116110
m_builder.CreateBr(m_endBranch);
117111

118112
m_builder.SetInsertPoint(m_endBranch);
119-
syncVariables(m_targetVariables);
113+
syncVariables();
120114

121115
// End the script function
122116
llvm::PointerType *pointerType = llvm::PointerType::get(llvm::Type::getInt8Ty(m_llvmCtx), 0);
@@ -309,25 +303,19 @@ LLVMListPtr &LLVMBuildUtils::listPtr(List *list)
309303
return m_listPtrs[list];
310304
}
311305

312-
void LLVMBuildUtils::syncVariables(llvm::Value *targetVariables)
306+
void LLVMBuildUtils::syncVariables()
313307
{
314308
// Copy stack variables to the actual variables
315-
for (auto &[var, varPtr] : m_variablePtrs) {
316-
if (varPtr.onStack)
317-
createValueCopy(varPtr.stackPtr, getVariablePtr(targetVariables, var));
318-
}
309+
for (auto &[var, varPtr] : m_variablePtrs)
310+
createValueCopy(varPtr.stackPtr, getVariablePtr(m_targetVariables, var));
319311
}
320312

321-
void LLVMBuildUtils::reloadVariables(llvm::Value *targetVariables)
313+
void LLVMBuildUtils::reloadVariables()
322314
{
323315
// Load variables to stack
324-
if (m_warp) {
325-
for (auto &[var, varPtr] : m_variablePtrs) {
326-
if (varPtr.onStack) {
327-
llvm::Value *ptr = getVariablePtr(m_targetVariables, var);
328-
createValueCopy(ptr, varPtr.stackPtr);
329-
}
330-
}
316+
for (auto &[var, varPtr] : m_variablePtrs) {
317+
llvm::Value *ptr = getVariablePtr(m_targetVariables, var);
318+
createValueCopy(ptr, varPtr.stackPtr);
331319
}
332320
}
333321

@@ -449,7 +437,7 @@ llvm::Value *LLVMBuildUtils::castValue(LLVMRegister *reg, Compiler::StaticType t
449437

450438
if (isSingleType(targetType)) {
451439
// Handle multiple source type cases with runtime switch
452-
typePtr = m_builder.CreateStructGEP(m_valueDataType, reg->value, 1);
440+
typePtr = getValueTypePtr(reg);
453441
loadedType = m_builder.CreateLoad(m_builder.getInt32Ty(), typePtr);
454442

455443
mergeBlock = llvm::BasicBlock::Create(m_llvmCtx, "merge", m_function);
@@ -651,7 +639,7 @@ llvm::Value *LLVMBuildUtils::removeNaN(llvm::Value *num)
651639
return m_builder.CreateSelect(isNaN(num), llvm::ConstantFP::get(m_llvmCtx, llvm::APFloat(0.0)), num);
652640
}
653641

654-
void LLVMBuildUtils::createValueStore(LLVMRegister *reg, llvm::Value *destPtr, Compiler::StaticType destType, Compiler::StaticType targetType)
642+
void LLVMBuildUtils::createValueStore(llvm::Value *destPtr, llvm::Value *destTypePtr, LLVMRegister *reg, Compiler::StaticType destType, Compiler::StaticType targetType)
655643
{
656644
llvm::Value *targetPtr = nullptr;
657645
const bool targetTypeIsSingle = isSingleType(targetType);
@@ -670,11 +658,10 @@ void LLVMBuildUtils::createValueStore(LLVMRegister *reg, llvm::Value *destPtr, C
670658
loadedTargetType = m_builder.getInt32(static_cast<uint32_t>(mappedType));
671659
else {
672660
assert(!reg->isConst());
673-
llvm::Value *targetTypePtr = m_builder.CreateStructGEP(m_valueDataType, reg->value, 1);
661+
llvm::Value *targetTypePtr = getValueTypePtr(reg);
674662
loadedTargetType = m_builder.CreateLoad(m_builder.getInt32Ty(), targetTypePtr);
675663
}
676664

677-
llvm::Value *destTypePtr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 1);
678665
llvm::Value *loadedDestType = m_builder.CreateLoad(m_builder.getInt32Ty(), destTypePtr);
679666

680667
llvm::BasicBlock *mergeBlock = llvm::BasicBlock::Create(m_llvmCtx, "merge", m_function);
@@ -723,8 +710,7 @@ void LLVMBuildUtils::createValueStore(LLVMRegister *reg, llvm::Value *destPtr, C
723710
// Write bool to number value directly and change type
724711
llvm::Value *ptr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 0);
725712
m_builder.CreateStore(targetPtr, ptr);
726-
llvm::Value *typePtr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 1);
727-
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::Bool)), typePtr);
713+
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::Bool)), destTypePtr);
728714
m_builder.CreateBr(mergeBlock);
729715
}
730716

@@ -744,8 +730,7 @@ void LLVMBuildUtils::createValueStore(LLVMRegister *reg, llvm::Value *destPtr, C
744730
llvm::Value *ptr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 0);
745731
llvm::Value *destStringPtr = m_builder.CreateCall(m_functions.resolve_string_pool_new(), m_builder.getInt1(false));
746732

747-
llvm::Value *typePtr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 1);
748-
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::String)), typePtr);
733+
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::String)), destTypePtr);
749734
m_builder.CreateStore(destStringPtr, ptr);
750735
m_builder.CreateCall(m_functions.resolve_string_assign(), { destStringPtr, targetPtr });
751736

@@ -775,9 +760,8 @@ void LLVMBuildUtils::createValueStore(LLVMRegister *reg, llvm::Value *destPtr, C
775760

776761
// Write number to bool value directly and change type
777762
llvm::Value *ptr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 0);
778-
llvm::Value *typePtr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 1);
779763
m_builder.CreateStore(targetPtr, ptr);
780-
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::Number)), typePtr);
764+
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::Number)), destTypePtr);
781765
m_builder.CreateBr(mergeBlock);
782766
}
783767

@@ -815,8 +799,7 @@ void LLVMBuildUtils::createValueStore(LLVMRegister *reg, llvm::Value *destPtr, C
815799
llvm::Value *ptr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 0);
816800
llvm::Value *destStringPtr = m_builder.CreateCall(m_functions.resolve_string_pool_new(), m_builder.getInt1(false));
817801

818-
llvm::Value *typePtr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 1);
819-
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::String)), typePtr);
802+
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::String)), destTypePtr);
820803
m_builder.CreateStore(destStringPtr, ptr);
821804
m_builder.CreateCall(m_functions.resolve_string_assign(), { destStringPtr, targetPtr });
822805

@@ -849,8 +832,7 @@ void LLVMBuildUtils::createValueStore(LLVMRegister *reg, llvm::Value *destPtr, C
849832
llvm::Value *destStringPtr = m_builder.CreateLoad(m_stringPtrType->getPointerTo(), ptr);
850833
m_builder.CreateCall(m_functions.resolve_string_pool_free(), destStringPtr);
851834
m_builder.CreateStore(targetPtr, ptr);
852-
llvm::Value *typePtr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 1);
853-
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::Number)), typePtr);
835+
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::Number)), destTypePtr);
854836
m_builder.CreateBr(mergeBlock);
855837
}
856838

@@ -871,8 +853,7 @@ void LLVMBuildUtils::createValueStore(LLVMRegister *reg, llvm::Value *destPtr, C
871853
llvm::Value *destStringPtr = m_builder.CreateLoad(m_stringPtrType->getPointerTo(), ptr);
872854
m_builder.CreateCall(m_functions.resolve_string_pool_free(), destStringPtr);
873855
m_builder.CreateStore(targetPtr, ptr);
874-
llvm::Value *typePtr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 1);
875-
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::Bool)), typePtr);
856+
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::Bool)), destTypePtr);
876857
m_builder.CreateBr(mergeBlock);
877858
}
878859

@@ -903,10 +884,23 @@ void LLVMBuildUtils::createValueStore(LLVMRegister *reg, llvm::Value *destPtr, C
903884
m_builder.SetInsertPoint(mergeBlock);
904885
}
905886

906-
void LLVMBuildUtils::createValueStore(LLVMRegister *reg, llvm::Value *destPtr, Compiler::StaticType targetType)
887+
void LLVMBuildUtils::createValueStore(llvm::Value *destPtr, llvm::Value *destTypePtr, LLVMRegister *reg, Compiler::StaticType targetType)
907888
{
908889
// Same as createValueStore(), but the destination type is unknown at compile time
909-
createValueStore(reg, destPtr, Compiler::StaticType::Unknown, targetType);
890+
createValueStore(destPtr, destTypePtr, reg, Compiler::StaticType::Unknown, targetType);
891+
}
892+
893+
llvm::Value *LLVMBuildUtils::getValueTypePtr(llvm::Value *value)
894+
{
895+
return m_builder.CreateStructGEP(m_valueDataType, value, 1);
896+
}
897+
898+
llvm::Value *LLVMBuildUtils::getValueTypePtr(LLVMRegister *reg)
899+
{
900+
if (reg->typeVar)
901+
return reg->typeVar;
902+
else
903+
return getValueTypePtr(reg->value);
910904
}
911905

912906
llvm::Value *LLVMBuildUtils::getListSize(const LLVMListPtr &listPtr)
@@ -1018,7 +1012,7 @@ llvm::Value *LLVMBuildUtils::createValue(LLVMRegister *reg)
10181012
}
10191013

10201014
// Store type
1021-
llvm::Value *typeField = m_builder.CreateStructGEP(m_valueDataType, ret, 1);
1015+
llvm::Value *typeField = getValueTypePtr(ret);
10221016
ValueType type = it->first;
10231017
m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(type)), typeField);
10241018

@@ -1272,9 +1266,9 @@ void LLVMBuildUtils::createSuspend()
12721266
m_builder.SetInsertPoint(suspendBranch);
12731267
}
12741268

1275-
syncVariables(m_targetVariables);
1269+
syncVariables();
12761270
m_coroutine->createSuspend();
1277-
reloadVariables(m_targetVariables);
1271+
reloadVariables();
12781272
reloadLists();
12791273

12801274
if (m_warpArg) {

0 commit comments

Comments
 (0)