test/CodeGen/PowerPC/anon_aggr.ll

   1 ; RUN: llc -O0 -mcpu=pwr7 -mtriple=powerpc64-unknown-linux-gnu < %s | FileCheck %s
   2
   3 ; Test case for PR 14779: anonymous aggregates are not handled correctly.
   4 ; The bug is triggered by passing a byval structure after an anonymous
   5 ; aggregate.
   6
   7 %tarray = type { i64, i8* }
   8
   9 define i8* @func1({ i64, i8* } %array, i8* %ptr) {
  10 entry:
  11   %array_ptr = extractvalue {i64, i8* } %array, 1
  12   %cond = icmp eq i8* %array_ptr, %ptr
  13   br i1 %cond, label %equal, label %unequal
  14 equal:
  15   ret i8* %array_ptr
  16 unequal:
  17   ret i8* %ptr
  18 }
  19
  20 ; CHECK: func1:
  21 ; CHECK: cmpld {{[0-9]+}}, 4, 5
  22 ; CHECK: std 4, -[[OFFSET1:[0-9]+]]
  23 ; CHECK: std 5, -[[OFFSET2:[0-9]+]]
  24 ; CHECK: ld 3, -[[OFFSET1]](1)
  25 ; CHECK: ld 3, -[[OFFSET2]](1)
  26
  27
  28 define i8* @func2({ i64, i8* } %array1, %tarray* byval %array2) {
  29 entry:
  30   %array1_ptr = extractvalue {i64, i8* } %array1, 1
  31   %tmp = getelementptr inbounds %tarray* %array2, i32 0, i32 1
  32   %array2_ptr = load i8** %tmp
  33   %cond = icmp eq i8* %array1_ptr, %array2_ptr
  34   br i1 %cond, label %equal, label %unequal
  35 equal:
  36   ret i8* %array1_ptr
  37 unequal:
  38   ret i8* %array2_ptr
  39 }
  40
  41 ; CHECK: func2:
  42 ; CHECK: addi [[REG1:[0-9]+]], 1, 64
  43 ; CHECK: ld [[REG2:[0-9]+]], 8([[REG1]])
  44 ; CHECK: cmpld {{[0-9]+}}, 4, [[REG2]]
  45 ; CHECK: std [[REG2]], -[[OFFSET1:[0-9]+]]
  46 ; CHECK: std 4, -[[OFFSET2:[0-9]+]]
  47 ; CHECK: ld 3, -[[OFFSET2]](1)
  48 ; CHECK: ld 3, -[[OFFSET1]](1)
  49
  50 define i8* @func3({ i64, i8* }* byval %array1, %tarray* byval %array2) {
  51 entry:
  52   %tmp1 = getelementptr inbounds { i64, i8* }* %array1, i32 0, i32 1
  53   %array1_ptr = load i8** %tmp1
  54   %tmp2 = getelementptr inbounds %tarray* %array2, i32 0, i32 1
  55   %array2_ptr = load i8** %tmp2
  56   %cond = icmp eq i8* %array1_ptr, %array2_ptr
  57   br i1 %cond, label %equal, label %unequal
  58 equal:
  59   ret i8* %array1_ptr
  60 unequal:
  61   ret i8* %array2_ptr
  62 }
  63
  64 ; CHECK: func3:
  65 ; CHECK: addi [[REG1:[0-9]+]], 1, 64
  66 ; CHECK: addi [[REG2:[0-9]+]], 1, 48
  67 ; CHECK: ld [[REG3:[0-9]+]], 8([[REG1]])
  68 ; CHECK: ld [[REG4:[0-9]+]], 8([[REG2]])
  69 ; CHECK: cmpld {{[0-9]+}}, [[REG4]], [[REG3]]
  70 ; CHECK: std [[REG3]], -[[OFFSET1:[0-9]+]](1)
  71 ; CHECK: std [[REG4]], -[[OFFSET2:[0-9]+]](1)
  72 ; CHECK: ld 3, -[[OFFSET2]](1)
  73 ; CHECK: ld 3, -[[OFFSET1]](1)
  74
  75 define i8* @func4(i64 %p1, i64 %p2, i64 %p3, i64 %p4,
  76                   i64 %p5, i64 %p6, i64 %p7, i64 %p8,
  77                   { i64, i8* } %array1, %tarray* byval %array2) {
  78 entry:
  79   %array1_ptr = extractvalue {i64, i8* } %array1, 1
  80   %tmp = getelementptr inbounds %tarray* %array2, i32 0, i32 1
  81   %array2_ptr = load i8** %tmp
  82   %cond = icmp eq i8* %array1_ptr, %array2_ptr
  83   br i1 %cond, label %equal, label %unequal
  84 equal:
  85   ret i8* %array1_ptr
  86 unequal:
  87   ret i8* %array2_ptr
  88 }
  89
  90 ; CHECK: func4:
  91 ; CHECK: addi [[REG1:[0-9]+]], 1, 128
  92 ; CHECK: ld [[REG2:[0-9]+]], 120(1)
  93 ; CHECK: ld [[REG3:[0-9]+]], 8([[REG1]])
  94 ; CHECK: cmpld {{[0-9]+}}, [[REG2]], [[REG3]]
  95 ; CHECK: std [[REG2]], -[[OFFSET1:[0-9]+]](1)
  96 ; CHECK: std [[REG3]], -[[OFFSET2:[0-9]+]](1)
  97 ; CHECK: ld 3, -[[OFFSET1]](1)
  98 ; CHECK: ld 3, -[[OFFSET2]](1)
  99