test/Instrumentation/MemorySanitizer/msan_basic.ll

   1 ; RUN: opt < %s -msan-check-access-address=0 -S -passes=msan 2>&1 | FileCheck  \
   2 ; RUN: -allow-deprecated-dag-overlap %s
   3 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck -allow-deprecated-dag-overlap %s
   4 ; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S          \
   5 ; RUN: -passes=msan 2>&1 | FileCheck -allow-deprecated-dag-overlap             \
   6 ; RUN: -check-prefix=CHECK -check-prefix=CHECK-ORIGINS %s
   7 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck -allow-deprecated-dag-overlap -check-prefix=CHECK -check-prefix=CHECK-ORIGINS %s
   8
   9 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"
  10 target triple = "x86_64-unknown-linux-gnu"
  11
  12 ; CHECK: @llvm.global_ctors {{.*}} { i32 0, void ()* @msan.module_ctor, i8* null }
  13
  14 ; Check the presence and the linkage type of __msan_track_origins and
  15 ; other interface symbols.
  16 ; CHECK-NOT: @__msan_track_origins
  17 ; CHECK-ORIGINS: @__msan_track_origins = weak_odr constant i32 1
  18 ; CHECK-NOT: @__msan_keep_going = weak_odr constant i32 0
  19 ; CHECK: @__msan_retval_tls = external thread_local(initialexec) global [{{.*}}]
  20 ; CHECK: @__msan_retval_origin_tls = external thread_local(initialexec) global i32
  21 ; CHECK: @__msan_param_tls = external thread_local(initialexec) global [{{.*}}]
  22 ; CHECK: @__msan_param_origin_tls = external thread_local(initialexec) global [{{.*}}]
  23 ; CHECK: @__msan_va_arg_tls = external thread_local(initialexec) global [{{.*}}]
  24 ; CHECK: @__msan_va_arg_overflow_size_tls = external thread_local(initialexec) global i64
  25 ; CHECK: @__msan_origin_tls = external thread_local(initialexec) global i32
  26
  27
  28 ; Check instrumentation of stores
  29
  30 define void @Store(i32* nocapture %p, i32 %x) nounwind uwtable sanitize_memory {
  31 entry:
  32   store i32 %x, i32* %p, align 4
  33   ret void
  34 }
  35
  36 ; CHECK-LABEL: @Store
  37 ; CHECK: load {{.*}} @__msan_param_tls
  38 ; CHECK-ORIGINS: load {{.*}} @__msan_param_origin_tls
  39 ; CHECK: store
  40 ; CHECK-ORIGINS: icmp
  41 ; CHECK-ORIGINS: br i1
  42 ; CHECK-ORIGINS: {{^[0-9]+}}:
  43 ; CHECK-ORIGINS: store
  44 ; CHECK-ORIGINS: br label
  45 ; CHECK-ORIGINS: {{^[0-9]+}}:
  46 ; CHECK: store
  47 ; CHECK: ret void
  48
  49
  50 ; Check instrumentation of aligned stores
  51 ; Shadow store has the same alignment as the original store; origin store
  52 ; does not specify explicit alignment.
  53
  54 define void @AlignedStore(i32* nocapture %p, i32 %x) nounwind uwtable sanitize_memory {
  55 entry:
  56   store i32 %x, i32* %p, align 32
  57   ret void
  58 }
  59
  60 ; CHECK-LABEL: @AlignedStore
  61 ; CHECK: load {{.*}} @__msan_param_tls
  62 ; CHECK-ORIGINS: load {{.*}} @__msan_param_origin_tls
  63 ; CHECK: store {{.*}} align 32
  64 ; CHECK-ORIGINS: icmp
  65 ; CHECK-ORIGINS: br i1
  66 ; CHECK-ORIGINS: {{^[0-9]+}}:
  67 ; CHECK-ORIGINS: store {{.*}} align 32
  68 ; CHECK-ORIGINS: br label
  69 ; CHECK-ORIGINS: {{^[0-9]+}}:
  70 ; CHECK: store {{.*}} align 32
  71 ; CHECK: ret void
  72
  73
  74 ; load followed by cmp: check that we load the shadow and call __msan_warning.
  75 define void @LoadAndCmp(i32* nocapture %a) nounwind uwtable sanitize_memory {
  76 entry:
  77   %0 = load i32, i32* %a, align 4
  78   %tobool = icmp eq i32 %0, 0
  79   br i1 %tobool, label %if.end, label %if.then
  80
  81 if.then:                                          ; preds = %entry
  82   tail call void (...) @foo() nounwind
  83   br label %if.end
  84
  85 if.end:                                           ; preds = %entry, %if.then
  86   ret void
  87 }
  88
  89 declare void @foo(...)
  90
  91 ; CHECK-LABEL: @LoadAndCmp
  92 ; CHECK: = load
  93 ; CHECK: = load
  94 ; CHECK: call void @__msan_warning_noreturn()
  95 ; CHECK-NEXT: call void asm sideeffect
  96 ; CHECK-NEXT: unreachable
  97 ; CHECK: ret void
  98
  99 ; Check that we store the shadow for the retval.
 100 define i32 @ReturnInt() nounwind uwtable readnone sanitize_memory {
 101 entry:
 102   ret i32 123
 103 }
 104
 105 ; CHECK-LABEL: @ReturnInt
 106 ; CHECK: store i32 0,{{.*}}__msan_retval_tls
 107 ; CHECK: ret i32
 108
 109 ; Check that we get the shadow for the retval.
 110 define void @CopyRetVal(i32* nocapture %a) nounwind uwtable sanitize_memory {
 111 entry:
 112   %call = tail call i32 @ReturnInt() nounwind
 113   store i32 %call, i32* %a, align 4
 114   ret void
 115 }
 116
 117 ; CHECK-LABEL: @CopyRetVal
 118 ; CHECK: load{{.*}}__msan_retval_tls
 119 ; CHECK: store
 120 ; CHECK: store
 121 ; CHECK: ret void
 122
 123
 124 ; Check that we generate PHIs for shadow.
 125 define void @FuncWithPhi(i32* nocapture %a, i32* %b, i32* nocapture %c) nounwind uwtable sanitize_memory {
 126 entry:
 127   %tobool = icmp eq i32* %b, null
 128   br i1 %tobool, label %if.else, label %if.then
 129
 130   if.then:                                          ; preds = %entry
 131   %0 = load i32, i32* %b, align 4
 132   br label %if.end
 133
 134   if.else:                                          ; preds = %entry
 135   %1 = load i32, i32* %c, align 4
 136   br label %if.end
 137
 138   if.end:                                           ; preds = %if.else, %if.then
 139   %t.0 = phi i32 [ %0, %if.then ], [ %1, %if.else ]
 140   store i32 %t.0, i32* %a, align 4
 141   ret void
 142 }
 143
 144 ; CHECK-LABEL: @FuncWithPhi
 145 ; CHECK: = phi
 146 ; CHECK-NEXT: = phi
 147 ; CHECK: store
 148 ; CHECK: store
 149 ; CHECK: ret void
 150
 151 ; Compute shadow for "x << 10"
 152 define void @ShlConst(i32* nocapture %x) nounwind uwtable sanitize_memory {
 153 entry:
 154   %0 = load i32, i32* %x, align 4
 155   %1 = shl i32 %0, 10
 156   store i32 %1, i32* %x, align 4
 157   ret void
 158 }
 159
 160 ; CHECK-LABEL: @ShlConst
 161 ; CHECK: = load
 162 ; CHECK: = load
 163 ; CHECK: shl
 164 ; CHECK: shl
 165 ; CHECK: store
 166 ; CHECK: store
 167 ; CHECK: ret void
 168
 169 ; Compute shadow for "10 << x": it should have 'sext i1'.
 170 define void @ShlNonConst(i32* nocapture %x) nounwind uwtable sanitize_memory {
 171 entry:
 172   %0 = load i32, i32* %x, align 4
 173   %1 = shl i32 10, %0
 174   store i32 %1, i32* %x, align 4
 175   ret void
 176 }
 177
 178 ; CHECK-LABEL: @ShlNonConst
 179 ; CHECK: = load
 180 ; CHECK: = load
 181 ; CHECK: = sext i1
 182 ; CHECK: store
 183 ; CHECK: store
 184 ; CHECK: ret void
 185
 186 ; SExt
 187 define void @SExt(i32* nocapture %a, i16* nocapture %b) nounwind uwtable sanitize_memory {
 188 entry:
 189   %0 = load i16, i16* %b, align 2
 190   %1 = sext i16 %0 to i32
 191   store i32 %1, i32* %a, align 4
 192   ret void
 193 }
 194
 195 ; CHECK-LABEL: @SExt
 196 ; CHECK: = load
 197 ; CHECK: = load
 198 ; CHECK: = sext
 199 ; CHECK: = sext
 200 ; CHECK: store
 201 ; CHECK: store
 202 ; CHECK: ret void
 203
 204
 205 ; memset
 206 define void @MemSet(i8* nocapture %x) nounwind uwtable sanitize_memory {
 207 entry:
 208   call void @llvm.memset.p0i8.i64(i8* %x, i8 42, i64 10, i1 false)
 209   ret void
 210 }
 211
 212 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind
 213
 214 ; CHECK-LABEL: @MemSet
 215 ; CHECK: call i8* @__msan_memset
 216 ; CHECK: ret void
 217
 218
 219 ; memcpy
 220 define void @MemCpy(i8* nocapture %x, i8* nocapture %y) nounwind uwtable sanitize_memory {
 221 entry:
 222   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %x, i8* %y, i64 10, i1 false)
 223   ret void
 224 }
 225
 226 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
 227
 228 ; CHECK-LABEL: @MemCpy
 229 ; CHECK: call i8* @__msan_memcpy
 230 ; CHECK: ret void
 231
 232
 233 ; memmove is lowered to a call
 234 define void @MemMove(i8* nocapture %x, i8* nocapture %y) nounwind uwtable sanitize_memory {
 235 entry:
 236   call void @llvm.memmove.p0i8.p0i8.i64(i8* %x, i8* %y, i64 10, i1 false)
 237   ret void
 238 }
 239
 240 declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
 241
 242 ; CHECK-LABEL: @MemMove
 243 ; CHECK: call i8* @__msan_memmove
 244 ; CHECK: ret void
 245
 246 ;; ------------
 247 ;; Placeholder tests that will fail once element atomic @llvm.mem[cpy|move|set] instrinsics have
 248 ;; been added to the MemIntrinsic class hierarchy. These will act as a reminder to
 249 ;; verify that MSAN handles these intrinsics properly once they have been
 250 ;; added to that class hierarchy.
 251 declare void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* nocapture writeonly, i8, i64, i32) nounwind
 252 declare void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32) nounwind
 253 declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32) nounwind
 254
 255 define void @atomic_memcpy(i8* nocapture %x, i8* nocapture %y) nounwind {
 256   ; CHECK-LABEL: atomic_memcpy
 257   ; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %x, i8* align 2 %y, i64 16, i32 1)
 258   ; CHECK-NEXT: ret void
 259   call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %x, i8* align 2 %y, i64 16, i32 1)
 260   ret void
 261 }
 262
 263 define void @atomic_memmove(i8* nocapture %x, i8* nocapture %y) nounwind {
 264   ; CHECK-LABEL: atomic_memmove
 265   ; CHECK-NEXT: call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %x, i8* align 2 %y, i64 16, i32 1)
 266   ; CHECK-NEXT: ret void
 267   call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %x, i8* align 2 %y, i64 16, i32 1)
 268   ret void
 269 }
 270
 271 define void @atomic_memset(i8* nocapture %x) nounwind {
 272   ; CHECK-LABEL: atomic_memset
 273   ; CHECK-NEXT: call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %x, i8 88, i64 16, i32 1)
 274   ; CHECK-NEXT: ret void
 275   call void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* align 1 %x, i8 88, i64 16, i32 1)
 276   ret void
 277 }
 278
 279 ;; ------------
 280
 281
 282 ; Check that we propagate shadow for "select"
 283
 284 define i32 @Select(i32 %a, i32 %b, i1 %c) nounwind uwtable readnone sanitize_memory {
 285 entry:
 286   %cond = select i1 %c, i32 %a, i32 %b
 287   ret i32 %cond
 288 }
 289
 290 ; CHECK-LABEL: @Select
 291 ; CHECK: select i1
 292 ; CHECK-DAG: or i32
 293 ; CHECK-DAG: xor i32
 294 ; CHECK: or i32
 295 ; CHECK-DAG: select i1
 296 ; CHECK-ORIGINS-DAG: select
 297 ; CHECK-ORIGINS-DAG: select
 298 ; CHECK-DAG: select i1
 299 ; CHECK: store i32{{.*}}@__msan_retval_tls
 300 ; CHECK-ORIGINS: store i32{{.*}}@__msan_retval_origin_tls
 301 ; CHECK: ret i32
 302
 303
 304 ; Check that we propagate origin for "select" with vector condition.
 305 ; Select condition is flattened to i1, which is then used to select one of the
 306 ; argument origins.
 307
 308 define <8 x i16> @SelectVector(<8 x i16> %a, <8 x i16> %b, <8 x i1> %c) nounwind uwtable readnone sanitize_memory {
 309 entry:
 310   %cond = select <8 x i1> %c, <8 x i16> %a, <8 x i16> %b
 311   ret <8 x i16> %cond
 312 }
 313
 314 ; CHECK-LABEL: @SelectVector
 315 ; CHECK: select <8 x i1>
 316 ; CHECK-DAG: or <8 x i16>
 317 ; CHECK-DAG: xor <8 x i16>
 318 ; CHECK: or <8 x i16>
 319 ; CHECK-DAG: select <8 x i1>
 320 ; CHECK-ORIGINS-DAG: select
 321 ; CHECK-ORIGINS-DAG: select
 322 ; CHECK-DAG: select <8 x i1>
 323 ; CHECK: store <8 x i16>{{.*}}@__msan_retval_tls
 324 ; CHECK-ORIGINS: store i32{{.*}}@__msan_retval_origin_tls
 325 ; CHECK: ret <8 x i16>
 326
 327
 328 ; Check that we propagate origin for "select" with scalar condition and vector
 329 ; arguments. Select condition shadow is sign-extended to the vector type and
 330 ; mixed into the result shadow.
 331
 332 define <8 x i16> @SelectVector2(<8 x i16> %a, <8 x i16> %b, i1 %c) nounwind uwtable readnone sanitize_memory {
 333 entry:
 334   %cond = select i1 %c, <8 x i16> %a, <8 x i16> %b
 335   ret <8 x i16> %cond
 336 }
 337
 338 ; CHECK-LABEL: @SelectVector2
 339 ; CHECK: select i1
 340 ; CHECK-DAG: or <8 x i16>
 341 ; CHECK-DAG: xor <8 x i16>
 342 ; CHECK: or <8 x i16>
 343 ; CHECK-DAG: select i1
 344 ; CHECK-ORIGINS-DAG: select i1
 345 ; CHECK-ORIGINS-DAG: select i1
 346 ; CHECK-DAG: select i1
 347 ; CHECK: ret <8 x i16>
 348
 349
 350 define { i64, i64 } @SelectStruct(i1 zeroext %x, { i64, i64 } %a, { i64, i64 } %b) readnone sanitize_memory {
 351 entry:
 352   %c = select i1 %x, { i64, i64 } %a, { i64, i64 } %b
 353   ret { i64, i64 } %c
 354 }
 355
 356 ; CHECK-LABEL: @SelectStruct
 357 ; CHECK: select i1 {{.*}}, { i64, i64 }
 358 ; CHECK-NEXT: select i1 {{.*}}, { i64, i64 } { i64 -1, i64 -1 }, { i64, i64 }
 359 ; CHECK-ORIGINS: select i1
 360 ; CHECK-ORIGINS: select i1
 361 ; CHECK-NEXT: select i1 {{.*}}, { i64, i64 }
 362 ; CHECK: ret { i64, i64 }
 363
 364
 365 define { i64*, double } @SelectStruct2(i1 zeroext %x, { i64*, double } %a, { i64*, double } %b) readnone sanitize_memory {
 366 entry:
 367   %c = select i1 %x, { i64*, double } %a, { i64*, double } %b
 368   ret { i64*, double } %c
 369 }
 370
 371 ; CHECK-LABEL: @SelectStruct2
 372 ; CHECK: select i1 {{.*}}, { i64, i64 }
 373 ; CHECK-NEXT: select i1 {{.*}}, { i64, i64 } { i64 -1, i64 -1 }, { i64, i64 }
 374 ; CHECK-ORIGINS: select i1
 375 ; CHECK-ORIGINS: select i1
 376 ; CHECK-NEXT: select i1 {{.*}}, { i64*, double }
 377 ; CHECK: ret { i64*, double }
 378
 379
 380 define i8* @IntToPtr(i64 %x) nounwind uwtable readnone sanitize_memory {
 381 entry:
 382   %0 = inttoptr i64 %x to i8*
 383   ret i8* %0
 384 }
 385
 386 ; CHECK-LABEL: @IntToPtr
 387 ; CHECK: load i64, i64*{{.*}}__msan_param_tls
 388 ; CHECK-ORIGINS-NEXT: load i32, i32*{{.*}}__msan_param_origin_tls
 389 ; CHECK-NEXT: inttoptr
 390 ; CHECK-NEXT: store i64{{.*}}__msan_retval_tls
 391 ; CHECK: ret i8*
 392
 393
 394 define i8* @IntToPtr_ZExt(i16 %x) nounwind uwtable readnone sanitize_memory {
 395 entry:
 396   %0 = inttoptr i16 %x to i8*
 397   ret i8* %0
 398 }
 399
 400 ; CHECK-LABEL: @IntToPtr_ZExt
 401 ; CHECK: load i16, i16*{{.*}}__msan_param_tls
 402 ; CHECK: zext
 403 ; CHECK-NEXT: inttoptr
 404 ; CHECK-NEXT: store i64{{.*}}__msan_retval_tls
 405 ; CHECK: ret i8*
 406
 407
 408 ; Check that we insert exactly one check on udiv
 409 ; (2nd arg shadow is checked, 1st arg shadow is propagated)
 410
 411 define i32 @Div(i32 %a, i32 %b) nounwind uwtable readnone sanitize_memory {
 412 entry:
 413   %div = udiv i32 %a, %b
 414   ret i32 %div
 415 }
 416
 417 ; CHECK-LABEL: @Div
 418 ; CHECK: icmp
 419 ; CHECK: call void @__msan_warning
 420 ; CHECK-NOT: icmp
 421 ; CHECK: udiv
 422 ; CHECK-NOT: icmp
 423 ; CHECK: ret i32
 424
 425 ; Check that fdiv, unlike udiv, simply propagates shadow.
 426
 427 define float @FDiv(float %a, float %b) nounwind uwtable readnone sanitize_memory {
 428 entry:
 429   %c = fdiv float %a, %b
 430   ret float %c
 431 }
 432
 433 ; CHECK-LABEL: @FDiv
 434 ; CHECK: %[[SA:.*]] = load i32,{{.*}}@__msan_param_tls
 435 ; CHECK: %[[SB:.*]] = load i32,{{.*}}@__msan_param_tls
 436 ; CHECK: %[[SC:.*]] = or i32 %[[SB]], %[[SA]]
 437 ; CHECK: = fdiv float
 438 ; CHECK: store i32 %[[SC]], i32* {{.*}}@__msan_retval_tls
 439 ; CHECK: ret float
 440
 441 ; Check that fneg simply propagates shadow.
 442
 443 define float @FNeg(float %a) nounwind uwtable readnone sanitize_memory {
 444 entry:
 445   %c = fneg float %a
 446   ret float %c
 447 }
 448
 449 ; CHECK-LABEL: @FNeg
 450 ; CHECK: %[[SA:.*]] = load i32,{{.*}}@__msan_param_tls
 451 ; CHECK-ORIGINS: %[[SB:.*]] = load i32,{{.*}}@__msan_param_origin_tls
 452 ; CHECK: = fneg float
 453 ; CHECK: store i32 %[[SA]], i32* {{.*}}@__msan_retval_tls
 454 ; CHECK-ORIGINS: store i32{{.*}}@__msan_retval_origin_tls
 455 ; CHECK: ret float
 456
 457 ; Check that we propagate shadow for x<0, x>=0, etc (i.e. sign bit tests)
 458
 459 define zeroext i1 @ICmpSLTZero(i32 %x) nounwind uwtable readnone sanitize_memory {
 460   %1 = icmp slt i32 %x, 0
 461   ret i1 %1
 462 }
 463
 464 ; CHECK-LABEL: @ICmpSLTZero
 465 ; CHECK: icmp slt
 466 ; CHECK-NOT: call void @__msan_warning
 467 ; CHECK: icmp slt
 468 ; CHECK-NOT: call void @__msan_warning
 469 ; CHECK: ret i1
 470
 471 define zeroext i1 @ICmpSGEZero(i32 %x) nounwind uwtable readnone sanitize_memory {
 472   %1 = icmp sge i32 %x, 0
 473   ret i1 %1
 474 }
 475
 476 ; CHECK-LABEL: @ICmpSGEZero
 477 ; CHECK: icmp slt
 478 ; CHECK-NOT: call void @__msan_warning
 479 ; CHECK: icmp sge
 480 ; CHECK-NOT: call void @__msan_warning
 481 ; CHECK: ret i1
 482
 483 define zeroext i1 @ICmpSGTZero(i32 %x) nounwind uwtable readnone sanitize_memory {
 484   %1 = icmp sgt i32 0, %x
 485   ret i1 %1
 486 }
 487
 488 ; CHECK-LABEL: @ICmpSGTZero
 489 ; CHECK: icmp slt
 490 ; CHECK-NOT: call void @__msan_warning
 491 ; CHECK: icmp sgt
 492 ; CHECK-NOT: call void @__msan_warning
 493 ; CHECK: ret i1
 494
 495 define zeroext i1 @ICmpSLEZero(i32 %x) nounwind uwtable readnone sanitize_memory {
 496   %1 = icmp sle i32 0, %x
 497   ret i1 %1
 498 }
 499
 500 ; CHECK-LABEL: @ICmpSLEZero
 501 ; CHECK: icmp slt
 502 ; CHECK-NOT: call void @__msan_warning
 503 ; CHECK: icmp sle
 504 ; CHECK-NOT: call void @__msan_warning
 505 ; CHECK: ret i1
 506
 507
 508 ; Check that we propagate shadow for x<=-1, x>-1, etc (i.e. sign bit tests)
 509
 510 define zeroext i1 @ICmpSLTAllOnes(i32 %x) nounwind uwtable readnone sanitize_memory {
 511   %1 = icmp slt i32 -1, %x
 512   ret i1 %1
 513 }
 514
 515 ; CHECK-LABEL: @ICmpSLTAllOnes
 516 ; CHECK: icmp slt
 517 ; CHECK-NOT: call void @__msan_warning
 518 ; CHECK: icmp slt
 519 ; CHECK-NOT: call void @__msan_warning
 520 ; CHECK: ret i1
 521
 522 define zeroext i1 @ICmpSGEAllOnes(i32 %x) nounwind uwtable readnone sanitize_memory {
 523   %1 = icmp sge i32 -1, %x
 524   ret i1 %1
 525 }
 526
 527 ; CHECK-LABEL: @ICmpSGEAllOnes
 528 ; CHECK: icmp slt
 529 ; CHECK-NOT: call void @__msan_warning
 530 ; CHECK: icmp sge
 531 ; CHECK-NOT: call void @__msan_warning
 532 ; CHECK: ret i1
 533
 534 define zeroext i1 @ICmpSGTAllOnes(i32 %x) nounwind uwtable readnone sanitize_memory {
 535   %1 = icmp sgt i32 %x, -1
 536   ret i1 %1
 537 }
 538
 539 ; CHECK-LABEL: @ICmpSGTAllOnes
 540 ; CHECK: icmp slt
 541 ; CHECK-NOT: call void @__msan_warning
 542 ; CHECK: icmp sgt
 543 ; CHECK-NOT: call void @__msan_warning
 544 ; CHECK: ret i1
 545
 546 define zeroext i1 @ICmpSLEAllOnes(i32 %x) nounwind uwtable readnone sanitize_memory {
 547   %1 = icmp sle i32 %x, -1
 548   ret i1 %1
 549 }
 550
 551 ; CHECK-LABEL: @ICmpSLEAllOnes
 552 ; CHECK: icmp slt
 553 ; CHECK-NOT: call void @__msan_warning
 554 ; CHECK: icmp sle
 555 ; CHECK-NOT: call void @__msan_warning
 556 ; CHECK: ret i1
 557
 558
 559 ; Check that we propagate shadow for x<0, x>=0, etc (i.e. sign bit tests)
 560 ; of the vector arguments.
 561
 562 define <2 x i1> @ICmpSLT_vector_Zero(<2 x i32*> %x) nounwind uwtable readnone sanitize_memory {
 563   %1 = icmp slt <2 x i32*> %x, zeroinitializer
 564   ret <2 x i1> %1
 565 }
 566
 567 ; CHECK-LABEL: @ICmpSLT_vector_Zero
 568 ; CHECK: icmp slt <2 x i64>
 569 ; CHECK-NOT: call void @__msan_warning
 570 ; CHECK: icmp slt <2 x i32*>
 571 ; CHECK-NOT: call void @__msan_warning
 572 ; CHECK: ret <2 x i1>
 573
 574 ; Check that we propagate shadow for x<=-1, x>0, etc (i.e. sign bit tests)
 575 ; of the vector arguments.
 576
 577 define <2 x i1> @ICmpSLT_vector_AllOnes(<2 x i32> %x) nounwind uwtable readnone sanitize_memory {
 578   %1 = icmp slt <2 x i32> <i32 -1, i32 -1>, %x
 579   ret <2 x i1> %1
 580 }
 581
 582 ; CHECK-LABEL: @ICmpSLT_vector_AllOnes
 583 ; CHECK: icmp slt <2 x i32>
 584 ; CHECK-NOT: call void @__msan_warning
 585 ; CHECK: icmp slt <2 x i32>
 586 ; CHECK-NOT: call void @__msan_warning
 587 ; CHECK: ret <2 x i1>
 588
 589
 590 ; Check that we propagate shadow for unsigned relational comparisons with
 591 ; constants
 592
 593 define zeroext i1 @ICmpUGTConst(i32 %x) nounwind uwtable readnone sanitize_memory {
 594 entry:
 595   %cmp = icmp ugt i32 %x, 7
 596   ret i1 %cmp
 597 }
 598
 599 ; CHECK-LABEL: @ICmpUGTConst
 600 ; CHECK: icmp ugt i32
 601 ; CHECK-NOT: call void @__msan_warning
 602 ; CHECK: icmp ugt i32
 603 ; CHECK-NOT: call void @__msan_warning
 604 ; CHECK: icmp ugt i32
 605 ; CHECK-NOT: call void @__msan_warning
 606 ; CHECK: ret i1
 607
 608
 609 ; Check that loads of shadow have the same alignment as the original loads.
 610 ; Check that loads of origin have the alignment of max(4, original alignment).
 611
 612 define i32 @ShadowLoadAlignmentLarge() nounwind uwtable sanitize_memory {
 613   %y = alloca i32, align 64
 614   %1 = load volatile i32, i32* %y, align 64
 615   ret i32 %1
 616 }
 617
 618 ; CHECK-LABEL: @ShadowLoadAlignmentLarge
 619 ; CHECK: load volatile i32, i32* {{.*}} align 64
 620 ; CHECK: load i32, i32* {{.*}} align 64
 621 ; CHECK: ret i32
 622
 623 define i32 @ShadowLoadAlignmentSmall() nounwind uwtable sanitize_memory {
 624   %y = alloca i32, align 2
 625   %1 = load volatile i32, i32* %y, align 2
 626   ret i32 %1
 627 }
 628
 629 ; CHECK-LABEL: @ShadowLoadAlignmentSmall
 630 ; CHECK: load volatile i32, i32* {{.*}} align 2
 631 ; CHECK: load i32, i32* {{.*}} align 2
 632 ; CHECK-ORIGINS: load i32, i32* {{.*}} align 4
 633 ; CHECK: ret i32
 634
 635
 636 ; Test vector manipulation instructions.
 637 ; Check that the same bit manipulation is applied to the shadow values.
 638 ; Check that there is a zero test of the shadow of %idx argument, where present.
 639
 640 define i32 @ExtractElement(<4 x i32> %vec, i32 %idx) sanitize_memory {
 641   %x = extractelement <4 x i32> %vec, i32 %idx
 642   ret i32 %x
 643 }
 644
 645 ; CHECK-LABEL: @ExtractElement
 646 ; CHECK: extractelement
 647 ; CHECK: call void @__msan_warning
 648 ; CHECK: extractelement
 649 ; CHECK: ret i32
 650
 651 define <4 x i32> @InsertElement(<4 x i32> %vec, i32 %idx, i32 %x) sanitize_memory {
 652   %vec1 = insertelement <4 x i32> %vec, i32 %x, i32 %idx
 653   ret <4 x i32> %vec1
 654 }
 655
 656 ; CHECK-LABEL: @InsertElement
 657 ; CHECK: insertelement
 658 ; CHECK: call void @__msan_warning
 659 ; CHECK: insertelement
 660 ; CHECK: ret <4 x i32>
 661
 662 define <4 x i32> @ShuffleVector(<4 x i32> %vec, <4 x i32> %vec1) sanitize_memory {
 663   %vec2 = shufflevector <4 x i32> %vec, <4 x i32> %vec1,
 664                         <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 665   ret <4 x i32> %vec2
 666 }
 667
 668 ; CHECK-LABEL: @ShuffleVector
 669 ; CHECK: shufflevector
 670 ; CHECK-NOT: call void @__msan_warning
 671 ; CHECK: shufflevector
 672 ; CHECK: ret <4 x i32>
 673
 674
 675 ; Test bswap intrinsic instrumentation
 676 define i32 @BSwap(i32 %x) nounwind uwtable readnone sanitize_memory {
 677   %y = tail call i32 @llvm.bswap.i32(i32 %x)
 678   ret i32 %y
 679 }
 680
 681 declare i32 @llvm.bswap.i32(i32) nounwind readnone
 682
 683 ; CHECK-LABEL: @BSwap
 684 ; CHECK-NOT: call void @__msan_warning
 685 ; CHECK: @llvm.bswap.i32
 686 ; CHECK-NOT: call void @__msan_warning
 687 ; CHECK: @llvm.bswap.i32
 688 ; CHECK-NOT: call void @__msan_warning
 689 ; CHECK: ret i32
 690
 691 ; Test handling of vectors of pointers.
 692 ; Check that shadow of such vector is a vector of integers.
 693
 694 define <8 x i8*> @VectorOfPointers(<8 x i8*>* %p) nounwind uwtable sanitize_memory {
 695   %x = load <8 x i8*>, <8 x i8*>* %p
 696   ret <8 x i8*> %x
 697 }
 698
 699 ; CHECK-LABEL: @VectorOfPointers
 700 ; CHECK: load <8 x i8*>, <8 x i8*>*
 701 ; CHECK: load <8 x i64>, <8 x i64>*
 702 ; CHECK: store <8 x i64> {{.*}} @__msan_retval_tls
 703 ; CHECK: ret <8 x i8*>
 704
 705 ; Test handling of va_copy.
 706
 707 declare void @llvm.va_copy(i8*, i8*) nounwind
 708
 709 define void @VACopy(i8* %p1, i8* %p2) nounwind uwtable sanitize_memory {
 710   call void @llvm.va_copy(i8* %p1, i8* %p2) nounwind
 711   ret void
 712 }
 713
 714 ; CHECK-LABEL: @VACopy
 715 ; CHECK: call void @llvm.memset.p0i8.i64({{.*}}, i8 0, i64 24, i1 false)
 716 ; CHECK: ret void
 717
 718
 719 ; Test that va_start instrumentation does not use va_arg_tls*.
 720 ; It should work with a local stack copy instead.
 721
 722 %struct.__va_list_tag = type { i32, i32, i8*, i8* }
 723 declare void @llvm.va_start(i8*) nounwind
 724
 725 ; Function Attrs: nounwind uwtable
 726 define void @VAStart(i32 %x, ...) sanitize_memory {
 727 entry:
 728   %x.addr = alloca i32, align 4
 729   %va = alloca [1 x %struct.__va_list_tag], align 16
 730   store i32 %x, i32* %x.addr, align 4
 731   %arraydecay = getelementptr inbounds [1 x %struct.__va_list_tag], [1 x %struct.__va_list_tag]* %va, i32 0, i32 0
 732   %arraydecay1 = bitcast %struct.__va_list_tag* %arraydecay to i8*
 733   call void @llvm.va_start(i8* %arraydecay1)
 734   ret void
 735 }
 736
 737 ; CHECK-LABEL: @VAStart
 738 ; CHECK: call void @llvm.va_start
 739 ; CHECK-NOT: @__msan_va_arg_tls
 740 ; CHECK-NOT: @__msan_va_arg_overflow_size_tls
 741 ; CHECK: ret void
 742
 743
 744 ; Test handling of volatile stores.
 745 ; Check that MemorySanitizer does not add a check of the value being stored.
 746
 747 define void @VolatileStore(i32* nocapture %p, i32 %x) nounwind uwtable sanitize_memory {
 748 entry:
 749   store volatile i32 %x, i32* %p, align 4
 750   ret void
 751 }
 752
 753 ; CHECK-LABEL: @VolatileStore
 754 ; CHECK-NOT: @__msan_warning
 755 ; CHECK: ret void
 756
 757
 758 ; Test that checks are omitted and returned value is always initialized if
 759 ; sanitize_memory attribute is missing.
 760
 761 define i32 @NoSanitizeMemory(i32 %x) uwtable {
 762 entry:
 763   %tobool = icmp eq i32 %x, 0
 764   br i1 %tobool, label %if.end, label %if.then
 765
 766 if.then:                                          ; preds = %entry
 767   tail call void @bar()
 768   br label %if.end
 769
 770 if.end:                                           ; preds = %entry, %if.then
 771   ret i32 %x
 772 }
 773
 774 declare void @bar()
 775
 776 ; CHECK-LABEL: @NoSanitizeMemory
 777 ; CHECK-NOT: @__msan_warning
 778 ; CHECK: store i32 0, {{.*}} @__msan_retval_tls
 779 ; CHECK-NOT: @__msan_warning
 780 ; CHECK: ret i32
 781
 782
 783 ; Test that stack allocations are unpoisoned in functions missing
 784 ; sanitize_memory attribute
 785
 786 define i32 @NoSanitizeMemoryAlloca() {
 787 entry:
 788   %p = alloca i32, align 4
 789   %x = call i32 @NoSanitizeMemoryAllocaHelper(i32* %p)
 790   ret i32 %x
 791 }
 792
 793 declare i32 @NoSanitizeMemoryAllocaHelper(i32* %p)
 794
 795 ; CHECK-LABEL: @NoSanitizeMemoryAlloca
 796 ; CHECK: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 0, i64 4, i1 false)
 797 ; CHECK: call i32 @NoSanitizeMemoryAllocaHelper(i32*
 798 ; CHECK: ret i32
 799
 800
 801 ; Test that undef is unpoisoned in functions missing
 802 ; sanitize_memory attribute
 803
 804 define i32 @NoSanitizeMemoryUndef() {
 805 entry:
 806   %x = call i32 @NoSanitizeMemoryUndefHelper(i32 undef)
 807   ret i32 %x
 808 }
 809
 810 declare i32 @NoSanitizeMemoryUndefHelper(i32 %x)
 811
 812 ; CHECK-LABEL: @NoSanitizeMemoryUndef
 813 ; CHECK: store i32 0, i32* {{.*}} @__msan_param_tls
 814 ; CHECK: call i32 @NoSanitizeMemoryUndefHelper(i32 undef)
 815 ; CHECK: ret i32
 816
 817
 818 ; Test PHINode instrumentation in blacklisted functions
 819
 820 define i32 @NoSanitizeMemoryPHI(i32 %x) {
 821 entry:
 822   %tobool = icmp ne i32 %x, 0
 823   br i1 %tobool, label %cond.true, label %cond.false
 824
 825 cond.true:                                        ; preds = %entry
 826   br label %cond.end
 827
 828 cond.false:                                       ; preds = %entry
 829   br label %cond.end
 830
 831 cond.end:                                         ; preds = %cond.false, %cond.true
 832   %cond = phi i32 [ undef, %cond.true ], [ undef, %cond.false ]
 833   ret i32 %cond
 834 }
 835
 836 ; CHECK: [[A:%.*]] = phi i32 [ undef, %cond.true ], [ undef, %cond.false ]
 837 ; CHECK: store i32 0, i32* bitcast {{.*}} @__msan_retval_tls
 838 ; CHECK: ret i32 [[A]]
 839
 840
 841 ; Test that there are no __msan_param_origin_tls stores when
 842 ; argument shadow is a compile-time zero constant (which is always the case
 843 ; in functions missing sanitize_memory attribute).
 844
 845 define i32 @NoSanitizeMemoryParamTLS(i32* nocapture readonly %x) {
 846 entry:
 847   %0 = load i32, i32* %x, align 4
 848   %call = tail call i32 @NoSanitizeMemoryParamTLSHelper(i32 %0)
 849   ret i32 %call
 850 }
 851
 852 declare i32 @NoSanitizeMemoryParamTLSHelper(i32 %x)
 853
 854 ; CHECK-LABEL: define i32 @NoSanitizeMemoryParamTLS(
 855 ; CHECK-NOT: __msan_param_origin_tls
 856 ; CHECK: ret i32
 857
 858
 859 ; Test argument shadow alignment
 860
 861 define <2 x i64> @ArgumentShadowAlignment(i64 %a, <2 x i64> %b) sanitize_memory {
 862 entry:
 863   ret <2 x i64> %b
 864 }
 865
 866 ; CHECK-LABEL: @ArgumentShadowAlignment
 867 ; CHECK: load <2 x i64>, <2 x i64>* {{.*}} @__msan_param_tls {{.*}}, align 8
 868 ; CHECK: store <2 x i64> {{.*}} @__msan_retval_tls {{.*}}, align 8
 869 ; CHECK: ret <2 x i64>
 870
 871
 872 ; Test origin propagation for insertvalue
 873
 874 define { i64, i32 } @make_pair_64_32(i64 %x, i32 %y) sanitize_memory {
 875 entry:
 876   %a = insertvalue { i64, i32 } undef, i64 %x, 0
 877   %b = insertvalue { i64, i32 } %a, i32 %y, 1
 878   ret { i64, i32 } %b
 879 }
 880
 881 ; CHECK-ORIGINS: @make_pair_64_32
 882 ; First element shadow
 883 ; CHECK-ORIGINS: insertvalue { i64, i32 } { i64 -1, i32 -1 }, i64 {{.*}}, 0
 884 ; First element origin
 885 ; CHECK-ORIGINS: icmp ne i64
 886 ; CHECK-ORIGINS: select i1
 887 ; First element app value
 888 ; CHECK-ORIGINS: insertvalue { i64, i32 } undef, i64 {{.*}}, 0
 889 ; Second element shadow
 890 ; CHECK-ORIGINS: insertvalue { i64, i32 } {{.*}}, i32 {{.*}}, 1
 891 ; Second element origin
 892 ; CHECK-ORIGINS: icmp ne i32
 893 ; CHECK-ORIGINS: select i1
 894 ; Second element app value
 895 ; CHECK-ORIGINS: insertvalue { i64, i32 } {{.*}}, i32 {{.*}}, 1
 896 ; CHECK-ORIGINS: ret { i64, i32 }
 897
 898
 899 ; Test shadow propagation for aggregates passed through ellipsis.
 900
 901 %struct.StructByVal = type { i32, i32, i32, i32 }
 902
 903 declare void @VAArgStructFn(i32 %guard, ...)
 904
 905 define void @VAArgStruct(%struct.StructByVal* nocapture %s) sanitize_memory {
 906 entry:
 907   %agg.tmp2 = alloca %struct.StructByVal, align 8
 908   %0 = bitcast %struct.StructByVal* %s to i8*
 909   %agg.tmp.sroa.0.0..sroa_cast = bitcast %struct.StructByVal* %s to i64*
 910   %agg.tmp.sroa.0.0.copyload = load i64, i64* %agg.tmp.sroa.0.0..sroa_cast, align 4
 911   %agg.tmp.sroa.2.0..sroa_idx = getelementptr inbounds %struct.StructByVal, %struct.StructByVal* %s, i64 0, i32 2
 912   %agg.tmp.sroa.2.0..sroa_cast = bitcast i32* %agg.tmp.sroa.2.0..sroa_idx to i64*
 913   %agg.tmp.sroa.2.0.copyload = load i64, i64* %agg.tmp.sroa.2.0..sroa_cast, align 4
 914   %1 = bitcast %struct.StructByVal* %agg.tmp2 to i8*
 915   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %1, i8* align 4 %0, i64 16, i1 false)
 916   call void (i32, ...) @VAArgStructFn(i32 undef, i64 %agg.tmp.sroa.0.0.copyload, i64 %agg.tmp.sroa.2.0.copyload, i64 %agg.tmp.sroa.0.0.copyload, i64 %agg.tmp.sroa.2.0.copyload, %struct.StructByVal* byval align 8 %agg.tmp2)
 917   ret void
 918 }
 919
 920 ; "undef" and the first 2 structs go to general purpose registers;
 921 ; the third struct goes to the overflow area byval
 922
 923 ; CHECK-LABEL: @VAArgStruct
 924 ; undef not stored to __msan_va_arg_tls - it's a fixed argument
 925 ; first struct through general purpose registers
 926 ; CHECK: store i64 {{.*}}, i64* {{.*}}@__msan_va_arg_tls{{.*}}, i64 8){{.*}}, align 8
 927 ; CHECK: store i64 {{.*}}, i64* {{.*}}@__msan_va_arg_tls{{.*}}, i64 16){{.*}}, align 8
 928 ; second struct through general purpose registers
 929 ; CHECK: store i64 {{.*}}, i64* {{.*}}@__msan_va_arg_tls{{.*}}, i64 24){{.*}}, align 8
 930 ; CHECK: store i64 {{.*}}, i64* {{.*}}@__msan_va_arg_tls{{.*}}, i64 32){{.*}}, align 8
 931 ; third struct through the overflow area byval
 932 ; CHECK: ptrtoint %struct.StructByVal* {{.*}} to i64
 933 ; CHECK: bitcast { i32, i32, i32, i32 }* {{.*}}@__msan_va_arg_tls {{.*}}, i64 176
 934 ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64
 935 ; CHECK: store i64 16, i64* @__msan_va_arg_overflow_size_tls
 936 ; CHECK: call void (i32, ...) @VAArgStructFn
 937 ; CHECK: ret void
 938
 939 ; Same code compiled without SSE (see attributes below).
 940 ; The register save area is only 48 bytes instead of 176.
 941 define void @VAArgStructNoSSE(%struct.StructByVal* nocapture %s) sanitize_memory #0 {
 942 entry:
 943   %agg.tmp2 = alloca %struct.StructByVal, align 8
 944   %0 = bitcast %struct.StructByVal* %s to i8*
 945   %agg.tmp.sroa.0.0..sroa_cast = bitcast %struct.StructByVal* %s to i64*
 946   %agg.tmp.sroa.0.0.copyload = load i64, i64* %agg.tmp.sroa.0.0..sroa_cast, align 4
 947   %agg.tmp.sroa.2.0..sroa_idx = getelementptr inbounds %struct.StructByVal, %struct.StructByVal* %s, i64 0, i32 2
 948   %agg.tmp.sroa.2.0..sroa_cast = bitcast i32* %agg.tmp.sroa.2.0..sroa_idx to i64*
 949   %agg.tmp.sroa.2.0.copyload = load i64, i64* %agg.tmp.sroa.2.0..sroa_cast, align 4
 950   %1 = bitcast %struct.StructByVal* %agg.tmp2 to i8*
 951   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %1, i8* align 4 %0, i64 16, i1 false)
 952   call void (i32, ...) @VAArgStructFn(i32 undef, i64 %agg.tmp.sroa.0.0.copyload, i64 %agg.tmp.sroa.2.0.copyload, i64 %agg.tmp.sroa.0.0.copyload, i64 %agg.tmp.sroa.2.0.copyload, %struct.StructByVal* byval align 8 %agg.tmp2)
 953   ret void
 954 }
 955
 956 attributes #0 = { "target-features"="+fxsr,+x87,-sse" }
 957
 958 ; CHECK: bitcast { i32, i32, i32, i32 }* {{.*}}@__msan_va_arg_tls {{.*}}, i64 48
 959
 960 declare i32 @InnerTailCall(i32 %a)
 961
 962 define void @MismatchedReturnTypeTailCall(i32 %a) sanitize_memory {
 963   %b = tail call i32 @InnerTailCall(i32 %a)
 964   ret void
 965 }
 966
 967 ; We used to strip off the 'tail' modifier, but now that we unpoison return slot
 968 ; shadow before the call, we don't need to anymore.
 969
 970 ; CHECK-LABEL: define void @MismatchedReturnTypeTailCall
 971 ; CHECK: tail call i32 @InnerTailCall
 972 ; CHECK: ret void
 973
 974
 975 declare i32 @MustTailCall(i32 %a)
 976
 977 define i32 @CallMustTailCall(i32 %a) sanitize_memory {
 978   %b = musttail call i32 @MustTailCall(i32 %a)
 979   ret i32 %b
 980 }
 981
 982 ; For "musttail" calls we can not insert any shadow manipulating code between
 983 ; call and the return instruction. And we don't need to, because everything is
 984 ; taken care of in the callee.
 985
 986 ; CHECK-LABEL: define i32 @CallMustTailCall
 987 ; CHECK: musttail call i32 @MustTailCall
 988 ; No instrumentation between call and ret.
 989 ; CHECK-NEXT: ret i32
 990
 991 declare i32* @MismatchingMustTailCall(i32 %a)
 992
 993 define i8* @MismatchingCallMustTailCall(i32 %a) sanitize_memory {
 994   %b = musttail call i32* @MismatchingMustTailCall(i32 %a)
 995   %c = bitcast i32* %b to i8*
 996   ret i8* %c
 997 }
 998
 999 ; For "musttail" calls we can not insert any shadow manipulating code between
1000 ; call and the return instruction. And we don't need to, because everything is
1001 ; taken care of in the callee.
1002
1003 ; CHECK-LABEL: define i8* @MismatchingCallMustTailCall
1004 ; CHECK: musttail call i32* @MismatchingMustTailCall
1005 ; No instrumentation between call and ret.
1006 ; CHECK-NEXT: bitcast i32* {{.*}} to i8*
1007 ; CHECK-NEXT: ret i8*
1008
1009
1010 ; CHECK-LABEL: define internal void @msan.module_ctor() {
1011 ; CHECK: call void @__msan_init()