API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 18th, 2018
176
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
LLVM 17.61 KB | None | 0 0
raw download clone embed print report
  1. ; ModuleID = 'AP_PlusPlus'
  2. source_filename = "AP_PlusPlus"
  3.  
  4. @fmt = private unnamed_addr constant [4 x i8] c"%d\0A\00"
  5. @fmt.1 = private unnamed_addr constant [4 x i8] c"%g\0A\00"
  6. @fmt.2 = private unnamed_addr constant [4 x i8] c"%s\0A\00"
  7.  
  8. declare i32 @printf(i8*, ...)
  9.  
  10. define i1 @list_getbool({ i32, i1* }*, i32) {
  11. entry:
  12.   %list_ptr_alloc = alloca { i32, i1* }*
  13.   store { i32, i1* }* %0, { i32, i1* }** %list_ptr_alloc
  14.   %idx_alloc = alloca i32
  15.   store i32 %1, i32* %idx_alloc
  16.   %list_load = load { i32, i1* }*, { i32, i1* }** %list_ptr_alloc
  17.   %list_array_ptr = getelementptr inbounds { i32, i1* }, { i32, i1* }* %list_load, i32 0, i32 1
  18.   %array_load = load i1*, i1** %list_array_ptr
  19.   %idx_load = load i32, i32* %idx_alloc
  20.   %list_arry_element_ptr = getelementptr i1, i1* %array_load, i32 %idx_load
  21.   %list_array_element_ptr = load i1, i1* %list_arry_element_ptr
  22.   ret i1 %list_array_element_ptr
  23. }
  24.  
  25. define i32 @list_getint({ i32, i32* }*, i32) {
  26. entry:
  27.   %list_ptr_alloc = alloca { i32, i32* }*
  28.   store { i32, i32* }* %0, { i32, i32* }** %list_ptr_alloc
  29.   %idx_alloc = alloca i32
  30.   store i32 %1, i32* %idx_alloc
  31.   %list_load = load { i32, i32* }*, { i32, i32* }** %list_ptr_alloc
  32.   %list_array_ptr = getelementptr inbounds { i32, i32* }, { i32, i32* }* %list_load, i32 0, i32 1
  33.   %array_load = load i32*, i32** %list_array_ptr
  34.   %idx_load = load i32, i32* %idx_alloc
  35.   %list_arry_element_ptr = getelementptr i32, i32* %array_load, i32 %idx_load
  36.   %list_array_element_ptr = load i32, i32* %list_arry_element_ptr
  37.   ret i32 %list_array_element_ptr
  38. }
  39.  
  40. define double @list_getfloat({ i32, double* }*, i32) {
  41. entry:
  42.   %list_ptr_alloc = alloca { i32, double* }*
  43.   store { i32, double* }* %0, { i32, double* }** %list_ptr_alloc
  44.   %idx_alloc = alloca i32
  45.   store i32 %1, i32* %idx_alloc
  46.   %list_load = load { i32, double* }*, { i32, double* }** %list_ptr_alloc
  47.   %list_array_ptr = getelementptr inbounds { i32, double* }, { i32, double* }* %list_load, i32 0, i32 1
  48.   %array_load = load double*, double** %list_array_ptr
  49.   %idx_load = load i32, i32* %idx_alloc
  50.   %list_arry_element_ptr = getelementptr double, double* %array_load, i32 %idx_load
  51.   %list_array_element_ptr = load double, double* %list_arry_element_ptr
  52.   ret double %list_array_element_ptr
  53. }
  54.  
  55. define void @list_setbool({ i32, i1* }*, i32, i1) {
  56. entry:
  57.   %list_ptr_alloc = alloca { i32, i1* }*
  58.   store { i32, i1* }* %0, { i32, i1* }** %list_ptr_alloc
  59.   %list_load = load { i32, i1* }*, { i32, i1* }** %list_ptr_alloc
  60.   %list_array_ptr = getelementptr inbounds { i32, i1* }, { i32, i1* }* %list_load, i32 0, i32 1
  61.   %list_array_load = load i1*, i1** %list_array_ptr
  62.   %list_arry_next_element_ptr = getelementptr i1, i1* %list_array_load, i32 %1
  63.   store i1 %2, i1* %list_arry_next_element_ptr
  64.   ret void
  65. }
  66.  
  67. define void @list_setint({ i32, i32* }*, i32, i32) {
  68. entry:
  69.   %list_ptr_alloc = alloca { i32, i32* }*
  70.   store { i32, i32* }* %0, { i32, i32* }** %list_ptr_alloc
  71.   %list_load = load { i32, i32* }*, { i32, i32* }** %list_ptr_alloc
  72.   %list_array_ptr = getelementptr inbounds { i32, i32* }, { i32, i32* }* %list_load, i32 0, i32 1
  73.   %list_array_load = load i32*, i32** %list_array_ptr
  74.   %list_arry_next_element_ptr = getelementptr i32, i32* %list_array_load, i32 %1
  75.   store i32 %2, i32* %list_arry_next_element_ptr
  76.   ret void
  77. }
  78.  
  79. define void @list_setfloat({ i32, double* }*, i32, double) {
  80. entry:
  81.   %list_ptr_alloc = alloca { i32, double* }*
  82.   store { i32, double* }* %0, { i32, double* }** %list_ptr_alloc
  83.   %list_load = load { i32, double* }*, { i32, double* }** %list_ptr_alloc
  84.   %list_array_ptr = getelementptr inbounds { i32, double* }, { i32, double* }* %list_load, i32 0, i32 1
  85.   %list_array_load = load double*, double** %list_array_ptr
  86.   %list_arry_next_element_ptr = getelementptr double, double* %list_array_load, i32 %1
  87.   store double %2, double* %list_arry_next_element_ptr
  88.   ret void
  89. }
  90.  
  91. define void @list_pushbool({ i32, i1* }*, i1) {
  92. entry:
  93.   %list_ptr_alloc = alloca { i32, i1* }*
  94.   store { i32, i1* }* %0, { i32, i1* }** %list_ptr_alloc
  95.   %val_alloc = alloca i1
  96.   store i1 %1, i1* %val_alloc
  97.   %list_load = load { i32, i1* }*, { i32, i1* }** %list_ptr_alloc
  98.   %list_array_ptr = getelementptr inbounds { i32, i1* }, { i32, i1* }* %list_load, i32 0, i32 1
  99.   %list_array_load = load i1*, i1** %list_array_ptr
  100.   %list_size = getelementptr inbounds { i32, i1* }, { i32, i1* }* %list_load, i32 0, i32 0
  101.   %list_size1 = load i32, i32* %list_size
  102.   %list_arry_next_element_ptr = getelementptr i1, i1* %list_array_load, i32 %list_size1
  103.   %inc_size = add i32 %list_size1, 1
  104.   store i32 %inc_size, i32* %list_size
  105.   %val = load i1, i1* %val_alloc
  106.   store i1 %val, i1* %list_arry_next_element_ptr
  107.   ret void
  108. }
  109.  
  110. define void @list_pushint({ i32, i32* }*, i32) {
  111. entry:
  112.   %list_ptr_alloc = alloca { i32, i32* }*
  113.   store { i32, i32* }* %0, { i32, i32* }** %list_ptr_alloc
  114.   %val_alloc = alloca i32
  115.   store i32 %1, i32* %val_alloc
  116.   %list_load = load { i32, i32* }*, { i32, i32* }** %list_ptr_alloc
  117.   %list_array_ptr = getelementptr inbounds { i32, i32* }, { i32, i32* }* %list_load, i32 0, i32 1
  118.   %list_array_load = load i32*, i32** %list_array_ptr
  119.   %list_size = getelementptr inbounds { i32, i32* }, { i32, i32* }* %list_load, i32 0, i32 0
  120.   %list_size1 = load i32, i32* %list_size
  121.   %list_arry_next_element_ptr = getelementptr i32, i32* %list_array_load, i32 %list_size1
  122.   %inc_size = add i32 %list_size1, 1
  123.   store i32 %inc_size, i32* %list_size
  124.   %val = load i32, i32* %val_alloc
  125.   store i32 %val, i32* %list_arry_next_element_ptr
  126.   ret void
  127. }
  128.  
  129. define void @list_pushfloat({ i32, double* }*, double) {
  130. entry:
  131.   %list_ptr_alloc = alloca { i32, double* }*
  132.   store { i32, double* }* %0, { i32, double* }** %list_ptr_alloc
  133.   %val_alloc = alloca double
  134.   store double %1, double* %val_alloc
  135.   %list_load = load { i32, double* }*, { i32, double* }** %list_ptr_alloc
  136.   %list_array_ptr = getelementptr inbounds { i32, double* }, { i32, double* }* %list_load, i32 0, i32 1
  137.   %list_array_load = load double*, double** %list_array_ptr
  138.   %list_size = getelementptr inbounds { i32, double* }, { i32, double* }* %list_load, i32 0, i32 0
  139.   %list_size1 = load i32, i32* %list_size
  140.   %list_arry_next_element_ptr = getelementptr double, double* %list_array_load, i32 %list_size1
  141.   %inc_size = add i32 %list_size1, 1
  142.   store i32 %inc_size, i32* %list_size
  143.   %val = load double, double* %val_alloc
  144.   store double %val, double* %list_arry_next_element_ptr
  145.   ret void
  146. }
  147.  
  148. define i1 @list_popbool({ i32, i1* }*) {
  149. entry:
  150.   %list_ptr_alloc = alloca { i32, i1* }*
  151.   store { i32, i1* }* %0, { i32, i1* }** %list_ptr_alloc
  152.   %list_load = load { i32, i1* }*, { i32, i1* }** %list_ptr_alloc
  153.   %list_array_ptr = getelementptr inbounds { i32, i1* }, { i32, i1* }* %list_load, i32 0, i32 1
  154.   %list_array_load = load i1*, i1** %list_array_ptr
  155.   %list_size_ptr = getelementptr inbounds { i32, i1* }, { i32, i1* }* %list_load, i32 0, i32 0
  156.   %list_size = load i32, i32* %list_size_ptr
  157.   %dec_size = sub i32 %list_size, 1
  158.   %list_arry_next_element_ptr = getelementptr i1, i1* %list_array_load, i32 %dec_size
  159.   %list_arry_next_element = load i1, i1* %list_arry_next_element_ptr
  160.   store i32 %dec_size, i32* %list_size_ptr
  161.   ret i1 %list_arry_next_element
  162. }
  163.  
  164. define i32 @list_popint({ i32, i32* }*) {
  165. entry:
  166.   %list_ptr_alloc = alloca { i32, i32* }*
  167.   store { i32, i32* }* %0, { i32, i32* }** %list_ptr_alloc
  168.   %list_load = load { i32, i32* }*, { i32, i32* }** %list_ptr_alloc
  169.   %list_array_ptr = getelementptr inbounds { i32, i32* }, { i32, i32* }* %list_load, i32 0, i32 1
  170.   %list_array_load = load i32*, i32** %list_array_ptr
  171.   %list_size_ptr = getelementptr inbounds { i32, i32* }, { i32, i32* }* %list_load, i32 0, i32 0
  172.   %list_size = load i32, i32* %list_size_ptr
  173.   %dec_size = sub i32 %list_size, 1
  174.   %list_arry_next_element_ptr = getelementptr i32, i32* %list_array_load, i32 %dec_size
  175.   %list_arry_next_element = load i32, i32* %list_arry_next_element_ptr
  176.   store i32 %dec_size, i32* %list_size_ptr
  177.   ret i32 %list_arry_next_element
  178. }
  179.  
  180. define double @list_popfloat({ i32, double* }*) {
  181. entry:
  182.   %list_ptr_alloc = alloca { i32, double* }*
  183.   store { i32, double* }* %0, { i32, double* }** %list_ptr_alloc
  184.   %list_load = load { i32, double* }*, { i32, double* }** %list_ptr_alloc
  185.   %list_array_ptr = getelementptr inbounds { i32, double* }, { i32, double* }* %list_load, i32 0, i32 1
  186.   %list_array_load = load double*, double** %list_array_ptr
  187.   %list_size_ptr = getelementptr inbounds { i32, double* }, { i32, double* }* %list_load, i32 0, i32 0
  188.   %list_size = load i32, i32* %list_size_ptr
  189.   %dec_size = sub i32 %list_size, 1
  190.   %list_arry_next_element_ptr = getelementptr double, double* %list_array_load, i32 %dec_size
  191.   %list_arry_next_element = load double, double* %list_arry_next_element_ptr
  192.   store i32 %dec_size, i32* %list_size_ptr
  193.   ret double %list_arry_next_element
  194. }
  195.  
  196. define i32 @list_sizebool({ i32, i1* }*) {
  197. entry:
  198.   %list_ptr_alloc = alloca { i32, i1* }*
  199.   store { i32, i1* }* %0, { i32, i1* }** %list_ptr_alloc
  200.   %list_load = load { i32, i1* }*, { i32, i1* }** %list_ptr_alloc
  201.   %list_size = getelementptr inbounds { i32, i1* }, { i32, i1* }* %list_load, i32 0, i32 0
  202.   %list_size1 = load i32, i32* %list_size
  203.   ret i32 %list_size1
  204. }
  205.  
  206. define i32 @list_sizeint({ i32, i32* }*) {
  207. entry:
  208.   %list_ptr_alloc = alloca { i32, i32* }*
  209.   store { i32, i32* }* %0, { i32, i32* }** %list_ptr_alloc
  210.   %list_load = load { i32, i32* }*, { i32, i32* }** %list_ptr_alloc
  211.   %list_size = getelementptr inbounds { i32, i32* }, { i32, i32* }* %list_load, i32 0, i32 0
  212.   %list_size1 = load i32, i32* %list_size
  213.   ret i32 %list_size1
  214. }
  215.  
  216. define i32 @list_sizefloat({ i32, double* }*) {
  217. entry:
  218.   %list_ptr_alloc = alloca { i32, double* }*
  219.   store { i32, double* }* %0, { i32, double* }** %list_ptr_alloc
  220.   %list_load = load { i32, double* }*, { i32, double* }** %list_ptr_alloc
  221.   %list_size = getelementptr inbounds { i32, double* }, { i32, double* }* %list_load, i32 0, i32 0
  222.   %list_size1 = load i32, i32* %list_size
  223.   ret i32 %list_size1
  224. }
  225.  
  226. define void @list_slicebool({ i32, i1* }*, { i32, i1* }*, i32, i32) {
  227. entry:
  228.   %list_ptr_alloc = alloca { i32, i1* }*
  229.   store { i32, i1* }* %0, { i32, i1* }** %list_ptr_alloc
  230.   %list_ptr_ptr = load { i32, i1* }*, { i32, i1* }** %list_ptr_alloc
  231.   %list_ptr_alloc2 = alloca { i32, i1* }*
  232.   store { i32, i1* }* %1, { i32, i1* }** %list_ptr_alloc2
  233.   %list_ptr_ptr2 = load { i32, i1* }*, { i32, i1* }** %list_ptr_alloc2
  234.   %idx_alloc = alloca i32
  235.   store i32 %2, i32* %idx_alloc
  236.   %idx_load = load i32, i32* %idx_alloc
  237.   %idx_alloc1 = alloca i32
  238.   store i32 %3, i32* %idx_alloc1
  239.   %idx_load2 = load i32, i32* %idx_alloc1
  240.   %loop_cnt = alloca i32
  241.   store i32 0, i32* %loop_cnt
  242.   %loop_upper_bound = sub i32 %idx_load2, %idx_load
  243.   br label %while
  244.  
  245. while:                                            ; preds = %while_body, %entry
  246.   %loop_cnt4 = load i32, i32* %loop_cnt
  247.   %loop_cond = icmp sle i32 %loop_cnt4, %loop_upper_bound
  248.   br i1 %loop_cond, label %while_body, label %merge
  249.  
  250. while_body:                                       ; preds = %while
  251.   %to_idx = load i32, i32* %loop_cnt
  252.   %from_idx = add i32 %to_idx, %idx_load
  253.   %list_get = call i1 @list_getbool({ i32, i1* }* %list_ptr_ptr, i32 %from_idx)
  254.   call void @list_setbool({ i32, i1* }* %list_ptr_ptr2, i32 %to_idx, i1 %list_get)
  255.   %loop_cnt3 = load i32, i32* %loop_cnt
  256.   %loop_itr = add i32 %loop_cnt3, 1
  257.   store i32 %loop_itr, i32* %loop_cnt
  258.   br label %while
  259.  
  260. merge:                                            ; preds = %while
  261.   ret void
  262. }
  263.  
  264. define void @list_sliceint({ i32, i32* }*, { i32, i32* }*, i32, i32) {
  265. entry:
  266.   %list_ptr_alloc = alloca { i32, i32* }*
  267.   store { i32, i32* }* %0, { i32, i32* }** %list_ptr_alloc
  268.   %list_ptr_ptr = load { i32, i32* }*, { i32, i32* }** %list_ptr_alloc
  269.   %list_ptr_alloc2 = alloca { i32, i32* }*
  270.   store { i32, i32* }* %1, { i32, i32* }** %list_ptr_alloc2
  271.   %list_ptr_ptr2 = load { i32, i32* }*, { i32, i32* }** %list_ptr_alloc2
  272.   %idx_alloc = alloca i32
  273.   store i32 %2, i32* %idx_alloc
  274.   %idx_load = load i32, i32* %idx_alloc
  275.   %idx_alloc1 = alloca i32
  276.   store i32 %3, i32* %idx_alloc1
  277.   %idx_load2 = load i32, i32* %idx_alloc1
  278.   %loop_cnt = alloca i32
  279.   store i32 0, i32* %loop_cnt
  280.   %loop_upper_bound = sub i32 %idx_load2, %idx_load
  281.   br label %while
  282.  
  283. while:                                            ; preds = %while_body, %entry
  284.   %loop_cnt4 = load i32, i32* %loop_cnt
  285.   %loop_cond = icmp sle i32 %loop_cnt4, %loop_upper_bound
  286.   br i1 %loop_cond, label %while_body, label %merge
  287.  
  288. while_body:                                       ; preds = %while
  289.   %to_idx = load i32, i32* %loop_cnt
  290.   %from_idx = add i32 %to_idx, %idx_load
  291.   %list_get = call i32 @list_getint({ i32, i32* }* %list_ptr_ptr, i32 %from_idx)
  292.   call void @list_setint({ i32, i32* }* %list_ptr_ptr2, i32 %to_idx, i32 %list_get)
  293.   %loop_cnt3 = load i32, i32* %loop_cnt
  294.   %loop_itr = add i32 %loop_cnt3, 1
  295.   store i32 %loop_itr, i32* %loop_cnt
  296.   br label %while
  297.  
  298. merge:                                            ; preds = %while
  299.   ret void
  300. }
  301.  
  302. define void @list_slicefloat({ i32, double* }*, { i32, double* }*, i32, i32) {
  303. entry:
  304.   %list_ptr_alloc = alloca { i32, double* }*
  305.   store { i32, double* }* %0, { i32, double* }** %list_ptr_alloc
  306.   %list_ptr_ptr = load { i32, double* }*, { i32, double* }** %list_ptr_alloc
  307.   %list_ptr_alloc2 = alloca { i32, double* }*
  308.   store { i32, double* }* %1, { i32, double* }** %list_ptr_alloc2
  309.   %list_ptr_ptr2 = load { i32, double* }*, { i32, double* }** %list_ptr_alloc2
  310.   %idx_alloc = alloca i32
  311.   store i32 %2, i32* %idx_alloc
  312.   %idx_load = load i32, i32* %idx_alloc
  313.   %idx_alloc1 = alloca i32
  314.   store i32 %3, i32* %idx_alloc1
  315.   %idx_load2 = load i32, i32* %idx_alloc1
  316.   %loop_cnt = alloca i32
  317.   store i32 0, i32* %loop_cnt
  318.   %loop_upper_bound = sub i32 %idx_load2, %idx_load
  319.   br label %while
  320.  
  321. while:                                            ; preds = %while_body, %entry
  322.   %loop_cnt4 = load i32, i32* %loop_cnt
  323.   %loop_cond = icmp sle i32 %loop_cnt4, %loop_upper_bound
  324.   br i1 %loop_cond, label %while_body, label %merge
  325.  
  326. while_body:                                       ; preds = %while
  327.   %to_idx = load i32, i32* %loop_cnt
  328.   %from_idx = add i32 %to_idx, %idx_load
  329.   %list_get = call double @list_getfloat({ i32, double* }* %list_ptr_ptr, i32 %from_idx)
  330.   call void @list_setfloat({ i32, double* }* %list_ptr_ptr2, i32 %to_idx, double %list_get)
  331.   %loop_cnt3 = load i32, i32* %loop_cnt
  332.   %loop_itr = add i32 %loop_cnt3, 1
  333.   store i32 %loop_itr, i32* %loop_cnt
  334.   br label %while
  335.  
  336. merge:                                            ; preds = %while
  337.   ret void
  338. }
  339.  
  340. define i32 @main() {
  341. entry:
  342.   %a = alloca { i32, i32* }
  343.   %list.size = getelementptr inbounds { i32, i32* }, { i32, i32* }* %a, i32 0, i32 0
  344.   store i32 0, i32* %list.size
  345.   %list.arry = getelementptr inbounds { i32, i32* }, { i32, i32* }* %a, i32 0, i32 1
  346.   %p = alloca i32, i32 1000
  347.   store i32* %p, i32** %list.arry
  348.   %b = alloca { i32, i32* }
  349.   %list.size1 = getelementptr inbounds { i32, i32* }, { i32, i32* }* %b, i32 0, i32 0
  350.   store i32 0, i32* %list.size1
  351.   %list.arry2 = getelementptr inbounds { i32, i32* }, { i32, i32* }* %b, i32 0, i32 1
  352.   %p3 = alloca i32, i32 1000
  353.   store i32* %p3, i32** %list.arry2
  354.   %c = alloca { i32, i32* }
  355.   %list.size4 = getelementptr inbounds { i32, i32* }, { i32, i32* }* %c, i32 0, i32 0
  356.   store i32 0, i32* %list.size4
  357.   %list.arry5 = getelementptr inbounds { i32, i32* }, { i32, i32* }* %c, i32 0, i32 1
  358.   %p6 = alloca i32, i32 1000
  359.   store i32* %p6, i32** %list.arry5
  360.   %i = alloca i32
  361.   %a7 = load { i32, i32* }, { i32, i32* }* %a
  362.   store { i32, i32* } %a7, { i32, i32* }* %c
  363.   store i32 0, i32* %i
  364.   br label %while
  365.  
  366. while:                                            ; preds = %while_body, %entry
  367.   %i10 = load i32, i32* %i
  368.   %tmp11 = icmp slt i32 %i10, 5
  369.   br i1 %tmp11, label %while_body, label %merge
  370.  
  371. while_body:                                       ; preds = %while
  372.   %i8 = load i32, i32* %i
  373.   call void @list_pushint({ i32, i32* }* %a, i32 %i8)
  374.   %i9 = load i32, i32* %i
  375.   %tmp = add i32 %i9, 1
  376.   store i32 %tmp, i32* %i
  377.   br label %while
  378.  
  379. merge:                                            ; preds = %while
  380.   %a12 = load { i32, i32* }, { i32, i32* }* %a
  381.   store { i32, i32* } %a12, { i32, i32* }* %b
  382.   %list_get = call i32 @list_getint({ i32, i32* }* %b, i32 0)
  383.   %printf = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @fmt, i32 0, i32 0), i32 %list_get)
  384.   %list_size = call i32 @list_sizeint({ i32, i32* }* %b)
  385.   %printf13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @fmt, i32 0, i32 0), i32 %list_size)
  386.   call void @list_pushint({ i32, i32* }* %b, i32 100)
  387.   %list_size14 = call i32 @list_sizeint({ i32, i32* }* %b)
  388.   %printf15 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @fmt, i32 0, i32 0), i32 %list_size14)
  389.   %list_size16 = call i32 @list_sizeint({ i32, i32* }* %b)
  390.   %tmp17 = sub i32 %list_size16, 1
  391.   %list_get18 = call i32 @list_getint({ i32, i32* }* %b, i32 %tmp17)
  392.   %printf19 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @fmt, i32 0, i32 0), i32 %list_get18)
  393.   call void @list_pushint({ i32, i32* }* %c, i32 101)
  394.   %list_size20 = call i32 @list_sizeint({ i32, i32* }* %c)
  395.   %printf21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @fmt, i32 0, i32 0), i32 %list_size20)
  396.   %list_size22 = call i32 @list_sizeint({ i32, i32* }* %c)
  397.   %tmp23 = sub i32 %list_size22, 1
  398.   %list_get24 = call i32 @list_getint({ i32, i32* }* %c, i32 %tmp23)
  399.   %printf25 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @fmt, i32 0, i32 0), i32 %list_get24)
  400.   ret i32 0
  401. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!