mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-07-21 02:29:22 +00:00
792a173523
Multiplication by an integer with a number of trailing zero bits leaves
the same number of lower bits of the result initialized to zero.
This change makes MSan take this into account in the case of multiplication by
a compile-time constant.
We don't handle the general, non-constant, case because
(a) it's not going to be cheap (computation-wise);
(b) multiplication by a partially uninitialized value in user code is
a bad idea anyway.
Constant case must be handled because it appears from LLVM optimization of a
completely valid user code, as the test case in compiler-rt demonstrates.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@211092 91177308-0d34-0410-b5e6-96231b3b80d8
95 lines
2.5 KiB
LLVM
95 lines
2.5 KiB
LLVM
; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
|
|
|
|
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
|
|
target triple = "x86_64-unknown-linux-gnu"
|
|
|
|
; Check instrumentation mul when one of the operands is a constant.
|
|
|
|
define i64 @MulConst(i64 %x) sanitize_memory {
|
|
entry:
|
|
%y = mul i64 %x, 42949672960000
|
|
ret i64 %y
|
|
}
|
|
|
|
; 42949672960000 = 2**32 * 10000
|
|
; 36 trailing zero bits
|
|
; 68719476736 = 2**36
|
|
|
|
; CHECK-LABEL: @MulConst(
|
|
; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls
|
|
; CHECK: [[B:%.*]] = mul i64 [[A]], 68719476736
|
|
; CHECK: store i64 [[B]], i64* {{.*}} @__msan_retval_tls
|
|
|
|
|
|
define i64 @MulZero(i64 %x) sanitize_memory {
|
|
entry:
|
|
%y = mul i64 %x, 0
|
|
ret i64 %y
|
|
}
|
|
|
|
; CHECK-LABEL: @MulZero(
|
|
; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls
|
|
; CHECK: [[B:%.*]] = mul i64 [[A]], 0{{$}}
|
|
; CHECK: store i64 [[B]], i64* {{.*}} @__msan_retval_tls
|
|
|
|
|
|
define i64 @MulNeg(i64 %x) sanitize_memory {
|
|
entry:
|
|
%y = mul i64 %x, -16
|
|
ret i64 %y
|
|
}
|
|
|
|
; CHECK-LABEL: @MulNeg(
|
|
; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls
|
|
; CHECK: [[B:%.*]] = mul i64 [[A]], 16
|
|
; CHECK: store i64 [[B]], i64* {{.*}} @__msan_retval_tls
|
|
|
|
|
|
define i64 @MulNeg2(i64 %x) sanitize_memory {
|
|
entry:
|
|
%y = mul i64 %x, -48
|
|
ret i64 %y
|
|
}
|
|
|
|
; CHECK-LABEL: @MulNeg2(
|
|
; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls
|
|
; CHECK: [[B:%.*]] = mul i64 [[A]], 16
|
|
; CHECK: store i64 [[B]], i64* {{.*}} @__msan_retval_tls
|
|
|
|
|
|
define i64 @MulOdd(i64 %x) sanitize_memory {
|
|
entry:
|
|
%y = mul i64 %x, 12345
|
|
ret i64 %y
|
|
}
|
|
|
|
; CHECK-LABEL: @MulOdd(
|
|
; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls
|
|
; CHECK: [[B:%.*]] = mul i64 [[A]], 1
|
|
; CHECK: store i64 [[B]], i64* {{.*}} @__msan_retval_tls
|
|
|
|
|
|
define i64 @MulLarge(i64 %x) sanitize_memory {
|
|
entry:
|
|
%y = mul i64 %x, -9223372036854775808
|
|
ret i64 %y
|
|
}
|
|
|
|
; -9223372036854775808 = 0x7000000000000000
|
|
|
|
; CHECK-LABEL: @MulLarge(
|
|
; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls
|
|
; CHECK: [[B:%.*]] = mul i64 [[A]], -9223372036854775808
|
|
; CHECK: store i64 [[B]], i64* {{.*}} @__msan_retval_tls
|
|
|
|
define <4 x i32> @MulVectorConst(<4 x i32> %x) sanitize_memory {
|
|
entry:
|
|
%y = mul <4 x i32> %x, <i32 3072, i32 0, i32 -16, i32 -48>
|
|
ret <4 x i32> %y
|
|
}
|
|
|
|
; CHECK-LABEL: @MulVectorConst(
|
|
; CHECK: [[A:%.*]] = load {{.*}} @__msan_param_tls
|
|
; CHECK: [[B:%.*]] = mul <4 x i32> [[A]], <i32 1024, i32 0, i32 16, i32 16>
|
|
; CHECK: store <4 x i32> [[B]], <4 x i32>* {{.*}} @__msan_retval_tls
|