Skip to content

Commit d0bd3f9

Browse files
natevmnatevm
committed
working on fixing formatting
1 parent 04c2638 commit d0bd3f9

7 files changed

+189
-114
lines changed

‎source/slang/slang-emit-c-like.cpp

+135-82
Original file line numberDiff line numberDiff line change
@@ -2866,7 +2866,7 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO
28662866
emitBitfieldExtractImpl(inst);
28672867
break;
28682868
}
2869-
case kIROp_BitfieldInsert:
2869+
case kIROp_BitfieldInsert:
28702870
{
28712871
emitBitfieldInsertImpl(inst);
28722872
break;
@@ -3843,40 +3843,60 @@ void CLikeSourceEmitter::emitFuncDecorationsImpl(IRFunc* func)
38433843
}
38443844
}
38453845

3846-
bool CLikeSourceEmitter::tryGetIntInfo(IRType* elementType, bool &isSigned, int &bitWidth)
3846+
bool CLikeSourceEmitter::tryGetIntInfo(IRType* elementType, bool& isSigned, int& bitWidth)
38473847
{
38483848
Slang::IROp type = elementType->getOp();
3849-
if (!(type >= kIROp_Int8Type && type <= kIROp_UInt64Type)) return false;
3849+
if (!(type >= kIROp_Int8Type && type <= kIROp_UInt64Type))
3850+
return false;
38503851
isSigned = (type >= kIROp_Int8Type && type <= kIROp_Int64Type);
38513852

38523853
Slang::IROp stype = (isSigned) ? type : Slang::IROp(type - 4);
38533854
bitWidth = 8 << (stype - kIROp_Int8Type);
38543855
return true;
38553856
}
38563857

3857-
void CLikeSourceEmitter::emitVecNOrScalar(IRVectorType* vectorType, std::function<void()> emitComponentLogic)
3858+
void CLikeSourceEmitter::emitVecNOrScalar(
3859+
IRVectorType* vectorType,
3860+
std::function<void()> emitComponentLogic)
38583861
{
38593862
if (vectorType)
38603863
{
38613864
int N = int(getIntVal(vectorType->getElementCount()));
3862-
Slang::IRType *elementType = vectorType->getElementType();
3865+
Slang::IRType* elementType = vectorType->getElementType();
38633866

38643867
// Special handling required for CUDA target
38653868
if (isCUDATarget(getTargetReq()))
38663869
{
38673870
m_writer->emit("make_");
38683871

3869-
switch(elementType->getOp())
3872+
switch (elementType->getOp())
38703873
{
3871-
case kIROp_Int8Type: m_writer->emit("char"); break;
3872-
case kIROp_Int16Type: m_writer->emit("short"); break;
3873-
case kIROp_IntType: m_writer->emit("int"); break;
3874-
case kIROp_Int64Type: m_writer->emit("longlong"); break;
3875-
case kIROp_UInt8Type: m_writer->emit("uchar"); break;
3876-
case kIROp_UInt16Type: m_writer->emit("ushort"); break;
3877-
case kIROp_UIntType: m_writer->emit("uint"); break;
3878-
case kIROp_UInt64Type: m_writer->emit("ulonglong"); break;
3879-
default: SLANG_ABORT_COMPILATION("Unhandled type emitting CUDA vector");
3874+
case kIROp_Int8Type:
3875+
m_writer->emit("char");
3876+
break;
3877+
case kIROp_Int16Type:
3878+
m_writer->emit("short");
3879+
break;
3880+
case kIROp_IntType:
3881+
m_writer->emit("int");
3882+
break;
3883+
case kIROp_Int64Type:
3884+
m_writer->emit("longlong");
3885+
break;
3886+
case kIROp_UInt8Type:
3887+
m_writer->emit("uchar");
3888+
break;
3889+
case kIROp_UInt16Type:
3890+
m_writer->emit("ushort");
3891+
break;
3892+
case kIROp_UIntType:
3893+
m_writer->emit("uint");
3894+
break;
3895+
case kIROp_UInt64Type:
3896+
m_writer->emit("ulonglong");
3897+
break;
3898+
default:
3899+
SLANG_ABORT_COMPILATION("Unhandled type emitting CUDA vector");
38803900
}
38813901

38823902
m_writer->emitRawText(std::to_string(N).c_str());
@@ -3892,12 +3912,13 @@ void CLikeSourceEmitter::emitVecNOrScalar(IRVectorType* vectorType, std::functio
38923912
}
38933913

38943914
// In other languages, we can output the Slang vector type directly
3895-
else {
3915+
else
3916+
{
38963917
emitType(vectorType);
38973918
}
38983919

38993920
m_writer->emit("(");
3900-
for (int i = 0; i < N; ++i)
3921+
for (int i = 0; i < N; ++i)
39013922
{
39023923
emitType(elementType);
39033924
m_writer->emit("(");
@@ -3916,7 +3937,7 @@ void CLikeSourceEmitter::emitVecNOrScalar(IRVectorType* vectorType, std::functio
39163937
}
39173938
}
39183939

3919-
void CLikeSourceEmitter::emitBitfieldExtractImpl(IRInst* inst)
3940+
void CLikeSourceEmitter::emitBitfieldExtractImpl(IRInst* inst)
39203941
{
39213942
// If unsigned, bfue := ((val>>off)&((1u<<bts)-1))
39223943
// Else signed, bfse := (((val>>off)&((1u<<bts)-1))<<(nbts-bts)>>(nbts-bts));
@@ -3930,26 +3951,38 @@ void CLikeSourceEmitter::emitBitfieldExtractImpl(IRInst* inst)
39303951
if (vectorType)
39313952
elementType = vectorType->getElementType();
39323953

3933-
bool isSigned;
3954+
bool isSigned;
39343955
int bitWidth;
3935-
if (!tryGetIntInfo(elementType, isSigned, bitWidth))
3956+
if (!tryGetIntInfo(elementType, isSigned, bitWidth))
39363957
{
3937-
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "non-integer element type given to bitfieldExtract");
3958+
SLANG_DIAGNOSE_UNEXPECTED(
3959+
getSink(),
3960+
SourceLoc(),
3961+
"non-integer element type given to bitfieldExtract");
39383962
return;
39393963
}
39403964

39413965
String one;
3942-
switch(bitWidth)
3966+
switch (bitWidth)
39433967
{
3944-
case 8: one = "uint8_t(1)"; break;
3945-
case 16: one = "uint16_t(1)"; break;
3946-
case 32: one = "uint32_t(1)"; break;
3947-
case 64: one = "uint64_t(1)"; break;
3948-
default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unexpected bit width");
3968+
case 8:
3969+
one = "uint8_t(1)";
3970+
break;
3971+
case 16:
3972+
one = "uint16_t(1)";
3973+
break;
3974+
case 32:
3975+
one = "uint32_t(1)";
3976+
break;
3977+
case 64:
3978+
one = "uint64_t(1)";
3979+
break;
3980+
default:
3981+
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unexpected bit width");
39493982
}
39503983

39513984
// Emit open paren and type cast for later sign extension
3952-
if (isSigned)
3985+
if (isSigned)
39533986
{
39543987
m_writer->emit("(");
39553988
emitType(inst->getDataType());
@@ -3960,50 +3993,55 @@ void CLikeSourceEmitter::emitBitfieldExtractImpl(IRInst* inst)
39603993
m_writer->emit("((");
39613994
emitOperand(val, getInfo(EmitOp::General));
39623995
m_writer->emit(">>");
3963-
emitVecNOrScalar(vectorType, [&]() {
3964-
emitOperand(off, getInfo(EmitOp::General));
3965-
});
3996+
emitVecNOrScalar(vectorType, [&]() { emitOperand(off, getInfo(EmitOp::General)); });
39663997
m_writer->emit(")&(");
3967-
emitVecNOrScalar(vectorType, [&]() {
3968-
m_writer->emit("((" + one + "<<");
3969-
emitOperand(bts, getInfo(EmitOp::General));
3970-
m_writer->emit(")-" + one + ")");
3971-
});
3998+
emitVecNOrScalar(
3999+
vectorType,
4000+
[&]()
4001+
{
4002+
m_writer->emit("((" + one + "<<");
4003+
emitOperand(bts, getInfo(EmitOp::General));
4004+
m_writer->emit(")-" + one + ")");
4005+
});
39724006
m_writer->emit("))");
39734007

39744008
// Emit sign extension logic
39754009
// (type(bitfield<<(numBits-bts))>>(numBits-bts))
39764010
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
3977-
if (isSigned)
4011+
if (isSigned)
39784012
{
39794013
m_writer->emit("<<");
3980-
emitVecNOrScalar(vectorType, [&]()
3981-
{
3982-
m_writer->emit("(");
3983-
m_writer->emit(bitWidth);
3984-
m_writer->emit("-");
3985-
emitOperand(bts, getInfo(EmitOp::General));
3986-
m_writer->emit(")");
3987-
});
4014+
emitVecNOrScalar(
4015+
vectorType,
4016+
[&]()
4017+
{
4018+
m_writer->emit("(");
4019+
m_writer->emit(bitWidth);
4020+
m_writer->emit("-");
4021+
emitOperand(bts, getInfo(EmitOp::General));
4022+
m_writer->emit(")");
4023+
});
39884024
m_writer->emit(")>>");
3989-
emitVecNOrScalar(vectorType, [&]()
3990-
{
3991-
m_writer->emit("(");
3992-
m_writer->emit(bitWidth);
3993-
m_writer->emit("-");
3994-
emitOperand(bts, getInfo(EmitOp::General));
3995-
m_writer->emit(")");
3996-
});
4025+
emitVecNOrScalar(
4026+
vectorType,
4027+
[&]()
4028+
{
4029+
m_writer->emit("(");
4030+
m_writer->emit(bitWidth);
4031+
m_writer->emit("-");
4032+
emitOperand(bts, getInfo(EmitOp::General));
4033+
m_writer->emit(")");
4034+
});
39974035
m_writer->emit(")");
39984036
}
39994037
}
40004038

4001-
void CLikeSourceEmitter::emitBitfieldInsertImpl(IRInst* inst)
4039+
void CLikeSourceEmitter::emitBitfieldInsertImpl(IRInst* inst)
40024040
{
40034041
// uint clearMask = ~(((1u << bits) - 1u) << offset);
40044042
// uint clearedBase = base & clearMask;
40054043
// uint maskedInsert = (insert & ((1u << bits) - 1u)) << offset;
4006-
// BitfieldInsert := T(uint(clearedBase) | uint(maskedInsert));
4044+
// BitfieldInsert := T(uint(clearedBase) | uint(maskedInsert));
40074045
Slang::IRType* dataType = inst->getDataType();
40084046
Slang::IRInst* bse = inst->getOperand(0);
40094047
Slang::IRInst* ins = inst->getOperand(1);
@@ -4019,55 +4057,70 @@ void CLikeSourceEmitter::emitBitfieldInsertImpl(IRInst* inst)
40194057
int bitWidth;
40204058
if (!tryGetIntInfo(elementType, isSigned, bitWidth))
40214059
{
4022-
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "non-integer element type given to bitfieldInsert");
4060+
SLANG_DIAGNOSE_UNEXPECTED(
4061+
getSink(),
4062+
SourceLoc(),
4063+
"non-integer element type given to bitfieldInsert");
40234064
return;
40244065
}
40254066

40264067
String one;
4027-
switch(bitWidth) {
4028-
case 8: one = "uint8_t(1)"; break;
4029-
case 16: one = "uint16_t(1)"; break;
4030-
case 32: one = "uint32_t(1)"; break;
4031-
case 64: one = "uint64_t(1)"; break;
4032-
default: SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unexpected bit width");
4068+
switch (bitWidth)
4069+
{
4070+
case 8:
4071+
one = "uint8_t(1)";
4072+
break;
4073+
case 16:
4074+
one = "uint16_t(1)";
4075+
break;
4076+
case 32:
4077+
one = "uint32_t(1)";
4078+
break;
4079+
case 64:
4080+
one = "uint64_t(1)";
4081+
break;
4082+
default:
4083+
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unexpected bit width");
40334084
}
40344085

40354086
m_writer->emit("((");
4036-
4087+
40374088
// emit clearedBase := uint(bse & ~(((1u<<bts)-1u)<<off))
40384089
emitOperand(bse, getInfo(EmitOp::General));
40394090
m_writer->emit("&");
4040-
emitVecNOrScalar(vectorType, [&]()
4041-
{
4042-
m_writer->emit("~(((" + one + "<<");
4043-
emitOperand(bts, getInfo(EmitOp::General));
4044-
m_writer->emit(")-" + one + ")<<");
4045-
emitOperand(off, getInfo(EmitOp::General));
4046-
m_writer->emit(")");
4047-
});
4048-
4049-
4091+
emitVecNOrScalar(
4092+
vectorType,
4093+
[&]()
4094+
{
4095+
m_writer->emit("~(((" + one + "<<");
4096+
emitOperand(bts, getInfo(EmitOp::General));
4097+
m_writer->emit(")-" + one + ")<<");
4098+
emitOperand(off, getInfo(EmitOp::General));
4099+
m_writer->emit(")");
4100+
});
4101+
40504102
// bitwise or clearedBase with maskedInsert
40514103
m_writer->emit(")|(");
40524104

40534105
// Emit maskedInsert := ((insert & ((1u << bits) - 1u)) << offset);
4054-
4106+
40554107
// - first emit mask := (insert & ((1u << bits) - 1u))
40564108
m_writer->emit("(");
40574109
emitOperand(ins, getInfo(EmitOp::General));
40584110
m_writer->emit("&");
4059-
emitVecNOrScalar(vectorType, [&](){
4060-
m_writer->emit("(" + one + "<<");
4061-
emitOperand(bts, getInfo(EmitOp::General));
4062-
m_writer->emit(")-" + one);
4063-
});
4111+
emitVecNOrScalar(
4112+
vectorType,
4113+
[&]()
4114+
{
4115+
m_writer->emit("(" + one + "<<");
4116+
emitOperand(bts, getInfo(EmitOp::General));
4117+
m_writer->emit(")-" + one);
4118+
});
40644119
m_writer->emit(")");
40654120

40664121
// then emit shift := << offset
40674122
m_writer->emit("<<");
4068-
emitVecNOrScalar(vectorType, [&](){
4069-
emitOperand(off, getInfo(EmitOp::General));
4070-
});
4123+
emitVecNOrScalar(vectorType, [&]() { emitOperand(off, getInfo(EmitOp::General)); });
40714124
m_writer->emit("))");
40724125
}
40734126

‎source/slang/slang-emit-c-like.h

+1-1
Original file line numberDiff line numberDiff line change
@@ -615,7 +615,7 @@ class CLikeSourceEmitter : public SourceEmitterBase
615615
SLANG_UNUSED(baseName);
616616
}
617617

618-
bool tryGetIntInfo(IRType* elementType, bool &isSigned, int &bitWidth);
618+
bool tryGetIntInfo(IRType* elementType, bool& isSigned, int& bitWidth);
619619
void emitVecNOrScalar(IRVectorType* vectorType, std::function<void()> func);
620620
virtual void emitBitfieldExtractImpl(IRInst* inst);
621621
virtual void emitBitfieldInsertImpl(IRInst* inst);

‎source/slang/slang-emit-metal.cpp

+8-7
Original file line numberDiff line numberDiff line change
@@ -919,7 +919,8 @@ bool MetalSourceEmitter::tryEmitInstExprImpl(IRInst* inst, const EmitOpInfo& inO
919919

920920
void MetalSourceEmitter::emitVectorTypeNameImpl(IRType* elementType, IRIntegerValue elementCount)
921921
{
922-
// NM: Passing count here, as Metal 64-bit vector type names do not match their scalar equivalents.
922+
// NM: Passing count here, as Metal 64-bit vector type names do not match their scalar
923+
// equivalents.
923924
emitSimpleTypeKnowingCount(elementType, elementCount);
924925

925926
switch (elementType->getOp())
@@ -1042,10 +1043,10 @@ void MetalSourceEmitter::emitParamTypeImpl(IRType* type, String const& name)
10421043

10431044
void MetalSourceEmitter::emitSimpleTypeKnowingCount(IRType* type, IRIntegerValue elementCount)
10441045
{
1045-
// NM: note, "ulong/ushort" is only type that works for i16/i64 vec, but can't be used for scalars.
1046-
// (See metal specification pg 26)
1046+
// NM: note, "ulong/ushort" is only type that works for i16/i64 vec, but can't be used for
1047+
// scalars. (See metal specification pg 26)
10471048

1048-
switch (type->getOp())
1049+
switch (type->getOp())
10491050
{
10501051
case kIROp_VoidType:
10511052
case kIROp_BoolType:
@@ -1063,7 +1064,7 @@ void MetalSourceEmitter::emitSimpleTypeKnowingCount(IRType* type, IRIntegerValue
10631064
case kIROp_Int64Type:
10641065
m_writer->emit("long");
10651066
return;
1066-
case kIROp_UInt64Type:
1067+
case kIROp_UInt64Type:
10671068
if (elementCount > 1)
10681069
m_writer->emit("ulong");
10691070
else
@@ -1073,7 +1074,7 @@ void MetalSourceEmitter::emitSimpleTypeKnowingCount(IRType* type, IRIntegerValue
10731074
m_writer->emit("short");
10741075
return;
10751076
case kIROp_UInt16Type:
1076-
if (elementCount > 1)
1077+
if (elementCount > 1)
10771078
m_writer->emit("ushort");
10781079
else
10791080
m_writer->emit("uint16_t");
@@ -1082,7 +1083,7 @@ void MetalSourceEmitter::emitSimpleTypeKnowingCount(IRType* type, IRIntegerValue
10821083
m_writer->emit("long");
10831084
return;
10841085
case kIROp_UIntPtrType:
1085-
if (elementCount > 1)
1086+
if (elementCount > 1)
10861087
m_writer->emit("ulong");
10871088
else
10881089
m_writer->emit("uint64_t");

0 commit comments

Comments
 (0)