llvm/test/CodeGen/X86/subcarry.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 declare { i8, i64 } @llvm.x86.subborrow.64(i8, i64, i64)
   5 declare { i64, i1 } @llvm.usub.with.overflow.i64(i64, i64)
   6
   7 define i128 @sub128(i128 %a, i128 %b) nounwind {
   8 ; CHECK-LABEL: sub128:
   9 ; CHECK:       # %bb.0: # %entry
  10 ; CHECK-NEXT:    movq %rdi, %rax
  11 ; CHECK-NEXT:    subq %rdx, %rax
  12 ; CHECK-NEXT:    sbbq %rcx, %rsi
  13 ; CHECK-NEXT:    movq %rsi, %rdx
  14 ; CHECK-NEXT:    retq
  15 entry:
  16   %0 = sub i128 %a, %b
  17   ret i128 %0
  18 }
  19
  20 define i256 @sub256(i256 %a, i256 %b) nounwind {
  21 ; CHECK-LABEL: sub256:
  22 ; CHECK:       # %bb.0: # %entry
  23 ; CHECK-NEXT:    movq %rdi, %rax
  24 ; CHECK-NEXT:    subq %r9, %rsi
  25 ; CHECK-NEXT:    sbbq {{[0-9]+}}(%rsp), %rdx
  26 ; CHECK-NEXT:    sbbq {{[0-9]+}}(%rsp), %rcx
  27 ; CHECK-NEXT:    sbbq {{[0-9]+}}(%rsp), %r8
  28 ; CHECK-NEXT:    movq %rdx, 8(%rdi)
  29 ; CHECK-NEXT:    movq %rsi, (%rdi)
  30 ; CHECK-NEXT:    movq %rcx, 16(%rdi)
  31 ; CHECK-NEXT:    movq %r8, 24(%rdi)
  32 ; CHECK-NEXT:    retq
  33 entry:
  34   %0 = sub i256 %a, %b
  35   ret i256 %0
  36 }
  37
  38 %S = type { [4 x i64] }
  39
  40 define %S @negate(%S* nocapture readonly %this) {
  41 ; CHECK-LABEL: negate:
  42 ; CHECK:       # %bb.0: # %entry
  43 ; CHECK-NEXT:    movq %rdi, %rax
  44 ; CHECK-NEXT:    xorl %r8d, %r8d
  45 ; CHECK-NEXT:    xorl %edx, %edx
  46 ; CHECK-NEXT:    subq (%rsi), %rdx
  47 ; CHECK-NEXT:    movl $0, %edi
  48 ; CHECK-NEXT:    sbbq 8(%rsi), %rdi
  49 ; CHECK-NEXT:    movl $0, %ecx
  50 ; CHECK-NEXT:    sbbq 16(%rsi), %rcx
  51 ; CHECK-NEXT:    sbbq 24(%rsi), %r8
  52 ; CHECK-NEXT:    movq %rdx, (%rax)
  53 ; CHECK-NEXT:    movq %rdi, 8(%rax)
  54 ; CHECK-NEXT:    movq %rcx, 16(%rax)
  55 ; CHECK-NEXT:    movq %r8, 24(%rax)
  56 ; CHECK-NEXT:    retq
  57 entry:
  58   %0 = getelementptr inbounds %S, %S* %this, i64 0, i32 0, i64 0
  59   %1 = load i64, i64* %0, align 8
  60   %2 = xor i64 %1, -1
  61   %3 = zext i64 %2 to i128
  62   %4 = add nuw nsw i128 %3, 1
  63   %5 = trunc i128 %4 to i64
  64   %6 = lshr i128 %4, 64
  65   %7 = getelementptr inbounds %S, %S* %this, i64 0, i32 0, i64 1
  66   %8 = load i64, i64* %7, align 8
  67   %9 = xor i64 %8, -1
  68   %10 = zext i64 %9 to i128
  69   %11 = add nuw nsw i128 %6, %10
  70   %12 = trunc i128 %11 to i64
  71   %13 = lshr i128 %11, 64
  72   %14 = getelementptr inbounds %S, %S* %this, i64 0, i32 0, i64 2
  73   %15 = load i64, i64* %14, align 8
  74   %16 = xor i64 %15, -1
  75   %17 = zext i64 %16 to i128
  76   %18 = add nuw nsw i128 %13, %17
  77   %19 = lshr i128 %18, 64
  78   %20 = trunc i128 %18 to i64
  79   %21 = getelementptr inbounds %S, %S* %this, i64 0, i32 0, i64 3
  80   %22 = load i64, i64* %21, align 8
  81   %23 = xor i64 %22, -1
  82   %24 = zext i64 %23 to i128
  83   %25 = add nuw nsw i128 %19, %24
  84   %26 = trunc i128 %25 to i64
  85   %27 = insertvalue [4 x i64] undef, i64 %5, 0
  86   %28 = insertvalue [4 x i64] %27, i64 %12, 1
  87   %29 = insertvalue [4 x i64] %28, i64 %20, 2
  88   %30 = insertvalue [4 x i64] %29, i64 %26, 3
  89   %31 = insertvalue %S undef, [4 x i64] %30, 0
  90   ret %S %31
  91 }
  92
  93 define %S @sub(%S* nocapture readonly %this, %S %arg.b) {
  94 ; CHECK-LABEL: sub:
  95 ; CHECK:       # %bb.0: # %entry
  96 ; CHECK-NEXT:    movq %rdi, %rax
  97 ; CHECK-NEXT:    movq (%rsi), %r10
  98 ; CHECK-NEXT:    movq 8(%rsi), %rdi
  99 ; CHECK-NEXT:    subq %rdx, %r10
 100 ; CHECK-NEXT:    setae %dl
 101 ; CHECK-NEXT:    addb $-1, %dl
 102 ; CHECK-NEXT:    adcq $0, %rdi
 103 ; CHECK-NEXT:    setb %dl
 104 ; CHECK-NEXT:    movzbl %dl, %r11d
 105 ; CHECK-NEXT:    notq %rcx
 106 ; CHECK-NEXT:    addq %rdi, %rcx
 107 ; CHECK-NEXT:    adcq 16(%rsi), %r11
 108 ; CHECK-NEXT:    setb %dl
 109 ; CHECK-NEXT:    movzbl %dl, %edx
 110 ; CHECK-NEXT:    notq %r8
 111 ; CHECK-NEXT:    addq %r11, %r8
 112 ; CHECK-NEXT:    adcq 24(%rsi), %rdx
 113 ; CHECK-NEXT:    notq %r9
 114 ; CHECK-NEXT:    addq %rdx, %r9
 115 ; CHECK-NEXT:    movq %r10, (%rax)
 116 ; CHECK-NEXT:    movq %rcx, 8(%rax)
 117 ; CHECK-NEXT:    movq %r8, 16(%rax)
 118 ; CHECK-NEXT:    movq %r9, 24(%rax)
 119 ; CHECK-NEXT:    retq
 120 entry:
 121   %0 = extractvalue %S %arg.b, 0
 122   %.elt6 = extractvalue [4 x i64] %0, 1
 123   %.elt8 = extractvalue [4 x i64] %0, 2
 124   %.elt10 = extractvalue [4 x i64] %0, 3
 125   %.elt = extractvalue [4 x i64] %0, 0
 126   %1 = getelementptr inbounds %S, %S* %this, i64 0, i32 0, i64 0
 127   %2 = load i64, i64* %1, align 8
 128   %3 = zext i64 %2 to i128
 129   %4 = add nuw nsw i128 %3, 1
 130   %5 = xor i64 %.elt, -1
 131   %6 = zext i64 %5 to i128
 132   %7 = add nuw nsw i128 %4, %6
 133   %8 = trunc i128 %7 to i64
 134   %9 = lshr i128 %7, 64
 135   %10 = getelementptr inbounds %S, %S* %this, i64 0, i32 0, i64 1
 136   %11 = load i64, i64* %10, align 8
 137   %12 = zext i64 %11 to i128
 138   %13 = add nuw nsw i128 %9, %12
 139   %14 = xor i64 %.elt6, -1
 140   %15 = zext i64 %14 to i128
 141   %16 = add nuw nsw i128 %13, %15
 142   %17 = trunc i128 %16 to i64
 143   %18 = lshr i128 %16, 64
 144   %19 = getelementptr inbounds %S, %S* %this, i64 0, i32 0, i64 2
 145   %20 = load i64, i64* %19, align 8
 146   %21 = zext i64 %20 to i128
 147   %22 = add nuw nsw i128 %18, %21
 148   %23 = xor i64 %.elt8, -1
 149   %24 = zext i64 %23 to i128
 150   %25 = add nuw nsw i128 %22, %24
 151   %26 = lshr i128 %25, 64
 152   %27 = trunc i128 %25 to i64
 153   %28 = getelementptr inbounds %S, %S* %this, i64 0, i32 0, i64 3
 154   %29 = load i64, i64* %28, align 8
 155   %30 = zext i64 %29 to i128
 156   %31 = add nuw nsw i128 %26, %30
 157   %32 = xor i64 %.elt10, -1
 158   %33 = zext i64 %32 to i128
 159   %34 = add nuw nsw i128 %31, %33
 160   %35 = trunc i128 %34 to i64
 161   %36 = insertvalue [4 x i64] undef, i64 %8, 0
 162   %37 = insertvalue [4 x i64] %36, i64 %17, 1
 163   %38 = insertvalue [4 x i64] %37, i64 %27, 2
 164   %39 = insertvalue [4 x i64] %38, i64 %35, 3
 165   %40 = insertvalue %S undef, [4 x i64] %39, 0
 166   ret %S %40
 167 }
 168
 169 declare {i64, i1} @llvm.uadd.with.overflow(i64, i64)
 170 declare {i64, i1} @llvm.usub.with.overflow(i64, i64)
 171
 172 define i64 @sub_from_carry(i64 %x, i64 %y, i64* %valout, i64 %z) {
 173 ; CHECK-LABEL: sub_from_carry:
 174 ; CHECK:       # %bb.0:
 175 ; CHECK-NEXT:    movq %rcx, %rax
 176 ; CHECK-NEXT:    negq %rax
 177 ; CHECK-NEXT:    addq %rsi, %rdi
 178 ; CHECK-NEXT:    movq %rdi, (%rdx)
 179 ; CHECK-NEXT:    adcq $0, %rax
 180 ; CHECK-NEXT:    retq
 181   %agg = call {i64, i1} @llvm.uadd.with.overflow(i64 %x, i64 %y)
 182   %val = extractvalue {i64, i1} %agg, 0
 183   %ov = extractvalue {i64, i1} %agg, 1
 184   store i64 %val, i64* %valout, align 4
 185   %carry = zext i1 %ov to i64
 186   %res = sub i64 %carry, %z
 187   ret i64 %res
 188 }
 189
 190 %struct.U320 = type { [5 x i64] }
 191
 192 define i32 @sub_U320_without_i128_or(%struct.U320* nocapture dereferenceable(40) %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5) {
 193 ; CHECK-LABEL: sub_U320_without_i128_or:
 194 ; CHECK:       # %bb.0:
 195 ; CHECK-NEXT:    subq %rsi, (%rdi)
 196 ; CHECK-NEXT:    sbbq %rdx, 8(%rdi)
 197 ; CHECK-NEXT:    sbbq %rcx, 16(%rdi)
 198 ; CHECK-NEXT:    sbbq %r8, 24(%rdi)
 199 ; CHECK-NEXT:    sbbq %r9, 32(%rdi)
 200 ; CHECK-NEXT:    setb %al
 201 ; CHECK-NEXT:    movzbl %al, %eax
 202 ; CHECK-NEXT:    retq
 203   %7 = getelementptr inbounds %struct.U320, %struct.U320* %0, i64 0, i32 0, i64 0
 204   %8 = load i64, i64* %7, align 8
 205   %9 = getelementptr inbounds %struct.U320, %struct.U320* %0, i64 0, i32 0, i64 1
 206   %10 = load i64, i64* %9, align 8
 207   %11 = getelementptr inbounds %struct.U320, %struct.U320* %0, i64 0, i32 0, i64 2
 208   %12 = load i64, i64* %11, align 8
 209   %13 = getelementptr inbounds %struct.U320, %struct.U320* %0, i64 0, i32 0, i64 3
 210   %14 = load i64, i64* %13, align 8
 211   %15 = getelementptr inbounds %struct.U320, %struct.U320* %0, i64 0, i32 0, i64 4
 212   %16 = load i64, i64* %15, align 8
 213   %17 = sub i64 %8, %1
 214   %18 = sub i64 %10, %2
 215   %19 = icmp ult i64 %8, %1
 216   %20 = zext i1 %19 to i64
 217   %21 = sub i64 %18, %20
 218   %22 = sub i64 %12, %3
 219   %23 = icmp ult i64 %10, %2
 220   %24 = icmp ult i64 %18, %20
 221   %25 = or i1 %23, %24
 222   %26 = zext i1 %25 to i64
 223   %27 = sub i64 %22, %26
 224   %28 = sub i64 %14, %4
 225   %29 = icmp ult i64 %12, %3
 226   %30 = icmp ult i64 %22, %26
 227   %31 = or i1 %29, %30
 228   %32 = zext i1 %31 to i64
 229   %33 = sub i64 %28, %32
 230   %34 = sub i64 %16, %5
 231   %35 = icmp ult i64 %14, %4
 232   %36 = icmp ult i64 %28, %32
 233   %37 = or i1 %35, %36
 234   %38 = zext i1 %37 to i64
 235   %39 = sub i64 %34, %38
 236   store i64 %17, i64* %7, align 8
 237   store i64 %21, i64* %9, align 8
 238   store i64 %27, i64* %11, align 8
 239   store i64 %33, i64* %13, align 8
 240   store i64 %39, i64* %15, align 8
 241   %40 = icmp ult i64 %16, %5
 242   %41 = icmp ult i64 %34, %38
 243   %42 = or i1 %40, %41
 244   %43 = zext i1 %42 to i32
 245   ret i32 %43
 246 }
 247
 248 define i32 @sub_U320_usubo(%struct.U320* nocapture dereferenceable(40) %0, i64 %1, i64 %2, i64 %3, i64 %4, i64 %5) {
 249 ; CHECK-LABEL: sub_U320_usubo:
 250 ; CHECK:       # %bb.0:
 251 ; CHECK-NEXT:    subq %rsi, (%rdi)
 252 ; CHECK-NEXT:    sbbq %rdx, 8(%rdi)
 253 ; CHECK-NEXT:    sbbq %rcx, 16(%rdi)
 254 ; CHECK-NEXT:    sbbq %r8, 24(%rdi)
 255 ; CHECK-NEXT:    sbbq %r9, 32(%rdi)
 256 ; CHECK-NEXT:    setb %al
 257 ; CHECK-NEXT:    movzbl %al, %eax
 258 ; CHECK-NEXT:    retq
 259   %7 = getelementptr inbounds %struct.U320, %struct.U320* %0, i64 0, i32 0, i64 0
 260   %8 = load i64, i64* %7, align 8
 261   %9 = getelementptr inbounds %struct.U320, %struct.U320* %0, i64 0, i32 0, i64 1
 262   %10 = load i64, i64* %9, align 8
 263   %11 = getelementptr inbounds %struct.U320, %struct.U320* %0, i64 0, i32 0, i64 2
 264   %12 = load i64, i64* %11, align 8
 265   %13 = getelementptr inbounds %struct.U320, %struct.U320* %0, i64 0, i32 0, i64 3
 266   %14 = load i64, i64* %13, align 8
 267   %15 = getelementptr inbounds %struct.U320, %struct.U320* %0, i64 0, i32 0, i64 4
 268   %16 = load i64, i64* %15, align 8
 269   %17 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %8, i64 %1)
 270   %18 = extractvalue { i64, i1 } %17, 1
 271   %19 = extractvalue { i64, i1 } %17, 0
 272   %20 = zext i1 %18 to i64
 273   %21 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %10, i64 %2)
 274   %22 = extractvalue { i64, i1 } %21, 1
 275   %23 = extractvalue { i64, i1 } %21, 0
 276   %24 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %23, i64 %20)
 277   %25 = extractvalue { i64, i1 } %24, 1
 278   %26 = extractvalue { i64, i1 } %24, 0
 279   %27 = or i1 %22, %25
 280   %28 = zext i1 %27 to i64
 281   %29 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %12, i64 %3)
 282   %30 = extractvalue { i64, i1 } %29, 1
 283   %31 = extractvalue { i64, i1 } %29, 0
 284   %32 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %31, i64 %28)
 285   %33 = extractvalue { i64, i1 } %32, 1
 286   %34 = extractvalue { i64, i1 } %32, 0
 287   %35 = or i1 %30, %33
 288   %36 = zext i1 %35 to i64
 289   %37 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %14, i64 %4)
 290   %38 = extractvalue { i64, i1 } %37, 1
 291   %39 = extractvalue { i64, i1 } %37, 0
 292   %40 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %39, i64 %36)
 293   %41 = extractvalue { i64, i1 } %40, 1
 294   %42 = extractvalue { i64, i1 } %40, 0
 295   %43 = or i1 %38, %41
 296   %44 = zext i1 %43 to i64
 297   %45 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %16, i64 %5)
 298   %46 = extractvalue { i64, i1 } %45, 1
 299   %47 = extractvalue { i64, i1 } %45, 0
 300   %48 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %47, i64 %44)
 301   %49 = extractvalue { i64, i1 } %48, 1
 302   %50 = extractvalue { i64, i1 } %48, 0
 303   %51 = or i1 %46, %49
 304   store i64 %19, i64* %7, align 8
 305   store i64 %26, i64* %9, align 8
 306   store i64 %34, i64* %11, align 8
 307   store i64 %42, i64* %13, align 8
 308   store i64 %50, i64* %15, align 8
 309   %52 = zext i1 %51 to i32
 310   ret i32 %52
 311 }
 312
 313 %struct.U192 = type { [3 x i64] }
 314
 315 define void @PR39464(%struct.U192* noalias nocapture sret(%struct.U192) %0, %struct.U192* nocapture readonly dereferenceable(24) %1, %struct.U192* nocapture readonly dereferenceable(24) %2) {
 316 ; CHECK-LABEL: PR39464:
 317 ; CHECK:       # %bb.0:
 318 ; CHECK-NEXT:    movq %rdi, %rax
 319 ; CHECK-NEXT:    movq (%rsi), %rcx
 320 ; CHECK-NEXT:    subq (%rdx), %rcx
 321 ; CHECK-NEXT:    movq %rcx, (%rdi)
 322 ; CHECK-NEXT:    movq 8(%rsi), %rcx
 323 ; CHECK-NEXT:    sbbq 8(%rdx), %rcx
 324 ; CHECK-NEXT:    movq %rcx, 8(%rdi)
 325 ; CHECK-NEXT:    movq 16(%rsi), %rcx
 326 ; CHECK-NEXT:    sbbq 16(%rdx), %rcx
 327 ; CHECK-NEXT:    movq %rcx, 16(%rdi)
 328 ; CHECK-NEXT:    retq
 329   %4 = getelementptr inbounds %struct.U192, %struct.U192* %1, i64 0, i32 0, i64 0
 330   %5 = load i64, i64* %4, align 8
 331   %6 = getelementptr inbounds %struct.U192, %struct.U192* %2, i64 0, i32 0, i64 0
 332   %7 = load i64, i64* %6, align 8
 333   %8 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %5, i64 %7)
 334   %9 = extractvalue { i64, i1 } %8, 1
 335   %10 = extractvalue { i64, i1 } %8, 0
 336   %11 = zext i1 %9 to i64
 337   %12 = getelementptr inbounds %struct.U192, %struct.U192* %0, i64 0, i32 0, i64 0
 338   store i64 %10, i64* %12, align 8
 339   %13 = getelementptr inbounds %struct.U192, %struct.U192* %1, i64 0, i32 0, i64 1
 340   %14 = load i64, i64* %13, align 8
 341   %15 = getelementptr inbounds %struct.U192, %struct.U192* %2, i64 0, i32 0, i64 1
 342   %16 = load i64, i64* %15, align 8
 343   %17 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %14, i64 %16)
 344   %18 = extractvalue { i64, i1 } %17, 1
 345   %19 = extractvalue { i64, i1 } %17, 0
 346   %20 = tail call { i64, i1 } @llvm.usub.with.overflow.i64(i64 %19, i64 %11)
 347   %21 = extractvalue { i64, i1 } %20, 1
 348   %22 = extractvalue { i64, i1 } %20, 0
 349   %23 = or i1 %18, %21
 350   %24 = zext i1 %23 to i64
 351   %25 = getelementptr inbounds %struct.U192, %struct.U192* %0, i64 0, i32 0, i64 1
 352   store i64 %22, i64* %25, align 8
 353   %26 = getelementptr inbounds %struct.U192, %struct.U192* %1, i64 0, i32 0, i64 2
 354   %27 = load i64, i64* %26, align 8
 355   %28 = getelementptr inbounds %struct.U192, %struct.U192* %2, i64 0, i32 0, i64 2
 356   %29 = load i64, i64* %28, align 8
 357   %30 = sub i64 %27, %29
 358   %31 = sub i64 %30, %24
 359   %32 = getelementptr inbounds %struct.U192, %struct.U192* %0, i64 0, i32 0, i64 2
 360   store i64 %31, i64* %32, align 8
 361   ret void
 362 }
 363
 364 %uint128 = type { i64, i64 }
 365 %uint256 = type { %uint128, %uint128 }
 366
 367 ; The 256-bit subtraction implementation using two inlined usubo procedures for U128 type { i64, i64 }.
 368 ; This is similar to how LLVM legalize types in CodeGen.
 369 define void @sub_U256_without_i128_or_recursive(%uint256* sret(%uint256) %0, %uint256* %1, %uint256* %2) nounwind {
 370 ; CHECK-LABEL: sub_U256_without_i128_or_recursive:
 371 ; CHECK:       # %bb.0:
 372 ; CHECK-NEXT:    movq %rdi, %rax
 373 ; CHECK-NEXT:    movq (%rsi), %r9
 374 ; CHECK-NEXT:    movq 8(%rsi), %r10
 375 ; CHECK-NEXT:    subq (%rdx), %r9
 376 ; CHECK-NEXT:    sbbq 8(%rdx), %r10
 377 ; CHECK-NEXT:    setb %r8b
 378 ; CHECK-NEXT:    movq 16(%rsi), %rcx
 379 ; CHECK-NEXT:    movq 24(%rsi), %rsi
 380 ; CHECK-NEXT:    xorl %edi, %edi
 381 ; CHECK-NEXT:    subq 16(%rdx), %rcx
 382 ; CHECK-NEXT:    setb %dil
 383 ; CHECK-NEXT:    subq 24(%rdx), %rsi
 384 ; CHECK-NEXT:    movzbl %r8b, %edx
 385 ; CHECK-NEXT:    subq %rdx, %rcx
 386 ; CHECK-NEXT:    sbbq %rdi, %rsi
 387 ; CHECK-NEXT:    movq %r9, (%rax)
 388 ; CHECK-NEXT:    movq %r10, 8(%rax)
 389 ; CHECK-NEXT:    movq %rcx, 16(%rax)
 390 ; CHECK-NEXT:    movq %rsi, 24(%rax)
 391 ; CHECK-NEXT:    retq
 392   %4 = getelementptr inbounds %uint256, %uint256* %1, i64 0, i32 0, i32 0
 393   %5 = load i64, i64* %4, align 8
 394   %6 = getelementptr inbounds %uint256, %uint256* %1, i64 0, i32 0, i32 1
 395   %7 = load i64, i64* %6, align 8
 396   %8 = getelementptr inbounds %uint256, %uint256* %2, i64 0, i32 0, i32 0
 397   %9 = load i64, i64* %8, align 8
 398   %10 = getelementptr inbounds %uint256, %uint256* %2, i64 0, i32 0, i32 1
 399   %11 = load i64, i64* %10, align 8
 400   %12 = sub i64 %5, %9
 401   %13 = icmp ult i64 %5, %9
 402   %14 = sub i64 %7, %11
 403   %15 = icmp ult i64 %7, %11
 404   %16 = zext i1 %13 to i64
 405   %17 = sub i64 %14, %16
 406   %18 = icmp ult i64 %14, %16
 407   %19 = or i1 %15, %18
 408   %20 = getelementptr inbounds %uint256, %uint256* %1, i64 0, i32 1, i32 0
 409   %21 = load i64, i64* %20, align 8
 410   %22 = getelementptr inbounds %uint256, %uint256* %1, i64 0, i32 1, i32 1
 411   %23 = load i64, i64* %22, align 8
 412   %24 = getelementptr inbounds %uint256, %uint256* %2, i64 0, i32 1, i32 0
 413   %25 = load i64, i64* %24, align 8
 414   %26 = getelementptr inbounds %uint256, %uint256* %2, i64 0, i32 1, i32 1
 415   %27 = load i64, i64* %26, align 8
 416   %28 = sub i64 %21, %25
 417   %29 = icmp ult i64 %21, %25
 418   %30 = sub i64 %23, %27
 419   %31 = zext i1 %29 to i64
 420   %32 = sub i64 %30, %31
 421   %33 = zext i1 %19 to i64
 422   %34 = sub i64 %28, %33
 423   %35 = icmp ult i64 %28, %33
 424   %36 = zext i1 %35 to i64
 425   %37 = sub i64 %32, %36
 426   %38 = getelementptr inbounds %uint256, %uint256* %0, i64 0, i32 0, i32 0
 427   store i64 %12, i64* %38, align 8
 428   %39 = getelementptr inbounds %uint256, %uint256* %0, i64 0, i32 0, i32 1
 429   store i64 %17, i64* %39, align 8
 430   %40 = getelementptr inbounds %uint256, %uint256* %0, i64 0, i32 1, i32 0
 431   store i64 %34, i64* %40, align 8
 432   %41 = getelementptr inbounds %uint256, %uint256* %0, i64 0, i32 1, i32 1
 433   store i64 %37, i64* %41, align 8
 434   ret void
 435 }