[HLSL] Compatibility overloads for integer operations

[llvm-beanz]

Many HLSL shaders call unary math operations with integers. To minimize disruptions at the source level we should implement additional integer overloads for unary floating-point math operations that take integers and explicitly convert them to float.

These should be enabled in HLSL 202x, but we should consider disabling them in 202y.

Some macros:

#define DXC_COMPAT_UNARY_INTEGER_OVERLOAD(fn)                                  \
  float fn(int V) { return fn((float)V); }                                     \
  float2 fn(int2 V) { return fn((float2)V); }                                  \
  float3 fn(int3 V) { return fn((float3)V); }                                  \
  float4 fn(int4 V) { return fn((float4)V); }                                  \
  float fn(uint V) { return fn((float)V); }                                    \
  float2 fn(uint2 V) { return fn((float2)V); }                                 \
  float3 fn(uint3 V) { return fn((float3)V); }                                 \
  float4 fn(uint4 V) { return fn((float4)V); }                                 \
  float fn(int64_t V) { return fn((float)V); }                                 \
  float2 fn(int64_t2 V) { return fn((float2)V); }                              \
  float3 fn(int64_t3 V) { return fn((float3)V); }                              \
  float4 fn(int64_t4 V) { return fn((float4)V); }                              \
  float fn(uint64_t V) { return fn((float)V); }                                \
  float2 fn(uint64_t2 V) { return fn((float2)V); }                             \
  float3 fn(uint64_t3 V) { return fn((float3)V); }                             \
  float4 fn(uint64_t4 V) { return fn((float4)V); }

#define DXC_COMPAT_BINARY_INTEGER_OVERLOAD(fn)                                 \
  float fn(int V1, int V2) { return fn((float)V1, (float)V2); }                \
  float2 fn(int2 V1, int2 V2) { return fn((float2)V1, (float2)V2); }           \
  float3 fn(int3 V1, int3 V2) { return fn((float3)V1, (float3)V2); }           \
  float4 fn(int4 V1, int4 V2) { return fn((float4)V1, (float4)V2); }           \
  float fn(uint V1, uint V2) { return fn((float)V1, (float)V2); }              \
  float2 fn(uint2 V1, uint2 V2) { return fn((float2)V1, (float2)V2); }         \
  float3 fn(uint3 V1, uint3 V2) { return fn((float3)V1, (float3)V2); }         \
  float4 fn(uint4 V1, uint4 V2) { return fn((float4)V1, (float4)V2); }         \
  float fn(int64_t V1, int64_t V2) { return fn((float)V1, (float)V2); }        \
  float2 fn(int64_t2 V1, int64_t2 V2) { return fn((float2)V1, (float2)V2); }   \
  float3 fn(int64_t3 V1, int64_t3 V2) { return fn((float3)V1, (float3)V2); }   \
  float4 fn(int64_t4 V1, int64_t4 V2) { return fn((float4)V1, (float4)V2); }   \
  float fn(uint64_t V1, uint64_t V2) { return fn((float)V1, (float)V2); }      \
  float2 fn(uint64_t2 V1, uint64_t2 V2) { return fn((float2)V1, (float2)V2); } \
  float3 fn(uint64_t3 V1, uint64_t3 V2) { return fn((float3)V1, (float3)V2); } \
  float4 fn(uint64_t4 V1, uint64_t4 V2) { return fn((float4)V1, (float4)V2); }