jit_typeinfo::jit_typeinfo *** entering
jit_typeinfo::jit_typeinfo *** leaving
-------------------- Compiling tree --------------------
for i = 1:nr
  if (i > 500)
    result = mat (100);
  else
    result = i;
  endif
endfor
-------------------- octave jit ir --------------------
body0:        %pred = 
        any: result#18 = extract result
        matrix: mat#14 = extract mat
        #unknown_function: i#6 = extract i
        range: #for_bounds0#0 = extract #for_bounds0
        index: #1 = call for_init (range: #for_bounds0#0)
        index: #iter0#2 = index: #1
        bool: #3 = call for_check (range: #for_bounds0#0, index: #iter0#2)
        cond_branch: bool: #3, [live] for_body3, [live] phi_split12
phi_split12:        %pred = body0
        any: #63 = call (any) (#unknown_function: i#6)
        any: i#64 = any: #63
        branch: [live] for_tail13
for_body3:        %pred = body0, phi_split2
        any: result#51 phi | body0 -> any: result#18
                           | phi_split2 -> any: result#58
        matrix: mat#48 phi | body0 -> matrix: mat#14
                           | phi_split2 -> matrix: mat#48
        index: #iter0#39 phi | body0 -> index: #iter0#2
                             | phi_split2 -> index: #iter0#26
        range: #for_bounds0#36 phi | body0 -> range: #for_bounds0#0
                                   | phi_split2 -> range: #for_bounds0#36
        scalar: #5 = call for_index (range: #for_bounds0#36, index: #iter0#39)
        scalar: i#7 = scalar: #5
        scalar: #8 = call  (scalar: i#7)
        bool: #9 = call binary> (scalar: #8, scalar: 500)
        branch: [live] for_body4
for_body4:        %pred = for_body3
        bool: #11 = call logically_true (bool: #9)
        branch: [live] for_body5
for_body5:        %pred = for_body4
        cond_branch: bool: #11, [live] if_body6, [live] else8
if_body6:        %pred = for_body5
        matrix: #15 = call  (matrix: mat#48)
        scalar: #16 = call  (matrix: #15, scalar: 100)
        call release (matrix: #15)
        error_check error_state, <for> scalar: #16, <normal> [live] if_body7, <error> [live] phi_split15
phi_split15:        %pred = if_body6
        any: #71 = call (any) (scalar: i#7)
        any: i#72 = any: #71
        branch: [live] final16
if_body7:        %pred = if_body6
        scalar: result#19 = scalar: #16
        branch: [live] if_tail9
else8:        %pred = for_body5
        scalar: #21 = call  (scalar: i#7)
        scalar: result#22 = scalar: #21
        branch: [live] if_tail9
if_tail9:        %pred = if_body7, else8
        scalar: result#49 phi | if_body7 -> scalar: result#19
                              | else8 -> scalar: result#22
        branch: [live] for_check10
for_check10:        %pred = if_tail9
        index: #25 = call binary+ (index: #iter0#39, index: 1)
        index: #iter0#26 = index: #25
        bool: #27 = call for_check (range: #for_bounds0#36, index: #iter0#26)
        cond_branch: bool: #27, [live] for_interrupt1, [live] phi_split11
phi_split11:        %pred = for_check10
        any: #60 = call (any) (scalar: result#49)
        any: result#61 = any: #60
        any: #65 = call (any) (scalar: i#7)
        any: i#66 = any: #65
        branch: [live] for_tail13
for_interrupt1:        %pred = for_check10
        error_check interrupt, <normal> [live] phi_split2, <error> [live] phi_split14
phi_split14:        %pred = for_interrupt1
        any: #68 = call (any) (scalar: result#49)
        any: result#69 = any: #68
        any: #73 = call (any) (scalar: i#7)
        any: i#74 = any: #73
        branch: [live] final16
phi_split2:        %pred = for_interrupt1
        any: #57 = call (any) (scalar: result#49)
        any: result#58 = any: #57
        branch: [live] for_body3
for_tail13:        %pred = phi_split11, phi_split12
        any: result#50 phi | phi_split12 -> any: result#18
                           | phi_split11 -> any: result#61
        matrix: mat#47 phi | phi_split12 -> matrix: mat#14
                           | phi_split11 -> matrix: mat#48
        any: i#42 phi | phi_split12 -> any: i#64
                      | phi_split11 -> any: i#66
        index: #iter0#38 phi | phi_split12 -> index: #iter0#2
                             | phi_split11 -> index: #iter0#26
        range: #for_bounds0#35 phi | phi_split12 -> range: #for_bounds0#0
                                   | phi_split11 -> range: #for_bounds0#36
        branch: [live] final16
final16:        %pred = for_tail13, phi_split14, phi_split15
        any: result#52 phi | phi_split15 -> any: result#51
                           | phi_split14 -> any: result#69
                           | for_tail13 -> any: result#50
        matrix: mat#46 phi | phi_split15 -> matrix: mat#48
                           | phi_split14 -> matrix: mat#48
                           | for_tail13 -> matrix: mat#47
        any: i#44 phi | phi_split15 -> any: i#72
                      | phi_split14 -> any: i#74
                      | for_tail13 -> any: i#42
        index: #iter0#40 phi | phi_split15 -> index: #iter0#39
                             | phi_split14 -> index: #iter0#26
                             | for_tail13 -> index: #iter0#38
        range: #for_bounds0#37 phi | phi_split15 -> range: #for_bounds0#36
                                   | phi_split14 -> range: #for_bounds0#36
                                   | for_tail13 -> range: #for_bounds0#35
        store i = any: i#44
        store mat = matrix: mat#46
        store result = any: result#52
        return

-------------------- llvm ir --------------------
define void @foobar(%octave_base_value**) {
prelude:
  %1 = alloca %matrix
  %2 = alloca %matrix
  %3 = alloca %matrix
  %4 = alloca %matrix
  %5 = alloca %range
  %6 = alloca %matrix
  %7 = getelementptr inbounds %octave_base_value** %0, i32 0
  %8 = getelementptr inbounds %octave_base_value** %0, i32 1
  %9 = getelementptr inbounds %octave_base_value** %0, i32 2
  %10 = getelementptr inbounds %octave_base_value** %0, i32 3
  br label %body

body:                                             ; preds = %prelude
  %11 = load %octave_base_value** %7
  %12 = call %octave_base_value* @id_any(%octave_base_value* %11)
  %13 = load %octave_base_value** %8
  call void @octave_jit_cast_matrix_any(%matrix* sret %6, %octave_base_value* %13)
  %14 = load %matrix* %6
  %15 = load %octave_base_value** %9
  %16 = call %octave_base_value* @id_any(%octave_base_value* %15)
  %17 = load %octave_base_value** %10
  call void @octave_jit_cast_range_any(%range* sret %5, %octave_base_value* %17)
  %18 = load %range* %5
  %19 = call i32 @octave_jit_for_range_init(%range %18)
  %20 = call i1 @octave_jit_for_range_check(%range %18, i32 %19)
  br i1 %20, label %for_body, label %phi_split

phi_split:                                        ; preds = %body
  %21 = call %octave_base_value* @id_any(%octave_base_value* %16)
  br label %for_tail

for_body:                                         ; preds = %phi_split7, %body
  %22 = phi %octave_base_value* [ %12, %body ], [ %44, %phi_split7 ]
  %23 = phi %matrix [ %14, %body ], [ %23, %phi_split7 ]
  %24 = phi i32 [ %19, %body ], [ %36, %phi_split7 ]
  %25 = phi %range [ %18, %body ], [ %25, %phi_split7 ]
  %26 = call double @octave_jit_for_range_idx(%range %25, i32 %24)
  %27 = call double @id_scalar(double %26)
  %28 = call i1 @"octave_jit>_scalar"(double %27, double 5.000000e+02)
  br label %for_body1

for_body1:                                        ; preds = %for_body
  %29 = call i1 @id_bool(i1 %28)
  br label %for_body2

for_body2:                                        ; preds = %for_body1
  br i1 %29, label %if_body, label %else

if_body:                                          ; preds = %for_body2
  store %matrix %23, %matrix* %4
  call void @octave_jit_grab_matrix(%matrix* sret %3, %matrix* %4)
  %30 = load %matrix* %3
  %31 = call double @"()subsref"(%matrix %30, double 1.000000e+02)
  store %matrix %30, %matrix* %2
  call void @octave_jit_release_matrix(%matrix* %2)
  %32 = load i1* @error_state
  br i1 %32, label %phi_split3, label %if_body4

phi_split3:                                       ; preds = %if_body
  %33 = call %octave_base_value* @octave_jit_cast_any_scalar(double %26)
  br label %final

if_body4:                                         ; preds = %if_body
  call void @octave_jit_release_any(%octave_base_value* %22)
  br label %if_tail

else:                                             ; preds = %for_body2
  %34 = call double @id_scalar(double %26)
  call void @octave_jit_release_any(%octave_base_value* %22)
  br label %if_tail

if_tail:                                          ; preds = %else, %if_body4
  %35 = phi double [ %31, %if_body4 ], [ %34, %else ]
  br label %for_check

for_check:                                        ; preds = %if_tail
  %36 = call i32 @"octave_jit_+_index"(i32 %24, i32 1)
  %37 = call i1 @octave_jit_for_range_check(%range %25, i32 %36)
  br i1 %37, label %for_interrupt, label %phi_split5

phi_split5:                                       ; preds = %for_check
  %38 = call %octave_base_value* @octave_jit_cast_any_scalar(double %35)
  %39 = call %octave_base_value* @octave_jit_cast_any_scalar(double %26)
  br label %for_tail

for_interrupt:                                    ; preds = %for_check
  %40 = load volatile i32* @octave_interrupt_state
  %41 = icmp sgt i32 %40, 0
  br i1 %41, label %phi_split6, label %phi_split7

phi_split6:                                       ; preds = %for_interrupt
  %42 = call %octave_base_value* @octave_jit_cast_any_scalar(double %35)
  %43 = call %octave_base_value* @octave_jit_cast_any_scalar(double %26)
  br label %final

phi_split7:                                       ; preds = %for_interrupt
  %44 = call %octave_base_value* @octave_jit_cast_any_scalar(double %35)
  br label %for_body

for_tail:                                         ; preds = %phi_split5, %phi_split
  %45 = phi %octave_base_value* [ %12, %phi_split ], [ %38, %phi_split5 ]
  %46 = phi %matrix [ %14, %phi_split ], [ %23, %phi_split5 ]
  %47 = phi %octave_base_value* [ %21, %phi_split ], [ %39, %phi_split5 ]
  %48 = phi i32 [ %19, %phi_split ], [ %36, %phi_split5 ]
  %49 = phi %range [ %18, %phi_split ], [ %25, %phi_split5 ]
  br label %final

final:                                            ; preds = %for_tail, %phi_split6, %phi_split3
  %50 = phi %octave_base_value* [ %22, %phi_split3 ], [ %42, %phi_split6 ], [ %45, %for_tail ]
  %51 = phi %matrix [ %23, %phi_split3 ], [ %23, %phi_split6 ], [ %46, %for_tail ]
  %52 = phi %octave_base_value* [ %33, %phi_split3 ], [ %43, %phi_split6 ], [ %47, %for_tail ]
  %53 = phi i32 [ %24, %phi_split3 ], [ %36, %phi_split6 ], [ %48, %for_tail ]
  %54 = phi %range [ %25, %phi_split3 ], [ %25, %phi_split6 ], [ %49, %for_tail ]
  %55 = call %octave_base_value* @id_any(%octave_base_value* %52)
  store %octave_base_value* %55, %octave_base_value** %9
  store %matrix %51, %matrix* %1
  %56 = call %octave_base_value* @octave_jit_cast_any_matrix(%matrix* %1)
  store %octave_base_value* %56, %octave_base_value** %8
  %57 = call %octave_base_value* @id_any(%octave_base_value* %50)
  store %octave_base_value* %57, %octave_base_value** %7
  ret void
}

-------------------- optimized llvm ir --------------------

define void @foobar(%octave_base_value**) {
prelude:
  %1 = alloca %matrix, align 8
  %2 = alloca %matrix, align 8
  %3 = alloca %matrix, align 8
  %4 = alloca %matrix, align 8
  %5 = alloca %range, align 8
  %6 = alloca %matrix, align 8
  %7 = getelementptr inbounds %octave_base_value** %0, i64 1
  %8 = getelementptr inbounds %octave_base_value** %0, i64 2
  %9 = getelementptr inbounds %octave_base_value** %0, i64 3
  %10 = load %octave_base_value** %0, align 8
  %11 = load %octave_base_value** %7, align 8
  call void @octave_jit_cast_matrix_any(%matrix* sret %6, %octave_base_value* %11)
  %12 = load %matrix* %6, align 8
  %13 = load %octave_base_value** %8, align 8
  %14 = load %octave_base_value** %9, align 8
  call void @octave_jit_cast_range_any(%range* sret %5, %octave_base_value* %14)
  %15 = load %range* %5, align 8
  %16 = extractvalue %range %15, 3
  %17 = icmp eq i32 %16, 0
  br i1 %17, label %final, label %for_body

for_body:                                         ; preds = %prelude, %for_interrupt
  %18 = phi %octave_base_value* [ %10, %prelude ], [ %42, %for_interrupt ]
  %19 = phi i32 [ 0, %prelude ], [ %36, %for_interrupt ]
  %20 = sitofp i32 %19 to double
  %21 = extractvalue %range %15, 0
  %22 = extractvalue %range %15, 2
  %23 = fmul double %22, %20
  %24 = fadd double %21, %23
  %25 = fcmp ugt double %24, 5.000000e+02
  br i1 %25, label %if_body, label %else

if_body:                                          ; preds = %for_body
  store %matrix %12, %matrix* %4, align 8
  call void @octave_jit_grab_matrix(%matrix* sret %3, %matrix* %4)
  %26 = load %matrix* %3, align 8
  %27 = extractvalue %matrix %26, 2
  %28 = icmp slt i32 %27, 100
  br i1 %28, label %bounds_error.i, label %success.i

bounds_error.i:                                   ; preds = %if_body
  call void @octave_jit_gindex_range(i32 1, i32 1, i32 100, i32 %27)
  br label %"()subsref.exit"

success.i:                                        ; preds = %if_body
  %29 = extractvalue %matrix %26, 1
  %30 = getelementptr inbounds double* %29, i64 100
  %31 = load double* %30, align 8
  br label %"()subsref.exit"

"()subsref.exit":                                 ; preds = %bounds_error.i, %success.i
  %32 = phi double [ undef, %bounds_error.i ], [ %31, %success.i ]
  store %matrix %26, %matrix* %2, align 8
  call void @octave_jit_release_matrix(%matrix* %2)
  %33 = load i1* @error_state, align 1
  br i1 %33, label %phi_split3, label %if_body4

phi_split3:                                       ; preds = %"()subsref.exit"
  %34 = call %octave_base_value* @octave_jit_cast_any_scalar(double %24)
  br label %final

if_body4:                                         ; preds = %"()subsref.exit"
  call void @octave_jit_release_any(%octave_base_value* %18)
  br label %for_check

else:                                             ; preds = %for_body
  call void @octave_jit_release_any(%octave_base_value* %18)
  br label %for_check

for_check:                                        ; preds = %if_body4, %else
  %35 = phi double [ %32, %if_body4 ], [ %24, %else ]
  %36 = add i32 %19, 1
  %37 = icmp ult i32 %36, %16
  br i1 %37, label %for_interrupt, label %phi_split5

phi_split5:                                       ; preds = %for_check
  %38 = call %octave_base_value* @octave_jit_cast_any_scalar(double %35)
  %39 = call %octave_base_value* @octave_jit_cast_any_scalar(double %24)
  br label %final

for_interrupt:                                    ; preds = %for_check
  %40 = load volatile i32* @octave_interrupt_state, align 4
  %41 = icmp sgt i32 %40, 0
  %42 = call %octave_base_value* @octave_jit_cast_any_scalar(double %35)
  br i1 %41, label %phi_split6, label %for_body

phi_split6:                                       ; preds = %for_interrupt
  %43 = call %octave_base_value* @octave_jit_cast_any_scalar(double %24)
  br label %final

final:                                            ; preds = %prelude, %phi_split5, %phi_split6, %phi_split3
  %44 = phi %octave_base_value* [ %18, %phi_split3 ], [ %42, %phi_split6 ], [ %38, %phi_split5 ], [ %10, %prelude ]
  %45 = phi %octave_base_value* [ %34, %phi_split3 ], [ %43, %phi_split6 ], [ %39, %phi_split5 ], [ %13, %prelude ]
  store %octave_base_value* %45, %octave_base_value** %8, align 8
  store %matrix %12, %matrix* %1, align 8
  %46 = call %octave_base_value* @octave_jit_cast_any_matrix(%matrix* %1)
  store %octave_base_value* %46, %octave_base_value** %7, align 8
  store %octave_base_value* %44, %octave_base_value** %0, align 8
  ret void
}

terminate called after throwing an instance of 'octave::out_of_range'