AST: Remove convertToBasicType() which was obfuscating the conversion design.

Test/baseResults/hlsl.logical.binary.frag.out

@@ -13,8 +13,7 @@ gl_FragCoord origin is upper left
 0:13              'anon@0' (layout( row_major std140) uniform block{ uniform int ival,  uniform 4-component vector of int ival4,  uniform float fval,  uniform 4-component vector of float fval4})
 0:13              Constant:
 0:13                0 (const uint)
-0:13          Convert int to bool ( temp bool)
-0:13            Convert float to int ( temp int)
+0:13          Convert float to bool ( temp bool)
 0:13            fval: direct index for structure ( uniform float)
 0:13              'anon@0' (layout( row_major std140) uniform block{ uniform int ival,  uniform 4-component vector of int ival4,  uniform float fval,  uniform 4-component vector of float fval4})
 0:13              Constant:
@@ -28,8 +27,7 @@ gl_FragCoord origin is upper left
 0:14              'anon@0' (layout( row_major std140) uniform block{ uniform int ival,  uniform 4-component vector of int ival4,  uniform float fval,  uniform 4-component vector of float fval4})
 0:14              Constant:
 0:14                0 (const uint)
-0:14          Convert int to bool ( temp bool)
-0:14            Convert float to int ( temp int)
+0:14          Convert float to bool ( temp bool)
 0:14            fval: direct index for structure ( uniform float)
 0:14              'anon@0' (layout( row_major std140) uniform block{ uniform int ival,  uniform 4-component vector of int ival4,  uniform float fval,  uniform 4-component vector of float fval4})
 0:14              Constant:
@@ -79,8 +77,7 @@ gl_FragCoord origin is upper left
 0:13              'anon@0' (layout( row_major std140) uniform block{ uniform int ival,  uniform 4-component vector of int ival4,  uniform float fval,  uniform 4-component vector of float fval4})
 0:13              Constant:
 0:13                0 (const uint)
-0:13          Convert int to bool ( temp bool)
-0:13            Convert float to int ( temp int)
+0:13          Convert float to bool ( temp bool)
 0:13            fval: direct index for structure ( uniform float)
 0:13              'anon@0' (layout( row_major std140) uniform block{ uniform int ival,  uniform 4-component vector of int ival4,  uniform float fval,  uniform 4-component vector of float fval4})
 0:13              Constant:
@@ -94,8 +91,7 @@ gl_FragCoord origin is upper left
 0:14              'anon@0' (layout( row_major std140) uniform block{ uniform int ival,  uniform 4-component vector of int ival4,  uniform float fval,  uniform 4-component vector of float fval4})
 0:14              Constant:
 0:14                0 (const uint)
-0:14          Convert int to bool ( temp bool)
-0:14            Convert float to int ( temp int)
+0:14          Convert float to bool ( temp bool)
 0:14            fval: direct index for structure ( uniform float)
 0:14              'anon@0' (layout( row_major std140) uniform block{ uniform int ival,  uniform 4-component vector of int ival4,  uniform float fval,  uniform 4-component vector of float fval4})
 0:14              Constant:
@@ -129,12 +125,12 @@ gl_FragCoord origin is upper left
 
 // Module Version 10000
 // Generated by (magic number): 80006
-// Id's are bound by 57
+// Id's are bound by 56
 
                               Capability Shader
                1:             ExtInstImport  "GLSL.std.450"
                               MemoryModel Logical GLSL450
-                              EntryPoint Fragment 4  "main" 54
+                              EntryPoint Fragment 4  "main" 53
                               ExecutionMode 4 OriginUpperLeft
                               Source HLSL 500
                               Name 4  "main"
@@ -147,15 +143,15 @@ gl_FragCoord origin is upper left
                               MemberName 14($Global) 2  "fval"
                               MemberName 14($Global) 3  "fval4"
                               Name 16  ""
-                              Name 45  "psout"
-                              Name 54  "@entryPointOutput.Color"
+                              Name 44  "psout"
+                              Name 53  "@entryPointOutput.Color"
                               MemberDecorate 14($Global) 0 Offset 0
                               MemberDecorate 14($Global) 1 Offset 16
                               MemberDecorate 14($Global) 2 Offset 32
                               MemberDecorate 14($Global) 3 Offset 48
                               Decorate 14($Global) Block
                               Decorate 16 DescriptorSet 0
-                              Decorate 54(@entryPointOutput.Color) Location 0
+                              Decorate 53(@entryPointOutput.Color) Location 0
                2:             TypeVoid
                3:             TypeFunction 2
                6:             TypeFloat 32
@@ -174,29 +170,29 @@ gl_FragCoord origin is upper left
               23:     22(int) Constant 0
               25:     12(int) Constant 2
               26:             TypePointer Uniform 6(float)
-              44:             TypePointer Function 8(PS_OUTPUT)
-              46:    6(float) Constant 1065353216
-              47:    7(fvec4) ConstantComposite 46 46 46 46
-              48:             TypePointer Function 7(fvec4)
-              53:             TypePointer Output 7(fvec4)
-54(@entryPointOutput.Color):     53(ptr) Variable Output
+              29:    6(float) Constant 0
+              43:             TypePointer Function 8(PS_OUTPUT)
+              45:    6(float) Constant 1065353216
+              46:    7(fvec4) ConstantComposite 45 45 45 45
+              47:             TypePointer Function 7(fvec4)
+              52:             TypePointer Output 7(fvec4)
+53(@entryPointOutput.Color):     52(ptr) Variable Output
          4(main):           2 Function None 3
                5:             Label
-              55:8(PS_OUTPUT) FunctionCall 10(@main()
-              56:    7(fvec4) CompositeExtract 55 0
-                              Store 54(@entryPointOutput.Color) 56
+              54:8(PS_OUTPUT) FunctionCall 10(@main()
+              55:    7(fvec4) CompositeExtract 54 0
+                              Store 53(@entryPointOutput.Color) 55
                               Return
                               FunctionEnd
       10(@main():8(PS_OUTPUT) Function None 9
               11:             Label
-       45(psout):     44(ptr) Variable Function
+       44(psout):     43(ptr) Variable Function
               19:     18(ptr) AccessChain 16 17
               20:     12(int) Load 19
               24:    21(bool) INotEqual 20 23
               27:     26(ptr) AccessChain 16 25
               28:    6(float) Load 27
-              29:     12(int) ConvertFToS 28
-              30:    21(bool) INotEqual 29 23
+              30:    21(bool) FOrdNotEqual 28 29
               31:    21(bool) LogicalAnd 24 30
                               SelectionMerge 33 None
                               BranchConditional 31 32 33
@@ -208,16 +204,15 @@ gl_FragCoord origin is upper left
               36:    21(bool) INotEqual 35 23
               37:     26(ptr) AccessChain 16 25
               38:    6(float) Load 37
-              39:     12(int) ConvertFToS 38
-              40:    21(bool) INotEqual 39 23
-              41:    21(bool) LogicalOr 36 40
-                              SelectionMerge 43 None
-                              BranchConditional 41 42 43
+              39:    21(bool) FOrdNotEqual 38 29
+              40:    21(bool) LogicalOr 36 39
+                              SelectionMerge 42 None
+                              BranchConditional 40 41 42
+              41:               Label
+                                Branch 42
               42:             Label
-                                Branch 43
-              43:             Label
-              49:     48(ptr) AccessChain 45(psout) 17
-                              Store 49 47
-              50:8(PS_OUTPUT) Load 45(psout)
-                              ReturnValue 50
+              48:     47(ptr) AccessChain 44(psout) 17
+                              Store 48 46
+              49:8(PS_OUTPUT) Load 44(psout)
+                              ReturnValue 49
                               FunctionEnd

glslang/MachineIndependent/Intermediate.cpp

@@ -475,7 +475,7 @@ bool TIntermediate::isConversionAllowed(TOperator op, TIntermTyped* node) const
 
 // This is 'mechanism' here, it does any conversion told.
 // It is about basic type, not about shape.
-// The policy comes from the shader or the above code.
+// The policy comes from the shader or the calling code.
 TIntermUnary* TIntermediate::createConversion(TBasicType convertTo, TIntermTyped* node) const
 {
     //
@@ -491,7 +491,7 @@ TIntermUnary* TIntermediate::createConversion(TBasicType convertTo, TIntermTyped
         case EbtInt8:    newOp = EOpConvInt8ToDouble;    break;
         case EbtUint8:   newOp = EOpConvUint8ToDouble;   break;
         case EbtInt16:   newOp = EOpConvInt16ToDouble;   break;
-        case EbtUint16:newOp = EOpConvUint16ToDouble;break;
+        case EbtUint16:  newOp = EOpConvUint16ToDouble;  break;
         case EbtInt:     newOp = EOpConvIntToDouble;     break;
         case EbtUint:    newOp = EOpConvUintToDouble;    break;
         case EbtBool:    newOp = EOpConvBoolToDouble;    break;
@@ -714,24 +714,33 @@ TIntermUnary* TIntermediate::createConversion(TBasicType convertTo, TIntermTyped
     return newNode;
 }
 
+// For converting a pair of operands to a binary operation to compatible
+// types with each other, relative to the operation in 'op'.
+// This does not cover assignment operations, which is asymmetric in that the
+// left type is not changeable.
+// See addConversion(op, type, node) for assignments and unary operation
+// conversions.
+//
+// Generally, this is focused on basic type conversion, not shape conversion.
+// See addShapeConversion() for shape conversions.
+//
+// Returns the converted pair of nodes.
+// Returns <nullptr, nullptr> when there is no conversion.
 std::tuple<TIntermTyped*, TIntermTyped*>
 TIntermediate::addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* node1) const
 {
-    if (!isConversionAllowed(op, node0) || !isConversionAllowed(op, node1)) {
+    if (!isConversionAllowed(op, node0) || !isConversionAllowed(op, node1))
         return std::make_tuple(nullptr, nullptr);
-    }
 
-    // If types are identical, no problem
-    if (node0->getType() == node1->getType())
-        return std::make_tuple(node0, node1);
-
-    // If one's a structure, then no conversions.
+    if (node0->getType() != node1->getType()) {
+        // If differing structure, then no conversions.
         if (node0->isStruct() || node1->isStruct())
             return std::make_tuple(nullptr, nullptr);
 
-    // If one's an array, then no conversions.
+        // If differing arrays, then no conversions.
         if (node0->getType().isArray() || node1->getType().isArray())
             return std::make_tuple(nullptr, nullptr);
+    }
 
     auto promoteTo = std::make_tuple(EbtNumTypes, EbtNumTypes);
 
@@ -767,11 +776,8 @@ TIntermediate::addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* no
     case EOpAndAssign:
     case EOpInclusiveOrAssign:
     case EOpExclusiveOrAssign:
-    case EOpLogicalNot:
-    case EOpLogicalAnd:
-    case EOpLogicalOr:
-    case EOpLogicalXor:
 
+    case EOpLogicalNot:
     case EOpFunctionCall:
     case EOpReturn:
     case EOpAssign:
@@ -782,7 +788,6 @@ TIntermediate::addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* no
     case EOpMatrixTimesScalarAssign:
     case EOpDivAssign:
     case EOpModAssign:
-
     case EOpAtan:
     case EOpClamp:
     case EOpCross:
@@ -803,10 +808,10 @@ TIntermediate::addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* no
     case EOpRefract:
     case EOpSmoothStep:
     case EOpStep:
-
-    case EOpSequence:
     case EOpConstructStruct:
 
+    case EOpSequence:          // used by ?:
+
         if (type0 == type1)
             return std::make_tuple(node0, node1);
 
@@ -816,6 +821,15 @@ TIntermediate::addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* no
 
         break;
 
+    case EOpLogicalAnd:
+    case EOpLogicalOr:
+    case EOpLogicalXor:
+        if (source == EShSourceHlsl)
+            promoteTo = std::make_tuple(EbtBool, EbtBool);
+        else
+            return std::make_tuple(node0, node1);
+        break;
+
     // Shifts can have mixed types as long as they are integer and of the same rank,
     // without converting.
     // It's the left operand's type that determines the resulting type, so no issue
@@ -824,6 +838,8 @@ TIntermediate::addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* no
     case EOpRightShift:
     case EOpLeftShiftAssign:
     case EOpRightShiftAssign:
+        if (node0->getType() == node1->getType())
+            return std::make_tuple(node0, node1);
 
         if (isTypeInt(type0) && isTypeInt(type1)) {
             if (getTypeRank(type0) == getTypeRank(type1)) {
@@ -838,6 +854,9 @@ TIntermediate::addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* no
         break;
 
     default:
+        if (node0->getType() == node1->getType())
+            return std::make_tuple(node0, node1);
+
         return std::make_tuple(nullptr, nullptr);
     }
 
@@ -872,7 +891,7 @@ TIntermediate::addConversion(TOperator op, TIntermTyped* node0, TIntermTyped* no
 // node passed in if no conversion was needed.
 //
 // Generally, this is focused on basic type conversion, not shape conversion.
-// See addShapeConversion().
+// See addShapeConversion() for shape conversions.
 //
 // Return nullptr if a conversion can't be done.
 //
@@ -2952,7 +2971,7 @@ bool TIntermediate::promoteUnary(TIntermUnary& node)
         // Convert operand to a boolean type
         if (operand->getBasicType() != EbtBool) {
             // Add constructor to boolean type. If that fails, we can't do it, so return false.
-            TIntermTyped* converted = convertToBasicType(op, EbtBool, operand);
+            TIntermTyped* converted = addConversion(op, TType(EbtBool), operand);
             if (converted == nullptr)
                 return false;
 
@@ -2997,24 +3016,6 @@ void TIntermUnary::updatePrecision()
     }
 }
 
-// If it is not already, convert this node to the given basic type.
-TIntermTyped* TIntermediate::convertToBasicType(TOperator op, TBasicType basicType, TIntermTyped* node) const
-{
-    if (node == nullptr)
-        return nullptr;
-
-    // It's already this basic type: nothing needs to be done, so use the node directly.
-    if (node->getBasicType() == basicType)
-        return node;
-
-    const TType& type = node->getType();
-    const TType newType(basicType, type.getQualifier().storage,
-                        type.getVectorSize(), type.getMatrixCols(), type.getMatrixRows(), type.isVector());
-
-    // Add constructor to the right vectorness of the right type. If that fails, we can't do it, so return nullptr.
-    return addConversion(op, newType, node);
-}
-
 //
 // See TIntermediate::promote
 //
@@ -3139,21 +3140,17 @@ bool TIntermediate::promoteBinary(TIntermBinary& node)
     case EOpLogicalAnd:
     case EOpLogicalOr:
     case EOpLogicalXor:
-        if (getSource() == EShSourceHlsl) {
-            TIntermTyped* convertedL = convertToBasicType(op, EbtBool, left);
-            TIntermTyped* convertedR = convertToBasicType(op, EbtBool, right);
-            if (convertedL == nullptr || convertedR == nullptr)
+        // logical ops operate only on Booleans or vectors of Booleans.
+        if (left->getBasicType() != EbtBool || left->isMatrix())
                 return false;
-            node.setLeft(left = convertedL);   // also updates stack variable
-            node.setRight(right = convertedR); // also updates stack variable
-        } else {
+
+        if (getSource() == EShSourceGlsl) {
             // logical ops operate only on scalar Booleans and will promote to scalar Boolean.
-            if (left->getBasicType() != EbtBool || left->isVector() || left->isMatrix())
+            if (left->isVector())
                 return false;
         }
 
         node.setType(TType(EbtBool, EvqTemporary, left->getVectorSize()));
-
         break;
 
     case EOpRightShift:

glslang/MachineIndependent/localintermediate.h

@@ -459,9 +459,6 @@ public:
     TIntermUnary* addUnaryNode(TOperator op, TIntermTyped* child, TSourceLoc) const;
     TIntermUnary* addUnaryNode(TOperator op, TIntermTyped* child, TSourceLoc, const TType&) const;
 
-    // Add conversion from node's type to given basic type.
-    TIntermTyped* convertToBasicType(TOperator op, TBasicType basicType, TIntermTyped* node) const;
-
     // Constant folding (in Constant.cpp)
     TIntermTyped* fold(TIntermAggregate* aggrNode);
     TIntermTyped* foldConstructor(TIntermAggregate* aggrNode);