diff options
Diffstat (limited to 'source')
27 files changed, 1089 insertions, 102 deletions
diff --git a/source/slang/hlsl.meta.slang b/source/slang/hlsl.meta.slang index f5b138f25..6c7a2c1d2 100644 --- a/source/slang/hlsl.meta.slang +++ b/source/slang/hlsl.meta.slang @@ -4793,7 +4793,7 @@ void __executeCallable(uint shaderIndex, int payloadLocation); __generic<Payload> __target_intrinsic(__glslRayTracing, "$XC") [__readNone] -int __callablePayloadLocation(Payload payload); +int __callablePayloadLocation(__ref Payload payload); // Now we provide a hard-coded definition of `CallShader()` for GLSL-based // targets, which maps the generic HLSL operation into the non-generic @@ -4848,7 +4848,7 @@ void __traceRay( __generic<Payload> __target_intrinsic(__glslRayTracing, "$XP") [__readNone] -int __rayPayloadLocation(Payload payload); +int __rayPayloadLocation(__ref Payload payload); __generic<payload_t> __specialized_for_target(glsl) @@ -5678,7 +5678,7 @@ struct VkSubpassInputMS<T> // We access the HitObjectAttributes via this function for the desired type, and it acts *as if* it's just an access // to the global t. [ForceInline] -__ref T __hitObjectAttributes<T>() +Ref<T> __hitObjectAttributes<T>() { [__vulkanHitObjectAttributes] static T t; @@ -5691,7 +5691,7 @@ __ref T __hitObjectAttributes<T>() __generic<Payload> __target_intrinsic(__glslRayTracing, "$XH") [__readNone] -int __hitObjectAttributesLocation(Payload payload); +int __hitObjectAttributesLocation(__ref Payload payload); /// Immutable data type representing a ray hit or a miss. Can be used to invoke hit or miss shading, /// or as a key in ReorderThread. Created by one of several methods described below. HitObject diff --git a/source/slang/slang-ast-expr.h b/source/slang/slang-ast-expr.h index 9fdc10807..d49db89a2 100644 --- a/source/slang/slang-ast-expr.h +++ b/source/slang/slang-ast-expr.h @@ -268,6 +268,13 @@ class SwizzleExpr: public Expr SourceLoc memberOpLoc; }; +// An operation to convert an l-value to a reference type. +class MakeRefExpr : public Expr +{ + SLANG_AST_CLASS(MakeRefExpr) + Expr* base = nullptr; +}; + // A dereference of a pointer or pointer-like type class DerefExpr: public Expr { diff --git a/source/slang/slang-ast-support-types.h b/source/slang/slang-ast-support-types.h index 21611bcb1..5fd9df400 100644 --- a/source/slang/slang-ast-support-types.h +++ b/source/slang/slang-ast-support-types.h @@ -78,6 +78,7 @@ namespace Slang // Conversion from a buffer to the type it carries needs to add a minimal // extra cost, just so we can distinguish an overload on `ConstantBuffer<Foo>` // from one on `Foo` + kConversionCost_GetRef = 5, kConversionCost_ImplicitDereference = 10, // Conversions based on explicit sub-typing relationships are the cheapest diff --git a/source/slang/slang-check-conversion.cpp b/source/slang/slang-check-conversion.cpp index 6decce625..71231b9e5 100644 --- a/source/slang/slang-check-conversion.cpp +++ b/source/slang/slang-check-conversion.cpp @@ -642,11 +642,6 @@ namespace Slang return true; } - if (auto refType = as<RefType>(toType)) - { - return _coerce(refType->getValueType(), outToExpr, fromType, fromExpr, outCost); - } - // If both are string types we assume they are convertable in both directions if (as<StringTypeBase>(fromType) && as<StringTypeBase>(toType)) { @@ -860,6 +855,63 @@ namespace Slang return true; } + if (auto refType = as<RefType>(toType)) + { + if (!refType->getValueType()->equals(fromType)) + return false; + if (!fromExpr->type.isLeftValue) + return false; + + ConversionCost subCost = kConversionCost_GetRef; + + MakeRefExpr* refExpr = nullptr; + if (outToExpr) + { + refExpr = m_astBuilder->create<MakeRefExpr>(); + refExpr->base = fromExpr; + refExpr->type = QualType(refType); + refExpr->type.isLeftValue = false; + *outToExpr = refExpr; + } + if (outCost) + *outCost = subCost; + return true; + } + + + // Allow implicit dereferencing a reference type. + if (auto fromRefType = as<RefType>(fromType)) + { + auto fromValueType = fromRefType->getValueType(); + + // If we convert, e.g., `ConstantBuffer<A> to `A`, we will allow + // subsequent conversion of `A` to `B` if such a conversion + // is possible. + // + ConversionCost subCost = kConversionCost_None; + + Expr* openRefExpr = nullptr; + if (outToExpr) + { + openRefExpr = maybeOpenRef(fromExpr); + } + + if (!_coerce( + toType, + outToExpr, + fromValueType, + openRefExpr, + &subCost)) + { + return false; + } + + if (outCost) + *outCost = subCost + kConversionCost_ImplicitDereference; + return true; + } + + // The main general-purpose approach for conversion is // using suitable marked initializer ("constructor") // declarations on the target type. diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp index 7e2bc3822..7d546e60b 100644 --- a/source/slang/slang-check-expr.cpp +++ b/source/slang/slang-check-expr.cpp @@ -1863,6 +1863,7 @@ namespace Slang Expr* SemanticsVisitor::checkAssignWithCheckedOperands(AssignExpr* expr) { + expr->left = maybeOpenRef(expr->left); auto type = expr->left->type; auto right = maybeOpenRef(expr->right); expr->right = coerce(type, right); diff --git a/source/slang/slang-check-impl.h b/source/slang/slang-check-impl.h index ac5fc8392..719706635 100644 --- a/source/slang/slang-check-impl.h +++ b/source/slang/slang-check-impl.h @@ -1928,6 +1928,7 @@ namespace Slang } CASE(DerefExpr) + CASE(MakeRefExpr) CASE(MatrixSwizzleExpr) CASE(SwizzleExpr) CASE(OverloadedExpr) diff --git a/source/slang/slang-emit-c-like.cpp b/source/slang/slang-emit-c-like.cpp index 160585e26..c664449e5 100644 --- a/source/slang/slang-emit-c-like.cpp +++ b/source/slang/slang-emit-c-like.cpp @@ -1082,6 +1082,7 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst) case kIROp_Param: case kIROp_Func: case kIROp_Alloca: + case kIROp_Store: return false; // Never fold these, because their result cannot be computed @@ -1997,17 +1998,6 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO } break; - case kIROp_Store: - { - auto prec = getInfo(EmitOp::Assign); - needClose = maybeEmitParens(outerPrec, prec); - - emitDereferenceOperand(inst->getOperand(0), leftSide(outerPrec, prec)); - m_writer->emit(" = "); - emitOperand(inst->getOperand(1), rightSide(prec, outerPrec)); - } - break; - case kIROp_Call: { emitCallExpr((IRCall*)inst, outerPrec); @@ -2393,6 +2383,22 @@ void CLikeSourceEmitter::_emitInst(IRInst* inst) } break; + case kIROp_Store: + { + if (inst->getPrevInst() == inst->getOperand(0) && inst->getOperand(0)->getOp() == kIROp_Var) + { + // If we are storing into a var that is defined right before the store, we have + // already folded the store in the initialization of the var, so we can skip here. + break; + } + auto prec = getInfo(EmitOp::Assign); + emitDereferenceOperand(inst->getOperand(0), leftSide(getInfo(EmitOp::General), prec)); + m_writer->emit(" = "); + emitOperand(inst->getOperand(1), rightSide(prec, getInfo(EmitOp::General))); + m_writer->emit(";\n"); + } + break; + case kIROp_Param: // Don't emit parameters, since they are declared as part of the function. break; @@ -3321,6 +3327,15 @@ void CLikeSourceEmitter::emitVar(IRVar* varDecl) emitLayoutSemantics(varDecl); + if (auto store = as<IRStore>(varDecl->getNextInst())) + { + if (store->getPtr() == varDecl) + { + m_writer->emit(" = "); + emitOperand(store->getVal(), getInfo(EmitOp::General)); + } + } + m_writer->emit(";\n"); } diff --git a/source/slang/slang-emit-source-writer.cpp b/source/slang/slang-emit-source-writer.cpp index bed9a2dbc..7692bd0ec 100644 --- a/source/slang/slang-emit-source-writer.cpp +++ b/source/slang/slang-emit-source-writer.cpp @@ -247,8 +247,21 @@ void SourceWriter::emit(double value) stream.setf(std::ios::fixed, std::ios::floatfield); stream.precision(20); stream << value; - - emit(stream.str().c_str()); + auto str = stream.str(); + auto slice = UnownedStringSlice(str.c_str()); + // Remove redundant trailing 0s. + if (slice.end() > slice.begin()) + { + auto lastChar = slice.end() - 1; + while (lastChar > slice.begin() && *lastChar == '0') + lastChar--; + if (*lastChar == '.') + lastChar++; + if (lastChar > slice.end() - 1) + lastChar = slice.end() - 1; + slice = slice.subString(0, lastChar - slice.begin() + 1); + } + emit(slice); } void SourceWriter::advanceToSourceLocationIfValid(const SourceLoc& sourceLocation) diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp index 3d923179c..2ef0a5647 100644 --- a/source/slang/slang-emit.cpp +++ b/source/slang/slang-emit.cpp @@ -54,6 +54,7 @@ #include "slang-ir-liveness.h" #include "slang-ir-glsl-liveness.h" #include "slang-ir-string-hash.h" +#include "slang-ir-simplify-for-emit.h" #include "slang-legalize-types.h" #include "slang-lower-to-ir.h" #include "slang-mangle.h" @@ -1008,6 +1009,9 @@ SlangResult CodeGenContext::emitEntryPointsSourceFromIR(ComPtr<IArtifact>& outAr linkedIR)); auto irModule = linkedIR.module; + + // Perform final simplifications to help emit logic to generate more compact code. + simplifyForEmit(irModule); metadata = linkedIR.metadata; @@ -1015,15 +1019,6 @@ SlangResult CodeGenContext::emitEntryPointsSourceFromIR(ComPtr<IArtifact>& outAr // passes have been performed, we can emit target code from // the IR module. // - // TODO: do we want to emit directly from IR, or translate the - // IR back into AST for emission? -#if 0 - { - StringBuilder sb; - StringWriter writer(&sb, Slang::WriterFlag::AutoFlush); - dumpIR(irModule, getIRDumpOptions(), sourceManager, &writer); - } -#endif sourceEmitter->emitModule(irModule, sink); } diff --git a/source/slang/slang-intrinsic-expand.cpp b/source/slang/slang-intrinsic-expand.cpp index 64ef4e761..de3396efb 100644 --- a/source/slang/slang-intrinsic-expand.cpp +++ b/source/slang/slang-intrinsic-expand.cpp @@ -735,14 +735,10 @@ const char* IntrinsicExpandContext::_emitSpecial(const char* cursor) Index argIndex = 0; SLANG_RELEASE_ASSERT(m_argCount > argIndex); auto arg = m_args[argIndex].get(); - auto argLoad = as<IRLoad>(arg); - SLANG_RELEASE_ASSERT(argLoad); - - auto argVar = argLoad->getOperand(0); // Find the associated decoration IRDecoration* foundDecoration = nullptr; - for (auto decoration : argVar->getDecorations()) + for (auto decoration : arg->getDecorations()) { const auto curKind = LocationTracker::getKindFromDecoration(decoration); if (curKind == kind) @@ -755,7 +751,7 @@ const char* IntrinsicExpandContext::_emitSpecial(const char* cursor) // Must have found the decoration SLANG_ASSERT(foundDecoration); - const auto location = m_emitter->getLocationTracker().getValue(kind, argVar, foundDecoration); + const auto location = m_emitter->getLocationTracker().getValue(kind, arg, foundDecoration); m_writer->emit(location); } } diff --git a/source/slang/slang-ir-autodiff-fwd.cpp b/source/slang/slang-ir-autodiff-fwd.cpp index 16b7a977c..a45a3abf9 100644 --- a/source/slang/slang-ir-autodiff-fwd.cpp +++ b/source/slang/slang-ir-autodiff-fwd.cpp @@ -1162,6 +1162,8 @@ InstPair ForwardDiffTranscriber::transcribeFuncHeader(IRBuilder* inBuilder, IRFu inBuilder->addForwardDerivativeDecoration(origFunc, diffFunc); } + inBuilder->addFloatingModeOverrideDecoration(diffFunc, FloatingPointMode::Fast); + FuncBodyTranscriptionTask task; task.type = FuncBodyTranscriptionTaskType::Forward; task.originalFunc = origFunc; diff --git a/source/slang/slang-ir-autodiff-rev.cpp b/source/slang/slang-ir-autodiff-rev.cpp index fed53b037..702f9819a 100644 --- a/source/slang/slang-ir-autodiff-rev.cpp +++ b/source/slang/slang-ir-autodiff-rev.cpp @@ -12,6 +12,7 @@ #include "slang-ir-addr-inst-elimination.h" #include "slang-ir-eliminate-multilevel-break.h" #include "slang-ir-init-local-var.h" +#include "slang-ir-redundancy-removal.h" namespace Slang { @@ -305,7 +306,14 @@ namespace Slang IRFunc* primalFunc = origFunc; maybeMigrateDifferentiableDictionaryFromDerivativeFunc(inBuilder, origFunc); - differentiableTypeConformanceContext.setFunc(origFunc); + + // The original func may not have a type dictionary if it is not originally marked as + // differentiable, in this case we would have already pulled the necessary types from + // the user-provided derivative function, so we are still fine. + if (origFunc->findDecoration<IRDifferentiableTypeDictionaryDecoration>()) + { + differentiableTypeConformanceContext.setFunc(origFunc); + } auto diffFunc = builder.createFunc(); @@ -334,7 +342,7 @@ namespace Slang builder.setInsertBefore(diffFunc->getFirstDecorationOrChild()); cloneInst(&cloneEnv, &builder, dictDecor); } - + builder.addFloatingModeOverrideDecoration(diffFunc, FloatingPointMode::Fast); return InstPair(primalFunc, diffFunc); } @@ -588,43 +596,6 @@ namespace Slang return result; } - void eliminateRedundantLoad(IRFunc* func) - { - for (auto block : func->getBlocks()) - { - for (auto inst = block->getFirstInst(); inst;) - { - auto nextInst = inst->getNextInst(); - if (auto load = as<IRLoad>(inst)) - { - for (auto prev = inst->getPrevInst(); prev; prev = prev->getPrevInst()) - { - if (auto store = as<IRStore>(prev)) - { - if (store->getPtr() == load->getPtr()) - { - // If the load is preceeded by a store without any side-effect insts in-between, remove the load. - auto value = store->getVal(); - load->replaceUsesWith(value); - load->removeAndDeallocate(); - break; - } - } - else if (as<IRCall>(prev)) - { - break; - } - else if (prev->mightHaveSideEffects()) - { - break; - } - } - } - inst = nextInst; - } - } - } - // Create a copy of originalFunc's forward derivative in the same generic context (if any) of // `diffPropagateFunc`. IRFunc* BackwardDiffTranscriberBase::generateNewForwardDerivativeForFunc( @@ -669,7 +640,7 @@ namespace Slang primalOuterParent->removeAndDeallocate(); // Remove redundant loads since they interfere with transposition logic. - eliminateRedundantLoad(fwdDiffFunc); + eliminateRedundantLoadStore(fwdDiffFunc); // Migrate the new forward derivative function into the generic parent of `diffPropagateFunc`. if (auto fwdParentGeneric = as<IRGeneric>(findOuterGeneric(fwdDiffFunc))) @@ -976,13 +947,16 @@ namespace Slang { // Create dOut param. auto diffParam = builder->emitParam(diffType); + copyNameHintDecoration(diffParam, fwdParam); result.propagateFuncParams.Add(diffParam); primalRefReplacement = builder->emitParam(builder->getOutType(primalType)); + copyNameHintDecoration(primalRefReplacement, fwdParam); // Create a local var for read access in pre-transpose code. // This will the var from which we will fetch the final resulting derivative // after transposition. auto tempVar = nextBlockBuilder.emitVar(diffType); + copyNameHintDecoration(tempVar, fwdParam); nextBlockBuilder.markInstAsDifferential(tempVar, diffPairType); // Initialize the var with input diff param at start. @@ -999,11 +973,13 @@ namespace Slang else { primalRefReplacement = builder->emitParam(outType); + copyNameHintDecoration(primalRefReplacement, fwdParam); } result.primalFuncParams.Add(primalRefReplacement); // Create a local var for the out param for the primal part of the prop func. auto tempPrimalVar = nextBlockBuilder.emitVar(outType->getValueType()); + copyNameHintDecoration(tempPrimalVar, fwdParam); result.mapPrimalSpecificParamToReplacementInPropFunc[primalRefReplacement] = tempPrimalVar; instsToRemove.Add(fwdParam); @@ -1023,10 +999,13 @@ namespace Slang // Create an in param for the prop func. auto propParam = builder->emitParam(inoutType->getValueType()); + copyNameHintDecoration(propParam, fwdParam); result.propagateFuncParams.Add(propParam); // Create a local var for the out param for the primal part of the prop func. auto tempPrimalVar = nextBlockBuilder.emitVar(inoutType->getValueType()); + copyNameHintDecoration(tempPrimalVar, fwdParam); + result.propagateFuncSpecificPrimalInsts.add(tempPrimalVar); auto storeInst = nextBlockBuilder.emitStore(tempPrimalVar, propParam); result.propagateFuncSpecificPrimalInsts.add(storeInst); @@ -1054,8 +1033,11 @@ namespace Slang // Create inout version. auto inoutDiffPairType = builder->getInOutType(diffPairType); primalRefReplacement = builder->emitParam(primalType); + copyNameHintDecoration(primalRefReplacement, fwdParam); + result.primalFuncParams.Add(primalRefReplacement); auto propParam = builder->emitParam(inoutDiffPairType); + copyNameHintDecoration(propParam, fwdParam); result.propagateFuncParams.Add(propParam); // A reference to this parameter from the diff blocks should be replaced with a load @@ -1085,9 +1067,11 @@ namespace Slang // Process differentiable inout parameters. auto primalParam = builder->emitParam(builder->getInOutType(primalType)); + copyNameHintDecoration(primalParam, fwdParam); result.primalFuncParams.Add(primalParam); auto diffParam = builder->emitParam(inoutType); + copyNameHintDecoration(diffParam, fwdParam); result.propagateFuncParams.Add(diffParam); // Primal references to this param is the new primal param. @@ -1102,6 +1086,7 @@ namespace Slang // Create a local var for diff read access. auto diffVar = nextBlockBuilder.emitVar(diffType); + copyNameHintDecoration(diffVar, fwdParam); result.propagateFuncSpecificPrimalInsts.add(diffVar); diffBuilder.markInstAsDifferential(diffVar, diffPairType); diffRefReplacement = diffVar; @@ -1114,6 +1099,8 @@ namespace Slang // Create a local var for diff write access. auto diffWriteVar = nextBlockBuilder.emitVar(diffType); + copyNameHintDecoration(diffWriteVar, fwdParam); + // Initialize write var to 0. auto writeStore = nextBlockBuilder.emitStore(diffWriteVar, initDiff); result.propagateFuncSpecificPrimalInsts.add(writeStore); @@ -1122,6 +1109,8 @@ namespace Slang // Create a local var for the primal logic in the propagate func. auto primalVar = nextBlockBuilder.emitVar(primalType); + copyNameHintDecoration(primalVar, fwdParam); + result.propagateFuncSpecificPrimalInsts.add(primalVar); auto initPrimalVal = nextBlockBuilder.emitDifferentialPairGetPrimal(loadedParam); result.propagateFuncSpecificPrimalInsts.add(initPrimalVal); @@ -1213,11 +1202,13 @@ namespace Slang SLANG_ASSERT(dOutParamType); dOutParam = builder->emitParam(dOutParamType); + builder->addNameHintDecoration(dOutParam, UnownedStringSlice("_s_dOut")); result.propagateFuncParams.Add(dOutParam); } // Add a parameter for intermediate val. auto ctxParam = builder->emitParam(as<IRFuncType>(diffFunc->getDataType())->getParamType(paramCount - 1)); + builder->addNameHintDecoration(ctxParam, UnownedStringSlice("_s_diff_ctx")); result.primalFuncParams.Add(ctxParam); result.propagateFuncParams.Add(ctxParam); result.dOutParam = dOutParam; diff --git a/source/slang/slang-ir-autodiff-unzip.cpp b/source/slang/slang-ir-autodiff-unzip.cpp index be20d8aa8..3e7e346d2 100644 --- a/source/slang/slang-ir-autodiff-unzip.cpp +++ b/source/slang/slang-ir-autodiff-unzip.cpp @@ -295,6 +295,7 @@ struct ExtractPrimalFuncContext auto oldIntermediateParam = func->getLastParam(); auto outIntermediary = builder.emitParam(builder.getInOutType((IRType*)intermediateType)); + oldIntermediateParam->transferDecorationsTo(outIntermediary); primalParams.Add(outIntermediary); oldIntermediateParam->replaceUsesWith(outIntermediary); oldIntermediateParam->removeAndDeallocate(); @@ -473,15 +474,34 @@ IRFunc* DiffUnzipPass::extractPrimalFunc( if (inst->getOp() == kIROp_Var) { // This is a var for intermediate context. - auto valType = cast<IRPtrTypeBase>(inst->getFullType())->getValueType(); - auto val = builder.emitFieldExtract( - valType, - intermediateVar, - structKeyDecor->getStructKey()); - auto tempVar = - builder.emitVar(valType); - builder.emitStore(tempVar, val); - inst->replaceUsesWith(tempVar); + // Replace all loads of the var with a field extract. + // Other type of uses will get a temp var that stores a copy of the field. + while (auto use = inst->firstUse) + { + if (as<IRDecoration>(use->getUser())) + { + use->set(builder.getVoidValue()); + continue; + } + builder.setInsertBefore(use->getUser()); + auto valType = cast<IRPtrTypeBase>(inst->getFullType())->getValueType(); + auto val = builder.emitFieldExtract( + valType, + intermediateVar, + structKeyDecor->getStructKey()); + if (use->getUser()->getOp() == kIROp_Load) + { + use->getUser()->replaceUsesWith(val); + use->getUser()->removeAndDeallocate(); + } + else + { + auto tempVar = + builder.emitVar(valType); + builder.emitStore(tempVar, val); + use->set(tempVar); + } + } } else { diff --git a/source/slang/slang-ir-autodiff.cpp b/source/slang/slang-ir-autodiff.cpp index fdaff4960..f38bdfdbd 100644 --- a/source/slang/slang-ir-autodiff.cpp +++ b/source/slang/slang-ir-autodiff.cpp @@ -256,6 +256,11 @@ IRInst* DifferentialPairTypeBuilder::_createDiffPairType(IRType* origBaseType, I builder.setInsertBefore(diffType); auto pairStructType = builder.createStructType(); + StringBuilder nameBuilder; + nameBuilder << "DiffPair_"; + getTypeNameHint(nameBuilder, origBaseType); + builder.addNameHintDecoration(pairStructType, nameBuilder.ToString().getUnownedSlice()); + builder.createStructField(pairStructType, _getOrCreatePrimalStructKey(), origBaseType); builder.createStructField(pairStructType, _getOrCreateDiffStructKey(), (IRType*)diffType); return pairStructType; diff --git a/source/slang/slang-ir-dce.cpp b/source/slang/slang-ir-dce.cpp index 33e5b3cb4..337caa246 100644 --- a/source/slang/slang-ir-dce.cpp +++ b/source/slang/slang-ir-dce.cpp @@ -3,6 +3,7 @@ #include "slang-ir.h" #include "slang-ir-insts.h" +#include "slang-ir-util.h" namespace Slang { @@ -16,6 +17,7 @@ struct DeadCodeEliminationContext // `eliminateDeadCode` function. // IRModule* module; + IRDeadCodeEliminationOptions options; // If we removed an inst, there may be still "weak references" to the inst. @@ -129,6 +131,9 @@ struct DeadCodeEliminationContext auto inst = workList.getLast(); workList.removeLast(); + if (!isChildInstOf(inst, root)) + continue; + // At this point we know that `inst` is live, // and we want to start considering which other // instructions must be live because of that @@ -426,7 +431,6 @@ bool eliminateDeadCode( DeadCodeEliminationContext context; context.module = module; context.options = options; - return context.processModule(); } @@ -437,7 +441,6 @@ bool eliminateDeadCode( DeadCodeEliminationContext context; context.module = root->getModule(); context.options = options; - return context.processInst(root); } diff --git a/source/slang/slang-ir-inst-defs.h b/source/slang/slang-ir-inst-defs.h index 1cb839751..26a92a17a 100644 --- a/source/slang/slang-ir-inst-defs.h +++ b/source/slang/slang-ir-inst-defs.h @@ -797,6 +797,9 @@ INST(HighLevelDeclDecoration, highLevelDecl, 1, 0) /* Differentiable Type Dictionary */ INST(DifferentiableTypeDictionaryDecoration, DifferentiableTypeDictionaryDecoration, 0, PARENT) + /// Overrides the floating mode for the target function + INST(FloatingPointModeOverrideDecoration, FloatingPointModeOverride, 1, 0) + /// Marks a struct type as being used as a structured buffer block. /// Recognized by SPIRV-emit pass so we can emit a SPIRV `BufferBlock` decoration. INST(SPIRVBufferBlockDecoration, spvBufferBlock, 0, 0) diff --git a/source/slang/slang-ir-insts.h b/source/slang/slang-ir-insts.h index d1374477f..fad20e900 100644 --- a/source/slang/slang-ir-insts.h +++ b/source/slang/slang-ir-insts.h @@ -846,6 +846,13 @@ struct IRDifferentiableTypeDictionaryDecoration : IRDecoration IR_LEAF_ISA(DifferentiableTypeDictionaryDecoration) }; +struct IRFloatingModeOverrideDecoration : IRDecoration +{ + IR_LEAF_ISA(FloatingPointModeOverrideDecoration) + + FloatingPointMode getFloatingPointMode() { return (FloatingPointMode)cast<IRIntLit>(getOperand(0))->getValue(); } +}; + // An instruction that specializes another IR value // (representing a generic) to a particular set of generic arguments // (instructions representing types, witness tables, etc.) @@ -2835,6 +2842,8 @@ public: // Add a differentiable type entry to the appropriate dictionary. IRInst* addDifferentiableTypeEntry(IRInst* dictDecoration, IRInst* irType, IRInst* conformanceWitness); + IRInst* addFloatingModeOverrideDecoration(IRInst* dest, FloatingPointMode mode); + IRInst* emitSpecializeInst( IRType* type, IRInst* genericVal, diff --git a/source/slang/slang-ir-peephole.cpp b/source/slang/slang-ir-peephole.cpp index fd0b4577a..65b4adcac 100644 --- a/source/slang/slang-ir-peephole.cpp +++ b/source/slang/slang-ir-peephole.cpp @@ -10,6 +10,7 @@ struct PeepholeContext : InstPassBase {} bool changed = false; + FloatingPointMode floatingPointMode = FloatingPointMode::Precise; bool tryFoldElementExtractFromUpdateInst(IRInst* inst) { @@ -96,8 +97,158 @@ struct PeepholeContext : InstPassBase return false; } + bool isZero(IRInst* inst) + { + switch (inst->getOp()) + { + case kIROp_IntLit: + return as<IRIntLit>(inst)->getValue() == 0; + case kIROp_FloatLit: + return as<IRFloatLit>(inst)->getValue() == 0.0; + case kIROp_MakeVector: + case kIROp_MakeVectorFromScalar: + case kIROp_MakeMatrix: + case kIROp_MakeMatrixFromScalar: + case kIROp_MatrixReshape: + case kIROp_VectorReshape: + { + for (UInt i = 0; i < inst->getOperandCount(); i++) + { + if (!isZero(inst->getOperand(i))) + { + return false; + } + } + return true; + } + case kIROp_CastIntToFloat: + case kIROp_CastFloatToInt: + return isZero(inst->getOperand(0)); + default: + return false; + } + } + + bool isOne(IRInst* inst) + { + switch (inst->getOp()) + { + case kIROp_IntLit: + return as<IRIntLit>(inst)->getValue() == 1; + case kIROp_FloatLit: + return as<IRFloatLit>(inst)->getValue() == 1.0; + case kIROp_MakeVector: + case kIROp_MakeVectorFromScalar: + case kIROp_MakeMatrix: + case kIROp_MakeMatrixFromScalar: + case kIROp_MatrixReshape: + case kIROp_VectorReshape: + { + for (UInt i = 0; i < inst->getOperandCount(); i++) + { + if (!isOne(inst->getOperand(i))) + { + return false; + } + } + return true; + } + case kIROp_CastIntToFloat: + case kIROp_CastFloatToInt: + return isOne(inst->getOperand(0)); + default: + return false; + } + } + + bool tryOptimizeArithmeticInst(IRInst* inst) + { + bool allowUnsafeOptimizations = + (floatingPointMode == FloatingPointMode::Fast || + isIntegralScalarOrCompositeType(inst->getDataType())); + + auto tryReplace = [&](IRInst* replacement) -> bool + { + if (replacement->getFullType() != inst->getFullType()) + { + // If the operand type is different from result type, + // we try to convert for some known cases. + if (auto vectorType = as<IRVectorType>(inst->getFullType())) + { + if (vectorType->getElementType() != replacement->getFullType()) + return false; + IRBuilder builder(sharedBuilderStorage); + builder.setInsertBefore(inst); + replacement = builder.emitMakeVectorFromScalar(inst->getFullType(), replacement); + } + else + { + return false; + } + } + + inst->replaceUsesWith(replacement); + inst->removeAndDeallocate(); + return true; + }; + + switch (inst->getOp()) + { + case kIROp_Add: + if (isZero(inst->getOperand(0))) + { + return tryReplace(inst->getOperand(1)); + } + else if (isZero(inst->getOperand(1))) + { + return tryReplace(inst->getOperand(0)); + } + break; + case kIROp_Sub: + if (isZero(inst->getOperand(1))) + { + return tryReplace(inst->getOperand(0)); + } + break; + case kIROp_Mul: + if (isOne(inst->getOperand(0))) + { + return tryReplace(inst->getOperand(1)); + } + else if (isOne(inst->getOperand(1))) + { + return tryReplace(inst->getOperand(0)); + } + else if (allowUnsafeOptimizations && isZero(inst->getOperand(0))) + { + return tryReplace(inst->getOperand(0)); + } + else if (allowUnsafeOptimizations && isZero(inst->getOperand(1))) + { + return tryReplace(inst->getOperand(1)); + } + break; + case kIROp_Div: + if (allowUnsafeOptimizations && isZero(inst->getOperand(0))) + { + return tryReplace(inst->getOperand(0)); + } + else if (isOne(inst->getOperand(1))) + { + return tryReplace(inst->getOperand(0)); + } + } + return false; + } + void processInst(IRInst* inst) { + if (as<IRGlobalValueWithCode>(inst)) + { + if (auto fpModeDecor = inst->findDecoration<IRFloatingModeOverrideDecoration>()) + floatingPointMode = fpModeDecor->getFloatingPointMode(); + } + switch (inst->getOp()) { case kIROp_GetResultError: @@ -432,6 +583,12 @@ struct PeepholeContext : InstPassBase } } break; + case kIROp_Add: + case kIROp_Mul: + case kIROp_Sub: + case kIROp_Div: + changed = tryOptimizeArithmeticInst(inst); + break; default: break; } @@ -443,6 +600,7 @@ struct PeepholeContext : InstPassBase sharedBuilder->init(module); sharedBuilderStorage.deduplicateAndRebuildGlobalNumberingMap(); bool result = false; + for (;;) { changed = false; diff --git a/source/slang/slang-ir-redundancy-removal.cpp b/source/slang/slang-ir-redundancy-removal.cpp index 9bd681115..176142601 100644 --- a/source/slang/slang-ir-redundancy-removal.cpp +++ b/source/slang/slang-ir-redundancy-removal.cpp @@ -109,6 +109,7 @@ bool removeRedundancy(IRModule* module) if (auto func = as<IRFunc>(inst)) { changed |= removeRedundancyInFunc(func); + changed |= eliminateRedundantLoadStore(func); } } return changed; @@ -126,4 +127,95 @@ bool removeRedundancyInFunc(IRGlobalValueWithCode* func) return context.removeRedundancyInBlock(deduplicateCtx, root); } +bool eliminateRedundantLoadStore(IRGlobalValueWithCode* func) +{ + bool changed = false; + for (auto block : func->getBlocks()) + { + for (auto inst = block->getFirstInst(); inst;) + { + auto nextInst = inst->getNextInst(); + if (auto load = as<IRLoad>(inst)) + { + for (auto prev = inst->getPrevInst(); prev; prev = prev->getPrevInst()) + { + if (auto store = as<IRStore>(prev)) + { + if (store->getPtr() == load->getPtr()) + { + // If the load is preceeded by a store without any side-effect insts in-between, remove the load. + auto value = store->getVal(); + load->replaceUsesWith(value); + load->removeAndDeallocate(); + changed = true; + break; + } + } + + if (canInstHaveSideEffectAtAddress(func, prev, load->getPtr())) + { + break; + } + } + } + else if (auto store = as<IRStore>(inst)) + { + // We perform a quick and conservative check: + // A store is redundant if it is followed by another store to the same address in + // the same basic block, and there are no instructions that may use any addresses + // related to this address. + bool hasAddrUse = false; + bool hasOverridingStore = false; + + // Stores to global variables will never get removed. + if (!isChildInstOf(store->getPtr(), func)) + hasAddrUse = true; + + for (auto next = store->getNextInst(); next; next = next->getNextInst()) + { + if (auto nextStore = as<IRStore>(next)) + { + if (nextStore->getPtr() == store->getPtr()) + { + hasOverridingStore = true; + break; + } + } + + // If we see any insts that have reads or modifies the address before seeing + // an overriding store, don't remove the store. + // We can make the test more accurate by collecting all addresses related to + // the target address first, and only bail out if any of the related addresses + // are involved. + switch (next->getOp()) + { + case kIROp_Load: + if (canAddressesPotentiallyAlias(func, next->getOperand(0), store->getPtr())) + { + hasAddrUse = true; + } + break; + default: + if (canInstHaveSideEffectAtAddress(func, next, store->getPtr())) + { + hasAddrUse = true; + } + break; + } + if (hasAddrUse) + break; + } + + if (!hasAddrUse && hasOverridingStore) + { + store->removeAndDeallocate(); + changed = true; + } + } + inst = nextInst; + } + } + return changed; +} + } diff --git a/source/slang/slang-ir-redundancy-removal.h b/source/slang/slang-ir-redundancy-removal.h index 26b265e77..c2df7853e 100644 --- a/source/slang/slang-ir-redundancy-removal.h +++ b/source/slang/slang-ir-redundancy-removal.h @@ -8,4 +8,6 @@ namespace Slang bool removeRedundancy(IRModule* module); bool removeRedundancyInFunc(IRGlobalValueWithCode* func); + + bool eliminateRedundantLoadStore(IRGlobalValueWithCode* func); } diff --git a/source/slang/slang-ir-simplify-for-emit.cpp b/source/slang/slang-ir-simplify-for-emit.cpp new file mode 100644 index 000000000..5e5f61a4a --- /dev/null +++ b/source/slang/slang-ir-simplify-for-emit.cpp @@ -0,0 +1,354 @@ +#include "slang-ir-simplify-for-emit.h" +#include "slang-ir-inst-pass-base.h" +#include "slang-ir-util.h" + +namespace Slang +{ + +struct SimplifyForEmitContext : public InstPassBase +{ + SimplifyForEmitContext(IRModule* inModule) + : InstPassBase(inModule) + {} + + List<IRInst*> followUpWorkList; + HashSet<IRInst*> followUpWorkListSet; + + void addToFollowUpWorkList(IRInst* inst) + { + if (followUpWorkListSet.Add(inst)) + followUpWorkList.add(inst); + } + + void processMakeStruct(IRInst* makeStruct) + { + auto structType = as<IRStructType>(makeStruct->getDataType()); + if (!structType) + return; + for (auto use = makeStruct->firstUse; use;) + { + auto nextUse = use->nextUse; + auto user = use->getUser(); + if (auto store = as<IRStore>(user)) + { + IRBuilder builder(sharedBuilderStorage); + builder.setInsertBefore(user); + UInt i = 0; + for (auto field : structType->getFields()) + { + auto fieldAddr = builder.emitFieldAddress( + builder.getPtrType(field->getFieldType()), + store->getPtr(), + field->getKey()); + builder.emitStore(fieldAddr, makeStruct->getOperand(i)); + addToFollowUpWorkList(makeStruct->getOperand(i)); + i++; + } + store->removeAndDeallocate(); + } + use = nextUse; + } + if (!makeStruct->hasUses()) + makeStruct->removeAndDeallocate(); + } + + void processMakeArray(IRInst* makeArray) + { + auto arrayType = as<IRArrayType>(makeArray->getDataType()); + if (!arrayType) + return; + + for (auto use = makeArray->firstUse; use;) + { + auto nextUse = use->nextUse; + auto user = use->getUser(); + if (auto store = as<IRStore>(user)) + { + IRBuilder builder(sharedBuilderStorage); + builder.setInsertBefore(user); + for (UInt i = 0; i < makeArray->getOperandCount(); i++) + { + auto elementAddr = builder.emitElementAddress( + builder.getPtrType(arrayType->getElementType()), + store->getPtr(), + builder.getIntValue(builder.getIntType(), (IRIntegerValue)i)); + builder.emitStore(elementAddr, makeArray->getOperand(i)); + addToFollowUpWorkList(makeArray->getOperand(i)); + } + store->removeAndDeallocate(); + } + use = nextUse; + } + if (!makeArray->hasUses()) + makeArray->removeAndDeallocate(); + } + + void processMakeArrayFromElement(IRInst* makeArray) + { + auto arrayType = as<IRArrayType>(makeArray->getDataType()); + if (!arrayType) + return; + auto arraySize = as<IRIntLit>(arrayType->getElementCount()); + if (!arraySize) + return; + + for (auto use = makeArray->firstUse; use;) + { + auto nextUse = use->nextUse; + auto user = use->getUser(); + if (auto store = as<IRStore>(user)) + { + IRBuilder builder(sharedBuilderStorage); + builder.setInsertBefore(user); + for (IRIntegerValue i = 0; i < arraySize->getValue(); i++) + { + auto elementAddr = builder.emitElementAddress( + builder.getPtrType(arrayType->getElementType()), + store->getPtr(), + builder.getIntValue(builder.getIntType(), i)); + builder.emitStore(elementAddr, makeArray->getOperand(0)); + addToFollowUpWorkList(makeArray->getOperand(0)); + } + store->removeAndDeallocate(); + } + use = nextUse; + } + if (!makeArray->hasUses()) + makeArray->removeAndDeallocate(); + } + + void processLoadUse(IRGlobalValueWithCode* func, IRLoad* load, IRUse* use) + { + auto user = use->getUser(); + if (user->getParent() != load->getParent()) + return; + for (auto inst = load->getNextInst(); inst; inst = inst->getNextInst()) + { + if (inst == user) + break; + if (canInstHaveSideEffectAtAddress(func, inst, load->getPtr())) + return; + } + + // If we reach here, it is OK to defer the load at use site. + IRBuilder builder(sharedBuilderStorage); + builder.setInsertBefore(user); + auto newLoad = builder.emitLoad(load->getPtr()); + use->set(newLoad); + } + + void processLoad(IRLoad* inst) + { + auto func = getParentFunc(inst); + if (!func) + return; + + for (auto use = inst->firstUse; use;) + { + auto nextUse = use->nextUse; + processLoadUse(func, inst, use); + use = nextUse; + } + + if (!inst->hasUses()) + inst->removeAndDeallocate(); + } + + void processElementExtract(IRInst* inst) + { + // Create a duplicate for each use site. + // This is safe because the result value of this inst should never + // change regardless of where the inst is defined. + // By creating the duplicates right before use sites, we will enable + // the emit logic to always fold these insts. + for (auto use = inst->firstUse; use;) + { + auto nextUse = use->nextUse; + + auto user = use->getUser(); + if (user->getPrevInst() == inst) + { + use = nextUse; + continue; + } + + IRBuilder builder(sharedBuilderStorage); + builder.setInsertBefore(user); + List<IRInst*> args; + for (UInt i = 0; i < inst->getOperandCount(); i++) + args.add(inst->getOperand(i)); + auto newInst = builder.emitIntrinsicInst(inst->getFullType(), inst->getOp(), inst->getOperandCount(), args.getBuffer()); + use->set(newInst); + + use = nextUse; + } + if (!inst->hasUses()) + inst->removeAndDeallocate(); + } + + void processVar(IRInst* var) + { + // Defer var to its first use, if the use is in the same basic block as the var. + HashSet<IRInst*> userInSameBlock; + for (auto use = var->firstUse; use; use = use->nextUse) + if (use->getUser()->getParent() == var->getParent()) + { + userInSameBlock.Add(use->getUser()); + } + IRInst* firstUser = nullptr; + for (auto inst = var->getNextInst(); inst; inst = inst->getNextInst()) + { + if (userInSameBlock.Contains(inst)) + { + firstUser = inst; + break; + } + } + if (!firstUser) + return; + var->insertBefore(firstUser); + } + + void processInst(IRInst* inst) + { + // We inspect each inst and see if the following simplifications + // can be applied: + // 1. If we see `store(addr, MakeArray/Struct)`, we should turn them + // into direct stores into each element/field and remove the need + // to create a temporary for the `MakeArray/Struct` inst. + // 2. If we see `load(addr)`, we duplicate the load right at each + // use site if it can be determined safe to do so. This allows + // emit logic to skip producing a temp var for the loaded result. + switch (inst->getOp()) + { + case kIROp_MakeStruct: + processMakeStruct(inst); + break; + case kIROp_MakeArray: + processMakeArray(inst); + break; + case kIROp_MakeArrayFromElement: + processMakeArrayFromElement(inst); + break; + case kIROp_Load: + processLoad(as<IRLoad>(inst)); + break; + case kIROp_GetElement: + case kIROp_FieldExtract: + processElementExtract(inst); + break; + case kIROp_Var: + processVar(inst); + break; + } + } + + void eliminateCompositeConstruct(IRGlobalValueWithCode* func) + { + followUpWorkList.clear(); + followUpWorkListSet.Clear(); + + for (auto block : func->getBlocks()) + { + for (auto inst = block->getFirstInst(); inst; inst = inst->getNextInst()) + { + switch (inst->getOp()) + { + case kIROp_MakeStruct: + case kIROp_MakeArray: + case kIROp_MakeArrayFromElement: + addToFollowUpWorkList(inst); + break; + } + } + } + for (Index i = 0; i < followUpWorkList.getCount(); i++) + processInst(followUpWorkList[i]); + } + + void deferAndDuplicateLoad(IRGlobalValueWithCode* func) + { + followUpWorkList.clear(); + followUpWorkListSet.Clear(); + + for (auto block : func->getBlocks()) + { + for (auto inst = block->getFirstInst(); inst; inst = inst->getNextInst()) + { + switch (inst->getOp()) + { + case kIROp_Load: + addToFollowUpWorkList(inst); + break; + } + } + } + for (Index i = 0; i < followUpWorkList.getCount(); i++) + processInst(followUpWorkList[i]); + } + + void deferVarDecl(IRGlobalValueWithCode* func) + { + followUpWorkList.clear(); + followUpWorkListSet.Clear(); + + for (auto block : func->getBlocks()) + { + for (auto inst = block->getFirstInst(); inst; inst = inst->getNextInst()) + { + switch (inst->getOp()) + { + case kIROp_Var: + addToFollowUpWorkList(inst); + break; + } + } + } + for (Index i = 0; i < followUpWorkList.getCount(); i++) + processInst(followUpWorkList[i]); + } + + void deferAndDuplicateElementExtract(IRGlobalValueWithCode* func) + { + followUpWorkList.clear(); + followUpWorkListSet.Clear(); + + for (auto block = func->getLastBlock(); block; block = block->getPrevBlock()) + { + for (auto inst = block->getLastChild(); inst; inst = inst->getPrevInst()) + { + switch (inst->getOp()) + { + case kIROp_GetElement: + case kIROp_FieldExtract: + addToFollowUpWorkList(inst); + break; + } + } + } + for (Index i = 0; i < followUpWorkList.getCount(); i++) + processInst(followUpWorkList[i]); + } + + void processFunc(IRGlobalValueWithCode* func) + { + eliminateCompositeConstruct(func); + deferAndDuplicateElementExtract(func); + deferAndDuplicateLoad(func); + deferVarDecl(func); + } + + void processModule() + { + sharedBuilderStorage.init(module); + processInstsOfType<IRFunc>(kIROp_Func, [this](IRFunc* f) { processFunc(f); }); + } +}; + +void simplifyForEmit(IRModule* module) +{ + SimplifyForEmitContext context(module); + context.processModule(); +} + +} diff --git a/source/slang/slang-ir-simplify-for-emit.h b/source/slang/slang-ir-simplify-for-emit.h new file mode 100644 index 000000000..a6cf3bad8 --- /dev/null +++ b/source/slang/slang-ir-simplify-for-emit.h @@ -0,0 +1,9 @@ +// slang-ir-simplify-for-emit.h +#pragma once + +namespace Slang +{ + struct IRModule; + + void simplifyForEmit(IRModule* inModule); +} diff --git a/source/slang/slang-ir-util.cpp b/source/slang/slang-ir-util.cpp index 5cf074484..af6fd8ac4 100644 --- a/source/slang/slang-ir-util.cpp +++ b/source/slang/slang-ir-util.cpp @@ -229,6 +229,217 @@ String dumpIRToString(IRInst* root) return sb.ToString(); } +void copyNameHintDecoration(IRInst* dest, IRInst* src) +{ + auto decor = src->findDecoration<IRNameHintDecoration>(); + if (decor) + { + cloneDecoration(decor, dest); + } +} + +void getTypeNameHint(StringBuilder& sb, IRInst* type) +{ + if (!type) + return; + + switch (type->getOp()) + { + case kIROp_FloatType: + sb << "float"; + break; + case kIROp_HalfType: + sb << "half"; + break; + case kIROp_DoubleType: + sb << "double"; + break; + case kIROp_IntType: + sb << "int"; + break; + case kIROp_Int8Type: + sb << "int8"; + break; + case kIROp_Int16Type: + sb << "int16"; + break; + case kIROp_Int64Type: + sb << "int64"; + break; + case kIROp_IntPtrType: + sb << "intptr"; + break; + case kIROp_UIntType: + sb << "uint"; + break; + case kIROp_UInt8Type: + sb << "uint8"; + break; + case kIROp_UInt16Type: + sb << "uint16"; + break; + case kIROp_UInt64Type: + sb << "uint64"; + break; + case kIROp_UIntPtrType: + sb << "uintptr"; + break; + case kIROp_CharType: + sb << "char"; + break; + case kIROp_StringType: + sb << "string"; + break; + case kIROp_ArrayType: + sb << "array_"; + getTypeNameHint(sb, type->getOperand(0)); + break; + case kIROp_VectorType: + getTypeNameHint(sb, type->getOperand(0)); + getTypeNameHint(sb, as<IRVectorType>(type)->getElementCount()); + break; + case kIROp_MatrixType: + getTypeNameHint(sb, type->getOperand(0)); + getTypeNameHint(sb, as<IRMatrixType>(type)->getRowCount()); + sb << "x"; + getTypeNameHint(sb, as<IRMatrixType>(type)->getColumnCount()); + break; + case kIROp_IntLit: + sb << as<IRIntLit>(type)->getValue(); + break; + default: + if (auto decor = type->findDecoration<IRNameHintDecoration>()) + sb << decor->getName(); + break; + } +} + +static IRInst* _getRootAddr(IRInst* addr) +{ + for (;;) + { + switch (addr->getOp()) + { + case kIROp_GetElementPtr: + case kIROp_FieldAddress: + addr = addr->getOperand(0); + continue; + default: + break; + } + break; + } + return addr; +} + +// A simple and conservative address aliasing check. +bool canAddressesPotentiallyAlias(IRGlobalValueWithCode* func, IRInst* addr1, IRInst* addr2) +{ + if (addr1 == addr2) + return true; + + // Two variables can never alias. + addr1 = _getRootAddr(addr1); + addr2 = _getRootAddr(addr2); + + // Global addresses can alias with anything. + if (!isChildInstOf(addr1, func)) + return true; + + if (!isChildInstOf(addr2, func)) + return true; + + if (addr1->getOp() == kIROp_Var && addr2->getOp() == kIROp_Var + && addr1 != addr2) + return false; + + // A param and a var can never alias. + if (addr1->getOp() == kIROp_Param && addr1->getParent() == func->getFirstBlock() && + addr2->getOp() == kIROp_Var || + addr1->getOp() == kIROp_Var && addr2->getOp() == kIROp_Param && + addr2->getParent() == func->getFirstBlock()) + return false; + return true; +} + +bool isPtrLikeOrHandleType(IRInst* type) +{ + switch (type->getOp()) + { + case kIROp_ComPtrType: + case kIROp_RawPointerType: + case kIROp_RTTIPointerType: + case kIROp_PseudoPtrType: + case kIROp_OutType: + case kIROp_InOutType: + case kIROp_PtrType: + case kIROp_RefType: + return true; + } + return false; +} + +bool canInstHaveSideEffectAtAddress(IRGlobalValueWithCode* func, IRInst* inst, IRInst* addr) +{ + switch (inst->getOp()) + { + case kIROp_Store: + // If the target of the store inst may overlap addr, return true. + if (canAddressesPotentiallyAlias(func, as<IRStore>(inst)->getPtr(), addr)) + return true; + break; + case kIROp_Call: + { + auto call = as<IRCall>(inst); + + // If addr is a global variable, calling a function may change its value. + // So we need to return true here to be conservative. + if (!isChildInstOf(_getRootAddr(addr), func)) + { + auto callee = call->getCallee(); + if (callee && + callee->findDecoration<IRReadNoneDecoration>() && + callee->findDecoration<IRNoSideEffectDecoration>()) + { + // An exception is if the callee is side-effect free and is not reading from + // memory. + } + else + { + return true; + } + } + + // If any pointer typed argument of the call inst may overlap addr, return true. + for (UInt i = 0; i < call->getArgCount(); i++) + { + if (isPtrLikeOrHandleType(call->getArg(i)->getDataType())) + { + if (canAddressesPotentiallyAlias(func, call->getArg(i), addr)) + return true; + } + } + } + break; + case kIROp_CastPtrToInt: + case kIROp_Reinterpret: + case kIROp_BitCast: + { + // If we are trying to cast an address to something else, return true. + if (isPtrLikeOrHandleType(inst->getOperand(0)->getDataType()) && + canAddressesPotentiallyAlias(func, inst->getOperand(0), addr)) + return true; + } + break; + default: + // Default behavior is that any insts that have side effect may affect `addr`. + if (inst->mightHaveSideEffects()) + return true; + break; + } + return false; +} + bool isPureFunctionalCall(IRCall* call) { auto callee = getResolvedInstForDecorations(call->getCallee()); diff --git a/source/slang/slang-ir-util.h b/source/slang/slang-ir-util.h index 26ad4bc68..c067bde44 100644 --- a/source/slang/slang-ir-util.h +++ b/source/slang/slang-ir-util.h @@ -153,11 +153,20 @@ inline IRInst* unwrapAttributedType(IRInst* type) return type; } +void getTypeNameHint(StringBuilder& sb, IRInst* type); +void copyNameHintDecoration(IRInst* dest, IRInst* src); + +bool canAddressesPotentiallyAlias(IRGlobalValueWithCode* func, IRInst* addr1, IRInst* addr2); + String dumpIRToString(IRInst* root); // Returns whether a call insts can be treated as a pure functional inst // (no writes to memory, no side effects). bool isPureFunctionalCall(IRCall* callInst); + +bool isPtrLikeOrHandleType(IRInst* type); + +bool canInstHaveSideEffectAtAddress(IRGlobalValueWithCode* func, IRInst* inst, IRInst* addr); } #endif diff --git a/source/slang/slang-ir.cpp b/source/slang/slang-ir.cpp index 558574bf6..1b16bfe1f 100644 --- a/source/slang/slang-ir.cpp +++ b/source/slang/slang-ir.cpp @@ -4604,6 +4604,14 @@ namespace Slang return inst; } + IRInst* IRBuilder::addFloatingModeOverrideDecoration(IRInst* dest, FloatingPointMode mode) + { + return addDecoration( + dest, + kIROp_FloatingPointModeOverrideDecoration, + getIntValue(getIntType(), (IRIntegerValue)mode)); + } + IRInst* IRBuilder::emitSwizzle( IRType* type, IRInst* base, @@ -6418,6 +6426,20 @@ namespace Slang return false; } + bool isIntegralScalarOrCompositeType(IRType* t) + { + if (!t) + return false; + switch (t->getOp()) + { + case kIROp_VectorType: + case kIROp_MatrixType: + return isIntegralType((IRType*)t->getOperand(0)); + default: + return isIntegralType(t); + } + } + void findAllInstsBreadthFirst(IRInst* inst, List<IRInst*>& outInsts) { Index index = outInsts.getCount(); @@ -6577,6 +6599,8 @@ namespace Slang void IRInst::insertBefore(IRInst* other) { SLANG_ASSERT(other); + if (other->getPrevInst() == this) + return; _insertAt(other->getPrevInst(), other, other->getParent()); } diff --git a/source/slang/slang-ir.h b/source/slang/slang-ir.h index e22e41f0c..41b140972 100644 --- a/source/slang/slang-ir.h +++ b/source/slang/slang-ir.h @@ -869,6 +869,8 @@ bool isTypeEqual(IRType* a, IRType* b); // True if this is an integral IRBasicType, not including Char or Ptr types bool isIntegralType(IRType* t); +bool isIntegralScalarOrCompositeType(IRType* t); + void findAllInstsBreadthFirst(IRInst* inst, List<IRInst*>& outInsts); // Constant Instructions @@ -943,6 +945,13 @@ struct IRIntLit : IRConstant IR_LEAF_ISA(IntLit); }; +struct IRFloatLit : IRConstant +{ + IRFloatingPointValue getValue() { return value.floatVal; } + + IR_LEAF_ISA(FloatLit); +}; + struct IRBoolLit : IRConstant { bool getValue() { return value.intVal != 0; } diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp index 149f5f6b9..8377246fb 100644 --- a/source/slang/slang-lower-to-ir.cpp +++ b/source/slang/slang-lower-to-ir.cpp @@ -3304,6 +3304,15 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo> } } + LoweredValInfo visitMakeRefExpr(MakeRefExpr* expr) + { + auto loweredBase = lowerLValueExpr(context, expr->base); + + SLANG_ASSERT(loweredBase.flavor == LoweredValInfo::Flavor::Ptr); + loweredBase.flavor = LoweredValInfo::Flavor::Simple; + return loweredBase; + } + LoweredValInfo visitParenExpr(ParenExpr* expr) { return lowerSubExpr(expr->base); @@ -4234,11 +4243,11 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo> switch (baseVal.flavor) { case LoweredValInfo::Flavor::Simple: - return LoweredValInfo::simple( - builder->emitElementExtract( - type, - getSimpleVal(context, baseVal), - indexVal)); + return LoweredValInfo::simple( + builder->emitElementExtract( + type, + getSimpleVal(context, baseVal), + indexVal)); case LoweredValInfo::Flavor::Ptr: return LoweredValInfo::ptr( @@ -4416,7 +4425,11 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo> LoweredValInfo visitOpenRefExpr(OpenRefExpr* expr) { - return lowerLValueExpr(context, expr->innerExpr); + auto info = lowerRValueExpr(context, expr->innerExpr); + SLANG_RELEASE_ASSERT(as<IRPtrTypeBase>(info.val->getFullType())); + SLANG_RELEASE_ASSERT(info.flavor == LoweredValInfo::Flavor::Simple); + info.flavor = LoweredValInfo::Flavor::Ptr; + return info; } }; @@ -4596,10 +4609,6 @@ LoweredValInfo lowerLValueExpr( LValueExprLoweringVisitor visitor; visitor.context = context; auto info = visitor.dispatch(expr); - if (as<RefType>(expr->type)) - { - info.flavor = LoweredValInfo::Flavor::Ptr; - } return info; } @@ -4612,10 +4621,6 @@ LoweredValInfo lowerRValueExpr( RValueExprLoweringVisitor visitor; visitor.context = context; auto info = visitor.dispatch(expr); - if (as<RefType>(expr->type)) - { - info.val = context->irBuilder->emitLoad(info.val); - } return info; } |