mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-01-19 04:32:19 +00:00
27c076ae40
This patch changes the design of GlobalAlias so that it doesn't take a ConstantExpr anymore. It now points directly to a GlobalObject, but its type is independent of the aliasee type. To avoid changing all alias related tests in this patches, I kept the common syntax @foo = alias i32* @bar to mean the same as now. The cases that used to use cast now use the more general syntax @foo = alias i16, i32* @bar. Note that GlobalAlias now behaves a bit more like GlobalVariable. We know that its type is always a pointer, so we omit the '*'. For the bitcode, a nice surprise is that we were writing both identical types already, so the format change is minimal. Auto upgrade is handled by looking through the casts and no new fields are needed for now. New bitcode will simply have different types for Alias and Aliasee. One last interesting point in the patch is that replaceAllUsesWith becomes smart enough to avoid putting a ConstantExpr in the aliasee. This seems better than checking and updating every caller. A followup patch will delete getAliasedGlobal now that it is redundant. Another patch will add support for an explicit offset. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@209007 91177308-0d34-0410-b5e6-96231b3b80d8
230 lines
8.0 KiB
LLVM
230 lines
8.0 KiB
LLVM
; RUN: opt -S -instcombine -o - %s | FileCheck %s
|
|
target datalayout = "e-p:32:32:32-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v64:64:64-v128:128:128-a0:0:64"
|
|
|
|
|
|
|
|
; Cases that should be bitcast
|
|
|
|
; Test cast between scalars with same bit sizes
|
|
@alias_i32_to_f32 = alias float (float), i32 (i32)* @func_i32
|
|
|
|
; Test cast between vectors with same number of elements and bit sizes
|
|
@alias_v2i32_to_v2f32 = alias <2 x float> (<2 x float>), <2 x i32> (<2 x i32>)* @func_v2i32
|
|
|
|
; Test cast from vector to scalar with same number of bits
|
|
@alias_v2f32_to_i64 = alias <2 x float> (<2 x float>), i64 (i64)* @func_i64
|
|
|
|
; Test cast from scalar to vector with same number of bits
|
|
@alias_i64_to_v2f32 = alias i64 (i64), <2 x float> (<2 x float>)* @func_v2f32
|
|
|
|
; Test cast between vectors of pointers
|
|
@alias_v2i32p_to_v2i64p = alias <2 x i64*> (<2 x i64*>), <2 x i32*> (<2 x i32*>)* @func_v2i32p
|
|
|
|
|
|
; Cases that should be invalid and unchanged
|
|
|
|
; Test cast between scalars with different bit sizes
|
|
@alias_i64_to_f32 = alias float (float), i64 (i64)* @func_i64
|
|
|
|
; Test cast between vectors with different bit sizes but the
|
|
; same number of elements
|
|
@alias_v2i64_to_v2f32 = alias <2 x float> (<2 x float>), <2 x i64> (<2 x i64>)* @func_v2i64
|
|
|
|
; Test cast between vectors with same number of bits and different
|
|
; numbers of elements
|
|
@alias_v2i32_to_v4f32 = alias <4 x float> (<4 x float>), <2 x i32> (<2 x i32>)* @func_v2i32
|
|
|
|
; Test cast between scalar and vector with different number of bits
|
|
@alias_i64_to_v4f32 = alias i64 (i64), <4 x float> (<4 x float>)* @func_v4f32
|
|
|
|
; Test cast between vector and scalar with different number of bits
|
|
@alias_v4f32_to_i64 = alias <4 x float> (<4 x float>), i64 (i64)* @func_i64
|
|
|
|
; Test cast from scalar to vector of pointers with same number of bits
|
|
; We don't know the pointer size at this point, so this can't be done
|
|
@alias_i64_to_v2i32p = alias i64 (i64), <2 x i32*> (<2 x i32*>)* @func_v2i32p
|
|
|
|
; Test cast between vector of pointers and scalar with different number of bits
|
|
@alias_v4i32p_to_i64 = alias <4 x i32*> (<4 x i32*>), i64 (i64)* @func_i64
|
|
|
|
|
|
|
|
define internal <2 x i32> @func_v2i32(<2 x i32> %v) noinline nounwind {
|
|
entry:
|
|
ret <2 x i32> %v
|
|
}
|
|
|
|
define internal <2 x float> @func_v2f32(<2 x float> %v) noinline nounwind {
|
|
entry:
|
|
ret <2 x float> %v
|
|
}
|
|
|
|
define internal <4 x float> @func_v4f32(<4 x float> %v) noinline nounwind {
|
|
entry:
|
|
ret <4 x float> %v
|
|
}
|
|
|
|
define internal i32 @func_i32(i32 %v) noinline nounwind {
|
|
entry:
|
|
ret i32 %v
|
|
}
|
|
|
|
define internal i64 @func_i64(i64 %v) noinline nounwind {
|
|
entry:
|
|
ret i64 %v
|
|
}
|
|
|
|
define internal <2 x i64> @func_v2i64(<2 x i64> %v) noinline nounwind {
|
|
entry:
|
|
ret <2 x i64> %v
|
|
}
|
|
|
|
define internal <2 x i32*> @func_v2i32p(<2 x i32*> %v) noinline nounwind {
|
|
entry:
|
|
ret <2 x i32*> %v
|
|
}
|
|
|
|
; Valid cases, only bitcast for argument / return type and call underlying function
|
|
|
|
; Sizes match, should only bitcast
|
|
define void @bitcast_alias_scalar(float* noalias %source, float* noalias %dest) nounwind {
|
|
entry:
|
|
; CHECK-LABEL: @bitcast_alias_scalar
|
|
; CHECK: bitcast float %tmp to i32
|
|
; CHECK-NOT: fptoui
|
|
; CHECK-NOT: uitofp
|
|
; CHECK: bitcast i32 %call to float
|
|
%tmp = load float* %source, align 8
|
|
%call = call float @alias_i32_to_f32(float %tmp) nounwind
|
|
store float %call, float* %dest, align 8
|
|
ret void
|
|
}
|
|
|
|
; Sizes match, should only bitcast
|
|
define void @bitcast_alias_vector(<2 x float>* noalias %source, <2 x float>* noalias %dest) nounwind {
|
|
entry:
|
|
; CHECK-LABEL: @bitcast_alias_vector
|
|
; CHECK: bitcast <2 x float> %tmp to <2 x i32>
|
|
; CHECK-NOT: fptoui
|
|
; CHECK-NOT: uitofp
|
|
; CHECK: bitcast <2 x i32> %call to <2 x float>
|
|
%tmp = load <2 x float>* %source, align 8
|
|
%call = call <2 x float> @alias_v2i32_to_v2f32(<2 x float> %tmp) nounwind
|
|
store <2 x float> %call, <2 x float>* %dest, align 8
|
|
ret void
|
|
}
|
|
|
|
; Sizes match, should only bitcast
|
|
define void @bitcast_alias_vector_scalar_same_size(<2 x float>* noalias %source, <2 x float>* noalias %dest) nounwind {
|
|
entry:
|
|
; CHECK-LABEL: @bitcast_alias_vector_scalar_same_size
|
|
; CHECK: bitcast <2 x float> %tmp to i64
|
|
; CHECK: %call = call i64 @func_i64
|
|
; CHECK: bitcast i64 %call to <2 x float>
|
|
%tmp = load <2 x float>* %source, align 8
|
|
%call = call <2 x float> @alias_v2f32_to_i64(<2 x float> %tmp) nounwind
|
|
store <2 x float> %call, <2 x float>* %dest, align 8
|
|
ret void
|
|
}
|
|
|
|
define void @bitcast_alias_scalar_vector_same_size(i64* noalias %source, i64* noalias %dest) nounwind {
|
|
entry:
|
|
; CHECK-LABEL: @bitcast_alias_scalar_vector_same_size
|
|
; CHECK: bitcast i64 %tmp to <2 x float>
|
|
; CHECK: call <2 x float> @func_v2f32
|
|
; CHECK: bitcast <2 x float> %call to i64
|
|
%tmp = load i64* %source, align 8
|
|
%call = call i64 @alias_i64_to_v2f32(i64 %tmp) nounwind
|
|
store i64 %call, i64* %dest, align 8
|
|
ret void
|
|
}
|
|
|
|
define void @bitcast_alias_vector_ptrs_same_size(<2 x i64*>* noalias %source, <2 x i64*>* noalias %dest) nounwind {
|
|
entry:
|
|
; CHECK-LABEL: @bitcast_alias_vector_ptrs_same_size
|
|
; CHECK: bitcast <2 x i64*> %tmp to <2 x i32*>
|
|
; CHECK: call <2 x i32*> @func_v2i32p
|
|
; CHECK: bitcast <2 x i32*> %call to <2 x i64*>
|
|
%tmp = load <2 x i64*>* %source, align 8
|
|
%call = call <2 x i64*> @alias_v2i32p_to_v2i64p(<2 x i64*> %tmp) nounwind
|
|
store <2 x i64*> %call, <2 x i64*>* %dest, align 8
|
|
ret void
|
|
}
|
|
|
|
; Invalid cases:
|
|
|
|
define void @bitcast_alias_mismatch_scalar_size(float* noalias %source, float* noalias %dest) nounwind {
|
|
entry:
|
|
; CHECK-LABEL: @bitcast_alias_mismatch_scalar_size
|
|
; CHECK-NOT: fptoui
|
|
; CHECK: @alias_i64_to_f32
|
|
; CHECK-NOT: uitofp
|
|
%tmp = load float* %source, align 8
|
|
%call = call float @alias_i64_to_f32(float %tmp) nounwind
|
|
store float %call, float* %dest, align 8
|
|
ret void
|
|
}
|
|
|
|
define void @bitcast_alias_mismatch_vector_element_and_bit_size(<2 x float>* noalias %source, <2 x float>* noalias %dest) nounwind {
|
|
entry:
|
|
; CHECK-LABEL: @bitcast_alias_mismatch_vector_element_and_bit_size
|
|
; CHECK-NOT: fptoui <2 x float> %tmp to <2 x i64>
|
|
; CHECK: @alias_v2i64_to_v2f32
|
|
; CHECK-NOT: uitofp <2 x i64> %call to <2 x float>
|
|
%tmp = load <2 x float>* %source, align 8
|
|
%call = call <2 x float> @alias_v2i64_to_v2f32(<2 x float> %tmp) nounwind
|
|
store <2 x float> %call, <2 x float>* %dest, align 8
|
|
ret void
|
|
}
|
|
|
|
define void @bitcast_alias_vector_mismatched_number_elements(<4 x float>* noalias %source, <4 x float>* noalias %dest) nounwind {
|
|
entry:
|
|
; CHECK-LABEL: @bitcast_alias_vector_mismatched_number_elements
|
|
; CHECK: %call = call <4 x float> @alias_v2i32_to_v4f32
|
|
%tmp = load <4 x float>* %source, align 8
|
|
%call = call <4 x float> @alias_v2i32_to_v4f32(<4 x float> %tmp) nounwind
|
|
store <4 x float> %call, <4 x float>* %dest, align 8
|
|
ret void
|
|
}
|
|
|
|
define void @bitcast_alias_vector_scalar_mismatched_bit_size(<4 x float>* noalias %source, <4 x float>* noalias %dest) nounwind {
|
|
entry:
|
|
; CHECK-LABEL: @bitcast_alias_vector_scalar_mismatched_bit_size
|
|
; CHECK: %call = call <4 x float> @alias_v4f32_to_i64
|
|
%tmp = load <4 x float>* %source, align 8
|
|
%call = call <4 x float> @alias_v4f32_to_i64(<4 x float> %tmp) nounwind
|
|
store <4 x float> %call, <4 x float>* %dest, align 8
|
|
ret void
|
|
}
|
|
|
|
define void @bitcast_alias_vector_ptrs_scalar_mismatched_bit_size(<4 x i32*>* noalias %source, <4 x i32*>* noalias %dest) nounwind {
|
|
entry:
|
|
; CHECK-LABEL: @bitcast_alias_vector_ptrs_scalar_mismatched_bit_size
|
|
; CHECK: @alias_v4i32p_to_i64
|
|
%tmp = load <4 x i32*>* %source, align 8
|
|
%call = call <4 x i32*> @alias_v4i32p_to_i64(<4 x i32*> %tmp) nounwind
|
|
store <4 x i32*> %call, <4 x i32*>* %dest, align 8
|
|
ret void
|
|
}
|
|
|
|
define void @bitcast_alias_scalar_vector_ptrs_same_size(i64* noalias %source, i64* noalias %dest) nounwind {
|
|
entry:
|
|
; CHECK-LABEL: @bitcast_alias_scalar_vector_ptrs_same_size
|
|
; CHECK: @alias_i64_to_v2i32p
|
|
%tmp = load i64* %source, align 8
|
|
%call = call i64 @alias_i64_to_v2i32p(i64 %tmp) nounwind
|
|
store i64 %call, i64* %dest, align 8
|
|
ret void
|
|
}
|
|
|
|
define void @bitcast_alias_scalar_vector_mismatched_bit_size(i64* noalias %source, i64* noalias %dest) nounwind {
|
|
entry:
|
|
; CHECK-LABEL: @bitcast_alias_scalar_vector_mismatched_bit_size
|
|
; CHECK: call i64 @alias_i64_to_v4f32
|
|
%tmp = load i64* %source, align 8
|
|
%call = call i64 @alias_i64_to_v4f32(i64 %tmp) nounwind
|
|
store i64 %call, i64* %dest, align 8
|
|
ret void
|
|
}
|
|
|