Implement the `length` HLSL Function

[farzonl]

• Implement length clang builtin,
• Link length clang builtin with hlsl_intrinsics.h
• Add sema checks for length to CheckHLSLBuiltinFunctionCall in SemaChecking.cpp #101096
• Add codegen for length to EmitHLSLBuiltinExpr in CGBuiltin.cpp
• Add codegen tests to clang/test/CodeGenHLSL/builtins/length.hlsl
• Add sema tests to clang/test/SemaHLSL/BuiltIns/length-errors.hlsl
• Create the int_dx_length intrinsic in IntrinsicsDirectX.td
• Create an intrinsic expansion of int_dx_length in llvm/lib/Target/DirectX/DXILIntrinsicExpansion.cpp
• Create the length.ll and length_errors.ll tests in llvm/test/CodeGen/DirectX/
• Create the int_spv_length intrinsic in IntrinsicsSPIRV.td
• In SPIRVInstructionSelector.cpp create the length lowering and map it to int_spv_length in SPIRVInstructionSelector::selectIntrinsic.
• Create SPIR-V backend test case in llvm/test/CodeGen/SPIRV/hlsl-intrinsics/length.ll

DirectX

DXIL Opcode	DXIL OpName	Shader Model	Shader Stages
24	Sqrt	6.0	()

SPIR-V

Length:

Description:

Length

Result is the length of vector x, i.e., sqrt(x [0] ² +
x [1] ² + …).

The operand x must be a scalar or vector whose component type is
floating-point.

Result Type must be a scalar of the same type as the component type of
x.

Number	Operand 1	Operand 2	Operand 3	Operand 4
66	<id> x

Test Case(s)

Example 1

//dxc length_test.hlsl -T lib_6_8 -enable-16bit-types -O0

export float fn(float4 p1) {
    return length(p1);
}

HLSL:

Returns the length of the specified floating-point vector.

ret length(x)

Parameters

Item	Description
x	The specified floating-point vector.

Return Value

A floating-point scalar that represents the length of the x parameter.

Type Description

Name	Template Type	Component Type	Size
x	vector	float	any
ret	scalar	float	1

Minimum Shader Model

This function is supported in the following shader models.

Shader Model	Supported
Shader Model 2 (DirectX HLSL) and higher shader models	yes
Shader Model 1 (DirectX HLSL)	yes (vs_1_1 only)

See also

Intrinsic Functions (DirectX HLSL)

[farzonl]

For the DXILIntrinsicExpansion.cpp
see IntrinsicOp::IOP_length TranslateLength implementation:
https://github.com/microsoft/DirectXShaderCompiler/blob/b6f7ff81e9cea7b82a6412b6d2521dfdacc09517/lib/HLSL/HLOperationLower.cpp#L2154-L2180

Expectations for the implementation would be to see an extractelement per scalar in the vector an fmul per scalar to get V[i]^2 LEN(V)-1 fadd(s) for the sumation. and finally one dxil sqrt.

https://hlsl.godbolt.org/z/5EfE6Yno8

define float @"fn"(<4 x float> %p1) #0 {
  call void @llvm.dbg.value(metadata <4 x float> %p1, i64 0, metadata !35, metadata !36), !dbg !37
  %1 = extractelement <4 x float> %p1, i64 0, !dbg !38
  %2 = fmul fast float %1, %1, !dbg !38
  %3 = extractelement <4 x float> %p1, i64 1, !dbg !38
  %4 = fmul fast float %3, %3, !dbg !38
  %5 = fadd fast float %2, %4, !dbg !38
  %6 = extractelement <4 x float> %p1, i64 2, !dbg !38
  %7 = fmul fast float %6, %6, !dbg !38
  %8 = fadd fast float %5, %7, !dbg !38
  %9 = extractelement <4 x float> %p1, i64 3, !dbg !38
  %10 = fmul fast float %9, %9, !dbg !38
  %11 = fadd fast float %8, %10, !dbg !38
  %Sqrt = call float @dx.op.unary.f32(i32 24, float %11), !dbg !38
  %12 = load i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @dx.nothing.a, i32 0, i32 0), !dbg !39
  ret float %Sqrt, !dbg !39
}

if it is not a vector input the behavior is to emit a DXIL abs call
https://hlsl.godbolt.org/z/eM7Gs38fP

define float @"fn"(float %p1) #0 {
  call void @llvm.dbg.value(metadata float %p1, i64 0, metadata !23, metadata !24), !dbg !25
  %FAbs = call float @dx.op.unary.f32(i32 6, float %p1), !dbg !26
  %1 = load i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @dx.nothing.a, i32 0, i32 0), !dbg !27
  ret float %FAbs, !dbg !27
}