From 5997feb7dcb212cc4d60896f5855e6a87e18a1b4 Mon Sep 17 00:00:00 2001 From: Evgeniy Stepanov Date: Thu, 31 Jul 2014 11:02:27 +0000 Subject: [PATCH] [msan] Fix handling of array types. Switch array type shadow from a single integer to an array of integers (i.e. make it per-element). This simplifies instrumentation of extractvalue and fixes PR20493. llvm-svn: 214398 --- .../Instrumentation/MemorySanitizer.cpp | 21 +++-- .../MemorySanitizer/array_types.ll | 89 +++++++++++++++++++ 2 files changed, 105 insertions(+), 5 deletions(-) create mode 100644 llvm/test/Instrumentation/MemorySanitizer/array_types.ll diff --git a/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp b/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp index 57e308c20dba..3df1d1574120 100644 --- a/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp +++ b/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp @@ -763,6 +763,10 @@ struct MemorySanitizerVisitor : public InstVisitor { return VectorType::get(IntegerType::get(*MS.C, EltSize), VT->getNumElements()); } + if (ArrayType *AT = dyn_cast(OrigTy)) { + return ArrayType::get(getShadowTy(AT->getElementType()), + AT->getNumElements()); + } if (StructType *ST = dyn_cast(OrigTy)) { SmallVector Elements; for (unsigned i = 0, n = ST->getNumElements(); i < n; i++) @@ -882,11 +886,18 @@ struct MemorySanitizerVisitor : public InstVisitor { assert(ShadowTy); if (isa(ShadowTy) || isa(ShadowTy)) return Constant::getAllOnesValue(ShadowTy); - StructType *ST = cast(ShadowTy); - SmallVector Vals; - for (unsigned i = 0, n = ST->getNumElements(); i < n; i++) - Vals.push_back(getPoisonedShadow(ST->getElementType(i))); - return ConstantStruct::get(ST, Vals); + if (ArrayType *AT = dyn_cast(ShadowTy)) { + SmallVector Vals(AT->getNumElements(), + getPoisonedShadow(AT->getElementType())); + return ConstantArray::get(AT, Vals); + } + if (StructType *ST = dyn_cast(ShadowTy)) { + SmallVector Vals; + for (unsigned i = 0, n = ST->getNumElements(); i < n; i++) + Vals.push_back(getPoisonedShadow(ST->getElementType(i))); + return ConstantStruct::get(ST, Vals); + } + llvm_unreachable("Unexpected shadow type"); } /// \brief Create a dirty shadow for a given value. diff --git a/llvm/test/Instrumentation/MemorySanitizer/array_types.ll b/llvm/test/Instrumentation/MemorySanitizer/array_types.ll new file mode 100644 index 000000000000..fa3835fac77a --- /dev/null +++ b/llvm/test/Instrumentation/MemorySanitizer/array_types.ll @@ -0,0 +1,89 @@ +; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s +; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-ORIGINS %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" + +define [2 x i32] @InsertValue(i32 %x, i32 %y) sanitize_memory { +entry: + %a = insertvalue [2 x i32] undef, i32 %x, 0 + %b = insertvalue [2 x i32] %a, i32 %y, 1 + ret [2 x i32] %b +} + +; CHECK-LABEL: @InsertValue( +; CHECK-DAG: [[Sy:%.*]] = load i32* {{.*}}@__msan_param_tls to i64), i64 8) to i32*) +; CHECK-DAG: [[Sx:%.*]] = load i32* {{.*}}@__msan_param_tls to i32*) +; CHECK: [[A:%.*]] = insertvalue [2 x i32] [i32 -1, i32 -1], i32 [[Sx]], 0 +; CHECK: [[B:%.*]] = insertvalue [2 x i32] [[A]], i32 [[Sy]], 1 +; CHECK: store [2 x i32] [[B]], [2 x i32]* {{.*}}@__msan_retval_tls +; CHECK: ret [2 x i32] + + +define [2 x double] @InsertValueDouble(double %x, double %y) sanitize_memory { +entry: + %a = insertvalue [2 x double] undef, double %x, 0 + %b = insertvalue [2 x double] %a, double %y, 1 + ret [2 x double] %b +} + +; CHECK-LABEL: @InsertValueDouble( +; CHECK-DAG: [[Sy:%.*]] = load i64* {{.*}}@__msan_param_tls to i64), i64 8) to i64*) +; CHECK-DAG: [[Sx:%.*]] = load i64* getelementptr {{.*}}@__msan_param_tls, i32 0, i32 0 +; CHECK: [[A:%.*]] = insertvalue [2 x i64] [i64 -1, i64 -1], i64 [[Sx]], 0 +; CHECK: [[B:%.*]] = insertvalue [2 x i64] [[A]], i64 [[Sy]], 1 +; CHECK: store [2 x i64] [[B]], [2 x i64]* {{.*}}@__msan_retval_tls +; CHECK: ret [2 x double] + + +define i32 @ExtractValue([2 x i32] %a) sanitize_memory { +entry: + %x = extractvalue [2 x i32] %a, 1 + ret i32 %x +} + +; CHECK-LABEL: @ExtractValue( +; CHECK: [[Sa:%.*]] = load [2 x i32]* {{.*}}@__msan_param_tls to [2 x i32]*) +; CHECK: [[Sx:%.*]] = extractvalue [2 x i32] [[Sa]], 1 +; CHECK: store i32 [[Sx]], i32* {{.*}}@__msan_retval_tls +; CHECK: ret i32 + + +; Regression test for PR20493. + +%MyStruct = type { i32, i32, [3 x i32] } + +define i32 @ArrayInStruct(%MyStruct %s) sanitize_memory { + %x = extractvalue %MyStruct %s, 2, 1 + ret i32 %x +} + +; CHECK-LABEL: @ArrayInStruct( +; CHECK: [[Ss:%.*]] = load { i32, i32, [3 x i32] }* {{.*}}@__msan_param_tls to { i32, i32, [3 x i32] }*) +; CHECK: [[Sx:%.*]] = extractvalue { i32, i32, [3 x i32] } [[Ss]], 2, 1 +; CHECK: store i32 [[Sx]], i32* {{.*}}@__msan_retval_tls +; CHECK: ret i32 + + +define i32 @ArrayOfStructs([3 x { i32, i32 }] %a) sanitize_memory { + %x = extractvalue [3 x { i32, i32 }] %a, 2, 1 + ret i32 %x +} + +; CHECK-LABEL: @ArrayOfStructs( +; CHECK: [[Ss:%.*]] = load [3 x { i32, i32 }]* {{.*}}@__msan_param_tls to [3 x { i32, i32 }]*) +; CHECK: [[Sx:%.*]] = extractvalue [3 x { i32, i32 }] [[Ss]], 2, 1 +; CHECK: store i32 [[Sx]], i32* {{.*}}@__msan_retval_tls +; CHECK: ret i32 + + +define <8 x i16> @ArrayOfVectors([3 x <8 x i16>] %a) sanitize_memory { + %x = extractvalue [3 x <8 x i16>] %a, 1 + ret <8 x i16> %x +} + +; CHECK-LABEL: @ArrayOfVectors( +; CHECK: [[Ss:%.*]] = load [3 x <8 x i16>]* {{.*}}@__msan_param_tls to [3 x <8 x i16>]*) +; CHECK: [[Sx:%.*]] = extractvalue [3 x <8 x i16>] [[Ss]], 1 +; CHECK: store <8 x i16> [[Sx]], <8 x i16>* {{.*}}@__msan_retval_tls +; CHECK: ret <8 x i16>