test/CodeGen/X86/addcarry.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc < %s -mtriple=x86_64-unknown | FileCheck %s
   3
   4 define i128 @add128(i128 %a, i128 %b) nounwind {
   5 ; CHECK-LABEL: add128:
   6 ; CHECK:       # %bb.0: # %entry
   7 ; CHECK-NEXT:    movq %rdi, %rax
   8 ; CHECK-NEXT:    addq %rdx, %rax
   9 ; CHECK-NEXT:    adcq %rcx, %rsi
  10 ; CHECK-NEXT:    movq %rsi, %rdx
  11 ; CHECK-NEXT:    retq
  12 entry:
  13   %0 = add i128 %a, %b
  14   ret i128 %0
  15 }
  16
  17 define void @add128_rmw(i128* %a, i128 %b) nounwind {
  18 ; CHECK-LABEL: add128_rmw:
  19 ; CHECK:       # %bb.0: # %entry
  20 ; CHECK-NEXT:    addq %rsi, (%rdi)
  21 ; CHECK-NEXT:    adcq %rdx, 8(%rdi)
  22 ; CHECK-NEXT:    retq
  23 entry:
  24   %0 = load i128, i128* %a
  25   %1 = add i128 %0, %b
  26   store i128 %1, i128* %a
  27   ret void
  28 }
  29
  30 define void @add128_rmw2(i128 %a, i128* %b) nounwind {
  31 ; CHECK-LABEL: add128_rmw2:
  32 ; CHECK:       # %bb.0: # %entry
  33 ; CHECK-NEXT:    addq %rdi, (%rdx)
  34 ; CHECK-NEXT:    adcq %rsi, 8(%rdx)
  35 ; CHECK-NEXT:    retq
  36 entry:
  37   %0 = load i128, i128* %b
  38   %1 = add i128 %a, %0
  39   store i128 %1, i128* %b
  40   ret void
  41 }
  42
  43 define i256 @add256(i256 %a, i256 %b) nounwind {
  44 ; CHECK-LABEL: add256:
  45 ; CHECK:       # %bb.0: # %entry
  46 ; CHECK-NEXT:    movq %rdi, %rax
  47 ; CHECK-NEXT:    addq %r9, %rsi
  48 ; CHECK-NEXT:    adcq {{[0-9]+}}(%rsp), %rdx
  49 ; CHECK-NEXT:    adcq {{[0-9]+}}(%rsp), %rcx
  50 ; CHECK-NEXT:    adcq {{[0-9]+}}(%rsp), %r8
  51 ; CHECK-NEXT:    movq %rdx, 8(%rdi)
  52 ; CHECK-NEXT:    movq %rsi, (%rdi)
  53 ; CHECK-NEXT:    movq %rcx, 16(%rdi)
  54 ; CHECK-NEXT:    movq %r8, 24(%rdi)
  55 ; CHECK-NEXT:    retq
  56 entry:
  57   %0 = add i256 %a, %b
  58   ret i256 %0
  59 }
  60
  61 define void @add256_rmw(i256* %a, i256 %b) nounwind {
  62 ; CHECK-LABEL: add256_rmw:
  63 ; CHECK:       # %bb.0: # %entry
  64 ; CHECK-NEXT:    addq %rsi, (%rdi)
  65 ; CHECK-NEXT:    adcq %rdx, 8(%rdi)
  66 ; CHECK-NEXT:    adcq %rcx, 16(%rdi)
  67 ; CHECK-NEXT:    adcq %r8, 24(%rdi)
  68 ; CHECK-NEXT:    retq
  69 entry:
  70   %0 = load i256, i256* %a
  71   %1 = add i256 %0, %b
  72   store i256 %1, i256* %a
  73   ret void
  74 }
  75
  76 define void @add256_rmw2(i256 %a, i256* %b) nounwind {
  77 ; CHECK-LABEL: add256_rmw2:
  78 ; CHECK:       # %bb.0: # %entry
  79 ; CHECK-NEXT:    addq %rdi, (%r8)
  80 ; CHECK-NEXT:    adcq %rsi, 8(%r8)
  81 ; CHECK-NEXT:    adcq %rdx, 16(%r8)
  82 ; CHECK-NEXT:    adcq %rcx, 24(%r8)
  83 ; CHECK-NEXT:    retq
  84 entry:
  85   %0 = load i256, i256* %b
  86   %1 = add i256 %a, %0
  87   store i256 %1, i256* %b
  88   ret void
  89 }
  90
  91 define void @a(i64* nocapture %s, i64* nocapture %t, i64 %a, i64 %b, i64 %c) nounwind {
  92 ; CHECK-LABEL: a:
  93 ; CHECK:       # %bb.0: # %entry
  94 ; CHECK-NEXT:    addq %rcx, %rdx
  95 ; CHECK-NEXT:    adcq $0, %r8
  96 ; CHECK-NEXT:    movq %r8, (%rdi)
  97 ; CHECK-NEXT:    movq %rdx, (%rsi)
  98 ; CHECK-NEXT:    retq
  99 entry:
 100  %0 = zext i64 %a to i128
 101  %1 = zext i64 %b to i128
 102  %2 = add i128 %1, %0
 103  %3 = zext i64 %c to i128
 104  %4 = shl i128 %3, 64
 105  %5 = add i128 %4, %2
 106  %6 = lshr i128 %5, 64
 107  %7 = trunc i128 %6 to i64
 108  store i64 %7, i64* %s, align 8
 109  %8 = trunc i128 %2 to i64
 110  store i64 %8, i64* %t, align 8
 111  ret void
 112 }
 113
 114 define void @b(i32* nocapture %r, i64 %a, i64 %b, i32 %c) nounwind {
 115 ; CHECK-LABEL: b:
 116 ; CHECK:       # %bb.0: # %entry
 117 ; CHECK-NEXT:    addq %rdx, %rsi
 118 ; CHECK-NEXT:    adcl $0, %ecx
 119 ; CHECK-NEXT:    movl %ecx, (%rdi)
 120 ; CHECK-NEXT:    retq
 121 entry:
 122  %0 = zext i64 %a to i128
 123  %1 = zext i64 %b to i128
 124  %2 = zext i32 %c to i128
 125  %3 = add i128 %1, %0
 126  %4 = lshr i128 %3, 64
 127  %5 = add i128 %4, %2
 128  %6 = trunc i128 %5 to i32
 129  store i32 %6, i32* %r, align 4
 130  ret void
 131 }
 132
 133 define void @c(i16* nocapture %r, i64 %a, i64 %b, i16 %c) nounwind {
 134 ; CHECK-LABEL: c:
 135 ; CHECK:       # %bb.0: # %entry
 136 ; CHECK-NEXT:    addq %rdx, %rsi
 137 ; CHECK-NEXT:    adcw $0, %cx
 138 ; CHECK-NEXT:    movw %cx, (%rdi)
 139 ; CHECK-NEXT:    retq
 140 entry:
 141  %0 = zext i64 %a to i128
 142  %1 = zext i64 %b to i128
 143  %2 = zext i16 %c to i128
 144  %3 = add i128 %1, %0
 145  %4 = lshr i128 %3, 64
 146  %5 = add i128 %4, %2
 147  %6 = trunc i128 %5 to i16
 148  store i16 %6, i16* %r, align 4
 149  ret void
 150 }
 151
 152 define void @d(i8* nocapture %r, i64 %a, i64 %b, i8 %c) nounwind {
 153 ; CHECK-LABEL: d:
 154 ; CHECK:       # %bb.0: # %entry
 155 ; CHECK-NEXT:    addq %rdx, %rsi
 156 ; CHECK-NEXT:    adcb $0, %cl
 157 ; CHECK-NEXT:    movb %cl, (%rdi)
 158 ; CHECK-NEXT:    retq
 159 entry:
 160  %0 = zext i64 %a to i128
 161  %1 = zext i64 %b to i128
 162  %2 = zext i8 %c to i128
 163  %3 = add i128 %1, %0
 164  %4 = lshr i128 %3, 64
 165  %5 = add i128 %4, %2
 166  %6 = trunc i128 %5 to i8
 167  store i8 %6, i8* %r, align 4
 168  ret void
 169 }
 170
 171 define i8 @e(i32* nocapture %a, i32 %b) nounwind {
 172 ; CHECK-LABEL: e:
 173 ; CHECK:       # %bb.0:
 174 ; CHECK-NEXT:    # kill: def $esi killed $esi def $rsi
 175 ; CHECK-NEXT:    movl (%rdi), %ecx
 176 ; CHECK-NEXT:    leal (%rsi,%rcx), %edx
 177 ; CHECK-NEXT:    addl %esi, %edx
 178 ; CHECK-NEXT:    setb %al
 179 ; CHECK-NEXT:    addl %esi, %ecx
 180 ; CHECK-NEXT:    movl %edx, (%rdi)
 181 ; CHECK-NEXT:    adcb $0, %al
 182 ; CHECK-NEXT:    retq
 183   %1 = load i32, i32* %a, align 4
 184   %2 = add i32 %1, %b
 185   %3 = icmp ult i32 %2, %b
 186   %4 = zext i1 %3 to i8
 187   %5 = add i32 %2, %b
 188   store i32 %5, i32* %a, align 4
 189   %6 = icmp ult i32 %5, %b
 190   %7 = zext i1 %6 to i8
 191   %8 = add nuw nsw i8 %7, %4
 192   ret i8 %8
 193 }
 194
 195 %scalar = type { [4 x i64] }
 196
 197 define %scalar @pr31719(%scalar* nocapture readonly %this, %scalar %arg.b) {
 198 ; CHECK-LABEL: pr31719:
 199 ; CHECK:       # %bb.0: # %entry
 200 ; CHECK-NEXT:    movq %rdi, %rax
 201 ; CHECK-NEXT:    addq (%rsi), %rdx
 202 ; CHECK-NEXT:    adcq 8(%rsi), %rcx
 203 ; CHECK-NEXT:    adcq 16(%rsi), %r8
 204 ; CHECK-NEXT:    adcq 24(%rsi), %r9
 205 ; CHECK-NEXT:    movq %rdx, (%rdi)
 206 ; CHECK-NEXT:    movq %rcx, 8(%rdi)
 207 ; CHECK-NEXT:    movq %r8, 16(%rdi)
 208 ; CHECK-NEXT:    movq %r9, 24(%rdi)
 209 ; CHECK-NEXT:    retq
 210 entry:
 211   %0 = extractvalue %scalar %arg.b, 0
 212   %.elt = extractvalue [4 x i64] %0, 0
 213   %.elt24 = extractvalue [4 x i64] %0, 1
 214   %.elt26 = extractvalue [4 x i64] %0, 2
 215   %.elt28 = extractvalue [4 x i64] %0, 3
 216   %1 = getelementptr inbounds %scalar , %scalar* %this, i64 0, i32 0, i64 0
 217   %2 = load i64, i64* %1, align 8
 218   %3 = zext i64 %2 to i128
 219   %4 = zext i64 %.elt to i128
 220   %5 = add nuw nsw i128 %3, %4
 221   %6 = trunc i128 %5 to i64
 222   %7 = lshr i128 %5, 64
 223   %8 = getelementptr inbounds %scalar , %scalar * %this, i64 0, i32 0, i64 1
 224   %9 = load i64, i64* %8, align 8
 225   %10 = zext i64 %9 to i128
 226   %11 = zext i64 %.elt24 to i128
 227   %12 = add nuw nsw i128 %10, %11
 228   %13 = add nuw nsw i128 %12, %7
 229   %14 = trunc i128 %13 to i64
 230   %15 = lshr i128 %13, 64
 231   %16 = getelementptr inbounds %scalar , %scalar* %this, i64 0, i32 0, i64 2
 232   %17 = load i64, i64* %16, align 8
 233   %18 = zext i64 %17 to i128
 234   %19 = zext i64 %.elt26 to i128
 235   %20 = add nuw nsw i128 %18, %19
 236   %21 = add nuw nsw i128 %20, %15
 237   %22 = trunc i128 %21 to i64
 238   %23 = lshr i128 %21, 64
 239   %24 = getelementptr inbounds %scalar , %scalar* %this, i64 0, i32 0, i64 3
 240   %25 = load i64, i64* %24, align 8
 241   %26 = zext i64 %25 to i128
 242   %27 = zext i64 %.elt28 to i128
 243   %28 = add nuw nsw i128 %26, %27
 244   %29 = add nuw nsw i128 %28, %23
 245   %30 = trunc i128 %29 to i64
 246   %31 = insertvalue [4 x i64] undef, i64 %6, 0
 247   %32 = insertvalue [4 x i64] %31, i64 %14, 1
 248   %33 = insertvalue [4 x i64] %32, i64 %22, 2
 249   %34 = insertvalue [4 x i64] %33, i64 %30, 3
 250   %35 = insertvalue %scalar undef, [4 x i64] %34, 0
 251   ret %scalar %35
 252 }
 253
 254 %accumulator= type { i64, i64, i32 }
 255
 256 define void @muladd(%accumulator* nocapture %this, i64 %arg.a, i64 %arg.b) {
 257 ; CHECK-LABEL: muladd:
 258 ; CHECK:       # %bb.0: # %entry
 259 ; CHECK-NEXT:    movq %rdx, %rax
 260 ; CHECK-NEXT:    mulq %rsi
 261 ; CHECK-NEXT:    addq %rax, (%rdi)
 262 ; CHECK-NEXT:    adcq %rdx, 8(%rdi)
 263 ; CHECK-NEXT:    adcl $0, 16(%rdi)
 264 ; CHECK-NEXT:    retq
 265 entry:
 266   %0 = zext i64 %arg.a to i128
 267   %1 = zext i64 %arg.b to i128
 268   %2 = mul nuw i128 %1, %0
 269   %3 = getelementptr inbounds %accumulator, %accumulator* %this, i64 0, i32 0
 270   %4 = load i64, i64* %3, align 8
 271   %5 = zext i64 %4 to i128
 272   %6 = add i128 %5, %2
 273   %7 = trunc i128 %6 to i64
 274   store i64 %7, i64* %3, align 8
 275   %8 = lshr i128 %6, 64
 276   %9 = getelementptr inbounds %accumulator, %accumulator* %this, i64 0, i32 1
 277   %10 = load i64, i64* %9, align 8
 278   %11 = zext i64 %10 to i128
 279   %12 = add nuw nsw i128 %8, %11
 280   %13 = trunc i128 %12 to i64
 281   store i64 %13, i64* %9, align 8
 282   %14 = lshr i128 %12, 64
 283   %15 = getelementptr inbounds %accumulator, %accumulator* %this, i64 0, i32 2
 284   %16 = load i32, i32* %15, align 4
 285   %17 = zext i32 %16 to i128
 286   %18 = add nuw nsw i128 %14, %17
 287   %19 = trunc i128 %18 to i32
 288   store i32 %19, i32* %15, align 4
 289   ret void
 290 }
 291
 292 define i64 @shiftadd(i64 %a, i64 %b, i64 %c, i64 %d) {
 293 ; CHECK-LABEL: shiftadd:
 294 ; CHECK:       # %bb.0: # %entry
 295 ; CHECK-NEXT:    movq %rdx, %rax
 296 ; CHECK-NEXT:    addq %rsi, %rdi
 297 ; CHECK-NEXT:    adcq %rcx, %rax
 298 ; CHECK-NEXT:    retq
 299 entry:
 300   %0 = zext i64 %a to i128
 301   %1 = zext i64 %b to i128
 302   %2 = add i128 %0, %1
 303   %3 = lshr i128 %2, 64
 304   %4 = trunc i128 %3 to i64
 305   %5 = add i64 %c, %d
 306   %6 = add i64 %4, %5
 307   ret i64 %6
 308 }
 309
 310 %S = type { [4 x i64] }
 311
 312 define %S @readd(%S* nocapture readonly %this, %S %arg.b) {
 313 ; CHECK-LABEL: readd:
 314 ; CHECK:       # %bb.0: # %entry
 315 ; CHECK-NEXT:    movq %rdi, %rax
 316 ; CHECK-NEXT:    addq (%rsi), %rdx
 317 ; CHECK-NEXT:    movq 8(%rsi), %r11
 318 ; CHECK-NEXT:    adcq $0, %r11
 319 ; CHECK-NEXT:    setb %r10b
 320 ; CHECK-NEXT:    movzbl %r10b, %edi
 321 ; CHECK-NEXT:    addq %rcx, %r11
 322 ; CHECK-NEXT:    adcq 16(%rsi), %rdi
 323 ; CHECK-NEXT:    setb %cl
 324 ; CHECK-NEXT:    movzbl %cl, %ecx
 325 ; CHECK-NEXT:    addq %r8, %rdi
 326 ; CHECK-NEXT:    adcq 24(%rsi), %rcx
 327 ; CHECK-NEXT:    addq %r9, %rcx
 328 ; CHECK-NEXT:    movq %rdx, (%rax)
 329 ; CHECK-NEXT:    movq %r11, 8(%rax)
 330 ; CHECK-NEXT:    movq %rdi, 16(%rax)
 331 ; CHECK-NEXT:    movq %rcx, 24(%rax)
 332 ; CHECK-NEXT:    retq
 333 entry:
 334   %0 = extractvalue %S %arg.b, 0
 335   %.elt6 = extractvalue [4 x i64] %0, 1
 336   %.elt8 = extractvalue [4 x i64] %0, 2
 337   %.elt10 = extractvalue [4 x i64] %0, 3
 338   %.elt = extractvalue [4 x i64] %0, 0
 339   %1 = getelementptr inbounds %S, %S* %this, i64 0, i32 0, i64 0
 340   %2 = load i64, i64* %1, align 8
 341   %3 = zext i64 %2 to i128
 342   %4 = zext i64 %.elt to i128
 343   %5 = add nuw nsw i128 %3, %4
 344   %6 = trunc i128 %5 to i64
 345   %7 = lshr i128 %5, 64
 346   %8 = getelementptr inbounds %S, %S* %this, i64 0, i32 0, i64 1
 347   %9 = load i64, i64* %8, align 8
 348   %10 = zext i64 %9 to i128
 349   %11 = add nuw nsw i128 %7, %10
 350   %12 = zext i64 %.elt6 to i128
 351   %13 = add nuw nsw i128 %11, %12
 352   %14 = trunc i128 %13 to i64
 353   %15 = lshr i128 %13, 64
 354   %16 = getelementptr inbounds %S, %S* %this, i64 0, i32 0, i64 2
 355   %17 = load i64, i64* %16, align 8
 356   %18 = zext i64 %17 to i128
 357   %19 = add nuw nsw i128 %15, %18
 358   %20 = zext i64 %.elt8 to i128
 359   %21 = add nuw nsw i128 %19, %20
 360   %22 = lshr i128 %21, 64
 361   %23 = trunc i128 %21 to i64
 362   %24 = getelementptr inbounds %S, %S* %this, i64 0,i32 0, i64 3
 363   %25 = load i64, i64* %24, align 8
 364   %26 = zext i64 %25 to i128
 365   %27 = add nuw nsw i128 %22, %26
 366   %28 = zext i64 %.elt10 to i128
 367   %29 = add nuw nsw i128 %27, %28
 368   %30 = trunc i128 %29 to i64
 369   %31 = insertvalue [4 x i64] undef, i64 %6, 0
 370   %32 = insertvalue [4 x i64] %31, i64 %14, 1
 371   %33 = insertvalue [4 x i64] %32, i64 %23, 2
 372   %34 = insertvalue [4 x i64] %33, i64 %30, 3
 373   %35 = insertvalue %S undef, [4 x i64] %34, 0
 374   ret %S %35
 375 }
 376
 377 define i128 @addcarry1_not(i128 %n) {
 378 ; CHECK-LABEL: addcarry1_not:
 379 ; CHECK:       # %bb.0:
 380 ; CHECK-NEXT:    movq %rdi, %rax
 381 ; CHECK-NEXT:    xorl %edx, %edx
 382 ; CHECK-NEXT:    negq %rax
 383 ; CHECK-NEXT:    sbbq %rsi, %rdx
 384 ; CHECK-NEXT:    retq
 385   %1 = xor i128 %n, -1
 386   %2 = add i128 %1, 1
 387   ret i128 %2
 388 }
 389
 390 define i128 @addcarry_to_subcarry(i64 %a, i64 %b) {
 391 ; CHECK-LABEL: addcarry_to_subcarry:
 392 ; CHECK:       # %bb.0:
 393 ; CHECK-NEXT:    movq %rdi, %rax
 394 ; CHECK-NEXT:    notq %rsi
 395 ; CHECK-NEXT:    movb $1, %cl
 396 ; CHECK-NEXT:    addb $-1, %cl
 397 ; CHECK-NEXT:    movq %rdi, %rcx
 398 ; CHECK-NEXT:    adcq %rsi, %rcx
 399 ; CHECK-NEXT:    adcq $0, %rax
 400 ; CHECK-NEXT:    setb %cl
 401 ; CHECK-NEXT:    movzbl %cl, %edx
 402 ; CHECK-NEXT:    addq %rsi, %rax
 403 ; CHECK-NEXT:    adcq $0, %rdx
 404 ; CHECK-NEXT:    retq
 405   %notb = xor i64 %b, -1
 406   %notb128 = zext i64 %notb to i128
 407   %a128 = zext i64 %a to i128
 408   %sum1 = add i128 %a128, 1
 409   %sub1 = add i128 %sum1, %notb128
 410   %hi = lshr i128 %sub1, 64
 411   %sum2 = add i128 %hi, %a128
 412   %sub2 = add i128 %sum2, %notb128
 413   ret i128 %sub2
 414 }