llvm/test/Transforms/ConstantHoisting/ARM/is-legal-addressing-imm.ll

   1 ; RUN: opt -passes=consthoist -S -o - %s | FileCheck %s
   2 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
   3 target triple = "thumbv6m-none--musleabi"
   4
   5 ; Check that for i8 type, the maximum legal offset is 31.
   6 ; Also check that an constant used as value to be stored rather than
   7 ; pointer in a store instruction is hoisted.
   8 ; CHECK: foo_i8
   9 ; CHECK-DAG:  %[[C1:const[0-9]?]] = bitcast i32 805874720 to i32
  10 ; CHECK-DAG:  %[[C2:const[0-9]?]] = bitcast i32 805874688 to i32
  11 ; CHECK-DAG:  %[[C3:const[0-9]?]] = bitcast i32 805873720 to i32
  12 ; CHECK-DAG:  %[[C4:const[0-9]?]] = bitcast i32 805873688 to i32
  13 ; CHECK:  %0 = inttoptr i32 %[[C2]] to ptr
  14 ; CHECK-NEXT:  %1 = load volatile i8, ptr %0
  15 ; CHECK-NEXT:  %[[M1:const_mat[0-9]?]] = add i32 %[[C2]], 4
  16 ; CHECK-NEXT:  %2 = inttoptr i32 %[[M1]] to ptr
  17 ; CHECK-NEXT:  %3 = load volatile i8, ptr %2
  18 ; CHECK-NEXT:  %[[M2:const_mat[0-9]?]] = add i32 %[[C2]], 31
  19 ; CHECK-NEXT:  %4 = inttoptr i32 %[[M2]] to ptr
  20 ; CHECK-NEXT:  %5 = load volatile i8, ptr %4
  21 ; CHECK-NEXT:  %6 = inttoptr i32 %[[C1]] to ptr
  22 ; CHECK-NEXT:  %7 = load volatile i8, ptr %6
  23 ; CHECK-NEXT:  %[[M3:const_mat[0-9]?]] = add i32 %[[C1]], 7
  24 ; CHECK-NEXT:  %8 = inttoptr i32 %[[M3]] to ptr
  25 ; CHECK-NEXT:  %9 = load volatile i8, ptr %8
  26 ; CHECK-NEXT:  %10 = inttoptr i32 %[[C4]] to ptr
  27 ; CHECK-NEXT:  store i8 %9, ptr %10
  28 ; CHECK-NEXT:  %[[M4:const_mat[0-9]?]] = add i32 %[[C4]], 31
  29 ; CHECK-NEXT:  %11 = inttoptr i32 %[[M4]] to ptr
  30 ; CHECK-NEXT:  store i8 %7, ptr %11
  31 ; CHECK-NEXT:  %12 = inttoptr i32 %[[C3]] to ptr
  32 ; CHECK-NEXT:  store i8 %5, ptr %12
  33 ; CHECK-NEXT:  %[[M5:const_mat[0-9]?]] = add i32 %[[C3]], 7
  34 ; CHECK-NEXT:  %13 = inttoptr i32 %[[M5]] to ptr
  35 ; CHECK-NEXT:  store i8 %3, ptr %13
  36 ; CHECK-NEXT:  %[[M6:const_mat[0-9]?]] = add i32 %[[C1]], 80
  37 ; CHECK-NEXT:  %14 = inttoptr i32 %[[M6]] to ptr
  38 ; CHECK-NEXT:  store ptr %14, ptr @goo
  39
  40 @goo = global ptr undef
  41
  42 define void @foo_i8() {
  43 entry:
  44   %0 = load volatile i8, ptr inttoptr (i32 805874688 to ptr)
  45   %1 = load volatile i8, ptr inttoptr (i32 805874692 to ptr)
  46   %2 = load volatile i8, ptr inttoptr (i32 805874719 to ptr)
  47   %3 = load volatile i8, ptr inttoptr (i32 805874720 to ptr)
  48   %4 = load volatile i8, ptr inttoptr (i32 805874727 to ptr)
  49   store i8 %4, ptr inttoptr(i32 805873688 to ptr)
  50   store i8 %3, ptr inttoptr(i32 805873719 to ptr)
  51   store i8 %2, ptr inttoptr(i32 805873720 to ptr)
  52   store i8 %1, ptr inttoptr(i32 805873727 to ptr)
  53   store ptr inttoptr(i32 805874800 to ptr), ptr @goo
  54   ret void
  55 }
  56
  57 ; Check that for i16 type, the maximum legal offset is 62.
  58 ; CHECK: foo_i16
  59 ; CHECK-DAG: %[[C1:const[0-9]?]] = bitcast i32 805874752 to i32
  60 ; CHECK-DAG: %[[C2:const[0-9]?]] = bitcast i32 805874688 to i32
  61 ; CHECK: %0 = inttoptr i32 %[[C2]] to ptr
  62 ; CHECK-NEXT: %1 = load volatile i16, ptr %0, align 2
  63 ; CHECK-NEXT: %[[M1:const_mat[0-9]?]] = add i32 %[[C2]], 4
  64 ; CHECK-NEXT: %2 = inttoptr i32 %[[M1]] to ptr
  65 ; CHECK-NEXT: %3 = load volatile i16, ptr %2, align 2
  66 ; CHECK-NEXT: %[[M2:const_mat[0-9]?]] = add i32 %[[C2]], 32
  67 ; CHECK-NEXT: %4 = inttoptr i32 %[[M2]] to ptr
  68 ; CHECK-NEXT: %5 = load volatile i16, ptr %4, align 2
  69 ; CHECK-NEXT: %[[M3:const_mat[0-9]?]] = add i32 %[[C2]], 62
  70 ; CHECK-NEXT: %6 = inttoptr i32 %[[M3]] to ptr
  71 ; CHECK-NEXT: %7 = load volatile i16, ptr %6, align 2
  72 ; CHECK-NEXT: %8 = inttoptr i32 %[[C1]] to ptr
  73 ; CHECK-NEXT: %9 = load volatile i16, ptr %8, align 2
  74 ; CHECK-NEXT: %[[M4:const_mat[0-9]?]] = add i32 %[[C1]], 22
  75 ; CHECK-NEXT: %10 = inttoptr i32 %[[M4]] to ptr
  76 ; CHECK-NEXT: %11 = load volatile i16, ptr %10, align 2
  77
  78 define void @foo_i16() {
  79 entry:
  80   %0 = load volatile i16, ptr inttoptr (i32 805874688 to ptr), align 2
  81   %1 = load volatile i16, ptr inttoptr (i32 805874692 to ptr), align 2
  82   %2 = load volatile i16, ptr inttoptr (i32 805874720 to ptr), align 2
  83   %3 = load volatile i16, ptr inttoptr (i32 805874750 to ptr), align 2
  84   %4 = load volatile i16, ptr inttoptr (i32 805874752 to ptr), align 2
  85   %5 = load volatile i16, ptr inttoptr (i32 805874774 to ptr), align 2
  86   ret void
  87 }
  88
  89 ; Check that for i32 type, the maximum legal offset is 124.
  90 ; CHECK: foo_i32
  91 ; CHECK-DAG:  %[[C1:const[0-9]?]] = bitcast i32 805874816 to i32
  92 ; CHECK-DAG:  %[[C2:const[0-9]?]] = bitcast i32 805874688 to i32
  93 ; CHECK:  %0 = inttoptr i32 %[[C2]] to ptr
  94 ; CHECK-NEXT:  %1 = load volatile i32, ptr %0, align 4
  95 ; CHECK-NEXT:  %[[M1:const_mat[0-9]?]] = add i32 %[[C2]], 4
  96 ; CHECK-NEXT:  %2 = inttoptr i32 %[[M1]] to ptr
  97 ; CHECK-NEXT:  %3 = load volatile i32, ptr %2, align 4
  98 ; CHECK-NEXT:  %[[M2:const_mat[0-9]?]] = add i32 %[[C2]], 124
  99 ; CHECK-NEXT:  %4 = inttoptr i32 %[[M2]] to ptr
 100 ; CHECK-NEXT:  %5 = load volatile i32, ptr %4, align 4
 101 ; CHECK-NEXT:  %6 = inttoptr i32 %[[C1]] to ptr
 102 ; CHECK-NEXT:  %7 = load volatile i32, ptr %6, align 4
 103 ; CHECK-NEXT:  %[[M3:const_mat[0-9]?]] = add i32 %[[C1]], 8
 104 ; CHECK-NEXT:  %8 = inttoptr i32 %[[M3]] to ptr
 105 ; CHECK-NEXT:  %9 = load volatile i32, ptr %8, align 4
 106 ; CHECK-NEXT:  %[[M4:const_mat[0-9]?]] = add i32 %[[C1]], 12
 107 ; CHECK-NEXT:  %10 = inttoptr i32 %[[M4]] to ptr
 108 ; CHECK-NEXT:  %11 = load volatile i32, ptr %10, align 4
 109
 110 define void @foo_i32() {
 111 entry:
 112   %0 = load volatile i32, ptr inttoptr (i32 805874688 to ptr), align 4
 113   %1 = load volatile i32, ptr inttoptr (i32 805874692 to ptr), align 4
 114   %2 = load volatile i32, ptr inttoptr (i32 805874812 to ptr), align 4
 115   %3 = load volatile i32, ptr inttoptr (i32 805874816 to ptr), align 4
 116   %4 = load volatile i32, ptr inttoptr (i32 805874824 to ptr), align 4
 117   %5 = load volatile i32, ptr inttoptr (i32 805874828 to ptr), align 4
 118   ret void
 119 }
 120