diff --git a/README.md b/README.md index 546fa07..7b02e3a 100644 --- a/README.md +++ b/README.md @@ -1,188 +1,18 @@ -# LIP (LLVM IR to Predicate) +drawing -## Project Structure +## Overview +Wyvern Graph (or **Wy-Graph**) is a python tool for translating LLVM IR into a knowledge graph. Wy-Graph takes an [LLVM IR](https://llvm.org/docs/LangRef.html) file as input and performs standard static analyses (Syntactic, Control-Flow, Data-Flow, and Memory). It encodes these analyses results in a list of unary and binary formal predicates with the intention of building data sets that convey knowledge graph equivalents of LLVM IR programs. The goal is for these data sets to be utilized to apply [Neuro-symbolic AI](https://en.wikipedia.org/wiki/Neuro-symbolic_AI) (Specifically differentiable Inductive Logic Programming AI) to program analysis. -The project will follow a structure derived from compiler design. -We aim to take LLVM IR input, and lex, parse, analyze, and generate resulting facts that capture the structure of the program and potentially important characteristics for understanding the structure of the program as well as potential vulnerability detection. +## Table of Contents +1. [Getting Started](docs/getting_started.md) +2. [Features](docs/features.md) +3. [Demo](docs/demo.md) +4. [Future Development](docs/future_dev.md) -### Dependencies +## Acknowledgments -1. **LLVMLite**: A lightweight LLVM-Python binding for writing JIT compilers. This package will allow us to lex and parse LLVM IR code into a tree structure. This tree structure, however, is a little too *lightweight* for our desires. It carries too much information on nodes and becomes too unfocused in an attempt to be extremely generalized. We will parse this structure into a more *fit* abstract syntax tree (AST) that we can make better use of. +This project was developed by [Christian Scaff](https://github.com/cscaff) at the Georgia Tech Research Institute's Advanced Research in Computing and Artificial Intelligence Division [(**ARCAID**)](https://www.gtri.gatech.edu/focus-areas/advanced-research-computing-and-artificial-intelligence) under the guidance of [Clayton Kerce](https://github.com/ckerce) in the summer of 2025. -2. **NetworkX**: A python package for creation, manipulation, and study of networks. We will use this to model the control flow of our program through a directed graph. - - -### Implementation - -The project will be implemented as such: - -1. LLVM IR --> Lexed/Parsed by LLVMLite --> Module Tree -2. Module Tree --> Parser --> AST -3. AST --> Analyzer --> Decorated AST -4. Decorated AST --> Generator --> Predicate Logic - -### Predicate Logic Result - -The goal of our predicate language is to formally express key characteristics of a program through solely unary and binary predicates. Effectively, we break down a program into properties and their relationships. - -### Control Flow - -1. *control_flow(X)* | {**X** = instruction}. -2. *entry(X)* | {**X** = entry block}. -3. *exit(X)* | {**X** = exit block}. -4. *has_successor(X, Y)* | {block **X** has a directed edge to block **Y**}. -5. *has_predecessor(X, Y)* | {block **Y** has a directed edge to block **X**}. -6. *dominates(X, Y)* | {block **X** dominates block **Y**}. -7. *post_dominates(X, Y)* | {block **X** post dominates block **Y**}. -8. *loop(X)* | {**X** is a loop}. -9. *loop_head(X, Y)* | {loop **X** has loop header block **Y**}. -10. *in_loop(X, Y)* | {block **X** resides in loop **Y**}. -11. *down_flow(X, Y)* | {block **X** flows down to block **Y**}. -12. *up_flow(X, Y)* | {block **X** flows back up to block **Y**}. -13. *originates_from(X, Y)* | {block **X** is called in block **Y**}. -14. *control_dependent(X, Y)* | {inst. **X** depends on the result of inst. **Y**}. -15. *exception_flow(X, Y)* | {try block **X** may throw an exception to catch block **Y**}. - -### Data Flow - -#### Reaching Definition Analysis - -1. *reaches(X, Y)* | {definition **X** reaches block **Y**}. -2. *defines(X, Y)* | {inst. **X** defines value **Y**}. -3. *uses(X, Y)* | {inst. **X** uses value **Y**}. -4. *kills(X, Y)* | {inst. **X** kills value **Y**}. -5. *data_dependent(X, Y)* | {inst. **X** depends on data from inst. **Y**}. - -#### Live Variable Analysis - -1. *live_in(X, Y)* | {variable **X** is live entering block **Y**}. -2. *live_out(X, Y)* | {variable **X** is live leaving block **Y**}. - -#### Definite Assignment Analysis - -1. *definitely_assigned(X)* | {variable **X** is definitely assigned}. -2. *definitely_unassigned(X)* | {variable **X** is definitely unassigned}. -3. *unknown_assignment(X)* | {variable **X** assignment status is unknown}. - -### Memory - -1. *allocates(X, Y)* | {inst. **X** allocates type width **Y**}. -2. *loads(X, Y)* | {inst. **X** loads value **Y** into virtual register}. -3. *stores_value(X, Y)* | {inst. **X** stores value **Y**}. -4. *stores_at(X, Y)* | {inst. **X** stores value at memory location **Y**}. -5. *local_variable(X)* | {**X** = local variable} -6. *has_atomic_ordering(X, Y)* | {inst. **X** has ordering **Y**}. - - -#### Pointers - -##### Andersen Style - -1. *points_to(X, Y)* | {pointer **X** may point to value **Y**}. (Core Rule) - - *assigns(X,Y)* | {pointer **X** is assigned to value of pointer **Y**}. - - *address_of(X, Y)* | {object **Y** is stored at address **X**}. - -##### Alias Style - -1. *may_alias(X, Y)* | {pointer **X** might alias pointer **Y**}. -2. *must_alias(X, Y)* | {pointer **X** must alias pointer **Y**}. - -### Syntactic - -#### Module - -1. *module(X)* | {**X** = module}. -2. *data_layout(X)* | {**X** = data layout for given module}. -3. *target_triple(X)* | {**X** = target triple for given module}. - -#### Global Variables - -1. *global_variable(X)* | {**X** = global variable}. -2. *constant(X)* | {**X** = constant variable}. -3. *has_initializer(X, Y)* | {variable **X** has initial value **Y**}. - - Denotes initializer or declaration. -4. *has_linkage(X, Y)* | {variable **X** has linkage **Y**}. -5. *has_storage_class(X, Y)* | {variable **X** has storage class **Y**}. - - Y = default, dll_import, dll_export, weak, private... -6. *has_type(X, Y)* | {variable **X** has type **Y**}. -7. *has_visibility(X, Y)* | {variable **X** has visibility **Y**}. - - Y = default, hidden, protected... -8. *has_attribute(X, Y)* | {variable **X** has attribute **Y**}. - -#### Functions - -1. *function(X)* | {**X** = function}. -2. *has_argument(X, Y)* | {function **X** has argument **Y**}. - - *has_attribute(X, Y)* | {argument **X** has attribute **Y**}. - - *has_type(X, Y)* | {argument **X** has type **Y**}. - - *constant(X)* | {**X** = constant argument}. - - *has_linkage(X, Y)* | {argument **X** has linkage **Y**}. -3. *has_attribute(X, Y)* | {function **X** has attribute **Y**}. -4. *has_type(X, Y)* | {function **X** has type **Y**}. -5. *constant(X)* | {**X** = constant function}. -6. *declaration(X)* | {**X** = function declaration}. -7. *has_linkage(X, Y)* | {function **X** has linkage **Y**}. -8. *has_visibility(X, Y)* | {function **X** has visibility **Y**}. - -#### Blocks - -1. *block(X)* | {**X** = basic block}. -2. *has_linkage(X, Y)* | {block **X** has linkage **Y**}. - -#### Instructions - -1. *instruction(X)* | {**X** = instruction}. -2. *instruction_opcode(X, Y)* | {inst. **X** has opcode **Y**}. -3. *instruction_operand(X, Y)* | {inst. **X** has operand **Y**}. -4. *has_type(X, Y)* | {inst. **X** is of type **Y**} -5. *has_attribute(X, Y)* | {inst. **X** has attribute **Y**}. -6. *has_linkage(X, Y)* | {inst. **X** has linkage **Y**}. -7. *const(X)* | {**X** = constant instruction}. - -##### Specifics - -1. *binary_operation(X)* | {**X** = instruction}. -2. *unary_operation(X)* | {**X** = instruction}. -3. *terminator(X)* | {**X** = instruction}. -4. *select_instruction(X)* | {**X** = instruction}. - - *select_operand(X, Y)* | {inst. **X** has operand **Y**}. -5. *invoke_instruction(X)* | {**X** = instruction}. - - *invokes(X, Y)* | {function **X** invokes function **Y**}. - - *invoke_normal(X, Y)* | {inst. **X** has normal location **Y**}. - - *invoke_unwind(X, Y)* | {inst. **X** has unwind location **Y**}. - - *landing_pad(X)* | {**X** = instruction}. - - *catches(X, Y)* | {landing pad **X** catches exception type **Y**}. - - *Filters(X, Y)* | {landing pad **X** filters exception type **Y**}. -6. *call_instruction(X)* | {**X** = instruction}. - - *calls(X, Y)* | {function **X** calls function **Y**}. -7. *aggregate_operation(X)* | {**X** = instruction}. - - *extract_val_instruction(X)* | {**X** = instruction}. - - *extract_val_agg(X, Y)* | {inst. **X** extracts agg **Y**}. - - *extract_val_index(X, Y)* | {inst. **X** extracts from index **Y**}. - - *insert_val_instruction(X)* | {**X** = instruction}. - - *insert_val_agg(X, Y)* | {inst. **X** inserts to agg **Y**}. - - *insert_val_index(X, Y)* | {inst. **X** inserts val **Y**}. -8. *vector_operation(X)* | {**X** = instruction}. - - *extract_val_instruction(X)* | {**X** = instruction}. - - *extract_element(X, Y)* | {inst. **X** extracts element **Y**}. - - *extract_val_index(X, Y)* | {inst. **X** extracts from index **Y**}. - - *insert_val_instruction(X)* | {**X** = instruction}. - - *insert_element(X, Y)* | {inst. **X** inserts element **Y**}. - - *insert_val_index(X, Y)* | {inst. **X** inserts val **Y**}. -9. *memory_access(X)* | {**X** = instruction}. - - get_element_ptr_operation(X)* | {**X** = instruction}. - - *get_element_ptr_base(X, Y)* | {inst. **X** has base index **Y**}. - - *get_element_ptr_index(X, Y)* | {inst. **X** has index **Y**}. - - *get_element_ptr_val(X, Y)* | {inst. **X** points to value **Y**}. -10. *conversion_operation(X)* | {**X** = instruction}. -11. *phi_node(X)* | {**X** = instruction}. - - *phi_operand(X, Y)* | {inst. **X** has operand **Y**}. - - *phi_incoming(X, Y)* | {inst. **X** has incoming block **Y**}. *Might need to change*! -12. *returns(X, Y)* | {inst. **X** returns value **Y**}. -13. *throws(X, Y)* | {inst. **X** throws exception **Y**}. -14. *has_metadata(X, Y)* | {object **X** has metadata **Y**}. -15. *metadata_value(X, Y)* | {metadata **X** has value **Y**}. -16. *constant_expression(X)* | {**X** = instruction}. -17. *constant_expression_opcode(X, Y)* | {inst. **X** has opcode **Y**}. - - Denotes operation that only uses constants. - - Maybe useful for constant propagation? \ No newline at end of file +The project was made possible with: +- The LLVM Project ([https://llvm.org](https://llvm.org)) +- LLVMLite Library ([https://github.com/numba/llvmlite](https://github.com/numba/llvmlite)) \ No newline at end of file diff --git a/docs/demo.md b/docs/demo.md new file mode 100644 index 0000000..f921e84 --- /dev/null +++ b/docs/demo.md @@ -0,0 +1,63 @@ +# Demo +Let's try it out and see what this program is capable of! + +You can find a collection of examples in `test/examples/input`. Most of these examples derive from [SV-Benchmarks](https://gitlab.com/sosy-lab/benchmarking/sv-benchmarks) which provides a solid collection of verification tasks. + +While, ironically, the dynamic nature of threads may not be the most suitable demo, we will look at an example of a data race within a C file as it illustrates a real application on a small file. + +Let's dive into [pthread-demo-datarace-2.ll](/test/examples/input/pthread-demo-datarace-2.ll)! + +## Running the Program +Let's run the command with our input file! +![demo](./demo/demo.gif) + +## Looking at our Predicates +We can view the predicate results [here](./demo/predicates.txt)! + +An excerpt: +``` +entry(reach_error_block_0) +exit(reach_error_virtual_exit) +has_successor(reach_error_block_0, reach_error_virtual_exit) +has_predecessor(reach_error_virtual_exit, reach_error_block_0) +dominates(reach_error_block_0, reach_error_virtual_exit) +post_dominates(reach_error_virtual_exit, reach_error_block_0) +``` +This illustrates some of our control flow for a specific function, `reach_error`, which has only one block. We can view that IR here: +``` +define void @reach_error() #0 { + call void @__assert_rtn(i8* noundef getelementptr inbounds ([12 x i8], [12 x i8]* @__func__.reach_error, i64 0, i64 0), i8* noundef getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i32 noundef 25, i8* noundef getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0)) #4 + unreachable +} +``` +We notice that we make a function call here to `@__assert_rtn`. However, this is an external call so we do not pick up on any control flow information regarding that. + +## Looking at our Graph + +### Uploading +We can upload our graph to [Gephi Lite](https://gephi.org/gephi-lite/) as shown: +![demo](./demo/uploading_graph.gif) + +### Displaying +That's a little messy though, no? We can clean it up by clicking on the layout tab on the left menu bar and applying a display algorithm. + ![demo](./demo/displayalgo.jpeg) +*Pretty!* + +### Filtering +What if we want to explore specific graph properties or relationships? + +We can accomplish this by going to the Filters tab. + +#### Filtering By Analysis Category +We can select category to filter by analysis types. + ![demo](./demo/filtering_category.gif) + +### Filtering By Binary Predicates +We can select predicates to filter specific edge types. + ![demo](./demo/filter_preds.png) + +### Filtering By Unary Predicates +We can select node types to filter specific node properties. Do note, the current filtering system needs a little work. + ![demo](./demo/filter_nodes.png) + +For more sophisticated graph exploration, you can use the full [Gephi](https://gephi.org) software. \ No newline at end of file diff --git a/docs/demo/demo.gif b/docs/demo/demo.gif new file mode 100644 index 0000000..519c61e Binary files /dev/null and b/docs/demo/demo.gif differ diff --git a/docs/demo/displayalgo.jpeg b/docs/demo/displayalgo.jpeg new file mode 100644 index 0000000..5aed264 Binary files /dev/null and b/docs/demo/displayalgo.jpeg differ diff --git a/docs/demo/filter_nodes.png b/docs/demo/filter_nodes.png new file mode 100644 index 0000000..b938f3c Binary files /dev/null and b/docs/demo/filter_nodes.png differ diff --git a/docs/demo/filter_preds.png b/docs/demo/filter_preds.png new file mode 100644 index 0000000..b33864f Binary files /dev/null and b/docs/demo/filter_preds.png differ diff --git a/docs/demo/filtering_category.gif b/docs/demo/filtering_category.gif new file mode 100644 index 0000000..2354807 Binary files /dev/null and b/docs/demo/filtering_category.gif differ diff --git a/docs/demo/predicates.txt b/docs/demo/predicates.txt new file mode 100644 index 0000000..a85069b --- /dev/null +++ b/docs/demo/predicates.txt @@ -0,0 +1,2124 @@ +entry(reach_error_block_0) +exit(reach_error_virtual_exit) +has_successor(reach_error_block_0, reach_error_virtual_exit) +has_predecessor(reach_error_virtual_exit, reach_error_block_0) +dominates(reach_error_block_0, reach_error_virtual_exit) +post_dominates(reach_error_virtual_exit, reach_error_block_0) +entry(__assert_rtn_virtual_exit) +exit(__assert_rtn_virtual_exit) +entry(__VERIFIER_assert_block_0) +exit(__VERIFIER_assert_virtual_exit) +has_successor(__VERIFIER_assert_block_0, __VERIFIER_assert_block_3) +has_predecessor(__VERIFIER_assert_block_3, __VERIFIER_assert_block_0) +has_successor(__VERIFIER_assert_block_0, __VERIFIER_assert_block_1) +has_predecessor(__VERIFIER_assert_block_1, __VERIFIER_assert_block_0) +has_successor(__VERIFIER_assert_block_1, __VERIFIER_assert_block_2) +has_predecessor(__VERIFIER_assert_block_2, __VERIFIER_assert_block_1) +has_successor(__VERIFIER_assert_block_2, __VERIFIER_assert_virtual_exit) +has_predecessor(__VERIFIER_assert_virtual_exit, __VERIFIER_assert_block_2) +has_successor(__VERIFIER_assert_block_3, __VERIFIER_assert_virtual_exit) +has_predecessor(__VERIFIER_assert_virtual_exit, __VERIFIER_assert_block_3) +dominates(__VERIFIER_assert_block_0, __VERIFIER_assert_block_1) +dominates(__VERIFIER_assert_block_0, __VERIFIER_assert_block_2) +dominates(__VERIFIER_assert_block_0, __VERIFIER_assert_block_3) +dominates(__VERIFIER_assert_block_0, __VERIFIER_assert_virtual_exit) +dominates(__VERIFIER_assert_block_1, __VERIFIER_assert_block_2) +post_dominates(__VERIFIER_assert_block_2, __VERIFIER_assert_block_1) +post_dominates(__VERIFIER_assert_virtual_exit, __VERIFIER_assert_block_0) +post_dominates(__VERIFIER_assert_virtual_exit, __VERIFIER_assert_block_2) +post_dominates(__VERIFIER_assert_virtual_exit, __VERIFIER_assert_block_1) +post_dominates(__VERIFIER_assert_virtual_exit, __VERIFIER_assert_block_3) +entry(abort_virtual_exit) +exit(abort_virtual_exit) +entry(thread_function_datarace_block_0) +exit(thread_function_datarace_virtual_exit) +has_successor(thread_function_datarace_block_0, thread_function_datarace_block_1) +has_predecessor(thread_function_datarace_block_1, thread_function_datarace_block_0) +has_successor(thread_function_datarace_block_1, thread_function_datarace_block_2) +has_predecessor(thread_function_datarace_block_2, thread_function_datarace_block_1) +has_successor(thread_function_datarace_block_1, thread_function_datarace_block_4) +has_predecessor(thread_function_datarace_block_4, thread_function_datarace_block_1) +has_successor(thread_function_datarace_block_2, thread_function_datarace_block_3) +has_predecessor(thread_function_datarace_block_3, thread_function_datarace_block_2) +has_successor(thread_function_datarace_block_3, thread_function_datarace_block_1) +has_predecessor(thread_function_datarace_block_1, thread_function_datarace_block_3) +has_successor(thread_function_datarace_block_4, thread_function_datarace_virtual_exit) +has_predecessor(thread_function_datarace_virtual_exit, thread_function_datarace_block_4) +dominates(thread_function_datarace_block_0, thread_function_datarace_block_1) +dominates(thread_function_datarace_block_0, thread_function_datarace_block_2) +dominates(thread_function_datarace_block_0, thread_function_datarace_block_3) +dominates(thread_function_datarace_block_0, thread_function_datarace_block_4) +dominates(thread_function_datarace_block_0, thread_function_datarace_virtual_exit) +dominates(thread_function_datarace_block_1, thread_function_datarace_block_2) +dominates(thread_function_datarace_block_1, thread_function_datarace_block_3) +dominates(thread_function_datarace_block_1, thread_function_datarace_block_4) +dominates(thread_function_datarace_block_1, thread_function_datarace_virtual_exit) +dominates(thread_function_datarace_block_2, thread_function_datarace_block_3) +dominates(thread_function_datarace_block_4, thread_function_datarace_virtual_exit) +post_dominates(thread_function_datarace_block_1, thread_function_datarace_block_0) +post_dominates(thread_function_datarace_block_1, thread_function_datarace_block_3) +post_dominates(thread_function_datarace_block_1, thread_function_datarace_block_2) +post_dominates(thread_function_datarace_block_3, thread_function_datarace_block_2) +post_dominates(thread_function_datarace_block_4, thread_function_datarace_block_1) +post_dominates(thread_function_datarace_block_4, thread_function_datarace_block_0) +post_dominates(thread_function_datarace_block_4, thread_function_datarace_block_3) +post_dominates(thread_function_datarace_block_4, thread_function_datarace_block_2) +post_dominates(thread_function_datarace_virtual_exit, thread_function_datarace_block_4) +post_dominates(thread_function_datarace_virtual_exit, thread_function_datarace_block_1) +post_dominates(thread_function_datarace_virtual_exit, thread_function_datarace_block_0) +post_dominates(thread_function_datarace_virtual_exit, thread_function_datarace_block_3) +post_dominates(thread_function_datarace_virtual_exit, thread_function_datarace_block_2) +loop(thread_function_datarace_loop_0) +loop_header(thread_function_datarace_loop_0, thread_function_datarace_block_1) +in_loop(thread_function_datarace_block_1, thread_function_datarace_loop_0) +in_loop(thread_function_datarace_block_2, thread_function_datarace_loop_0) +in_loop(thread_function_datarace_block_3, thread_function_datarace_loop_0) +entry(printf_virtual_exit) +exit(printf_virtual_exit) +entry(main_block_0) +exit(main_virtual_exit) +has_successor(main_block_0, main_block_1) +has_predecessor(main_block_1, main_block_0) +has_successor(main_block_0, main_block_2) +has_predecessor(main_block_2, main_block_0) +has_successor(main_block_2, main_block_3) +has_predecessor(main_block_3, main_block_2) +has_successor(main_block_3, main_block_4) +has_predecessor(main_block_4, main_block_3) +has_successor(main_block_3, main_block_6) +has_predecessor(main_block_6, main_block_3) +has_successor(main_block_4, main_block_5) +has_predecessor(main_block_5, main_block_4) +has_successor(main_block_5, main_block_3) +has_predecessor(main_block_3, main_block_5) +has_successor(main_block_6, main_block_7) +has_predecessor(main_block_7, main_block_6) +has_successor(main_block_6, main_block_8) +has_predecessor(main_block_8, main_block_6) +has_successor(main_block_1, main_virtual_exit) +has_predecessor(main_virtual_exit, main_block_1) +has_successor(main_block_7, main_virtual_exit) +has_predecessor(main_virtual_exit, main_block_7) +has_successor(main_block_8, main_virtual_exit) +has_predecessor(main_virtual_exit, main_block_8) +dominates(main_block_0, main_block_1) +dominates(main_block_0, main_block_2) +dominates(main_block_0, main_block_3) +dominates(main_block_0, main_block_4) +dominates(main_block_0, main_block_5) +dominates(main_block_0, main_block_6) +dominates(main_block_0, main_block_7) +dominates(main_block_0, main_block_8) +dominates(main_block_0, main_virtual_exit) +dominates(main_block_2, main_block_3) +dominates(main_block_2, main_block_4) +dominates(main_block_2, main_block_5) +dominates(main_block_2, main_block_6) +dominates(main_block_2, main_block_7) +dominates(main_block_2, main_block_8) +dominates(main_block_3, main_block_4) +dominates(main_block_3, main_block_5) +dominates(main_block_3, main_block_6) +dominates(main_block_3, main_block_7) +dominates(main_block_3, main_block_8) +dominates(main_block_4, main_block_5) +dominates(main_block_6, main_block_7) +dominates(main_block_6, main_block_8) +post_dominates(main_block_3, main_block_2) +post_dominates(main_block_3, main_block_5) +post_dominates(main_block_3, main_block_4) +post_dominates(main_block_5, main_block_4) +post_dominates(main_block_6, main_block_3) +post_dominates(main_block_6, main_block_2) +post_dominates(main_block_6, main_block_5) +post_dominates(main_block_6, main_block_4) +post_dominates(main_virtual_exit, main_block_0) +post_dominates(main_virtual_exit, main_block_1) +post_dominates(main_virtual_exit, main_block_6) +post_dominates(main_virtual_exit, main_block_3) +post_dominates(main_virtual_exit, main_block_2) +post_dominates(main_virtual_exit, main_block_5) +post_dominates(main_virtual_exit, main_block_4) +post_dominates(main_virtual_exit, main_block_7) +post_dominates(main_virtual_exit, main_block_8) +loop(main_loop_0) +loop_header(main_loop_0, main_block_3) +in_loop(main_block_3, main_loop_0) +in_loop(main_block_4, main_loop_0) +in_loop(main_block_5, main_loop_0) +entry(pthread_create_virtual_exit) +exit(pthread_create_virtual_exit) +entry(exit_virtual_exit) +exit(exit_virtual_exit) +entry(_pthread_join_virtual_exit) +exit(_pthread_join_virtual_exit) +originates_from(__assert_rtn_virtual_exit, reach_error_block_0) +returns_from(reach_error_block_0, __assert_rtn_virtual_exit) +originates_from(reach_error_block_0, __VERIFIER_assert_block_2) +returns_from(__VERIFIER_assert_block_2, reach_error_virtual_exit) +originates_from(abort_virtual_exit, __VERIFIER_assert_block_2) +returns_from(__VERIFIER_assert_block_2, abort_virtual_exit) +originates_from(printf_virtual_exit, thread_function_datarace_block_2) +returns_from(thread_function_datarace_block_2, printf_virtual_exit) +originates_from(pthread_create_virtual_exit, main_block_0) +returns_from(main_block_0, pthread_create_virtual_exit) +originates_from(exit_virtual_exit, main_block_1) +returns_from(main_block_1, exit_virtual_exit) +originates_from(printf_virtual_exit, main_block_2) +returns_from(main_block_2, printf_virtual_exit) +originates_from(printf_virtual_exit, main_block_2) +returns_from(main_block_2, printf_virtual_exit) +originates_from(printf_virtual_exit, main_block_2) +returns_from(main_block_2, printf_virtual_exit) +originates_from(printf_virtual_exit, main_block_2) +returns_from(main_block_2, printf_virtual_exit) +originates_from(printf_virtual_exit, main_block_2) +returns_from(main_block_2, printf_virtual_exit) +originates_from(printf_virtual_exit, main_block_2) +returns_from(main_block_2, printf_virtual_exit) +originates_from(_pthread_join_virtual_exit, main_block_6) +returns_from(main_block_6, _pthread_join_virtual_exit) +originates_from(exit_virtual_exit, main_block_7) +returns_from(main_block_7, exit_virtual_exit) +originates_from(__VERIFIER_assert_block_0, main_block_8) +returns_from(main_block_8, __VERIFIER_assert_virtual_exit) +originates_from(printf_virtual_exit, main_block_8) +returns_from(main_block_8, printf_virtual_exit) +originates_from(printf_virtual_exit, main_block_8) +returns_from(main_block_8, printf_virtual_exit) +originates_from(exit_virtual_exit, main_block_8) +returns_from(main_block_8, exit_virtual_exit) +defines_register(reach_error_instr_0, reach_error_None) +defines_register(__VERIFIER_assert_instr_0, __VERIFIER_assert_%2) +defines_register(__VERIFIER_assert_instr_2, __VERIFIER_assert_%3) +defines_register(__VERIFIER_assert_instr_3, __VERIFIER_assert_%4) +defines_register(__VERIFIER_assert_instr_6, __VERIFIER_assert_None) +defines_register(__VERIFIER_assert_instr_7, __VERIFIER_assert_None) +uses(__VERIFIER_assert_instr_1, __VERIFIER_assert_%2) +uses(__VERIFIER_assert_instr_1, __VERIFIER_assert_arg_0) +uses(__VERIFIER_assert_instr_2, __VERIFIER_assert_%2) +uses(__VERIFIER_assert_instr_3, __VERIFIER_assert_%3) +uses(__VERIFIER_assert_instr_4, __VERIFIER_assert_%4) +reaches(__VERIFIER_assert_instr_1, __VERIFIER_assert_block_1) +reaches(__VERIFIER_assert_instr_1, __VERIFIER_assert_block_2) +reaches(__VERIFIER_assert_instr_1, __VERIFIER_assert_block_3) +definitely_assigned(__VERIFIER_assert_%2) +definitely_assigned(__VERIFIER_assert_%2) +definitely_assigned(__VERIFIER_assert_%2) +definitely_assigned(__VERIFIER_assert_%2) +defines_register(thread_function_datarace_instr_0, thread_function_datarace_%2) +defines_register(thread_function_datarace_instr_1, thread_function_datarace_%3) +defines_register(thread_function_datarace_instr_2, thread_function_datarace_%4) +defines_register(thread_function_datarace_instr_6, thread_function_datarace_%6) +defines_register(thread_function_datarace_instr_7, thread_function_datarace_%7) +defines_register(thread_function_datarace_instr_9, thread_function_datarace_%9) +defines_register(thread_function_datarace_instr_11, thread_function_datarace_%10) +defines_register(thread_function_datarace_instr_12, thread_function_datarace_%11) +defines_register(thread_function_datarace_instr_14, thread_function_datarace_%12) +defines_register(thread_function_datarace_instr_15, thread_function_datarace_%13) +defines_register(thread_function_datarace_instr_18, thread_function_datarace_%15) +defines_register(thread_function_datarace_instr_19, thread_function_datarace_%16) +uses(thread_function_datarace_instr_3, thread_function_datarace_%2) +uses(thread_function_datarace_instr_3, thread_function_datarace_arg_0) +uses(thread_function_datarace_instr_4, thread_function_datarace_%3) +uses(thread_function_datarace_instr_6, thread_function_datarace_%3) +uses(thread_function_datarace_instr_7, thread_function_datarace_%6) +uses(thread_function_datarace_instr_8, thread_function_datarace_%7) +uses(thread_function_datarace_instr_9, global_4) +uses(thread_function_datarace_instr_10, thread_function_datarace_%9) +uses(thread_function_datarace_instr_10, thread_function_datarace_%4) +uses(thread_function_datarace_instr_11, thread_function_datarace_%4) +uses(thread_function_datarace_instr_12, thread_function_datarace_%10) +uses(thread_function_datarace_instr_13, thread_function_datarace_%11) +uses(thread_function_datarace_instr_13, thread_function_datarace_%4) +uses(thread_function_datarace_instr_15, thread_function_datarace_%4) +uses(thread_function_datarace_instr_16, thread_function_datarace_%13) +uses(thread_function_datarace_instr_16, global_4) +uses(thread_function_datarace_instr_18, thread_function_datarace_%3) +uses(thread_function_datarace_instr_19, thread_function_datarace_%15) +uses(thread_function_datarace_instr_20, thread_function_datarace_%3) +uses(thread_function_datarace_instr_20, thread_function_datarace_%16) +reaches(thread_function_datarace_instr_13, thread_function_datarace_block_1) +reaches(thread_function_datarace_instr_20, thread_function_datarace_block_1) +reaches(thread_function_datarace_instr_3, thread_function_datarace_block_1) +reaches(thread_function_datarace_instr_16, thread_function_datarace_block_1) +reaches(thread_function_datarace_instr_4, thread_function_datarace_block_1) +reaches(thread_function_datarace_instr_13, thread_function_datarace_block_2) +reaches(thread_function_datarace_instr_20, thread_function_datarace_block_2) +reaches(thread_function_datarace_instr_3, thread_function_datarace_block_2) +reaches(thread_function_datarace_instr_16, thread_function_datarace_block_2) +reaches(thread_function_datarace_instr_4, thread_function_datarace_block_2) +reaches(thread_function_datarace_instr_13, thread_function_datarace_block_3) +reaches(thread_function_datarace_instr_20, thread_function_datarace_block_3) +reaches(thread_function_datarace_instr_3, thread_function_datarace_block_3) +reaches(thread_function_datarace_instr_16, thread_function_datarace_block_3) +reaches(thread_function_datarace_instr_4, thread_function_datarace_block_3) +reaches(thread_function_datarace_instr_13, thread_function_datarace_block_4) +reaches(thread_function_datarace_instr_20, thread_function_datarace_block_4) +reaches(thread_function_datarace_instr_3, thread_function_datarace_block_4) +reaches(thread_function_datarace_instr_16, thread_function_datarace_block_4) +reaches(thread_function_datarace_instr_4, thread_function_datarace_block_4) +live_in(global_4, thread_function_datarace_block_0) +live_in(thread_function_datarace_%3, thread_function_datarace_block_1) +live_in(global_4, thread_function_datarace_block_1) +live_in(thread_function_datarace_%3, thread_function_datarace_block_2) +live_in(global_4, thread_function_datarace_block_2) +live_in(thread_function_datarace_%3, thread_function_datarace_block_3) +live_in(global_4, thread_function_datarace_block_3) +live_out(thread_function_datarace_%3, thread_function_datarace_block_0) +live_out(global_4, thread_function_datarace_block_0) +live_out(thread_function_datarace_%3, thread_function_datarace_block_1) +live_out(global_4, thread_function_datarace_block_1) +live_out(thread_function_datarace_%3, thread_function_datarace_block_2) +live_out(global_4, thread_function_datarace_block_2) +live_out(thread_function_datarace_%3, thread_function_datarace_block_3) +live_out(global_4, thread_function_datarace_block_3) +definitely_assigned(thread_function_datarace_%2) +definitely_assigned(thread_function_datarace_%3) +definitely_unassigned(thread_function_datarace_%4) +definitely_assigned(thread_function_datarace_%3) +unknown_assignment(thread_function_datarace_%2) +unknown_assignment(thread_function_datarace_%4) +unknown_assignment(global_4) +definitely_assigned(thread_function_datarace_%3) +definitely_assigned(thread_function_datarace_%4) +definitely_assigned(global_4) +unknown_assignment(thread_function_datarace_%2) +definitely_assigned(thread_function_datarace_%3) +definitely_assigned(thread_function_datarace_%4) +definitely_assigned(global_4) +unknown_assignment(thread_function_datarace_%2) +definitely_assigned(thread_function_datarace_%3) +unknown_assignment(thread_function_datarace_%2) +unknown_assignment(thread_function_datarace_%4) +unknown_assignment(global_4) +defines_register(main_instr_0, main_%1) +defines_register(main_instr_1, main_%2) +defines_register(main_instr_2, main_%3) +defines_register(main_instr_4, main_%4) +defines_register(main_instr_5, main_%5) +defines_register(main_instr_7, main_None) +defines_register(main_instr_9, main_%8) +defines_register(main_instr_10, main_%9) +defines_register(main_instr_11, main_%10) +defines_register(main_instr_12, main_%11) +defines_register(main_instr_13, main_%12) +defines_register(main_instr_14, main_%13) +defines_register(main_instr_17, main_%15) +defines_register(main_instr_18, main_%16) +defines_register(main_instr_20, main_%18) +defines_register(main_instr_21, main_%19) +defines_register(main_instr_24, main_%21) +defines_register(main_instr_25, main_%22) +defines_register(main_instr_28, main_%24) +defines_register(main_instr_29, main_%25) +defines_register(main_instr_30, main_%26) +defines_register(main_instr_32, main_None) +defines_register(main_instr_34, main_%29) +defines_register(main_instr_35, main_%30) +defines_register(main_instr_36, main_%31) +defines_register(main_instr_37, main_None) +defines_register(main_instr_38, main_%32) +defines_register(main_instr_39, main_%33) +defines_register(main_instr_40, main_%34) +defines_register(main_instr_41, main_None) +uses(main_instr_3, main_%1) +uses(main_instr_4, main_%2) +uses(main_instr_5, main_%4) +uses(main_instr_6, main_%5) +uses(main_instr_15, main_%3) +uses(main_instr_17, main_%3) +uses(main_instr_18, main_%15) +uses(main_instr_19, main_%16) +uses(main_instr_20, global_4) +uses(main_instr_21, main_%18) +uses(main_instr_22, main_%19) +uses(main_instr_22, global_4) +uses(main_instr_24, main_%3) +uses(main_instr_25, main_%21) +uses(main_instr_26, main_%22) +uses(main_instr_26, main_%3) +uses(main_instr_28, main_%2) +uses(main_instr_29, main_%24) +uses(main_instr_30, main_%25) +uses(main_instr_31, main_%26) +uses(main_instr_34, global_4) +uses(main_instr_35, main_%29) +uses(main_instr_36, main_%30) +uses(main_instr_37, main_%31) +uses(main_instr_38, global_4) +uses(main_instr_39, main_%32) +reaches(main_instr_3, main_block_1) +reaches(main_instr_3, main_block_2) +reaches(main_instr_26, main_block_3) +reaches(main_instr_3, main_block_3) +reaches(main_instr_22, main_block_3) +reaches(main_instr_15, main_block_3) +reaches(main_instr_26, main_block_4) +reaches(main_instr_3, main_block_4) +reaches(main_instr_22, main_block_4) +reaches(main_instr_15, main_block_4) +reaches(main_instr_26, main_block_5) +reaches(main_instr_3, main_block_5) +reaches(main_instr_22, main_block_5) +reaches(main_instr_15, main_block_5) +reaches(main_instr_26, main_block_6) +reaches(main_instr_3, main_block_6) +reaches(main_instr_22, main_block_6) +reaches(main_instr_15, main_block_6) +reaches(main_instr_26, main_block_7) +reaches(main_instr_3, main_block_7) +reaches(main_instr_22, main_block_7) +reaches(main_instr_15, main_block_7) +reaches(main_instr_26, main_block_8) +reaches(main_instr_3, main_block_8) +reaches(main_instr_22, main_block_8) +reaches(main_instr_15, main_block_8) +live_in(main_%2, main_block_0) +live_in(global_4, main_block_0) +live_in(main_%2, main_block_2) +live_in(global_4, main_block_2) +live_in(main_%2, main_block_3) +live_in(main_%3, main_block_3) +live_in(global_4, main_block_3) +live_in(main_%2, main_block_4) +live_in(main_%3, main_block_4) +live_in(global_4, main_block_4) +live_in(main_%2, main_block_5) +live_in(main_%3, main_block_5) +live_in(global_4, main_block_5) +live_in(main_%2, main_block_6) +live_in(global_4, main_block_6) +live_in(global_4, main_block_8) +live_out(main_%2, main_block_0) +live_out(global_4, main_block_0) +live_out(main_%2, main_block_2) +live_out(main_%3, main_block_2) +live_out(global_4, main_block_2) +live_out(main_%2, main_block_3) +live_out(global_4, main_block_3) +live_out(main_%3, main_block_3) +live_out(main_%2, main_block_4) +live_out(main_%3, main_block_4) +live_out(global_4, main_block_4) +live_out(main_%2, main_block_5) +live_out(main_%3, main_block_5) +live_out(global_4, main_block_5) +live_out(global_4, main_block_6) +definitely_assigned(main_%1) +definitely_unassigned(main_%2) +definitely_unassigned(main_%3) +definitely_assigned(main_%1) +definitely_unassigned(main_%2) +definitely_unassigned(main_%3) +definitely_assigned(main_%3) +definitely_assigned(main_%1) +definitely_unassigned(main_%2) +definitely_assigned(main_%3) +unknown_assignment(main_%2) +unknown_assignment(main_%1) +unknown_assignment(global_4) +definitely_assigned(main_%3) +definitely_assigned(global_4) +unknown_assignment(main_%2) +unknown_assignment(main_%1) +definitely_assigned(main_%3) +definitely_assigned(global_4) +unknown_assignment(main_%2) +unknown_assignment(main_%1) +definitely_assigned(main_%3) +unknown_assignment(main_%2) +unknown_assignment(main_%1) +unknown_assignment(global_4) +definitely_assigned(main_%3) +unknown_assignment(main_%2) +unknown_assignment(main_%1) +unknown_assignment(global_4) +definitely_assigned(main_%3) +unknown_assignment(main_%2) +unknown_assignment(main_%1) +unknown_assignment(global_4) +points_to(main_%3, main_%3_obj) +points_to(global_10, global_10_obj) +points_to(thread_function_datarace_%4, thread_function_datarace_%4_obj) +points_to(global_5, global_5_obj) +points_to(main_%2, main_%2_obj) +points_to(global_7, global_7_obj) +points_to(thread_function_datarace_%2, thread_function_datarace_%2_obj) +points_to(thread_function_datarace_%3, thread_function_datarace_%3_obj) +points_to(global_11, global_11_obj) +points_to(__VERIFIER_assert_%2, __VERIFIER_assert_%2_obj) +points_to(global_1, global_1_obj) +points_to(global_0, global_0_obj) +points_to(global_9, global_9_obj) +points_to(global_6, global_6_obj) +points_to(global_2, global_2_obj) +points_to(global_12, global_12_obj) +points_to(global_4, global_4_obj) +points_to(global_8, global_8_obj) +points_to(global_3, global_3_obj) +points_to(main_%1, main_%1_obj) +memory_location(main_%3_obj) +memory_location(global_10_obj) +memory_location(thread_function_datarace_%4_obj) +memory_location(global_5_obj) +memory_location(main_%2_obj) +memory_location(global_7_obj) +memory_location(thread_function_datarace_%2_obj) +memory_location(thread_function_datarace_%3_obj) +memory_location(global_11_obj) +memory_location(__VERIFIER_assert_%2_obj) +memory_location(global_1_obj) +memory_location(global_0_obj) +memory_location(global_9_obj) +memory_location(global_6_obj) +memory_location(global_2_obj) +memory_location(global_12_obj) +memory_location(global_4_obj) +memory_location(global_8_obj) +memory_location(global_3_obj) +memory_location(main_%1_obj) +virtual_register(reach_error_None) +virtual_register(__VERIFIER_assert_%2) +local_variable(__VERIFIER_assert_%2) +allocates(__VERIFIER_assert_instr_0, i32*) +stores(__VERIFIER_assert_instr_1, __VERIFIER_assert_instr_1_operand_0) +stores_at(__VERIFIER_assert_instr_1, __VERIFIER_assert_instr_1_operand_1) +virtual_register(__VERIFIER_assert_%3) +loads(__VERIFIER_assert_instr_2, __VERIFIER_assert_instr_2_operand_0) +virtual_register(__VERIFIER_assert_%4) +virtual_register(__VERIFIER_assert_None) +virtual_register(__VERIFIER_assert_None) +virtual_register(thread_function_datarace_%2) +local_variable(thread_function_datarace_%2) +allocates(thread_function_datarace_instr_0, i8**) +virtual_register(thread_function_datarace_%3) +local_variable(thread_function_datarace_%3) +allocates(thread_function_datarace_instr_1, i32*) +virtual_register(thread_function_datarace_%4) +local_variable(thread_function_datarace_%4) +allocates(thread_function_datarace_instr_2, i32*) +stores(thread_function_datarace_instr_3, thread_function_datarace_instr_3_operand_0) +stores_at(thread_function_datarace_instr_3, thread_function_datarace_instr_3_operand_1) +stores(thread_function_datarace_instr_4, thread_function_datarace_instr_4_operand_0) +stores_at(thread_function_datarace_instr_4, thread_function_datarace_instr_4_operand_1) +virtual_register(thread_function_datarace_%6) +loads(thread_function_datarace_instr_6, thread_function_datarace_instr_6_operand_0) +virtual_register(thread_function_datarace_%7) +virtual_register(thread_function_datarace_%9) +loads(thread_function_datarace_instr_9, thread_function_datarace_instr_9_operand_0) +stores(thread_function_datarace_instr_10, thread_function_datarace_instr_10_operand_0) +stores_at(thread_function_datarace_instr_10, thread_function_datarace_instr_10_operand_1) +virtual_register(thread_function_datarace_%10) +loads(thread_function_datarace_instr_11, thread_function_datarace_instr_11_operand_0) +virtual_register(thread_function_datarace_%11) +stores(thread_function_datarace_instr_13, thread_function_datarace_instr_13_operand_0) +stores_at(thread_function_datarace_instr_13, thread_function_datarace_instr_13_operand_1) +virtual_register(thread_function_datarace_%12) +virtual_register(thread_function_datarace_%13) +loads(thread_function_datarace_instr_15, thread_function_datarace_instr_15_operand_0) +stores(thread_function_datarace_instr_16, thread_function_datarace_instr_16_operand_0) +stores_at(thread_function_datarace_instr_16, thread_function_datarace_instr_16_operand_1) +virtual_register(thread_function_datarace_%15) +loads(thread_function_datarace_instr_18, thread_function_datarace_instr_18_operand_0) +virtual_register(thread_function_datarace_%16) +stores(thread_function_datarace_instr_20, thread_function_datarace_instr_20_operand_0) +stores_at(thread_function_datarace_instr_20, thread_function_datarace_instr_20_operand_1) +virtual_register(main_%1) +local_variable(main_%1) +allocates(main_instr_0, i32*) +virtual_register(main_%2) +local_variable(main_%2) +allocates(main_instr_1, %struct._opaque_pthread_t**) +virtual_register(main_%3) +local_variable(main_%3) +allocates(main_instr_2, i32*) +stores(main_instr_3, main_instr_3_operand_0) +stores_at(main_instr_3, main_instr_3_operand_1) +virtual_register(main_%4) +virtual_register(main_%5) +virtual_register(main_None) +virtual_register(main_%8) +virtual_register(main_%9) +virtual_register(main_%10) +virtual_register(main_%11) +virtual_register(main_%12) +virtual_register(main_%13) +stores(main_instr_15, main_instr_15_operand_0) +stores_at(main_instr_15, main_instr_15_operand_1) +virtual_register(main_%15) +loads(main_instr_17, main_instr_17_operand_0) +virtual_register(main_%16) +virtual_register(main_%18) +loads(main_instr_20, main_instr_20_operand_0) +virtual_register(main_%19) +stores(main_instr_22, main_instr_22_operand_0) +stores_at(main_instr_22, main_instr_22_operand_1) +virtual_register(main_%21) +loads(main_instr_24, main_instr_24_operand_0) +virtual_register(main_%22) +stores(main_instr_26, main_instr_26_operand_0) +stores_at(main_instr_26, main_instr_26_operand_1) +virtual_register(main_%24) +loads(main_instr_28, main_instr_28_operand_0) +virtual_register(main_%25) +virtual_register(main_%26) +virtual_register(main_None) +virtual_register(main_%29) +loads(main_instr_34, main_instr_34_operand_0) +virtual_register(main_%30) +virtual_register(main_%31) +virtual_register(main_None) +virtual_register(main_%32) +loads(main_instr_38, main_instr_38_operand_0) +virtual_register(main_%33) +virtual_register(main_%34) +virtual_register(main_None) +module(module_0) +data_layout(e-m:o-i64:64-i128:128-n32:64-S128) +has_data_layout(module_0, e-m:o-i64:64-i128:128-n32:64-S128) +data_layout(arm64-apple-macosx15.0.0) +target_triple(module_0) +has_global_variable(module_0, global_0) +global_variable(global_0) +has_type(global_0, [12 x i8]) +constant(global_0) +has_linkage(global_0, private) +has_visibility(global_0, default) +has_storage_class(global_0, default) +has_attribute(global_0, align 1) +attribute(align 1) +has_initializer(global_0, c"reach_error\00") +has_global_variable(module_0, global_1) +global_variable(global_1) +has_type(global_1, [26 x i8]) +constant(global_1) +has_linkage(global_1, private) +has_visibility(global_1, default) +has_storage_class(global_1, default) +has_attribute(global_1, align 1) +attribute(align 1) +has_initializer(global_1, c"pthread-demo-datarace-2.c\00") +has_global_variable(module_0, global_2) +global_variable(global_2) +has_type(global_2, [2 x i8]) +constant(global_2) +has_linkage(global_2, private) +has_visibility(global_2, default) +has_storage_class(global_2, default) +has_attribute(global_2, align 1) +attribute(align 1) +has_initializer(global_2, c"0\00") +has_global_variable(module_0, global_3) +global_variable(global_3) +has_type(global_3, { i64, [56 x i8] }) +constant(global_3) +has_linkage(global_3, external) +has_visibility(global_3, default) +has_storage_class(global_3, default) +has_attribute(global_3, align 8) +attribute(align 8) +has_initializer(global_3, { i64 850045863, [56 x i8] zeroinitializer }) +has_global_variable(module_0, global_4) +global_variable(global_4) +has_type(global_4, i32) +constant(global_4) +has_linkage(global_4, external) +has_visibility(global_4, default) +has_storage_class(global_4, default) +has_attribute(global_4, align 4) +attribute(align 4) +has_initializer(global_4, 0) +has_global_variable(module_0, global_5) +global_variable(global_5) +has_type(global_5, [32 x i8]) +constant(global_5) +has_linkage(global_5, private) +has_visibility(global_5, default) +has_storage_class(global_5, default) +has_attribute(global_5, align 1) +attribute(align 1) +has_initializer(global_5, c"\0AIn thread_function_datarace..\09\00") +has_global_variable(module_0, global_6) +global_variable(global_6) +has_type(global_6, [79 x i8]) +constant(global_6) +has_linkage(global_6, private) +has_visibility(global_6, default) +has_storage_class(global_6, default) +has_attribute(global_6, align 1) +attribute(align 1) +has_initializer(global_6, c"\0A\09\09---------------------------------------------------------------------------\00") +has_global_variable(module_0, global_7) +global_variable(global_7) +has_type(global_7, [57 x i8]) +constant(global_7) +has_linkage(global_7, private) +has_visibility(global_7, default) +has_storage_class(global_7, default) +has_attribute(global_7, align 1) +attribute(align 1) +has_initializer(global_7, c"\0A\09\09 Centre for Development of Advanced Computing (C-DAC)\00") +has_global_variable(module_0, global_8) +global_variable(global_8) +has_type(global_8, [27 x i8]) +constant(global_8) +has_linkage(global_8, private) +has_visibility(global_8, default) +has_storage_class(global_8, default) +has_attribute(global_8, align 1) +attribute(align 1) +has_initializer(global_8, c"\0A\09\09 Email : hpcfte@cdac.in\00") +has_global_variable(module_0, global_9) +global_variable(global_9) +has_type(global_9, [83 x i8]) +constant(global_9) +has_linkage(global_9, private) +has_visibility(global_9, default) +has_storage_class(global_9, default) +has_attribute(global_9, align 1) +attribute(align 1) +has_initializer(global_9, c"\0A\09\09 Objective : Pthread code to illustrate data race condition and its solution \0A \00") +has_global_variable(module_0, global_10) +global_variable(global_10) +has_type(global_10, [79 x i8]) +constant(global_10) +has_linkage(global_10, private) +has_visibility(global_10, default) +has_storage_class(global_10, default) +has_attribute(global_10, align 1) +attribute(align 1) +has_initializer(global_10, c"\0A\09\09..........................................................................\0A\00") +has_global_variable(module_0, global_11) +global_variable(global_11) +has_type(global_11, [57 x i8]) +constant(global_11) +has_linkage(global_11, private) +has_visibility(global_11, default) +has_storage_class(global_11, default) +has_attribute(global_11, align 1) +attribute(align 1) +has_initializer(global_11, c"\0AValue of myglobal in thread_function_datarace is : %d\0A\00") +has_global_variable(module_0, global_12) +global_variable(global_12) +has_type(global_12, [104 x i8]) +constant(global_12) +has_linkage(global_12, private) +has_visibility(global_12, default) +has_storage_class(global_12, default) +has_attribute(global_12, align 1) +attribute(align 1) +has_initializer(global_12, c"\0A ----------------------------------------------------------------------------------------------------\0A\00") +has_function(module_0, function_0) +function(function_0) +has_type(function_0, void ()*) +definition(function_0) +has_linkage(function_0, external) +has_visibility(function_0, default) +has_attribute(function_0, b'noinline') +attribute(b'noinline') +has_attribute(function_0, b'nounwind') +attribute(b'nounwind') +has_attribute(function_0, b'optnone') +attribute(b'optnone') +has_attribute(function_0, b'ssp') +attribute(b'ssp') +has_attribute(function_0, b'uwtable') +attribute(b'uwtable') +has_attribute(function_0, b'"frame-pointer"="non-leaf"') +attribute(b'"frame-pointer"="non-leaf"') +has_attribute(function_0, b'"min-legal-vector-width"="0"') +attribute(b'"min-legal-vector-width"="0"') +has_attribute(function_0, b'"no-trapping-math"="true"') +attribute(b'"no-trapping-math"="true"') +has_attribute(function_0, b'"stack-protector-buffer-size"="8"') +attribute(b'"stack-protector-buffer-size"="8"') +has_attribute(function_0, b'"target-cpu"="apple-m1"') +attribute(b'"target-cpu"="apple-m1"') +has_attribute(function_0, b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +attribute(b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +has_block(function_0, reach_error_block_0) +block(reach_error_block_0) +has_instruction(reach_error_block_0, reach_error_instr_0) +instruction(reach_error_instr_0) +inter_procedural_flow_operation(reach_error_instr_0) +has_opcode(reach_error_instr_0, call) +has_operand(reach_error_instr_0, reach_error_instr_0_operand_0) +operand(reach_error_instr_0_operand_0) +has_value(reach_error_instr_0_operand_0, function_1) +has_type(reach_error_instr_0_operand_0, void (i8*, i8*, i32, i8*)*) +constant(reach_error_instr_0_operand_0) +has_operand(reach_error_instr_0, reach_error_instr_0_operand_1) +operand(reach_error_instr_0_operand_1) +has_value(reach_error_instr_0_operand_1, reach_error_instr_0_operand_1_const_0) +constant(reach_error_instr_0_operand_1_const_0) +has_expression(reach_error_instr_0_operand_1_const_0, reach_error_instr_0_operand_1_const_0_const_expr_0) +instruction(reach_error_instr_0_operand_1_const_0_const_expr_0) +memory_operation(reach_error_instr_0_operand_1_const_0_const_expr_0) +has_opcode(reach_error_instr_0_operand_1_const_0_const_expr_0, getelementptr) +has_operand(reach_error_instr_0_operand_1_const_0_const_expr_0, reach_error_instr_0_operand_1_const_0_const_expr_0_operand_0) +operand(reach_error_instr_0_operand_1_const_0_const_expr_0_operand_0) +has_value(reach_error_instr_0_operand_1_const_0_const_expr_0_operand_0, global_0) +has_type(reach_error_instr_0_operand_1_const_0_const_expr_0_operand_0, [12 x i8]*) +constant(reach_error_instr_0_operand_1_const_0_const_expr_0_operand_0) +has_operand(reach_error_instr_0_operand_1_const_0_const_expr_0, reach_error_instr_0_operand_1_const_0_const_expr_0_operand_1) +operand(reach_error_instr_0_operand_1_const_0_const_expr_0_operand_1) +has_value(reach_error_instr_0_operand_1_const_0_const_expr_0_operand_1, 0) +has_type(reach_error_instr_0_operand_1_const_0_const_expr_0_operand_1, i64) +constant(reach_error_instr_0_operand_1_const_0_const_expr_0_operand_1) +has_operand(reach_error_instr_0_operand_1_const_0_const_expr_0, reach_error_instr_0_operand_1_const_0_const_expr_0_operand_2) +operand(reach_error_instr_0_operand_1_const_0_const_expr_0_operand_2) +has_value(reach_error_instr_0_operand_1_const_0_const_expr_0_operand_2, 0) +has_type(reach_error_instr_0_operand_1_const_0_const_expr_0_operand_2, i64) +constant(reach_error_instr_0_operand_1_const_0_const_expr_0_operand_2) +has_type(reach_error_instr_0_operand_1, i8*) +constant(reach_error_instr_0_operand_1) +has_operand(reach_error_instr_0, reach_error_instr_0_operand_2) +operand(reach_error_instr_0_operand_2) +has_value(reach_error_instr_0_operand_2, reach_error_instr_0_operand_2_const_0) +constant(reach_error_instr_0_operand_2_const_0) +has_expression(reach_error_instr_0_operand_2_const_0, reach_error_instr_0_operand_2_const_0_const_expr_0) +instruction(reach_error_instr_0_operand_2_const_0_const_expr_0) +memory_operation(reach_error_instr_0_operand_2_const_0_const_expr_0) +has_opcode(reach_error_instr_0_operand_2_const_0_const_expr_0, getelementptr) +has_operand(reach_error_instr_0_operand_2_const_0_const_expr_0, reach_error_instr_0_operand_2_const_0_const_expr_0_operand_0) +operand(reach_error_instr_0_operand_2_const_0_const_expr_0_operand_0) +has_value(reach_error_instr_0_operand_2_const_0_const_expr_0_operand_0, global_1) +has_type(reach_error_instr_0_operand_2_const_0_const_expr_0_operand_0, [26 x i8]*) +constant(reach_error_instr_0_operand_2_const_0_const_expr_0_operand_0) +has_operand(reach_error_instr_0_operand_2_const_0_const_expr_0, reach_error_instr_0_operand_2_const_0_const_expr_0_operand_1) +operand(reach_error_instr_0_operand_2_const_0_const_expr_0_operand_1) +has_value(reach_error_instr_0_operand_2_const_0_const_expr_0_operand_1, 0) +has_type(reach_error_instr_0_operand_2_const_0_const_expr_0_operand_1, i64) +constant(reach_error_instr_0_operand_2_const_0_const_expr_0_operand_1) +has_operand(reach_error_instr_0_operand_2_const_0_const_expr_0, reach_error_instr_0_operand_2_const_0_const_expr_0_operand_2) +operand(reach_error_instr_0_operand_2_const_0_const_expr_0_operand_2) +has_value(reach_error_instr_0_operand_2_const_0_const_expr_0_operand_2, 0) +has_type(reach_error_instr_0_operand_2_const_0_const_expr_0_operand_2, i64) +constant(reach_error_instr_0_operand_2_const_0_const_expr_0_operand_2) +has_type(reach_error_instr_0_operand_2, i8*) +constant(reach_error_instr_0_operand_2) +has_operand(reach_error_instr_0, reach_error_instr_0_operand_3) +operand(reach_error_instr_0_operand_3) +has_value(reach_error_instr_0_operand_3, 25) +has_type(reach_error_instr_0_operand_3, i32) +constant(reach_error_instr_0_operand_3) +has_operand(reach_error_instr_0, reach_error_instr_0_operand_4) +operand(reach_error_instr_0_operand_4) +has_value(reach_error_instr_0_operand_4, reach_error_instr_0_operand_4_const_0) +constant(reach_error_instr_0_operand_4_const_0) +has_expression(reach_error_instr_0_operand_4_const_0, reach_error_instr_0_operand_4_const_0_const_expr_0) +instruction(reach_error_instr_0_operand_4_const_0_const_expr_0) +memory_operation(reach_error_instr_0_operand_4_const_0_const_expr_0) +has_opcode(reach_error_instr_0_operand_4_const_0_const_expr_0, getelementptr) +has_operand(reach_error_instr_0_operand_4_const_0_const_expr_0, reach_error_instr_0_operand_4_const_0_const_expr_0_operand_0) +operand(reach_error_instr_0_operand_4_const_0_const_expr_0_operand_0) +has_value(reach_error_instr_0_operand_4_const_0_const_expr_0_operand_0, global_2) +has_type(reach_error_instr_0_operand_4_const_0_const_expr_0_operand_0, [2 x i8]*) +constant(reach_error_instr_0_operand_4_const_0_const_expr_0_operand_0) +has_operand(reach_error_instr_0_operand_4_const_0_const_expr_0, reach_error_instr_0_operand_4_const_0_const_expr_0_operand_1) +operand(reach_error_instr_0_operand_4_const_0_const_expr_0_operand_1) +has_value(reach_error_instr_0_operand_4_const_0_const_expr_0_operand_1, 0) +has_type(reach_error_instr_0_operand_4_const_0_const_expr_0_operand_1, i64) +constant(reach_error_instr_0_operand_4_const_0_const_expr_0_operand_1) +has_operand(reach_error_instr_0_operand_4_const_0_const_expr_0, reach_error_instr_0_operand_4_const_0_const_expr_0_operand_2) +operand(reach_error_instr_0_operand_4_const_0_const_expr_0_operand_2) +has_value(reach_error_instr_0_operand_4_const_0_const_expr_0_operand_2, 0) +has_type(reach_error_instr_0_operand_4_const_0_const_expr_0_operand_2, i64) +constant(reach_error_instr_0_operand_4_const_0_const_expr_0_operand_2) +has_type(reach_error_instr_0_operand_4, i8*) +constant(reach_error_instr_0_operand_4) +has_instruction(reach_error_block_0, reach_error_instr_1) +instruction(reach_error_instr_1) +terminator(reach_error_instr_1) +has_opcode(reach_error_instr_1, unreachable) +has_function(module_0, function_1) +function(function_1) +has_type(function_1, void (i8*, i8*, i32, i8*)*) +declaration(function_1) +has_linkage(function_1, external) +has_visibility(function_1, default) +has_attribute(function_1, b'cold') +attribute(b'cold') +has_attribute(function_1, b'noreturn') +attribute(b'noreturn') +has_attribute(function_1, b'"disable-tail-calls"="true"') +attribute(b'"disable-tail-calls"="true"') +has_attribute(function_1, b'"frame-pointer"="non-leaf"') +attribute(b'"frame-pointer"="non-leaf"') +has_attribute(function_1, b'"no-trapping-math"="true"') +attribute(b'"no-trapping-math"="true"') +has_attribute(function_1, b'"stack-protector-buffer-size"="8"') +attribute(b'"stack-protector-buffer-size"="8"') +has_attribute(function_1, b'"target-cpu"="apple-m1"') +attribute(b'"target-cpu"="apple-m1"') +has_attribute(function_1, b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +attribute(b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +has_argument(function_1, __assert_rtn_arg_0) +argument(__assert_rtn_arg_0) +has_type(__assert_rtn_arg_0, i8*) +has_attribute(__assert_rtn_arg_0, b'noundef') +attribute(b'noundef') +has_argument(function_1, __assert_rtn_arg_1) +argument(__assert_rtn_arg_1) +has_type(__assert_rtn_arg_1, i8*) +has_attribute(__assert_rtn_arg_1, b'noundef') +attribute(b'noundef') +has_argument(function_1, __assert_rtn_arg_2) +argument(__assert_rtn_arg_2) +has_type(__assert_rtn_arg_2, i32) +has_attribute(__assert_rtn_arg_2, b'noundef') +attribute(b'noundef') +has_argument(function_1, __assert_rtn_arg_3) +argument(__assert_rtn_arg_3) +has_type(__assert_rtn_arg_3, i8*) +has_attribute(__assert_rtn_arg_3, b'noundef') +attribute(b'noundef') +has_function(module_0, function_2) +function(function_2) +has_type(function_2, void (i32)*) +definition(function_2) +has_linkage(function_2, external) +has_visibility(function_2, default) +has_attribute(function_2, b'noinline') +attribute(b'noinline') +has_attribute(function_2, b'nounwind') +attribute(b'nounwind') +has_attribute(function_2, b'optnone') +attribute(b'optnone') +has_attribute(function_2, b'ssp') +attribute(b'ssp') +has_attribute(function_2, b'uwtable') +attribute(b'uwtable') +has_attribute(function_2, b'"frame-pointer"="non-leaf"') +attribute(b'"frame-pointer"="non-leaf"') +has_attribute(function_2, b'"min-legal-vector-width"="0"') +attribute(b'"min-legal-vector-width"="0"') +has_attribute(function_2, b'"no-trapping-math"="true"') +attribute(b'"no-trapping-math"="true"') +has_attribute(function_2, b'"stack-protector-buffer-size"="8"') +attribute(b'"stack-protector-buffer-size"="8"') +has_attribute(function_2, b'"target-cpu"="apple-m1"') +attribute(b'"target-cpu"="apple-m1"') +has_attribute(function_2, b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +attribute(b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +has_argument(function_2, __VERIFIER_assert_arg_0) +argument(__VERIFIER_assert_arg_0) +has_type(__VERIFIER_assert_arg_0, i32) +has_attribute(__VERIFIER_assert_arg_0, b'noundef') +attribute(b'noundef') +has_block(function_2, __VERIFIER_assert_block_0) +block(__VERIFIER_assert_block_0) +has_instruction(__VERIFIER_assert_block_0, __VERIFIER_assert_instr_0) +instruction(__VERIFIER_assert_instr_0) +memory_operation(__VERIFIER_assert_instr_0) +has_opcode(__VERIFIER_assert_instr_0, alloca) +has_instruction(__VERIFIER_assert_block_0, __VERIFIER_assert_instr_1) +instruction(__VERIFIER_assert_instr_1) +memory_operation(__VERIFIER_assert_instr_1) +has_opcode(__VERIFIER_assert_instr_1, store) +has_operand(__VERIFIER_assert_instr_1, __VERIFIER_assert_instr_1_operand_0) +operand(__VERIFIER_assert_instr_1_operand_0) +has_value(__VERIFIER_assert_instr_1_operand_0, __VERIFIER_assert_arg_0) +has_type(__VERIFIER_assert_instr_1_operand_0, i32) +has_operand(__VERIFIER_assert_instr_1, __VERIFIER_assert_instr_1_operand_1) +operand(__VERIFIER_assert_instr_1_operand_1) +has_value(__VERIFIER_assert_instr_1_operand_1, __VERIFIER_assert_%2) +has_type(__VERIFIER_assert_instr_1_operand_1, i32*) +has_instruction(__VERIFIER_assert_block_0, __VERIFIER_assert_instr_2) +instruction(__VERIFIER_assert_instr_2) +memory_operation(__VERIFIER_assert_instr_2) +has_opcode(__VERIFIER_assert_instr_2, load) +has_operand(__VERIFIER_assert_instr_2, __VERIFIER_assert_instr_2_operand_0) +operand(__VERIFIER_assert_instr_2_operand_0) +has_value(__VERIFIER_assert_instr_2_operand_0, __VERIFIER_assert_%2) +has_type(__VERIFIER_assert_instr_2_operand_0, i32*) +has_instruction(__VERIFIER_assert_block_0, __VERIFIER_assert_instr_3) +instruction(__VERIFIER_assert_instr_3) +has_opcode(__VERIFIER_assert_instr_3, cmp) +has_operand(__VERIFIER_assert_instr_3, __VERIFIER_assert_instr_3_operand_0) +operand(__VERIFIER_assert_instr_3_operand_0) +has_value(__VERIFIER_assert_instr_3_operand_0, __VERIFIER_assert_%3) +has_type(__VERIFIER_assert_instr_3_operand_0, i32) +has_operand(__VERIFIER_assert_instr_3, __VERIFIER_assert_instr_3_operand_1) +operand(__VERIFIER_assert_instr_3_operand_1) +has_value(__VERIFIER_assert_instr_3_operand_1, 0) +has_type(__VERIFIER_assert_instr_3_operand_1, i32) +constant(__VERIFIER_assert_instr_3_operand_1) +has_instruction(__VERIFIER_assert_block_0, __VERIFIER_assert_instr_4) +instruction(__VERIFIER_assert_instr_4) +terminator(__VERIFIER_assert_instr_4) +has_opcode(__VERIFIER_assert_instr_4, br) +has_operand(__VERIFIER_assert_instr_4, __VERIFIER_assert_instr_4_operand_0) +operand(__VERIFIER_assert_instr_4_operand_0) +has_value(__VERIFIER_assert_instr_4_operand_0, __VERIFIER_assert_%4) +has_type(__VERIFIER_assert_instr_4_operand_0, i1) +has_operand(__VERIFIER_assert_instr_4, __VERIFIER_assert_instr_4_operand_1) +operand(__VERIFIER_assert_instr_4_operand_1) +has_value(__VERIFIER_assert_instr_4_operand_1, __VERIFIER_assert_block_3) +has_type(__VERIFIER_assert_instr_4_operand_1, label) +has_operand(__VERIFIER_assert_instr_4, __VERIFIER_assert_instr_4_operand_2) +operand(__VERIFIER_assert_instr_4_operand_2) +has_value(__VERIFIER_assert_instr_4_operand_2, __VERIFIER_assert_block_1) +has_type(__VERIFIER_assert_instr_4_operand_2, label) +has_block(function_2, __VERIFIER_assert_block_1) +block(__VERIFIER_assert_block_1) +has_instruction(__VERIFIER_assert_block_1, __VERIFIER_assert_instr_5) +instruction(__VERIFIER_assert_instr_5) +terminator(__VERIFIER_assert_instr_5) +has_opcode(__VERIFIER_assert_instr_5, br) +has_operand(__VERIFIER_assert_instr_5, __VERIFIER_assert_instr_5_operand_0) +operand(__VERIFIER_assert_instr_5_operand_0) +has_value(__VERIFIER_assert_instr_5_operand_0, __VERIFIER_assert_block_2) +has_type(__VERIFIER_assert_instr_5_operand_0, label) +has_block(function_2, __VERIFIER_assert_block_2) +block(__VERIFIER_assert_block_2) +has_instruction(__VERIFIER_assert_block_2, __VERIFIER_assert_instr_6) +instruction(__VERIFIER_assert_instr_6) +inter_procedural_flow_operation(__VERIFIER_assert_instr_6) +has_opcode(__VERIFIER_assert_instr_6, call) +has_operand(__VERIFIER_assert_instr_6, __VERIFIER_assert_instr_6_operand_0) +operand(__VERIFIER_assert_instr_6_operand_0) +has_value(__VERIFIER_assert_instr_6_operand_0, function_0) +has_type(__VERIFIER_assert_instr_6_operand_0, void ()*) +constant(__VERIFIER_assert_instr_6_operand_0) +has_instruction(__VERIFIER_assert_block_2, __VERIFIER_assert_instr_7) +instruction(__VERIFIER_assert_instr_7) +inter_procedural_flow_operation(__VERIFIER_assert_instr_7) +has_opcode(__VERIFIER_assert_instr_7, call) +has_operand(__VERIFIER_assert_instr_7, __VERIFIER_assert_instr_7_operand_0) +operand(__VERIFIER_assert_instr_7_operand_0) +has_value(__VERIFIER_assert_instr_7_operand_0, function_3) +has_type(__VERIFIER_assert_instr_7_operand_0, void ()*) +constant(__VERIFIER_assert_instr_7_operand_0) +has_instruction(__VERIFIER_assert_block_2, __VERIFIER_assert_instr_8) +instruction(__VERIFIER_assert_instr_8) +terminator(__VERIFIER_assert_instr_8) +has_opcode(__VERIFIER_assert_instr_8, unreachable) +has_block(function_2, __VERIFIER_assert_block_3) +block(__VERIFIER_assert_block_3) +has_instruction(__VERIFIER_assert_block_3, __VERIFIER_assert_instr_9) +instruction(__VERIFIER_assert_instr_9) +terminator(__VERIFIER_assert_instr_9) +has_opcode(__VERIFIER_assert_instr_9, ret) +has_operand(__VERIFIER_assert_instr_9, __VERIFIER_assert_instr_9_operand_0) +operand(__VERIFIER_assert_instr_9_operand_0) +has_type(__VERIFIER_assert_instr_9_operand_0, void) +has_function(module_0, function_3) +function(function_3) +has_type(function_3, void ()*) +declaration(function_3) +has_linkage(function_3, external) +has_visibility(function_3, default) +has_attribute(function_3, b'noreturn') +attribute(b'noreturn') +has_attribute(function_3, b'"frame-pointer"="non-leaf"') +attribute(b'"frame-pointer"="non-leaf"') +has_attribute(function_3, b'"no-trapping-math"="true"') +attribute(b'"no-trapping-math"="true"') +has_attribute(function_3, b'"stack-protector-buffer-size"="8"') +attribute(b'"stack-protector-buffer-size"="8"') +has_attribute(function_3, b'"target-cpu"="apple-m1"') +attribute(b'"target-cpu"="apple-m1"') +has_attribute(function_3, b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +attribute(b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +has_function(module_0, function_4) +function(function_4) +has_type(function_4, i8* (i8*)*) +definition(function_4) +has_linkage(function_4, external) +has_visibility(function_4, default) +has_attribute(function_4, b'noinline') +attribute(b'noinline') +has_attribute(function_4, b'nounwind') +attribute(b'nounwind') +has_attribute(function_4, b'optnone') +attribute(b'optnone') +has_attribute(function_4, b'ssp') +attribute(b'ssp') +has_attribute(function_4, b'uwtable') +attribute(b'uwtable') +has_attribute(function_4, b'"frame-pointer"="non-leaf"') +attribute(b'"frame-pointer"="non-leaf"') +has_attribute(function_4, b'"min-legal-vector-width"="0"') +attribute(b'"min-legal-vector-width"="0"') +has_attribute(function_4, b'"no-trapping-math"="true"') +attribute(b'"no-trapping-math"="true"') +has_attribute(function_4, b'"stack-protector-buffer-size"="8"') +attribute(b'"stack-protector-buffer-size"="8"') +has_attribute(function_4, b'"target-cpu"="apple-m1"') +attribute(b'"target-cpu"="apple-m1"') +has_attribute(function_4, b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +attribute(b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +has_argument(function_4, thread_function_datarace_arg_0) +argument(thread_function_datarace_arg_0) +has_type(thread_function_datarace_arg_0, i8*) +has_attribute(thread_function_datarace_arg_0, b'noundef') +attribute(b'noundef') +has_block(function_4, thread_function_datarace_block_0) +block(thread_function_datarace_block_0) +has_instruction(thread_function_datarace_block_0, thread_function_datarace_instr_0) +instruction(thread_function_datarace_instr_0) +memory_operation(thread_function_datarace_instr_0) +has_opcode(thread_function_datarace_instr_0, alloca) +has_instruction(thread_function_datarace_block_0, thread_function_datarace_instr_1) +instruction(thread_function_datarace_instr_1) +memory_operation(thread_function_datarace_instr_1) +has_opcode(thread_function_datarace_instr_1, alloca) +has_instruction(thread_function_datarace_block_0, thread_function_datarace_instr_2) +instruction(thread_function_datarace_instr_2) +memory_operation(thread_function_datarace_instr_2) +has_opcode(thread_function_datarace_instr_2, alloca) +has_instruction(thread_function_datarace_block_0, thread_function_datarace_instr_3) +instruction(thread_function_datarace_instr_3) +memory_operation(thread_function_datarace_instr_3) +has_opcode(thread_function_datarace_instr_3, store) +has_operand(thread_function_datarace_instr_3, thread_function_datarace_instr_3_operand_0) +operand(thread_function_datarace_instr_3_operand_0) +has_value(thread_function_datarace_instr_3_operand_0, thread_function_datarace_arg_0) +has_type(thread_function_datarace_instr_3_operand_0, i8*) +has_operand(thread_function_datarace_instr_3, thread_function_datarace_instr_3_operand_1) +operand(thread_function_datarace_instr_3_operand_1) +has_value(thread_function_datarace_instr_3_operand_1, thread_function_datarace_%2) +has_type(thread_function_datarace_instr_3_operand_1, i8**) +has_instruction(thread_function_datarace_block_0, thread_function_datarace_instr_4) +instruction(thread_function_datarace_instr_4) +memory_operation(thread_function_datarace_instr_4) +has_opcode(thread_function_datarace_instr_4, store) +has_operand(thread_function_datarace_instr_4, thread_function_datarace_instr_4_operand_0) +operand(thread_function_datarace_instr_4_operand_0) +has_value(thread_function_datarace_instr_4_operand_0, 0) +has_type(thread_function_datarace_instr_4_operand_0, i32) +constant(thread_function_datarace_instr_4_operand_0) +has_operand(thread_function_datarace_instr_4, thread_function_datarace_instr_4_operand_1) +operand(thread_function_datarace_instr_4_operand_1) +has_value(thread_function_datarace_instr_4_operand_1, thread_function_datarace_%3) +has_type(thread_function_datarace_instr_4_operand_1, i32*) +has_instruction(thread_function_datarace_block_0, thread_function_datarace_instr_5) +instruction(thread_function_datarace_instr_5) +terminator(thread_function_datarace_instr_5) +has_opcode(thread_function_datarace_instr_5, br) +has_operand(thread_function_datarace_instr_5, thread_function_datarace_instr_5_operand_0) +operand(thread_function_datarace_instr_5_operand_0) +has_value(thread_function_datarace_instr_5_operand_0, thread_function_datarace_block_1) +has_type(thread_function_datarace_instr_5_operand_0, label) +has_block(function_4, thread_function_datarace_block_1) +block(thread_function_datarace_block_1) +has_instruction(thread_function_datarace_block_1, thread_function_datarace_instr_6) +instruction(thread_function_datarace_instr_6) +memory_operation(thread_function_datarace_instr_6) +has_opcode(thread_function_datarace_instr_6, load) +has_operand(thread_function_datarace_instr_6, thread_function_datarace_instr_6_operand_0) +operand(thread_function_datarace_instr_6_operand_0) +has_value(thread_function_datarace_instr_6_operand_0, thread_function_datarace_%3) +has_type(thread_function_datarace_instr_6_operand_0, i32*) +has_instruction(thread_function_datarace_block_1, thread_function_datarace_instr_7) +instruction(thread_function_datarace_instr_7) +has_opcode(thread_function_datarace_instr_7, cmp) +has_operand(thread_function_datarace_instr_7, thread_function_datarace_instr_7_operand_0) +operand(thread_function_datarace_instr_7_operand_0) +has_value(thread_function_datarace_instr_7_operand_0, thread_function_datarace_%6) +has_type(thread_function_datarace_instr_7_operand_0, i32) +has_operand(thread_function_datarace_instr_7, thread_function_datarace_instr_7_operand_1) +operand(thread_function_datarace_instr_7_operand_1) +has_value(thread_function_datarace_instr_7_operand_1, 20) +has_type(thread_function_datarace_instr_7_operand_1, i32) +constant(thread_function_datarace_instr_7_operand_1) +has_instruction(thread_function_datarace_block_1, thread_function_datarace_instr_8) +instruction(thread_function_datarace_instr_8) +terminator(thread_function_datarace_instr_8) +has_opcode(thread_function_datarace_instr_8, br) +has_operand(thread_function_datarace_instr_8, thread_function_datarace_instr_8_operand_0) +operand(thread_function_datarace_instr_8_operand_0) +has_value(thread_function_datarace_instr_8_operand_0, thread_function_datarace_%7) +has_type(thread_function_datarace_instr_8_operand_0, i1) +has_operand(thread_function_datarace_instr_8, thread_function_datarace_instr_8_operand_1) +operand(thread_function_datarace_instr_8_operand_1) +has_value(thread_function_datarace_instr_8_operand_1, thread_function_datarace_block_2) +has_type(thread_function_datarace_instr_8_operand_1, label) +has_operand(thread_function_datarace_instr_8, thread_function_datarace_instr_8_operand_2) +operand(thread_function_datarace_instr_8_operand_2) +has_value(thread_function_datarace_instr_8_operand_2, thread_function_datarace_block_4) +has_type(thread_function_datarace_instr_8_operand_2, label) +has_block(function_4, thread_function_datarace_block_2) +block(thread_function_datarace_block_2) +has_instruction(thread_function_datarace_block_2, thread_function_datarace_instr_9) +instruction(thread_function_datarace_instr_9) +memory_operation(thread_function_datarace_instr_9) +has_opcode(thread_function_datarace_instr_9, load) +has_operand(thread_function_datarace_instr_9, thread_function_datarace_instr_9_operand_0) +operand(thread_function_datarace_instr_9_operand_0) +has_value(thread_function_datarace_instr_9_operand_0, global_4) +has_type(thread_function_datarace_instr_9_operand_0, i32*) +constant(thread_function_datarace_instr_9_operand_0) +has_instruction(thread_function_datarace_block_2, thread_function_datarace_instr_10) +instruction(thread_function_datarace_instr_10) +memory_operation(thread_function_datarace_instr_10) +has_opcode(thread_function_datarace_instr_10, store) +has_operand(thread_function_datarace_instr_10, thread_function_datarace_instr_10_operand_0) +operand(thread_function_datarace_instr_10_operand_0) +has_value(thread_function_datarace_instr_10_operand_0, thread_function_datarace_%9) +has_type(thread_function_datarace_instr_10_operand_0, i32) +has_operand(thread_function_datarace_instr_10, thread_function_datarace_instr_10_operand_1) +operand(thread_function_datarace_instr_10_operand_1) +has_value(thread_function_datarace_instr_10_operand_1, thread_function_datarace_%4) +has_type(thread_function_datarace_instr_10_operand_1, i32*) +has_instruction(thread_function_datarace_block_2, thread_function_datarace_instr_11) +instruction(thread_function_datarace_instr_11) +memory_operation(thread_function_datarace_instr_11) +has_opcode(thread_function_datarace_instr_11, load) +has_operand(thread_function_datarace_instr_11, thread_function_datarace_instr_11_operand_0) +operand(thread_function_datarace_instr_11_operand_0) +has_value(thread_function_datarace_instr_11_operand_0, thread_function_datarace_%4) +has_type(thread_function_datarace_instr_11_operand_0, i32*) +has_instruction(thread_function_datarace_block_2, thread_function_datarace_instr_12) +instruction(thread_function_datarace_instr_12) +binary_operation(thread_function_datarace_instr_12) +has_opcode(thread_function_datarace_instr_12, add) +has_operand(thread_function_datarace_instr_12, thread_function_datarace_instr_12_operand_0) +operand(thread_function_datarace_instr_12_operand_0) +has_value(thread_function_datarace_instr_12_operand_0, thread_function_datarace_%10) +has_type(thread_function_datarace_instr_12_operand_0, i32) +has_operand(thread_function_datarace_instr_12, thread_function_datarace_instr_12_operand_1) +operand(thread_function_datarace_instr_12_operand_1) +has_value(thread_function_datarace_instr_12_operand_1, 1) +has_type(thread_function_datarace_instr_12_operand_1, i32) +constant(thread_function_datarace_instr_12_operand_1) +has_instruction(thread_function_datarace_block_2, thread_function_datarace_instr_13) +instruction(thread_function_datarace_instr_13) +memory_operation(thread_function_datarace_instr_13) +has_opcode(thread_function_datarace_instr_13, store) +has_operand(thread_function_datarace_instr_13, thread_function_datarace_instr_13_operand_0) +operand(thread_function_datarace_instr_13_operand_0) +has_value(thread_function_datarace_instr_13_operand_0, thread_function_datarace_%11) +has_type(thread_function_datarace_instr_13_operand_0, i32) +has_operand(thread_function_datarace_instr_13, thread_function_datarace_instr_13_operand_1) +operand(thread_function_datarace_instr_13_operand_1) +has_value(thread_function_datarace_instr_13_operand_1, thread_function_datarace_%4) +has_type(thread_function_datarace_instr_13_operand_1, i32*) +has_instruction(thread_function_datarace_block_2, thread_function_datarace_instr_14) +instruction(thread_function_datarace_instr_14) +inter_procedural_flow_operation(thread_function_datarace_instr_14) +has_opcode(thread_function_datarace_instr_14, call) +has_operand(thread_function_datarace_instr_14, thread_function_datarace_instr_14_operand_0) +operand(thread_function_datarace_instr_14_operand_0) +has_value(thread_function_datarace_instr_14_operand_0, function_5) +has_type(thread_function_datarace_instr_14_operand_0, i32 (i8*, ...)*) +constant(thread_function_datarace_instr_14_operand_0) +has_operand(thread_function_datarace_instr_14, thread_function_datarace_instr_14_operand_1) +operand(thread_function_datarace_instr_14_operand_1) +has_value(thread_function_datarace_instr_14_operand_1, thread_function_datarace_instr_14_operand_1_const_0) +constant(thread_function_datarace_instr_14_operand_1_const_0) +has_expression(thread_function_datarace_instr_14_operand_1_const_0, thread_function_datarace_instr_14_operand_1_const_0_const_expr_0) +instruction(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0) +memory_operation(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0) +has_opcode(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0, getelementptr) +has_operand(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0, thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_0) +operand(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_0) +has_value(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_0, global_5) +has_type(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_0, [32 x i8]*) +constant(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_0) +has_operand(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0, thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_1) +operand(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_1) +has_value(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_1, 0) +has_type(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_1, i64) +constant(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_1) +has_operand(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0, thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_2) +operand(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_2) +has_value(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_2, 0) +has_type(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_2, i64) +constant(thread_function_datarace_instr_14_operand_1_const_0_const_expr_0_operand_2) +has_type(thread_function_datarace_instr_14_operand_1, i8*) +constant(thread_function_datarace_instr_14_operand_1) +has_instruction(thread_function_datarace_block_2, thread_function_datarace_instr_15) +instruction(thread_function_datarace_instr_15) +memory_operation(thread_function_datarace_instr_15) +has_opcode(thread_function_datarace_instr_15, load) +has_operand(thread_function_datarace_instr_15, thread_function_datarace_instr_15_operand_0) +operand(thread_function_datarace_instr_15_operand_0) +has_value(thread_function_datarace_instr_15_operand_0, thread_function_datarace_%4) +has_type(thread_function_datarace_instr_15_operand_0, i32*) +has_instruction(thread_function_datarace_block_2, thread_function_datarace_instr_16) +instruction(thread_function_datarace_instr_16) +memory_operation(thread_function_datarace_instr_16) +has_opcode(thread_function_datarace_instr_16, store) +has_operand(thread_function_datarace_instr_16, thread_function_datarace_instr_16_operand_0) +operand(thread_function_datarace_instr_16_operand_0) +has_value(thread_function_datarace_instr_16_operand_0, thread_function_datarace_%13) +has_type(thread_function_datarace_instr_16_operand_0, i32) +has_operand(thread_function_datarace_instr_16, thread_function_datarace_instr_16_operand_1) +operand(thread_function_datarace_instr_16_operand_1) +has_value(thread_function_datarace_instr_16_operand_1, global_4) +has_type(thread_function_datarace_instr_16_operand_1, i32*) +constant(thread_function_datarace_instr_16_operand_1) +has_instruction(thread_function_datarace_block_2, thread_function_datarace_instr_17) +instruction(thread_function_datarace_instr_17) +terminator(thread_function_datarace_instr_17) +has_opcode(thread_function_datarace_instr_17, br) +has_operand(thread_function_datarace_instr_17, thread_function_datarace_instr_17_operand_0) +operand(thread_function_datarace_instr_17_operand_0) +has_value(thread_function_datarace_instr_17_operand_0, thread_function_datarace_block_3) +has_type(thread_function_datarace_instr_17_operand_0, label) +has_block(function_4, thread_function_datarace_block_3) +block(thread_function_datarace_block_3) +has_instruction(thread_function_datarace_block_3, thread_function_datarace_instr_18) +instruction(thread_function_datarace_instr_18) +memory_operation(thread_function_datarace_instr_18) +has_opcode(thread_function_datarace_instr_18, load) +has_operand(thread_function_datarace_instr_18, thread_function_datarace_instr_18_operand_0) +operand(thread_function_datarace_instr_18_operand_0) +has_value(thread_function_datarace_instr_18_operand_0, thread_function_datarace_%3) +has_type(thread_function_datarace_instr_18_operand_0, i32*) +has_instruction(thread_function_datarace_block_3, thread_function_datarace_instr_19) +instruction(thread_function_datarace_instr_19) +binary_operation(thread_function_datarace_instr_19) +has_opcode(thread_function_datarace_instr_19, add) +has_operand(thread_function_datarace_instr_19, thread_function_datarace_instr_19_operand_0) +operand(thread_function_datarace_instr_19_operand_0) +has_value(thread_function_datarace_instr_19_operand_0, thread_function_datarace_%15) +has_type(thread_function_datarace_instr_19_operand_0, i32) +has_operand(thread_function_datarace_instr_19, thread_function_datarace_instr_19_operand_1) +operand(thread_function_datarace_instr_19_operand_1) +has_value(thread_function_datarace_instr_19_operand_1, 1) +has_type(thread_function_datarace_instr_19_operand_1, i32) +constant(thread_function_datarace_instr_19_operand_1) +has_instruction(thread_function_datarace_block_3, thread_function_datarace_instr_20) +instruction(thread_function_datarace_instr_20) +memory_operation(thread_function_datarace_instr_20) +has_opcode(thread_function_datarace_instr_20, store) +has_operand(thread_function_datarace_instr_20, thread_function_datarace_instr_20_operand_0) +operand(thread_function_datarace_instr_20_operand_0) +has_value(thread_function_datarace_instr_20_operand_0, thread_function_datarace_%16) +has_type(thread_function_datarace_instr_20_operand_0, i32) +has_operand(thread_function_datarace_instr_20, thread_function_datarace_instr_20_operand_1) +operand(thread_function_datarace_instr_20_operand_1) +has_value(thread_function_datarace_instr_20_operand_1, thread_function_datarace_%3) +has_type(thread_function_datarace_instr_20_operand_1, i32*) +has_instruction(thread_function_datarace_block_3, thread_function_datarace_instr_21) +instruction(thread_function_datarace_instr_21) +terminator(thread_function_datarace_instr_21) +has_opcode(thread_function_datarace_instr_21, br) +has_operand(thread_function_datarace_instr_21, thread_function_datarace_instr_21_operand_0) +operand(thread_function_datarace_instr_21_operand_0) +has_value(thread_function_datarace_instr_21_operand_0, thread_function_datarace_block_1) +has_type(thread_function_datarace_instr_21_operand_0, label) +has_block(function_4, thread_function_datarace_block_4) +block(thread_function_datarace_block_4) +has_instruction(thread_function_datarace_block_4, thread_function_datarace_instr_22) +instruction(thread_function_datarace_instr_22) +terminator(thread_function_datarace_instr_22) +has_opcode(thread_function_datarace_instr_22, ret) +has_operand(thread_function_datarace_instr_22, thread_function_datarace_instr_22_operand_0) +operand(thread_function_datarace_instr_22_operand_0) +has_value(thread_function_datarace_instr_22_operand_0, null) +has_type(thread_function_datarace_instr_22_operand_0, i8*) +constant(thread_function_datarace_instr_22_operand_0) +has_function(module_0, function_5) +function(function_5) +has_type(function_5, i32 (i8*, ...)*) +declaration(function_5) +has_linkage(function_5, external) +has_visibility(function_5, default) +has_attribute(function_5, b'"frame-pointer"="non-leaf"') +attribute(b'"frame-pointer"="non-leaf"') +has_attribute(function_5, b'"no-trapping-math"="true"') +attribute(b'"no-trapping-math"="true"') +has_attribute(function_5, b'"stack-protector-buffer-size"="8"') +attribute(b'"stack-protector-buffer-size"="8"') +has_attribute(function_5, b'"target-cpu"="apple-m1"') +attribute(b'"target-cpu"="apple-m1"') +has_attribute(function_5, b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +attribute(b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +has_argument(function_5, printf_arg_0) +argument(printf_arg_0) +has_type(printf_arg_0, i8*) +has_attribute(printf_arg_0, b'noundef') +attribute(b'noundef') +has_function(module_0, function_6) +function(function_6) +has_type(function_6, i32 ()*) +definition(function_6) +has_linkage(function_6, external) +has_visibility(function_6, default) +has_attribute(function_6, b'noinline') +attribute(b'noinline') +has_attribute(function_6, b'nounwind') +attribute(b'nounwind') +has_attribute(function_6, b'optnone') +attribute(b'optnone') +has_attribute(function_6, b'ssp') +attribute(b'ssp') +has_attribute(function_6, b'uwtable') +attribute(b'uwtable') +has_attribute(function_6, b'"frame-pointer"="non-leaf"') +attribute(b'"frame-pointer"="non-leaf"') +has_attribute(function_6, b'"min-legal-vector-width"="0"') +attribute(b'"min-legal-vector-width"="0"') +has_attribute(function_6, b'"no-trapping-math"="true"') +attribute(b'"no-trapping-math"="true"') +has_attribute(function_6, b'"stack-protector-buffer-size"="8"') +attribute(b'"stack-protector-buffer-size"="8"') +has_attribute(function_6, b'"target-cpu"="apple-m1"') +attribute(b'"target-cpu"="apple-m1"') +has_attribute(function_6, b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +attribute(b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +has_block(function_6, main_block_0) +block(main_block_0) +has_instruction(main_block_0, main_instr_0) +instruction(main_instr_0) +memory_operation(main_instr_0) +has_opcode(main_instr_0, alloca) +has_instruction(main_block_0, main_instr_1) +instruction(main_instr_1) +memory_operation(main_instr_1) +has_opcode(main_instr_1, alloca) +has_instruction(main_block_0, main_instr_2) +instruction(main_instr_2) +memory_operation(main_instr_2) +has_opcode(main_instr_2, alloca) +has_instruction(main_block_0, main_instr_3) +instruction(main_instr_3) +memory_operation(main_instr_3) +has_opcode(main_instr_3, store) +has_operand(main_instr_3, main_instr_3_operand_0) +operand(main_instr_3_operand_0) +has_value(main_instr_3_operand_0, 0) +has_type(main_instr_3_operand_0, i32) +constant(main_instr_3_operand_0) +has_operand(main_instr_3, main_instr_3_operand_1) +operand(main_instr_3_operand_1) +has_value(main_instr_3_operand_1, main_%1) +has_type(main_instr_3_operand_1, i32*) +has_instruction(main_block_0, main_instr_4) +instruction(main_instr_4) +inter_procedural_flow_operation(main_instr_4) +has_opcode(main_instr_4, call) +has_operand(main_instr_4, main_instr_4_operand_0) +operand(main_instr_4_operand_0) +has_value(main_instr_4_operand_0, function_7) +has_type(main_instr_4_operand_0, i32 (%struct._opaque_pthread_t**, %struct._opaque_pthread_attr_t*, i8* (i8*)*, i8*)*) +constant(main_instr_4_operand_0) +has_operand(main_instr_4, main_instr_4_operand_1) +operand(main_instr_4_operand_1) +has_value(main_instr_4_operand_1, main_%2) +has_type(main_instr_4_operand_1, %struct._opaque_pthread_t**) +has_operand(main_instr_4, main_instr_4_operand_2) +operand(main_instr_4_operand_2) +has_value(main_instr_4_operand_2, null) +has_type(main_instr_4_operand_2, %struct._opaque_pthread_attr_t*) +constant(main_instr_4_operand_2) +has_operand(main_instr_4, main_instr_4_operand_3) +operand(main_instr_4_operand_3) +has_value(main_instr_4_operand_3, function_4) +has_type(main_instr_4_operand_3, i8* (i8*)*) +constant(main_instr_4_operand_3) +has_operand(main_instr_4, main_instr_4_operand_4) +operand(main_instr_4_operand_4) +has_value(main_instr_4_operand_4, null) +has_type(main_instr_4_operand_4, i8*) +constant(main_instr_4_operand_4) +has_instruction(main_block_0, main_instr_5) +instruction(main_instr_5) +has_opcode(main_instr_5, cmp) +has_operand(main_instr_5, main_instr_5_operand_0) +operand(main_instr_5_operand_0) +has_value(main_instr_5_operand_0, main_%4) +has_type(main_instr_5_operand_0, i32) +has_operand(main_instr_5, main_instr_5_operand_1) +operand(main_instr_5_operand_1) +has_value(main_instr_5_operand_1, 0) +has_type(main_instr_5_operand_1, i32) +constant(main_instr_5_operand_1) +has_instruction(main_block_0, main_instr_6) +instruction(main_instr_6) +terminator(main_instr_6) +has_opcode(main_instr_6, br) +has_operand(main_instr_6, main_instr_6_operand_0) +operand(main_instr_6_operand_0) +has_value(main_instr_6_operand_0, main_%5) +has_type(main_instr_6_operand_0, i1) +has_operand(main_instr_6, main_instr_6_operand_1) +operand(main_instr_6_operand_1) +has_value(main_instr_6_operand_1, main_block_1) +has_type(main_instr_6_operand_1, label) +has_operand(main_instr_6, main_instr_6_operand_2) +operand(main_instr_6_operand_2) +has_value(main_instr_6_operand_2, main_block_2) +has_type(main_instr_6_operand_2, label) +has_block(function_6, main_block_1) +block(main_block_1) +has_instruction(main_block_1, main_instr_7) +instruction(main_instr_7) +inter_procedural_flow_operation(main_instr_7) +has_opcode(main_instr_7, call) +has_operand(main_instr_7, main_instr_7_operand_0) +operand(main_instr_7_operand_0) +has_value(main_instr_7_operand_0, function_8) +has_type(main_instr_7_operand_0, void (i32)*) +constant(main_instr_7_operand_0) +has_operand(main_instr_7, main_instr_7_operand_1) +operand(main_instr_7_operand_1) +has_value(main_instr_7_operand_1, -1) +has_type(main_instr_7_operand_1, i32) +constant(main_instr_7_operand_1) +has_instruction(main_block_1, main_instr_8) +instruction(main_instr_8) +terminator(main_instr_8) +has_opcode(main_instr_8, unreachable) +has_block(function_6, main_block_2) +block(main_block_2) +has_instruction(main_block_2, main_instr_9) +instruction(main_instr_9) +inter_procedural_flow_operation(main_instr_9) +has_opcode(main_instr_9, call) +has_operand(main_instr_9, main_instr_9_operand_0) +operand(main_instr_9_operand_0) +has_value(main_instr_9_operand_0, function_5) +has_type(main_instr_9_operand_0, i32 (i8*, ...)*) +constant(main_instr_9_operand_0) +has_operand(main_instr_9, main_instr_9_operand_1) +operand(main_instr_9_operand_1) +has_value(main_instr_9_operand_1, main_instr_9_operand_1_const_0) +constant(main_instr_9_operand_1_const_0) +has_expression(main_instr_9_operand_1_const_0, main_instr_9_operand_1_const_0_const_expr_0) +instruction(main_instr_9_operand_1_const_0_const_expr_0) +memory_operation(main_instr_9_operand_1_const_0_const_expr_0) +has_opcode(main_instr_9_operand_1_const_0_const_expr_0, getelementptr) +has_operand(main_instr_9_operand_1_const_0_const_expr_0, main_instr_9_operand_1_const_0_const_expr_0_operand_0) +operand(main_instr_9_operand_1_const_0_const_expr_0_operand_0) +has_value(main_instr_9_operand_1_const_0_const_expr_0_operand_0, global_6) +has_type(main_instr_9_operand_1_const_0_const_expr_0_operand_0, [79 x i8]*) +constant(main_instr_9_operand_1_const_0_const_expr_0_operand_0) +has_operand(main_instr_9_operand_1_const_0_const_expr_0, main_instr_9_operand_1_const_0_const_expr_0_operand_1) +operand(main_instr_9_operand_1_const_0_const_expr_0_operand_1) +has_value(main_instr_9_operand_1_const_0_const_expr_0_operand_1, 0) +has_type(main_instr_9_operand_1_const_0_const_expr_0_operand_1, i64) +constant(main_instr_9_operand_1_const_0_const_expr_0_operand_1) +has_operand(main_instr_9_operand_1_const_0_const_expr_0, main_instr_9_operand_1_const_0_const_expr_0_operand_2) +operand(main_instr_9_operand_1_const_0_const_expr_0_operand_2) +has_value(main_instr_9_operand_1_const_0_const_expr_0_operand_2, 0) +has_type(main_instr_9_operand_1_const_0_const_expr_0_operand_2, i64) +constant(main_instr_9_operand_1_const_0_const_expr_0_operand_2) +has_type(main_instr_9_operand_1, i8*) +constant(main_instr_9_operand_1) +has_instruction(main_block_2, main_instr_10) +instruction(main_instr_10) +inter_procedural_flow_operation(main_instr_10) +has_opcode(main_instr_10, call) +has_operand(main_instr_10, main_instr_10_operand_0) +operand(main_instr_10_operand_0) +has_value(main_instr_10_operand_0, function_5) +has_type(main_instr_10_operand_0, i32 (i8*, ...)*) +constant(main_instr_10_operand_0) +has_operand(main_instr_10, main_instr_10_operand_1) +operand(main_instr_10_operand_1) +has_value(main_instr_10_operand_1, main_instr_10_operand_1_const_0) +constant(main_instr_10_operand_1_const_0) +has_expression(main_instr_10_operand_1_const_0, main_instr_10_operand_1_const_0_const_expr_0) +instruction(main_instr_10_operand_1_const_0_const_expr_0) +memory_operation(main_instr_10_operand_1_const_0_const_expr_0) +has_opcode(main_instr_10_operand_1_const_0_const_expr_0, getelementptr) +has_operand(main_instr_10_operand_1_const_0_const_expr_0, main_instr_10_operand_1_const_0_const_expr_0_operand_0) +operand(main_instr_10_operand_1_const_0_const_expr_0_operand_0) +has_value(main_instr_10_operand_1_const_0_const_expr_0_operand_0, global_7) +has_type(main_instr_10_operand_1_const_0_const_expr_0_operand_0, [57 x i8]*) +constant(main_instr_10_operand_1_const_0_const_expr_0_operand_0) +has_operand(main_instr_10_operand_1_const_0_const_expr_0, main_instr_10_operand_1_const_0_const_expr_0_operand_1) +operand(main_instr_10_operand_1_const_0_const_expr_0_operand_1) +has_value(main_instr_10_operand_1_const_0_const_expr_0_operand_1, 0) +has_type(main_instr_10_operand_1_const_0_const_expr_0_operand_1, i64) +constant(main_instr_10_operand_1_const_0_const_expr_0_operand_1) +has_operand(main_instr_10_operand_1_const_0_const_expr_0, main_instr_10_operand_1_const_0_const_expr_0_operand_2) +operand(main_instr_10_operand_1_const_0_const_expr_0_operand_2) +has_value(main_instr_10_operand_1_const_0_const_expr_0_operand_2, 0) +has_type(main_instr_10_operand_1_const_0_const_expr_0_operand_2, i64) +constant(main_instr_10_operand_1_const_0_const_expr_0_operand_2) +has_type(main_instr_10_operand_1, i8*) +constant(main_instr_10_operand_1) +has_instruction(main_block_2, main_instr_11) +instruction(main_instr_11) +inter_procedural_flow_operation(main_instr_11) +has_opcode(main_instr_11, call) +has_operand(main_instr_11, main_instr_11_operand_0) +operand(main_instr_11_operand_0) +has_value(main_instr_11_operand_0, function_5) +has_type(main_instr_11_operand_0, i32 (i8*, ...)*) +constant(main_instr_11_operand_0) +has_operand(main_instr_11, main_instr_11_operand_1) +operand(main_instr_11_operand_1) +has_value(main_instr_11_operand_1, main_instr_11_operand_1_const_0) +constant(main_instr_11_operand_1_const_0) +has_expression(main_instr_11_operand_1_const_0, main_instr_11_operand_1_const_0_const_expr_0) +instruction(main_instr_11_operand_1_const_0_const_expr_0) +memory_operation(main_instr_11_operand_1_const_0_const_expr_0) +has_opcode(main_instr_11_operand_1_const_0_const_expr_0, getelementptr) +has_operand(main_instr_11_operand_1_const_0_const_expr_0, main_instr_11_operand_1_const_0_const_expr_0_operand_0) +operand(main_instr_11_operand_1_const_0_const_expr_0_operand_0) +has_value(main_instr_11_operand_1_const_0_const_expr_0_operand_0, global_8) +has_type(main_instr_11_operand_1_const_0_const_expr_0_operand_0, [27 x i8]*) +constant(main_instr_11_operand_1_const_0_const_expr_0_operand_0) +has_operand(main_instr_11_operand_1_const_0_const_expr_0, main_instr_11_operand_1_const_0_const_expr_0_operand_1) +operand(main_instr_11_operand_1_const_0_const_expr_0_operand_1) +has_value(main_instr_11_operand_1_const_0_const_expr_0_operand_1, 0) +has_type(main_instr_11_operand_1_const_0_const_expr_0_operand_1, i64) +constant(main_instr_11_operand_1_const_0_const_expr_0_operand_1) +has_operand(main_instr_11_operand_1_const_0_const_expr_0, main_instr_11_operand_1_const_0_const_expr_0_operand_2) +operand(main_instr_11_operand_1_const_0_const_expr_0_operand_2) +has_value(main_instr_11_operand_1_const_0_const_expr_0_operand_2, 0) +has_type(main_instr_11_operand_1_const_0_const_expr_0_operand_2, i64) +constant(main_instr_11_operand_1_const_0_const_expr_0_operand_2) +has_type(main_instr_11_operand_1, i8*) +constant(main_instr_11_operand_1) +has_instruction(main_block_2, main_instr_12) +instruction(main_instr_12) +inter_procedural_flow_operation(main_instr_12) +has_opcode(main_instr_12, call) +has_operand(main_instr_12, main_instr_12_operand_0) +operand(main_instr_12_operand_0) +has_value(main_instr_12_operand_0, function_5) +has_type(main_instr_12_operand_0, i32 (i8*, ...)*) +constant(main_instr_12_operand_0) +has_operand(main_instr_12, main_instr_12_operand_1) +operand(main_instr_12_operand_1) +has_value(main_instr_12_operand_1, main_instr_12_operand_1_const_0) +constant(main_instr_12_operand_1_const_0) +has_expression(main_instr_12_operand_1_const_0, main_instr_12_operand_1_const_0_const_expr_0) +instruction(main_instr_12_operand_1_const_0_const_expr_0) +memory_operation(main_instr_12_operand_1_const_0_const_expr_0) +has_opcode(main_instr_12_operand_1_const_0_const_expr_0, getelementptr) +has_operand(main_instr_12_operand_1_const_0_const_expr_0, main_instr_12_operand_1_const_0_const_expr_0_operand_0) +operand(main_instr_12_operand_1_const_0_const_expr_0_operand_0) +has_value(main_instr_12_operand_1_const_0_const_expr_0_operand_0, global_6) +has_type(main_instr_12_operand_1_const_0_const_expr_0_operand_0, [79 x i8]*) +constant(main_instr_12_operand_1_const_0_const_expr_0_operand_0) +has_operand(main_instr_12_operand_1_const_0_const_expr_0, main_instr_12_operand_1_const_0_const_expr_0_operand_1) +operand(main_instr_12_operand_1_const_0_const_expr_0_operand_1) +has_value(main_instr_12_operand_1_const_0_const_expr_0_operand_1, 0) +has_type(main_instr_12_operand_1_const_0_const_expr_0_operand_1, i64) +constant(main_instr_12_operand_1_const_0_const_expr_0_operand_1) +has_operand(main_instr_12_operand_1_const_0_const_expr_0, main_instr_12_operand_1_const_0_const_expr_0_operand_2) +operand(main_instr_12_operand_1_const_0_const_expr_0_operand_2) +has_value(main_instr_12_operand_1_const_0_const_expr_0_operand_2, 0) +has_type(main_instr_12_operand_1_const_0_const_expr_0_operand_2, i64) +constant(main_instr_12_operand_1_const_0_const_expr_0_operand_2) +has_type(main_instr_12_operand_1, i8*) +constant(main_instr_12_operand_1) +has_instruction(main_block_2, main_instr_13) +instruction(main_instr_13) +inter_procedural_flow_operation(main_instr_13) +has_opcode(main_instr_13, call) +has_operand(main_instr_13, main_instr_13_operand_0) +operand(main_instr_13_operand_0) +has_value(main_instr_13_operand_0, function_5) +has_type(main_instr_13_operand_0, i32 (i8*, ...)*) +constant(main_instr_13_operand_0) +has_operand(main_instr_13, main_instr_13_operand_1) +operand(main_instr_13_operand_1) +has_value(main_instr_13_operand_1, main_instr_13_operand_1_const_0) +constant(main_instr_13_operand_1_const_0) +has_expression(main_instr_13_operand_1_const_0, main_instr_13_operand_1_const_0_const_expr_0) +instruction(main_instr_13_operand_1_const_0_const_expr_0) +memory_operation(main_instr_13_operand_1_const_0_const_expr_0) +has_opcode(main_instr_13_operand_1_const_0_const_expr_0, getelementptr) +has_operand(main_instr_13_operand_1_const_0_const_expr_0, main_instr_13_operand_1_const_0_const_expr_0_operand_0) +operand(main_instr_13_operand_1_const_0_const_expr_0_operand_0) +has_value(main_instr_13_operand_1_const_0_const_expr_0_operand_0, global_9) +has_type(main_instr_13_operand_1_const_0_const_expr_0_operand_0, [83 x i8]*) +constant(main_instr_13_operand_1_const_0_const_expr_0_operand_0) +has_operand(main_instr_13_operand_1_const_0_const_expr_0, main_instr_13_operand_1_const_0_const_expr_0_operand_1) +operand(main_instr_13_operand_1_const_0_const_expr_0_operand_1) +has_value(main_instr_13_operand_1_const_0_const_expr_0_operand_1, 0) +has_type(main_instr_13_operand_1_const_0_const_expr_0_operand_1, i64) +constant(main_instr_13_operand_1_const_0_const_expr_0_operand_1) +has_operand(main_instr_13_operand_1_const_0_const_expr_0, main_instr_13_operand_1_const_0_const_expr_0_operand_2) +operand(main_instr_13_operand_1_const_0_const_expr_0_operand_2) +has_value(main_instr_13_operand_1_const_0_const_expr_0_operand_2, 0) +has_type(main_instr_13_operand_1_const_0_const_expr_0_operand_2, i64) +constant(main_instr_13_operand_1_const_0_const_expr_0_operand_2) +has_type(main_instr_13_operand_1, i8*) +constant(main_instr_13_operand_1) +has_instruction(main_block_2, main_instr_14) +instruction(main_instr_14) +inter_procedural_flow_operation(main_instr_14) +has_opcode(main_instr_14, call) +has_operand(main_instr_14, main_instr_14_operand_0) +operand(main_instr_14_operand_0) +has_value(main_instr_14_operand_0, function_5) +has_type(main_instr_14_operand_0, i32 (i8*, ...)*) +constant(main_instr_14_operand_0) +has_operand(main_instr_14, main_instr_14_operand_1) +operand(main_instr_14_operand_1) +has_value(main_instr_14_operand_1, main_instr_14_operand_1_const_0) +constant(main_instr_14_operand_1_const_0) +has_expression(main_instr_14_operand_1_const_0, main_instr_14_operand_1_const_0_const_expr_0) +instruction(main_instr_14_operand_1_const_0_const_expr_0) +memory_operation(main_instr_14_operand_1_const_0_const_expr_0) +has_opcode(main_instr_14_operand_1_const_0_const_expr_0, getelementptr) +has_operand(main_instr_14_operand_1_const_0_const_expr_0, main_instr_14_operand_1_const_0_const_expr_0_operand_0) +operand(main_instr_14_operand_1_const_0_const_expr_0_operand_0) +has_value(main_instr_14_operand_1_const_0_const_expr_0_operand_0, global_10) +has_type(main_instr_14_operand_1_const_0_const_expr_0_operand_0, [79 x i8]*) +constant(main_instr_14_operand_1_const_0_const_expr_0_operand_0) +has_operand(main_instr_14_operand_1_const_0_const_expr_0, main_instr_14_operand_1_const_0_const_expr_0_operand_1) +operand(main_instr_14_operand_1_const_0_const_expr_0_operand_1) +has_value(main_instr_14_operand_1_const_0_const_expr_0_operand_1, 0) +has_type(main_instr_14_operand_1_const_0_const_expr_0_operand_1, i64) +constant(main_instr_14_operand_1_const_0_const_expr_0_operand_1) +has_operand(main_instr_14_operand_1_const_0_const_expr_0, main_instr_14_operand_1_const_0_const_expr_0_operand_2) +operand(main_instr_14_operand_1_const_0_const_expr_0_operand_2) +has_value(main_instr_14_operand_1_const_0_const_expr_0_operand_2, 0) +has_type(main_instr_14_operand_1_const_0_const_expr_0_operand_2, i64) +constant(main_instr_14_operand_1_const_0_const_expr_0_operand_2) +has_type(main_instr_14_operand_1, i8*) +constant(main_instr_14_operand_1) +has_instruction(main_block_2, main_instr_15) +instruction(main_instr_15) +memory_operation(main_instr_15) +has_opcode(main_instr_15, store) +has_operand(main_instr_15, main_instr_15_operand_0) +operand(main_instr_15_operand_0) +has_value(main_instr_15_operand_0, 0) +has_type(main_instr_15_operand_0, i32) +constant(main_instr_15_operand_0) +has_operand(main_instr_15, main_instr_15_operand_1) +operand(main_instr_15_operand_1) +has_value(main_instr_15_operand_1, main_%3) +has_type(main_instr_15_operand_1, i32*) +has_instruction(main_block_2, main_instr_16) +instruction(main_instr_16) +terminator(main_instr_16) +has_opcode(main_instr_16, br) +has_operand(main_instr_16, main_instr_16_operand_0) +operand(main_instr_16_operand_0) +has_value(main_instr_16_operand_0, main_block_3) +has_type(main_instr_16_operand_0, label) +has_block(function_6, main_block_3) +block(main_block_3) +has_instruction(main_block_3, main_instr_17) +instruction(main_instr_17) +memory_operation(main_instr_17) +has_opcode(main_instr_17, load) +has_operand(main_instr_17, main_instr_17_operand_0) +operand(main_instr_17_operand_0) +has_value(main_instr_17_operand_0, main_%3) +has_type(main_instr_17_operand_0, i32*) +has_instruction(main_block_3, main_instr_18) +instruction(main_instr_18) +has_opcode(main_instr_18, cmp) +has_operand(main_instr_18, main_instr_18_operand_0) +operand(main_instr_18_operand_0) +has_value(main_instr_18_operand_0, main_%15) +has_type(main_instr_18_operand_0, i32) +has_operand(main_instr_18, main_instr_18_operand_1) +operand(main_instr_18_operand_1) +has_value(main_instr_18_operand_1, main_block_5) +has_type(main_instr_18_operand_1, i32) +constant(main_instr_18_operand_1) +has_instruction(main_block_3, main_instr_19) +instruction(main_instr_19) +terminator(main_instr_19) +has_opcode(main_instr_19, br) +has_operand(main_instr_19, main_instr_19_operand_0) +operand(main_instr_19_operand_0) +has_value(main_instr_19_operand_0, main_%16) +has_type(main_instr_19_operand_0, i1) +has_operand(main_instr_19, main_instr_19_operand_1) +operand(main_instr_19_operand_1) +has_value(main_instr_19_operand_1, main_block_4) +has_type(main_instr_19_operand_1, label) +has_operand(main_instr_19, main_instr_19_operand_2) +operand(main_instr_19_operand_2) +has_value(main_instr_19_operand_2, main_block_6) +has_type(main_instr_19_operand_2, label) +has_block(function_6, main_block_4) +block(main_block_4) +has_instruction(main_block_4, main_instr_20) +instruction(main_instr_20) +memory_operation(main_instr_20) +has_opcode(main_instr_20, load) +has_operand(main_instr_20, main_instr_20_operand_0) +operand(main_instr_20_operand_0) +has_value(main_instr_20_operand_0, global_4) +has_type(main_instr_20_operand_0, i32*) +constant(main_instr_20_operand_0) +has_instruction(main_block_4, main_instr_21) +instruction(main_instr_21) +binary_operation(main_instr_21) +has_opcode(main_instr_21, add) +has_operand(main_instr_21, main_instr_21_operand_0) +operand(main_instr_21_operand_0) +has_value(main_instr_21_operand_0, main_%18) +has_type(main_instr_21_operand_0, i32) +has_operand(main_instr_21, main_instr_21_operand_1) +operand(main_instr_21_operand_1) +has_value(main_instr_21_operand_1, 1) +has_type(main_instr_21_operand_1, i32) +constant(main_instr_21_operand_1) +has_instruction(main_block_4, main_instr_22) +instruction(main_instr_22) +memory_operation(main_instr_22) +has_opcode(main_instr_22, store) +has_operand(main_instr_22, main_instr_22_operand_0) +operand(main_instr_22_operand_0) +has_value(main_instr_22_operand_0, main_%19) +has_type(main_instr_22_operand_0, i32) +has_operand(main_instr_22, main_instr_22_operand_1) +operand(main_instr_22_operand_1) +has_value(main_instr_22_operand_1, global_4) +has_type(main_instr_22_operand_1, i32*) +constant(main_instr_22_operand_1) +has_instruction(main_block_4, main_instr_23) +instruction(main_instr_23) +terminator(main_instr_23) +has_opcode(main_instr_23, br) +has_operand(main_instr_23, main_instr_23_operand_0) +operand(main_instr_23_operand_0) +has_value(main_instr_23_operand_0, main_block_5) +has_type(main_instr_23_operand_0, label) +has_block(function_6, main_block_5) +block(main_block_5) +has_instruction(main_block_5, main_instr_24) +instruction(main_instr_24) +memory_operation(main_instr_24) +has_opcode(main_instr_24, load) +has_operand(main_instr_24, main_instr_24_operand_0) +operand(main_instr_24_operand_0) +has_value(main_instr_24_operand_0, main_%3) +has_type(main_instr_24_operand_0, i32*) +has_instruction(main_block_5, main_instr_25) +instruction(main_instr_25) +binary_operation(main_instr_25) +has_opcode(main_instr_25, add) +has_operand(main_instr_25, main_instr_25_operand_0) +operand(main_instr_25_operand_0) +has_value(main_instr_25_operand_0, main_%21) +has_type(main_instr_25_operand_0, i32) +has_operand(main_instr_25, main_instr_25_operand_1) +operand(main_instr_25_operand_1) +has_value(main_instr_25_operand_1, 1) +has_type(main_instr_25_operand_1, i32) +constant(main_instr_25_operand_1) +has_instruction(main_block_5, main_instr_26) +instruction(main_instr_26) +memory_operation(main_instr_26) +has_opcode(main_instr_26, store) +has_operand(main_instr_26, main_instr_26_operand_0) +operand(main_instr_26_operand_0) +has_value(main_instr_26_operand_0, main_%22) +has_type(main_instr_26_operand_0, i32) +has_operand(main_instr_26, main_instr_26_operand_1) +operand(main_instr_26_operand_1) +has_value(main_instr_26_operand_1, main_%3) +has_type(main_instr_26_operand_1, i32*) +has_instruction(main_block_5, main_instr_27) +instruction(main_instr_27) +terminator(main_instr_27) +has_opcode(main_instr_27, br) +has_operand(main_instr_27, main_instr_27_operand_0) +operand(main_instr_27_operand_0) +has_value(main_instr_27_operand_0, main_block_3) +has_type(main_instr_27_operand_0, label) +has_block(function_6, main_block_6) +block(main_block_6) +has_instruction(main_block_6, main_instr_28) +instruction(main_instr_28) +memory_operation(main_instr_28) +has_opcode(main_instr_28, load) +has_operand(main_instr_28, main_instr_28_operand_0) +operand(main_instr_28_operand_0) +has_value(main_instr_28_operand_0, main_%2) +has_type(main_instr_28_operand_0, %struct._opaque_pthread_t**) +has_instruction(main_block_6, main_instr_29) +instruction(main_instr_29) +inter_procedural_flow_operation(main_instr_29) +has_opcode(main_instr_29, call) +has_operand(main_instr_29, main_instr_29_operand_0) +operand(main_instr_29_operand_0) +has_value(main_instr_29_operand_0, function_9) +has_type(main_instr_29_operand_0, i32 (%struct._opaque_pthread_t*, i8**)*) +constant(main_instr_29_operand_0) +has_operand(main_instr_29, main_instr_29_operand_1) +operand(main_instr_29_operand_1) +has_value(main_instr_29_operand_1, main_%24) +has_type(main_instr_29_operand_1, %struct._opaque_pthread_t*) +has_operand(main_instr_29, main_instr_29_operand_2) +operand(main_instr_29_operand_2) +has_value(main_instr_29_operand_2, null) +has_type(main_instr_29_operand_2, i8**) +constant(main_instr_29_operand_2) +has_instruction(main_block_6, main_instr_30) +instruction(main_instr_30) +has_opcode(main_instr_30, cmp) +has_operand(main_instr_30, main_instr_30_operand_0) +operand(main_instr_30_operand_0) +has_value(main_instr_30_operand_0, main_%25) +has_type(main_instr_30_operand_0, i32) +has_operand(main_instr_30, main_instr_30_operand_1) +operand(main_instr_30_operand_1) +has_value(main_instr_30_operand_1, 0) +has_type(main_instr_30_operand_1, i32) +constant(main_instr_30_operand_1) +has_instruction(main_block_6, main_instr_31) +instruction(main_instr_31) +terminator(main_instr_31) +has_opcode(main_instr_31, br) +has_operand(main_instr_31, main_instr_31_operand_0) +operand(main_instr_31_operand_0) +has_value(main_instr_31_operand_0, main_%26) +has_type(main_instr_31_operand_0, i1) +has_operand(main_instr_31, main_instr_31_operand_1) +operand(main_instr_31_operand_1) +has_value(main_instr_31_operand_1, main_block_7) +has_type(main_instr_31_operand_1, label) +has_operand(main_instr_31, main_instr_31_operand_2) +operand(main_instr_31_operand_2) +has_value(main_instr_31_operand_2, main_block_8) +has_type(main_instr_31_operand_2, label) +has_block(function_6, main_block_7) +block(main_block_7) +has_instruction(main_block_7, main_instr_32) +instruction(main_instr_32) +inter_procedural_flow_operation(main_instr_32) +has_opcode(main_instr_32, call) +has_operand(main_instr_32, main_instr_32_operand_0) +operand(main_instr_32_operand_0) +has_value(main_instr_32_operand_0, function_8) +has_type(main_instr_32_operand_0, void (i32)*) +constant(main_instr_32_operand_0) +has_operand(main_instr_32, main_instr_32_operand_1) +operand(main_instr_32_operand_1) +has_value(main_instr_32_operand_1, -1) +has_type(main_instr_32_operand_1, i32) +constant(main_instr_32_operand_1) +has_instruction(main_block_7, main_instr_33) +instruction(main_instr_33) +terminator(main_instr_33) +has_opcode(main_instr_33, unreachable) +has_block(function_6, main_block_8) +block(main_block_8) +has_instruction(main_block_8, main_instr_34) +instruction(main_instr_34) +memory_operation(main_instr_34) +has_opcode(main_instr_34, load) +has_operand(main_instr_34, main_instr_34_operand_0) +operand(main_instr_34_operand_0) +has_value(main_instr_34_operand_0, global_4) +has_type(main_instr_34_operand_0, i32*) +constant(main_instr_34_operand_0) +has_instruction(main_block_8, main_instr_35) +instruction(main_instr_35) +has_opcode(main_instr_35, cmp) +has_operand(main_instr_35, main_instr_35_operand_0) +operand(main_instr_35_operand_0) +has_value(main_instr_35_operand_0, main_%29) +has_type(main_instr_35_operand_0, i32) +has_operand(main_instr_35, main_instr_35_operand_1) +operand(main_instr_35_operand_1) +has_value(main_instr_35_operand_1, 40) +has_type(main_instr_35_operand_1, i32) +constant(main_instr_35_operand_1) +has_instruction(main_block_8, main_instr_36) +instruction(main_instr_36) +conversion_operation(main_instr_36) +has_opcode(main_instr_36, zext) +has_operand(main_instr_36, main_instr_36_operand_0) +operand(main_instr_36_operand_0) +has_value(main_instr_36_operand_0, main_%30) +has_type(main_instr_36_operand_0, i1) +has_instruction(main_block_8, main_instr_37) +instruction(main_instr_37) +inter_procedural_flow_operation(main_instr_37) +has_opcode(main_instr_37, call) +has_operand(main_instr_37, main_instr_37_operand_0) +operand(main_instr_37_operand_0) +has_value(main_instr_37_operand_0, function_2) +has_type(main_instr_37_operand_0, void (i32)*) +constant(main_instr_37_operand_0) +has_operand(main_instr_37, main_instr_37_operand_1) +operand(main_instr_37_operand_1) +has_value(main_instr_37_operand_1, main_%31) +has_type(main_instr_37_operand_1, i32) +has_instruction(main_block_8, main_instr_38) +instruction(main_instr_38) +memory_operation(main_instr_38) +has_opcode(main_instr_38, load) +has_operand(main_instr_38, main_instr_38_operand_0) +operand(main_instr_38_operand_0) +has_value(main_instr_38_operand_0, global_4) +has_type(main_instr_38_operand_0, i32*) +constant(main_instr_38_operand_0) +has_instruction(main_block_8, main_instr_39) +instruction(main_instr_39) +inter_procedural_flow_operation(main_instr_39) +has_opcode(main_instr_39, call) +has_operand(main_instr_39, main_instr_39_operand_0) +operand(main_instr_39_operand_0) +has_value(main_instr_39_operand_0, function_5) +has_type(main_instr_39_operand_0, i32 (i8*, ...)*) +constant(main_instr_39_operand_0) +has_operand(main_instr_39, main_instr_39_operand_1) +operand(main_instr_39_operand_1) +has_value(main_instr_39_operand_1, main_instr_39_operand_1_const_0) +constant(main_instr_39_operand_1_const_0) +has_expression(main_instr_39_operand_1_const_0, main_instr_39_operand_1_const_0_const_expr_0) +instruction(main_instr_39_operand_1_const_0_const_expr_0) +memory_operation(main_instr_39_operand_1_const_0_const_expr_0) +has_opcode(main_instr_39_operand_1_const_0_const_expr_0, getelementptr) +has_operand(main_instr_39_operand_1_const_0_const_expr_0, main_instr_39_operand_1_const_0_const_expr_0_operand_0) +operand(main_instr_39_operand_1_const_0_const_expr_0_operand_0) +has_value(main_instr_39_operand_1_const_0_const_expr_0_operand_0, global_11) +has_type(main_instr_39_operand_1_const_0_const_expr_0_operand_0, [57 x i8]*) +constant(main_instr_39_operand_1_const_0_const_expr_0_operand_0) +has_operand(main_instr_39_operand_1_const_0_const_expr_0, main_instr_39_operand_1_const_0_const_expr_0_operand_1) +operand(main_instr_39_operand_1_const_0_const_expr_0_operand_1) +has_value(main_instr_39_operand_1_const_0_const_expr_0_operand_1, 0) +has_type(main_instr_39_operand_1_const_0_const_expr_0_operand_1, i64) +constant(main_instr_39_operand_1_const_0_const_expr_0_operand_1) +has_operand(main_instr_39_operand_1_const_0_const_expr_0, main_instr_39_operand_1_const_0_const_expr_0_operand_2) +operand(main_instr_39_operand_1_const_0_const_expr_0_operand_2) +has_value(main_instr_39_operand_1_const_0_const_expr_0_operand_2, 0) +has_type(main_instr_39_operand_1_const_0_const_expr_0_operand_2, i64) +constant(main_instr_39_operand_1_const_0_const_expr_0_operand_2) +has_type(main_instr_39_operand_1, i8*) +constant(main_instr_39_operand_1) +has_operand(main_instr_39, main_instr_39_operand_2) +operand(main_instr_39_operand_2) +has_value(main_instr_39_operand_2, main_%32) +has_type(main_instr_39_operand_2, i32) +has_instruction(main_block_8, main_instr_40) +instruction(main_instr_40) +inter_procedural_flow_operation(main_instr_40) +has_opcode(main_instr_40, call) +has_operand(main_instr_40, main_instr_40_operand_0) +operand(main_instr_40_operand_0) +has_value(main_instr_40_operand_0, function_5) +has_type(main_instr_40_operand_0, i32 (i8*, ...)*) +constant(main_instr_40_operand_0) +has_operand(main_instr_40, main_instr_40_operand_1) +operand(main_instr_40_operand_1) +has_value(main_instr_40_operand_1, main_instr_40_operand_1_const_0) +constant(main_instr_40_operand_1_const_0) +has_expression(main_instr_40_operand_1_const_0, main_instr_40_operand_1_const_0_const_expr_0) +instruction(main_instr_40_operand_1_const_0_const_expr_0) +memory_operation(main_instr_40_operand_1_const_0_const_expr_0) +has_opcode(main_instr_40_operand_1_const_0_const_expr_0, getelementptr) +has_operand(main_instr_40_operand_1_const_0_const_expr_0, main_instr_40_operand_1_const_0_const_expr_0_operand_0) +operand(main_instr_40_operand_1_const_0_const_expr_0_operand_0) +has_value(main_instr_40_operand_1_const_0_const_expr_0_operand_0, global_12) +has_type(main_instr_40_operand_1_const_0_const_expr_0_operand_0, [104 x i8]*) +constant(main_instr_40_operand_1_const_0_const_expr_0_operand_0) +has_operand(main_instr_40_operand_1_const_0_const_expr_0, main_instr_40_operand_1_const_0_const_expr_0_operand_1) +operand(main_instr_40_operand_1_const_0_const_expr_0_operand_1) +has_value(main_instr_40_operand_1_const_0_const_expr_0_operand_1, 0) +has_type(main_instr_40_operand_1_const_0_const_expr_0_operand_1, i64) +constant(main_instr_40_operand_1_const_0_const_expr_0_operand_1) +has_operand(main_instr_40_operand_1_const_0_const_expr_0, main_instr_40_operand_1_const_0_const_expr_0_operand_2) +operand(main_instr_40_operand_1_const_0_const_expr_0_operand_2) +has_value(main_instr_40_operand_1_const_0_const_expr_0_operand_2, 0) +has_type(main_instr_40_operand_1_const_0_const_expr_0_operand_2, i64) +constant(main_instr_40_operand_1_const_0_const_expr_0_operand_2) +has_type(main_instr_40_operand_1, i8*) +constant(main_instr_40_operand_1) +has_instruction(main_block_8, main_instr_41) +instruction(main_instr_41) +inter_procedural_flow_operation(main_instr_41) +has_opcode(main_instr_41, call) +has_operand(main_instr_41, main_instr_41_operand_0) +operand(main_instr_41_operand_0) +has_value(main_instr_41_operand_0, function_8) +has_type(main_instr_41_operand_0, void (i32)*) +constant(main_instr_41_operand_0) +has_operand(main_instr_41, main_instr_41_operand_1) +operand(main_instr_41_operand_1) +has_value(main_instr_41_operand_1, 0) +has_type(main_instr_41_operand_1, i32) +constant(main_instr_41_operand_1) +has_instruction(main_block_8, main_instr_42) +instruction(main_instr_42) +terminator(main_instr_42) +has_opcode(main_instr_42, unreachable) +has_function(module_0, function_7) +function(function_7) +has_type(function_7, i32 (%struct._opaque_pthread_t**, %struct._opaque_pthread_attr_t*, i8* (i8*)*, i8*)*) +declaration(function_7) +has_linkage(function_7, external) +has_visibility(function_7, default) +has_attribute(function_7, b'"frame-pointer"="non-leaf"') +attribute(b'"frame-pointer"="non-leaf"') +has_attribute(function_7, b'"no-trapping-math"="true"') +attribute(b'"no-trapping-math"="true"') +has_attribute(function_7, b'"stack-protector-buffer-size"="8"') +attribute(b'"stack-protector-buffer-size"="8"') +has_attribute(function_7, b'"target-cpu"="apple-m1"') +attribute(b'"target-cpu"="apple-m1"') +has_attribute(function_7, b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +attribute(b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +has_argument(function_7, pthread_create_arg_0) +argument(pthread_create_arg_0) +has_type(pthread_create_arg_0, %struct._opaque_pthread_t**) +has_attribute(pthread_create_arg_0, b'noundef') +attribute(b'noundef') +has_argument(function_7, pthread_create_arg_1) +argument(pthread_create_arg_1) +has_type(pthread_create_arg_1, %struct._opaque_pthread_attr_t*) +has_attribute(pthread_create_arg_1, b'noundef') +attribute(b'noundef') +has_argument(function_7, pthread_create_arg_2) +argument(pthread_create_arg_2) +has_type(pthread_create_arg_2, i8* (i8*)*) +has_attribute(pthread_create_arg_2, b'noundef') +attribute(b'noundef') +has_argument(function_7, pthread_create_arg_3) +argument(pthread_create_arg_3) +has_type(pthread_create_arg_3, i8*) +has_attribute(pthread_create_arg_3, b'noundef') +attribute(b'noundef') +has_function(module_0, function_8) +function(function_8) +has_type(function_8, void (i32)*) +declaration(function_8) +has_linkage(function_8, external) +has_visibility(function_8, default) +has_attribute(function_8, b'noreturn') +attribute(b'noreturn') +has_attribute(function_8, b'"frame-pointer"="non-leaf"') +attribute(b'"frame-pointer"="non-leaf"') +has_attribute(function_8, b'"no-trapping-math"="true"') +attribute(b'"no-trapping-math"="true"') +has_attribute(function_8, b'"stack-protector-buffer-size"="8"') +attribute(b'"stack-protector-buffer-size"="8"') +has_attribute(function_8, b'"target-cpu"="apple-m1"') +attribute(b'"target-cpu"="apple-m1"') +has_attribute(function_8, b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +attribute(b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +has_argument(function_8, exit_arg_0) +argument(exit_arg_0) +has_type(exit_arg_0, i32) +has_attribute(exit_arg_0, b'noundef') +attribute(b'noundef') +has_function(module_0, function_9) +function(function_9) +has_type(function_9, i32 (%struct._opaque_pthread_t*, i8**)*) +declaration(function_9) +has_linkage(function_9, external) +has_visibility(function_9, default) +has_attribute(function_9, b'"frame-pointer"="non-leaf"') +attribute(b'"frame-pointer"="non-leaf"') +has_attribute(function_9, b'"no-trapping-math"="true"') +attribute(b'"no-trapping-math"="true"') +has_attribute(function_9, b'"stack-protector-buffer-size"="8"') +attribute(b'"stack-protector-buffer-size"="8"') +has_attribute(function_9, b'"target-cpu"="apple-m1"') +attribute(b'"target-cpu"="apple-m1"') +has_attribute(function_9, b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +attribute(b'"target-features"="+aes,+crc,+crypto,+dotprod,+fp-armv8,+fp16fml,+fullfp16,+lse,+neon,+ras,+rcpc,+rdm,+sha2,+sha3,+sm4,+v8.5a,+zcm,+zcz"') +has_argument(function_9, _pthread_join_arg_0) +argument(_pthread_join_arg_0) +has_type(_pthread_join_arg_0, %struct._opaque_pthread_t*) +has_attribute(_pthread_join_arg_0, b'noundef') +attribute(b'noundef') +has_argument(function_9, _pthread_join_arg_1) +argument(_pthread_join_arg_1) +has_type(_pthread_join_arg_1, i8**) +has_attribute(_pthread_join_arg_1, b'noundef') +attribute(b'noundef') diff --git a/docs/demo/uploading_graph.gif b/docs/demo/uploading_graph.gif new file mode 100644 index 0000000..297a513 Binary files /dev/null and b/docs/demo/uploading_graph.gif differ diff --git a/docs/features.md b/docs/features.md new file mode 100644 index 0000000..b8b96e2 --- /dev/null +++ b/docs/features.md @@ -0,0 +1,94 @@ +# Features +Wy-Graph takes an LLVM IR file and executes the following pipeline: +1. Parses LLVM IR input into an [abstract syntax tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree) (**AST**). +2. Analyzes semantic and syntactic structure of the AST. + 1. Control Flow Analysis + 2. Data Flow Analysis + 3. Memory Analysis + 4. Syntactic Analysis +3. Generates formal predicates that represent the semantic and syntactic structure gained from the analyses. +4. Outputs the [formal predicates](/docs/predicates.md) as strings to a text file. +5. Optionally, outputs formal predicates as nodes and vertices in a graphml file that can be visualized via Gephi. + +## Parser +The parser is primarily built on top of LLVMLite's parser. + +The first thing our parser does is call LLVMLite's parser to generate an AST we refer to as the `module`. +``` +def parse(self, source_input: str): + self.module = llvm.parse_assembly(source_input) + return self.parse_module(self.module) +``` +Then the real fun begins. ```parse_module()``` calls our parser that transforms LLVMLite's "lite" or vague AST into a more complete and expressive AST we can utilize for program analysis. + +Our AST comprises of: +1. [Module.py](/src/AST/module.py): Defines the general constructs of a program module such as global variables, functions, blocks, instructions, and more... +2. [Instructions.py](/src/AST/instructions.py): Defines specific information regarding each kind of instruction per the [LLVM IR instruction reference manual](https://llvm.org/docs/LangRef.html#instruction-reference). + +In some cases, LLVMLite's AST is not sufficient for parsing. In these cases, we utilize [Lark](https://lark-parser.readthedocs.io/en/stable/), a python parsing library that generates a parser based on an EBNF grammar. + +For our EBNF grammar, we utilize this [repository](https://github.com/llir/grammar) that provides an EBNF grammar written for a GoLang library. The repository appears to no longer be maintained but has commits supporting features up to LLVM 15. + +We converted a tiny subset of the grammar to be compatible with Lark, however, did not have time to extensively test due to time constraints. Most bugs I ran into seemed to be due to minor translation errors from the original grammar to our lark mapping. Our grammar can be found [here](/src/Grammar/llvmir.lark). + +## Analyzer +The analyzer can be decomposed into four core components: + 1. Control Flow Analysis + 2. Data Flow Analysis + 3. Memory Analysis + 4. Syntactic Analysis + +The analyzer performs each analysis and stores the results as predicates in the [predicate tree](/src/PredTree/predicates.py). + +### Control Flow Analysis +The Control Flow Analyzer takes an AST and performs the following: +- Generates a [Control Flow Graph](https://en.wikipedia.org/wiki/Control-flow_graph) (**CFG**) for each procedure. +- Computes the [dominator](https://en.wikipedia.org/wiki/Dominator_(graph_theory)) and post dominator trees for the CFG, allowing us to better identify dependencies in the execution flow. +- Discovers loops in the CFG. +- Discovers edges in the CFG where an exception may be thrown. +- Connects each procedure's CFG into an inter-procedural CFG. + - We do not implement any method of discovering functions referenced by indirect function pointers. + - Likewise, we do not currently support discovering functions within constant expressions. Feel free to contribute that! +- Stores results as predicate in the predicate tree. + +### Data Flow Analysis +The Data Flow Analyzer takes an AST and performs the following: + +- Computes [Use-Def Chains](https://en.wikipedia.org/wiki/Use-define_chain). +- Computes [Reaching Definitions](https://en.wikipedia.org/wiki/Reaching_definition) for each stack allocated variable definition. +- Computes [Live-Variable Analysis](https://en.wikipedia.org/wiki/Live-variable_analysis) for each stack allocated variable. +- Computes [Definite Assignment Analysis](https://en.wikipedia.org/wiki/Definite_assignment_analysis) for each stack allocated variable. +- Stores results as predicate in the predicate tree. + +### Memory Analysis +The Memory Analyzer takes an AST and performs the following: + +- Computes [Andersen Style Pointer Analysis](https://courses.cs.washington.edu/courses/cse501/15sp/slides/L5-pointer-analysis.pdf). + - Scans program for constraints as defined in Andersen Style Pointer Analysis. + - Our procedure for finding constraints in LLVM IR as primarily inspired as a subset of this [repository](https://github.com/grievejia/andersen/blob/master/lib/ConstraintCollect.cpp#L290). + - Due to constraints from our parser, there are limitations to our constraint building. + - We are unable to analyze pointers stored in global variables. + - We are unable to process pointers that are passed into a variadic function as a vararg. This is because LLVMLite does not directly give us a way to discern which operands are arguments or operand bundles within a call/invoke/callbr instruction. See the [LLVM reference manual](https://llvm.org/docs/LangRef.html#invoke-instruction) for further details. + - We are unable to process function calls to external libraries. + - We do not implement pointer constraints for exception handling instructions. That can be implemented. + - We do not implement pointer constraints for function pointers passed within constant expressions. Feel free to contribute. + - Creates constraint graph and solves constraints by computing the [dynamic transitive closure](https://en.wikipedia.org/wiki/Transitive_closure). + - We identify [strongly connected components](https://en.wikipedia.org/wiki/Strongly_connected_component) prior to computing the closure in order to reduce time complexity. While we were unable to implement it, there are improved approaches to eliminating cycles. See [The Ant and the Grasshopper: Fast and Accurate Pointer +Analysis for Millions of Lines of Code](https://www.cs.utexas.edu/~lin/papers/pldi07.pdf). This could further improve performance if implemented. +- Computes [alias analysis](https://en.wikipedia.org/wiki/Alias_analysis). +- Stores results as predicate in the predicate tree. + + +### Syntactic Analysis +The Syntactic Analyzer takes an AST and performs the following: +- Extracts the syntactic constructs, storing them as predicates. + - Tree edges can be thought of binary predicates, depicting relationships between syntactic properties. + - Tree vertices can be thought of unary predicates, conveying syntactic properties. +- Stores results as predicate in the predicate tree. + +## Generator +The generator calls our visitor patterns that visit each node in our predicate tree and generate our output. +- Predicate Visitor: + - The predicate visitor generates a list of string predicates. A comprehensive list of all 69 (*28 unary, 41 binary*) current predicates can be found at this [page](/docs/predicates.md). +- Visualizer Visitor: + - The visualizer visitor generates a graphml file that allows you to visualize the knowledge graph via [Gephi](https://gephi.org). \ No newline at end of file diff --git a/docs/future_dev.md b/docs/future_dev.md new file mode 100644 index 0000000..481bd83 --- /dev/null +++ b/docs/future_dev.md @@ -0,0 +1,83 @@ +# Future Development +While I will no longer be working on this project, I hope anyone interested in the idea will contribute their creativity. For those who want to contribute, I have provided some potential next steps. + +## Next Steps +### More Complete Testing +- While I have tested as much as I could in the period I worked on this project, the massive variance in our input due to the size of LLVM IR means there are likely edge cases. +- I have **82%** test coverage of the whole program and have tested translation for over **20** LLVM IR files. Nonetheless, it would be appreciated for someone to implement more extensive end to end tests. + +### Parsing +#### Reduce Dependence on Manual Parsing +- A major difficulty in development was parsing all necessary information from LLVMLite's module data structure. Some desired information it simply does not provide. I attempted to resolve this by manually parsing those specific items via the Lark grammar. However, I worry this restricts us to that specific instance of the LLVM IR grammar and is not fully tested. +- This program was written in python as it was inspired initially by [VANDALIR](https://github.com/vandaltool/vandalir), a python tool that used LLVMLite to convert LLVM IR into datalog. I now question if this would be better implemented in C++, directly utilizing the LLVM IR C++ API. I honestly don't know though. +- A useful contribution would be to identify if there are better ways to parse LLVM IR that avoids manual string parsing. This would avoid edge case errors. +#### Parsing Inline Assembly +- I was not exactly sure how to treat inline assembly when parsing so I did not treat it at all. Exploring this would be a useful addition. +``` +Warning: Inline Assembly "void (i8*, i32, i64)* asm sideeffect "1:\09ud2\0A.pushsection __bug_table,\22a\22\0A2:\09.long 1b - 2b, ${0:c} - 2b\0A\09.word ${1:c}, 0\0A\09.org 2b+${2:c}\0A.popsection", "i,i,i"" parsing is not implemented! +``` + +### Control Flow +#### Indirect Pointer Support +- Indirect pointers cannot be resolved in the control flow analysis. That means we cannot encode inter-procedural predicates that involve a function that is referenced by an indirect function pointer. My understanding is that this can only be done dynamically unless we utilize our memory analysis to supplement our control flow analysis. Exploring this would be useful. +``` +Function '%5' not found in symbol table for function. Possible indirect. +``` +#### Better Constant Expression Support +- Function pointers wrapped in constant expressions such as a `Bitcast` are not resolved in the control flow analysis either. + - For instance, looking at the example below, we lose information regarding this block's call to `@__VERIFIER_atomic_end`. It will not exist in our control flow analysis. This is because, I ultimately did not account for constant expressions as much as I should have. This derives from my own lack of experience in LLVM as I dove into this project. + - Adding more robust support for constant expressions would prevent unnecessary information lose in our translation. +``` +Conversion( + result=%inline, + conv_type=bitcast, + val= + Operand( + id=BCSP_PnpStop_instr_10_operand_0_const_0_const_expr_0_operand_0, + value=@__VERIFIER_atomic_end, + type=void (...)*, + is_const=True + ), + new_type=void ()* + ) +``` +### Data Flow +#### Adding relationships between each procedure. +- Data flow analysis is performed on each procedure but they all remain independent. If we were to relate them to one another, we could paint a more accurate picture of how data moves through the entire program. +- Take for example how much information we lose by not being able to track global variables' propagation into different procedures. +- Exploring this would be beneficial. + +### Memory Analysis +#### Improving Constraint Solver Performance +- [The Ant and the Grasshopper: Fast and Accurate Pointer +Analysis for Millions of Lines of Code](https://www.cs.utexas.edu/~lin/papers/pldi07.pdf) details a high performance algorithm for solving our pointer constraints in Andersen Style Pointer Analysis. Implementing this as a replacement to the current algorithm would offer better performance. + +#### Improving Constraint Coverage +- To compute Andersen Analysis, we traverse our LLVM IR program in search of operations involving multiple pointers. We generate a set of constraints representing each pointer operation, solving for that to identify where each pointer points to. +- Currently, we apply a shallow perspective to global variables where each global variable is really a pointer to some global variable. We do not check what value the global holds (which may be a pointer). +- Because of parsing limitations, we are only able to build constraints based on arguments passed into functions as **fixed arguments**. This means if we have a variadic function as below: +``` +int variadic_example(int* count, ...) +``` +- We only track the `count` pointer. If more pointers are passed in for `...`, we cannot identify or track them. +- Implementing more robust manual argument parsing for `call`, `invoke`, and `callbr` instructions would resolve this. +- We cannot process information regarding pointers derived from external libraries such as: +``` +%15 = call i8* @malloc(i64 noundef 4) +``` +- We do not implement pointer constraint building for pointers derived from exception handling instructions. + +## Contributing + +- Information regarding contributing to a project can be found [here](https://docs.github.com/en/get-started/exploring-projects-on-github/contributing-to-a-project). + +- You can add to unit tests in `test/unit_tests` to test your modifications. To run all unit tests, run: +``` +cd Wyvern-Graph +python ./test/run_unit_tests.py +``` +- To confirm example files run, use: +``` +cd Wyvern-Graph +python ./test/run_examples.py +``` diff --git a/docs/getting_started.md b/docs/getting_started.md new file mode 100644 index 0000000..820c7a1 --- /dev/null +++ b/docs/getting_started.md @@ -0,0 +1,79 @@ +# Getting Started +This documentation will detail the basics of installing and using this program. + +## Installation +1. Install [Python 3.10](https://www.python.org/downloads/) or higher. +2. Clone the repository to your local machine using Git: +``` +git clone https://github.com/cscaff/Wyvern-Graph.git +``` +1. Create Virtual Environment +``` +Mac OS: +1. python -m venv wyvern-env +2. source wyvern-env/bin/activate +``` +``` +Windows: +1. python -m venv wyvern-env +2. wyvern-env\Scripts\activate +``` +1. Install Dependencies +``` +pip install -r requirements.txt +``` +You're all set! +## Usage + +### Prerequisites +It should be noted that this program has only been tested with C and C++ files compiled into LLVM IR via [Clang/Clang++ 15](https://releases.llvm.org/15.0.0/tools/clang/docs/ReleaseNotes.html) as LLVM 15 is the default version for our core dependency, [LLVMLite 0.44.0](https://llvmlite.readthedocs.io/en/v0.44.0/). For usage, it is recommended to use LLVM IR files emitted via Clang 15. This can be done with the following command: +``` + -S -emit-llvm -Xclang -no-opaque-pointers -o +``` +Command Specifics: +1. `-S`: Generate assembly rather than binary. +2. `-emit-llvm`: Emit IR rather than assembly. +3. `-Xclang -no-opaque-pointers`: Disable opaque pointers. Wy-Graph's parser is dependent on LLVMLite which does not support opaque pointers. +4. `-o .ll`: Name of output LLVM IR file. + +### Running the Translator +Running the program is simple and only takes one command! +``` +python -m src [--visualize ] [--output ] [--debug] +``` +#### Options: + - `--visualize`: Specifies path to the ".graphml" graph file. + - `--output`: Specifies path to ".txt" predicates file. + - Defaults to `output_predicates.txt` + - `--debug`: Displays detailed processing information for debugging. This includes printing the limitations of the translator. + +#### Example: +``` +python -m input.ll --visualize visual.graphml --output predicates.txt +``` + +### Notice +I want to make it clear that while I have extensively tested this program, the size and nature of the LLVM IR language inevitably leaves us with edge-cases I may have missed in the short time I had to work on this. + +If you encounter an issue or failure while running this program on a sound LLVM IR file, there is a good chance you found a minor bug that can be quickly fixed. Feel free to contribute a fix via a pull-request. +#### Test Coverage +``` +Name Stmts Miss Cover +------------------------------------------------------------- +src/AST/instructions.py 528 0 100% +src/AST/module.py 155 0 100% +src/Grammar/lark_interface.py 188 6 97% +src/PredTree/predicates.py 685 86 87% +src/PredTree/visit_visualizer.py 207 207 0% +src/PredTree/visitor.py 167 167 0% +src/Translator/Analyzer/control_flow.py 160 5 97% +src/Translator/Analyzer/data_flow.py 268 17 94% +src/Translator/Analyzer/memory.py 249 13 95% +src/Translator/Analyzer/syntax.py 237 53 78% +src/Translator/analyzer.py 105 12 89% +src/Translator/generator.py 16 16 0% +src/Translator/parser.py 546 8 99% +src/__main__.py 41 41 0% +------------------------------------------------------------- +TOTAL 3552 631 82% +``` \ No newline at end of file diff --git a/docs/logo.png b/docs/logo.png new file mode 100644 index 0000000..80a33b0 Binary files /dev/null and b/docs/logo.png differ diff --git a/docs/predicates.md b/docs/predicates.md new file mode 100644 index 0000000..8a1a591 --- /dev/null +++ b/docs/predicates.md @@ -0,0 +1,104 @@ +# Formal Predicate Language + +This document presents all possible predicates our LLVM IR input can decompose to. + +## Unary Predicates + +### Control Flow +1. `entry(X)`: X is a basic block. +2. `exit(X)`: X is a basic block. +3. `loop(X)`: X is a loop. + +### Syntax: +1. `module(X)`: X is a program module. +2. `data_layout(X)`: X is the data layout string for the module. +3. `target_triple(X)`: X is the target triple string for the module. +4. `global_variable(X)`: X is a global variable. +5. `function(X)`: X is a function. +6. `declaration(X)`: X is a function declaration. +7. `definition(X)`: X is a function definition. +8. `argument(X)`: X is a function argument. +9. `block(X)`: X is a basic block. +10. `instruction(X)`: X is an instruction. +11. `binary_operation(X)`: X is a binary instruction. +12. `unary_operation(X)`: X is an unary instruction. +13. `terminator(X)`: X is a terminator instruction. +14. `vector_operation(X)`: X is a vector operation instruction. +15. `aggregate_operation(X)`: X is an aggregate operation instruction. +16. `conversion_operation(X)`: X is a conversion instruction. +17. `phi_operation(X)`: X is a phi instruction. +18. `inter_procedural_flow_operation(X)`: X is an instruction that branches to another instruction. +19. `memory_operation(X)`: X is an instruction dealing with memory. +20. `virtual_register(X)`: X is a virtual register. +21. `local_variable(X)`: X is a stack allocated variable within a function. +22. `memory_location(X)`: X is an address in memory. +23. `operand(X)`: X is an instruction operand. +24. `constant(X)`: X is a constant value. +25. `attribute(X)`: X is an attribute. + +## Binary Predicates + +### Control Flow +1. `has_successor(X, Y)`: Block X is succeeded by block Y. +2. `has_predecessor(X, Y)`: Block X is preceded by block Y. +3. `dominates(X, Y)`: Block X dominates block Y. +4. `post_dominates(X, Y)`: Block X post dominates block Y. +5. `loop_header(X, Y)`: Loop X has loop header block Y. +6. `in_loop(X, Y)`: Block X resides in loop Y. +7. `originates_from(X, Y)`: Block X of callee is called in block Y of caller function. +8. `returns_from(X, Y)`: Block X of callee returns to block Y of caller function. +9. `exception_flow(X, Y)`: Block X may throw an exception to catch block Y. + +### Data Flow +1. `reaches(X, Y)`: Definition X reaches block Y. +2. `defines_register(X, Y)`: Instruction X defines virtual register Y. +3. `uses(X, Y)`: Instruction X uses value Y. +4. `live_in(X, Y)`: Stack allocated variable X is live entering block Y. +5. `live_out(X, Y)`: Stack allocated variable X is live leaving block Y. +6. `definitely_assigned(X, Y)`: Stack allocated variable X is definitely assigned at block Y. +7. `definitely_unassigned(X, Y)`: Stack allocated variable X is definitely unassigned at block Y. +8. `unknown_assignment(X, Y)`: Stack allocated variable X has an undefined assignment status at block Y. + +### Memory +1. `allocates(X, Y)`: Instruction X allocates type width Y. +2. `loads(X, Y)`: Instruction X loads value from address Y. +3. `stores_val(X, Y)`: Instruction X stores value Y. +4. `stores_at(X, Y)`: Instruction X stores value at address Y. +5. `ordering(X, Y)`: Instruction X has ordering Y. +6. `points_to(X, Y)`: Pointer X points to object Y. +7. `may_alias(X, Y)`: Pointer X may alias pointer Y. + +### Syntax + +#### Module +1. `has_data_layout(X, Y)`: Module X has data layout string Y. +2. `has_target_triple(X, Y)`: Module X has target triple string Y. +3. `has_global_variable(X, Y)`: Module X has global variable Y. +4. `has_function(X, Y)`: Module X has function Y. + +#### Global Properties +1. `has_linkage(X, Y)`: Global item X has linkage Y. +2. `has_visibility(X, Y)`: Global item X has visibility Y. + +#### Global Variables +1. `has_initializer(X, Y)`: Variable X has initial value Y. +2. `has_storage_class(X, Y)`: Variable X has storage class Y. + +#### Functions +1. `has_argument(X, Y)`: Function X has argument Y. +2. `has_block(X, Y)`: Function X has block Y. + +#### Blocks +1. `has_instruction(X, Y)`: Block X has instruction Y. + +#### Instructions +1. `has_opcode(X, Y)`: Instruction X has opcode Y. +2. `has_operand(X, Y)`: Instruction X has operand Y. + +#### Constants +1. `has_expression(X, Y)`: Constant X has expression Y. + +#### Generic Properties +1. `has_type(X, Y)`: Item X has type Y. +2. `has_value(X, Y)`: Item X has value Y. +3. `has_attribute(X, Y)`: Item X has attribute Y. \ No newline at end of file diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index f3e7ac8..0000000 --- a/requirements.txt +++ /dev/null @@ -1,4 +0,0 @@ -alive_progress==3.3.0 # Progress Bar Display -lark==1.2.2 # Manual Parser Generator -llvmlite==0.44.0 # LLVM Lite Binding -python_igraph==0.11.9 # iGraph \ No newline at end of file diff --git a/src/PredTree/predicates.py b/src/PredTree/predicates.py index 0b5f96c..37ba2f6 100644 --- a/src/PredTree/predicates.py +++ b/src/PredTree/predicates.py @@ -583,7 +583,7 @@ def accept(self, visitor): class StoresValPredicate(PredicateNode): """StoresValPredicate - stores_val(X, Y) | {inst. X stores value Y}. + stores(X, Y) | {inst. X stores value Y}. """ def __init__(self, X, Y): @@ -647,10 +647,10 @@ def accept(self, visitor): visitor.visit_local_variable_predicate(self) -class HasAtomicOrdering(PredicateNode): - """HasAtomicOrdering +class OrderingPredicate(PredicateNode): + """Ordering Predicate - has_atomic_ordering(X, Y) | {inst. X has atomic ordering Y}. + ordering(X, Y) | {instruction X has ordering Y}. """ def __init__(self, X, Y): @@ -659,7 +659,7 @@ def __init__(self, X, Y): def __eq__(self, other): return ( - isinstance(other, HasAtomicOrdering) + isinstance(other, OrderingPredicate) and self.X == other.X and self.Y == other.Y ) @@ -668,7 +668,7 @@ def __hash__(self): return hash((self.X, self.Y)) def accept(self, visitor): - visitor.visit_has_atomic_ordering(self) + visitor.visit_ordering(self) # ------------ Andersen Pointer Analysis ------------ @@ -1053,7 +1053,7 @@ def accept(self, visitor): class HasExprPredicate(PredicateNode): """HasExprPredicate - has_expression(X) | {Constant X has constant expression Y}. + has_expression(X, Y) | {Constant X has constant expression Y}. """ def __init__(self, X, Y): @@ -1497,126 +1497,6 @@ def accept(self, visitor): visitor.visit_memory_operation_predicate(self) -class AllocatesPredicate(PredicateNode): - """AllocatesPredicate - - allocates(X, Y) | {instruction X allocates width Y}. - """ - - def __init__(self, X, Y): - self.X = X - self.Y = Y - - def __eq__(self, other): - return ( - isinstance(other, AllocatesPredicate) - and self.X == other.X - and self.Y == other.Y - ) - - def __hash__(self): - return hash((self.X, self.Y)) - - def accept(self, visitor): - visitor.visit_allocates_predicate(self) - - -class LoadsPredicate(PredicateNode): - """LoadsPredicate - - loads(X, Y) | {instruction X loads pointer Y}. - """ - - def __init__(self, X, Y): - self.X = X - self.Y = Y - - def __eq__(self, other): - return ( - isinstance(other, LoadsPredicate) - and self.X == other.X - and self.Y == other.Y - ) - - def __hash__(self): - return hash((self.X, self.Y)) - - def accept(self, visitor): - visitor.visit_loads_predicate(self) - - -class StoresPredicate(PredicateNode): - """StoresPredicate - - stores(X, Y) | {instruction X stores register value Y}. - """ - - def __init__(self, X, Y): - self.X = X - self.Y = Y - - def __eq__(self, other): - return ( - isinstance(other, StoresPredicate) - and self.X == other.X - and self.Y == other.Y - ) - - def __hash__(self): - return hash((self.X, self.Y)) - - def accept(self, visitor): - visitor.visit_stores_predicate(self) - - -class OrderingPredicate(PredicateNode): - """StoresPredicate - - ordering(X, Y) | {instruction X has ordering Y}. - """ - - def __init__(self, X, Y): - self.X = X - self.Y = Y - - def __eq__(self, other): - return ( - isinstance(other, OrderingPredicate) - and self.X == other.X - and self.Y == other.Y - ) - - def __hash__(self): - return hash((self.X, self.Y)) - - def accept(self, visitor): - visitor.visit_ordering(self) - - -class StoresAtPredicate(PredicateNode): - """StoresPredicate - - stores(X, Y) | {instruction X stores register value at pointer Y}. - """ - - def __init__(self, X, Y): - self.X = X - self.Y = Y - - def __eq__(self, other): - return ( - isinstance(other, StoresAtPredicate) - and self.X == other.X - and self.Y == other.Y - ) - - def __hash__(self): - return hash((self.X, self.Y)) - - def accept(self, visitor): - visitor.visit_stores_at_predicate(self) - - class VirtualRegisterPredicate(PredicateNode): """VirtualRegisterPredicate @@ -1636,25 +1516,6 @@ def accept(self, visitor): visitor.visit_virtual_register_predicate(self) -class LocalVariablePredicate(PredicateNode): - """LocalVariablePredicate - - local_variable(X) | {X is a local variable declaration}. - """ - - def __init__(self, X): - self.X = X - - def __eq__(self, other): - return isinstance(other, LocalVariablePredicate) and self.X == other.X - - def __hash__(self): - return hash((self.X)) - - def accept(self, visitor): - visitor.visit_local_variable_predicate(self) - - class MemoryLocationPredicate(PredicateNode): """MemoryLocationPredicate diff --git a/src/PredTree/visit_visualizer.py b/src/PredTree/visit_visualizer.py index 7fc9179..79844de 100644 --- a/src/PredTree/visit_visualizer.py +++ b/src/PredTree/visit_visualizer.py @@ -231,7 +231,7 @@ def visit_allocates_predicate(self, node): def visit_loads_predicate(self, node): self._add_edge(node.X, node.Y, label="loads", category="memory") - def visit_stores_predicate(self, node): + def visit_stores_val_predicate(self, node): self._add_edge(node.X, node.Y, label="stores", category="memory") def visit_stores_at_predicate(self, node): diff --git a/src/PredTree/visitor.py b/src/PredTree/visitor.py index a467311..23c2c44 100644 --- a/src/PredTree/visitor.py +++ b/src/PredTree/visitor.py @@ -115,7 +115,7 @@ def visit_allocates_predicate(self, node): def visit_loads_predicate(self, node): self.memory.append(f"loads({node.X}, {node.Y})") - def visit_stores_predicate(self, node): + def visit_stores_val_predicate(self, node): self.memory.append(f"stores({node.X}, {node.Y})") def visit_stores_at_predicate(self, node): diff --git a/src/Translator/Analyzer/syntax.py b/src/Translator/Analyzer/syntax.py index 2731af6..04b2f9e 100644 --- a/src/Translator/Analyzer/syntax.py +++ b/src/Translator/Analyzer/syntax.py @@ -249,7 +249,7 @@ def extract_instruction(self, function: Function, instruction: Instruction): elif isinstance(instruction, StoreInstruction): opcode = "store" predicates.append(MemoryOperationPredicate(instruction.id)) - predicates.append(StoresPredicate(instruction.id, instruction.val.id)) + predicates.append(StoresValPredicate(instruction.id, instruction.val.id)) predicates.append(StoresAtPredicate(instruction.id, instruction.ptr.id)) elif isinstance(instruction, FenceInstruction): opcode = "fence" diff --git a/test/unit_tests/Translator/Analyzer/syntax.py b/test/unit_tests/Translator/Analyzer/syntax.py index 49dd74e..37cbd25 100644 --- a/test/unit_tests/Translator/Analyzer/syntax.py +++ b/test/unit_tests/Translator/Analyzer/syntax.py @@ -853,7 +853,7 @@ def test_instruction_extraction_store(self): expected_predicates = { InstructionPredicate("test_instr_1"), MemoryOperationPredicate("test_instr_1"), - StoresPredicate("test_instr_1", "test_instr_1_operand_0"), + StoresValPredicate("test_instr_1", "test_instr_1_operand_0"), StoresAtPredicate("test_instr_1", "test_instr_1_operand_1"), HasOpcodePredicate("test_instr_1", "store"), HasOperandPredicate("test_instr_1", "test_instr_1_operand_0"),