├── .github └── workflows │ ├── blacklist.cex-y2.txt │ ├── blacklist.cex.txt │ ├── blacklist.df-coi.txt │ ├── blacklist.smack.txt │ ├── blacklist.vac.txt │ ├── fuzz.yml │ ├── klee.yml │ ├── main.yml │ └── smack.yml ├── .gitignore ├── .travis.yml ├── CMakeLists.txt ├── CMakePresets.json ├── README.md ├── assets ├── arch.png ├── fmcad2022.pdf └── paper_expanded.pdf ├── azure-pipelines.yml ├── cmake └── llvmir │ ├── LICENSE │ ├── LLVMIRUtil.cmake │ ├── LLVMIRUtilInternal.cmake │ ├── README.md │ └── SOURCE ├── docker ├── aws-c-common.Dockerfile ├── verify-c-common-fuzz.Dockerfile ├── verify-c-common-klee.Dockerfile ├── verify-c-common-smack.Dockerfile ├── verify-c-common-symbiotic.Dockerfile └── verify-c-common.Dockerfile ├── experiment_results.ipynb ├── patch ├── 0001-fix-undefined-behavior-in-aws_is_mem_zeroed.patch ├── 0002-feat-define-assert-macros-for-SeaHorn.patch └── README.md ├── res ├── aws-cbmc.csv ├── klee.csv ├── loc.csv ├── seahorn.csv ├── smack.csv └── symbiotic.csv ├── scripts ├── get_exper_brunch_stat.py ├── get_exper_res.py ├── get_fuzzing_coverage.py ├── get_loc_info.py ├── metrics.yaml └── run_aws_res.py ├── seahorn ├── CMakeLists.txt ├── aws-c-common-stubs │ ├── CMakeLists.txt │ ├── aws_hash_iter_overrides.c │ ├── byte_cursor_advance_nospec_override.c │ ├── hash_table_state_is_valid_ignore_entry_count_override.c │ ├── hash_table_state_is_valid_override.c │ ├── s_emplace_item_override.c │ ├── s_expand_table_override.c │ ├── s_hash_for_override.c │ ├── s_remove_node_override.c │ ├── s_safe_eq_check_override.c │ ├── s_sift_either_override.c │ ├── s_sift_up_override.c │ └── s_update_template_size_override.c ├── include │ ├── array_list_helper.h │ ├── aws │ │ └── common │ │ │ └── config.h │ ├── bounds.h │ ├── byte_buf_helper.h │ ├── cbmc │ │ └── ring_buffer_abstract_states.h │ ├── config.h.in │ ├── hash_table_helper.h │ ├── klee_switch.h │ ├── linked_list_helper.h │ ├── macros.h │ ├── nondet.h │ ├── priority_queue_helper.h │ ├── proof_allocators.h │ ├── ring_buffer_helper.h │ ├── sea_allocators.h │ ├── sea_mem_helper.h │ ├── sea_string.h │ ├── smack │ │ └── smack.h │ ├── string_helper.h │ └── utils.h ├── jobs │ ├── add_size_checked │ │ ├── CMakeLists.txt │ │ └── aws_add_size_checked_harness.c │ ├── add_size_saturating │ │ ├── CMakeLists.txt │ │ └── aws_add_size_saturating_harness.c │ ├── array_eq │ │ ├── CMakeLists.txt │ │ ├── aws_array_eq_harness.c │ │ └── sea.yaml │ ├── array_eq_c_str │ │ ├── CMakeLists.txt │ │ ├── aws_array_eq_c_str_harness.c │ │ └── sea.yaml │ ├── array_eq_c_str_ignore_case │ │ ├── CMakeLists.txt │ │ ├── aws_array_eq_c_str_ignore_case_harness.c │ │ └── sea.yaml │ ├── array_eq_ignore_case │ │ ├── CMakeLists.txt │ │ ├── aws_array_eq_ignore_case_harness.c │ │ └── sea.yaml │ ├── array_list_back │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_back_harness.c │ │ └── sea.yaml │ ├── array_list_capacity │ │ ├── CMakeLists.txt │ │ └── aws_array_list_capacity_harness.c │ ├── array_list_clean_up │ │ ├── CMakeLists.txt │ │ └── aws_array_list_clean_up_harness.c │ ├── array_list_clear │ │ ├── CMakeLists.txt │ │ └── aws_array_list_clear_harness.c │ ├── array_list_comparator_string │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_comparator_string_harness.c │ │ └── sea.yaml │ ├── array_list_copy │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_copy_harness.c │ │ └── sea.yaml │ ├── array_list_ensure_capacity │ │ ├── CMakeLists.txt │ │ └── aws_array_list_ensure_capacity_harness.c │ ├── array_list_erase │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_erase_harness.c │ │ └── sea.yaml │ ├── array_list_front │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_front_harness.c │ │ └── sea.yaml │ ├── array_list_get_at │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_get_at_harness.c │ │ └── sea.yaml │ ├── array_list_get_at_ptr │ │ ├── CMakeLists.txt │ │ └── aws_array_list_get_at_ptr_harness.c │ ├── array_list_init_dynamic │ │ ├── CMakeLists.txt │ │ └── aws_array_list_init_dynamic_harness.c │ ├── array_list_init_static │ │ ├── CMakeLists.txt │ │ └── aws_array_list_init_static_harness.c │ ├── array_list_length │ │ ├── CMakeLists.txt │ │ └── aws_array_list_length_harness.c │ ├── array_list_pop_back │ │ ├── CMakeLists.txt │ │ └── aws_array_list_pop_back_harness.c │ ├── array_list_pop_front │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_pop_front_harness.c │ │ └── sea.yaml │ ├── array_list_pop_front_n │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_pop_front_n_harness.c │ │ └── sea.yaml │ ├── array_list_push_back │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_push_back_harness.c │ │ └── sea.yaml │ ├── array_list_push_front │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_push_front_harness.c │ │ └── sea.yaml │ ├── array_list_set_at │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_set_at_harness.c │ │ └── sea.yaml │ ├── array_list_shrink_to_fit │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_shrink_to_fit_harness.c │ │ └── sea.yaml │ ├── array_list_sort │ │ ├── CMakeLists.txt │ │ └── aws_array_list_sort_harness.c │ ├── array_list_swap │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_swap_harness.c │ │ └── sea.yaml │ ├── array_list_swap_contents │ │ ├── CMakeLists.txt │ │ └── aws_array_list_swap_contents_harness.c │ ├── byte_buf_advance │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_advance_harness.c │ ├── byte_buf_append │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_append_harness.c │ ├── byte_buf_append_dynamic │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_append_dynamic_harness.c │ ├── byte_buf_append_with_lookup │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_append_with_lookup_harness.c │ │ └── sea.yaml │ ├── byte_buf_cat │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_cat_harness.c │ │ └── sea.yaml │ ├── byte_buf_clean_up │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_clean_up_harness.c │ ├── byte_buf_clean_up_secure │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_clean_up_secure_harness.c │ ├── byte_buf_eq │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_eq_harness.c │ │ └── sea.yaml │ ├── byte_buf_eq_c_str │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_eq_c_str_harness.c │ │ └── sea.yaml │ ├── byte_buf_eq_c_str_ignore_case │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_eq_c_str_ignore_case_harness.c │ │ └── sea.yaml │ ├── byte_buf_eq_ignore_case │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_eq_ignore_case_harness.c │ │ └── sea.yaml │ ├── byte_buf_from_array │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_from_array_harness.c │ ├── byte_buf_from_c_str │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_from_c_str_harness.c │ │ └── sea.yaml │ ├── byte_buf_from_empty_array │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_from_empty_array_harness.c │ ├── byte_buf_init │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_init_harness.c │ ├── byte_buf_init_copy │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_init_copy_harness.c │ │ └── sea.yaml │ ├── byte_buf_init_copy_from_cursor │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_init_copy_from_cursor_harness.c │ │ └── sea.yaml │ ├── byte_buf_reserve │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_reserve_harness.c │ │ └── sea.yaml │ ├── byte_buf_reserve_relative │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_reserve_relative_harness.c │ ├── byte_buf_reset │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_reset_harness.c │ │ └── sea.yaml │ ├── byte_buf_secure_zero │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_secure_zero_harness.c │ │ └── sea.yaml │ ├── byte_buf_write │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_write_harness.c │ │ └── sea.yaml │ ├── byte_buf_write_be16 │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_write_be16_harness.c │ ├── byte_buf_write_be32 │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_write_be32_harness.c │ ├── byte_buf_write_be64 │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_write_be64_harness.c │ ├── byte_buf_write_from_whole_buffer │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_write_from_whole_buffer_harness.c │ │ └── sea.yaml │ ├── byte_buf_write_from_whole_cursor │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_write_from_whole_cursor_harness.c │ │ └── sea.yaml │ ├── byte_buf_write_from_whole_string │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_write_from_whole_string_harness.c │ │ └── sea.yaml │ ├── byte_buf_write_u8 │ │ ├── CMakeLists.txt │ │ └── aws_byte_buf_write_u8_harness.c │ ├── byte_cursor_advance │ │ ├── CMakeLists.txt │ │ └── aws_byte_cursor_advance_harness.c │ ├── byte_cursor_advance_nospec │ │ ├── CMakeLists.txt │ │ └── aws_byte_cursor_advance_nospec_harness.c │ ├── byte_cursor_compare_lexical │ │ ├── CMakeLists.txt │ │ └── aws_byte_cursor_compare_lexical_harness.c │ ├── byte_cursor_compare_lookup │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_compare_lookup_harness.c │ │ └── sea.yaml │ ├── byte_cursor_eq │ │ ├── CMakeLists.txt │ │ └── aws_byte_cursor_eq_harness.c │ ├── byte_cursor_eq_byte_buf │ │ ├── .DS_Store │ │ ├── CMakeLists.txt │ │ └── aws_byte_cursor_eq_byte_buf_harness.c │ ├── byte_cursor_eq_byte_buf_ignore_case │ │ ├── .DS_Store │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_eq_byte_buf_ignore_case_harness.c │ │ └── sea.yaml │ ├── byte_cursor_eq_c_str │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_eq_c_str_harness.c │ │ └── sea.yaml │ ├── byte_cursor_eq_c_str_ignore_case │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_eq_c_str_ignore_case_harness.c │ │ └── sea.yaml │ ├── byte_cursor_eq_ignore_case │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_eq_ignore_case_harness.c │ │ └── sea.yaml │ ├── byte_cursor_from_array │ │ ├── CMakeLists.txt │ │ └── aws_byte_cursor_from_array_harness.c │ ├── byte_cursor_from_buf │ │ ├── CMakeLists.txt │ │ └── aws_byte_cursor_from_buf_harness.c │ ├── byte_cursor_from_c_str │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_from_c_str_harness.c │ │ └── sea.yaml │ ├── byte_cursor_from_string │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_from_string_harness.c │ │ └── sea.yaml │ ├── byte_cursor_left_trim_pred │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_left_trim_pred_harness.c │ │ └── sea.yaml │ ├── byte_cursor_read │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_read_harness.c │ │ └── sea.yaml │ ├── byte_cursor_read_and_fill_buffer │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_read_and_fill_buffer_harness.c │ │ └── sea.yaml │ ├── byte_cursor_read_be16 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_read_be16_harness.c │ │ └── sea.yaml │ ├── byte_cursor_read_be32 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_read_be32_harness.c │ │ └── sea.yaml │ ├── byte_cursor_read_be64 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_read_be64_harness.c │ │ └── sea.yaml │ ├── byte_cursor_read_u8 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_read_u8_harness.c │ │ └── sea.yaml │ ├── byte_cursor_right_trim_pred │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_right_trim_pred_harness.c │ │ └── sea.yaml │ ├── byte_cursor_satisfies_pred │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_satisfies_pred_harness.c │ │ └── sea.yaml │ ├── byte_cursor_trim_pred │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_trim_pred_harness.c │ │ └── sea.yaml │ ├── hash_array_ignore_case │ │ ├── CMakeLists.txt │ │ ├── aws_hash_array_ignore_case_harness.c │ │ └── sea.yaml │ ├── hash_byte_cursor_ptr │ │ ├── CMakeLists.txt │ │ ├── aws_hash_byte_cursor_ptr_harness.c │ │ └── sea.yaml │ ├── hash_byte_cursor_ptr_ignore_case │ │ ├── CMakeLists.txt │ │ ├── aws_hash_byte_cursor_ptr_ignore_case_harness.c │ │ └── sea.yaml │ ├── hash_c_string │ │ ├── CMakeLists.txt │ │ ├── aws_hash_c_string_harness.c │ │ └── sea.yaml │ ├── hash_callback_c_str_eq │ │ ├── CMakeLists.txt │ │ ├── aws_hash_callback_c_str_eq_harness.c │ │ └── sea.yaml │ ├── hash_callback_string_destroy │ │ ├── CMakeLists.txt │ │ └── aws_hash_callback_string_destroy_harness.c │ ├── hash_callback_string_eq │ │ ├── CMakeLists.txt │ │ ├── aws_hash_callback_string_eq_harness.c │ │ └── sea.yaml │ ├── hash_iter_begin │ │ ├── CMakeLists.txt │ │ ├── aws_hash_iter_begin_harness.c │ │ └── sea.yaml │ ├── hash_iter_begin_done │ │ ├── CMakeLists.txt │ │ ├── aws_hash_iter_begin_done_harness.c │ │ └── sea.yaml │ ├── hash_iter_delete │ │ ├── CMakeLists.txt │ │ ├── aws_hash_iter_delete_harness.c │ │ └── sea.yaml │ ├── hash_iter_done │ │ ├── CMakeLists.txt │ │ └── aws_hash_iter_done_harness.c │ ├── hash_iter_next │ │ ├── CMakeLists.txt │ │ ├── aws_hash_iter_next_harness.c │ │ └── sea.yaml │ ├── hash_ptr │ │ ├── CMakeLists.txt │ │ └── aws_hash_ptr_harness.c │ ├── hash_string │ │ ├── CMakeLists.txt │ │ └── aws_hash_string_harness.c │ ├── hash_table_clean_up │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_clean_up_harness.c │ │ └── sea.yaml │ ├── hash_table_clear │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_clear_harness.c │ │ └── sea.yaml │ ├── hash_table_create │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_create_harness.c │ │ └── sea.yaml │ ├── hash_table_eq │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_eq_harness.c │ │ └── sea.yaml │ ├── hash_table_find │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_find_harness.c │ │ └── sea.yaml │ ├── hash_table_foreach │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_foreach_harness.c │ │ └── sea.yaml │ ├── hash_table_foreach_deep_loose │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_foreach_deep_loose_harness.c │ │ └── sea.yaml │ ├── hash_table_foreach_deep_precise │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_foreach_deep_precise_harness.c │ │ └── sea.yaml │ ├── hash_table_get_entry_count │ │ ├── CMakeLists.txt │ │ └── aws_hash_table_get_entry_count_harness.c │ ├── hash_table_init_bounded │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_init_bounded_harness.c │ │ └── sea.yaml │ ├── hash_table_init_unbounded │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_init_unbounded_harness.c │ │ └── sea.yaml │ ├── hash_table_move │ │ ├── CMakeLists.txt │ │ └── aws_hash_table_move_harness.c │ ├── hash_table_put │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_put_harness.c │ │ └── sea.yaml │ ├── hash_table_remove │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_remove_harness.c │ │ └── sea.yaml │ ├── hash_table_swap │ │ ├── CMakeLists.txt │ │ └── aws_hash_table_swap_harness.c │ ├── is_power_of_two │ │ ├── CMakeLists.txt │ │ └── aws_is_power_of_two_harness.c │ ├── linked_list_back │ │ ├── CMakeLists.txt │ │ ├── aws_linked_list_back_harness.c │ │ └── sea.yaml │ ├── linked_list_begin │ │ ├── CMakeLists.txt │ │ ├── aws_linked_list_begin_harness.c │ │ └── sea.yaml │ ├── linked_list_end │ │ ├── CMakeLists.txt │ │ └── aws_linked_list_end_harness.c │ ├── linked_list_front │ │ ├── CMakeLists.txt │ │ ├── aws_linked_list_front_harness.c │ │ └── sea.yaml │ ├── linked_list_init │ │ ├── CMakeLists.txt │ │ └── aws_linked_list_init_harness.c │ ├── linked_list_insert_after │ │ ├── CMakeLists.txt │ │ └── aws_linked_list_insert_after_harness.c │ ├── linked_list_insert_before │ │ ├── CMakeLists.txt │ │ └── aws_linked_list_insert_before_harness.c │ ├── linked_list_next │ │ ├── CMakeLists.txt │ │ └── aws_linked_list_next_harness.c │ ├── linked_list_node_reset │ │ ├── CMakeLists.txt │ │ ├── aws_linked_list_node_reset_harness.c │ │ └── sea.yaml │ ├── linked_list_pop_back │ │ ├── CMakeLists.txt │ │ └── aws_linked_list_pop_back_harness.c │ ├── linked_list_pop_front │ │ ├── CMakeLists.txt │ │ └── aws_linked_list_pop_front_harness.c │ ├── linked_list_prev │ │ ├── CMakeLists.txt │ │ └── aws_linked_list_prev_harness.c │ ├── linked_list_push_back │ │ ├── CMakeLists.txt │ │ └── aws_linked_list_push_back_harness.c │ ├── linked_list_push_front │ │ ├── CMakeLists.txt │ │ └── aws_linked_list_push_front_harness.c │ ├── linked_list_rbegin │ │ ├── CMakeLists.txt │ │ ├── aws_linked_list_rbegin_harness.c │ │ └── sea.yaml │ ├── linked_list_remove │ │ ├── CMakeLists.txt │ │ └── aws_linked_list_remove_harness.c │ ├── linked_list_rend │ │ ├── CMakeLists.txt │ │ ├── aws_linked_list_rend_harness.c │ │ └── sea.yaml │ ├── linked_list_swap_contents │ │ ├── CMakeLists.txt │ │ └── aws_linked_list_swap_contents_harness.c │ ├── mul_size_checked │ │ ├── CMakeLists.txt │ │ └── aws_mul_size_checked_harness.c │ ├── mul_size_saturating │ │ ├── CMakeLists.txt │ │ └── aws_mul_size_saturating_harness.c │ ├── nospec_mask │ │ ├── CMakeLists.txt │ │ └── aws_nospec_mask_harness.c │ ├── priority_queue_capacity │ │ ├── CMakeLists.txt │ │ └── aws_priority_queue_capacity_harness.c │ ├── priority_queue_clean_up │ │ ├── CMakeLists.txt │ │ └── aws_priority_queue_clean_up_harness.c │ ├── priority_queue_init_dynamic │ │ ├── CMakeLists.txt │ │ ├── aws_priority_queue_init_dynamic_harness.c │ │ └── sea.yaml │ ├── priority_queue_init_static │ │ ├── CMakeLists.txt │ │ ├── aws_priority_queue_init_static_harness.c │ │ └── sea.yaml │ ├── priority_queue_pop │ │ ├── CMakeLists.txt │ │ └── aws_priority_queue_pop_harness.c │ ├── priority_queue_push │ │ ├── CMakeLists.txt │ │ ├── aws_priority_queue_push_harness.c │ │ └── sea.yaml │ ├── priority_queue_push_ref │ │ ├── CMakeLists.txt │ │ ├── aws_priority_queue_push_ref_harness.c │ │ └── sea.yaml │ ├── priority_queue_remove │ │ ├── CMakeLists.txt │ │ └── aws_priority_queue_remove_harness.c │ ├── priority_queue_s_remove_node │ │ ├── CMakeLists.txt │ │ ├── aws_priority_queue_s_remove_node_harness.c │ │ └── sea.yaml │ ├── priority_queue_s_sift_down │ │ ├── CMakeLists.txt │ │ ├── aws_priority_queue_s_sift_down_harness.c │ │ └── sea.yaml │ ├── priority_queue_s_sift_either │ │ ├── CMakeLists.txt │ │ ├── aws_priority_queue_s_sift_either_harness.c │ │ └── sea.yaml │ ├── priority_queue_s_sift_up │ │ ├── CMakeLists.txt │ │ ├── aws_priority_queue_s_sift_up_harness.c │ │ └── sea.yaml │ ├── priority_queue_s_swap │ │ ├── CMakeLists.txt │ │ ├── aws_priority_queue_s_swap_harness.c │ │ └── sea.yaml │ ├── priority_queue_size │ │ ├── CMakeLists.txt │ │ └── aws_priority_queue_size_harness.c │ ├── priority_queue_top │ │ ├── CMakeLists.txt │ │ └── aws_priority_queue_top_harness.c │ ├── ptr_eq │ │ ├── CMakeLists.txt │ │ └── aws_ptr_eq_harness.c │ ├── ring_buffer_acquire │ │ ├── CMakeLists.txt │ │ └── aws_ring_buffer_acquire_harness.c │ ├── ring_buffer_acquire_up_to │ │ ├── CMakeLists.txt │ │ ├── aws_ring_buffer_acquire_up_to_harness.c │ │ └── sea.yaml │ ├── ring_buffer_buf_belongs_to_pool │ │ ├── CMakeLists.txt │ │ └── aws_ring_buffer_buf_belongs_to_pool_harness.c │ ├── ring_buffer_clean_up │ │ ├── CMakeLists.txt │ │ └── aws_ring_buffer_clean_up_harness.c │ ├── ring_buffer_init │ │ ├── CMakeLists.txt │ │ └── aws_ring_buffer_init_harness.c │ ├── ring_buffer_release │ │ ├── CMakeLists.txt │ │ ├── aws_ring_buffer_release_harness.c │ │ └── sea.yaml │ ├── round_up_to_power_of_two │ │ ├── CMakeLists.txt │ │ └── aws_round_up_to_power_of_two_harness.c │ ├── string_bytes │ │ ├── CMakeLists.txt │ │ └── aws_string_bytes_harness.c │ ├── string_compare │ │ ├── CMakeLists.txt │ │ └── aws_string_compare_harness.c │ ├── string_destroy │ │ ├── CMakeLists.txt │ │ └── aws_string_destroy_harness.c │ ├── string_destroy_secure │ │ ├── CMakeLists.txt │ │ ├── aws_string_destroy_secure_harness.c │ │ └── sea.yaml │ ├── string_eq │ │ ├── CMakeLists.txt │ │ └── aws_string_eq_harness.c │ ├── string_eq_byte_buf │ │ ├── CMakeLists.txt │ │ ├── aws_string_eq_byte_buf_harness.c │ │ └── sea.yaml │ ├── string_eq_byte_buf_ignore_case │ │ ├── CMakeLists.txt │ │ ├── aws_string_eq_byte_buf_ignore_case_harness.c │ │ └── sea.yaml │ ├── string_eq_byte_cursor │ │ ├── CMakeLists.txt │ │ ├── aws_string_eq_byte_cursor_harness.c │ │ └── sea.yaml │ ├── string_eq_byte_cursor_ignore_case │ │ ├── CMakeLists.txt │ │ ├── aws_string_eq_byte_cursor_ignore_case_harness.c │ │ └── sea.yaml │ ├── string_eq_c_str │ │ ├── CMakeLists.txt │ │ ├── aws_string_eq_c_str_harness.c │ │ └── sea.yaml │ ├── string_eq_c_str_ignore_case │ │ ├── CMakeLists.txt │ │ ├── aws_string_eq_c_str_ignore_case_harness.c │ │ └── sea.yaml │ ├── string_eq_ignore_case │ │ ├── CMakeLists.txt │ │ ├── aws_string_eq_ignore_case_harness.c │ │ └── sea.yaml │ ├── string_new_from_array │ │ ├── CMakeLists.txt │ │ ├── aws_string_new_from_array_harness.c │ │ └── sea.yaml │ ├── string_new_from_c_str │ │ ├── CMakeLists.txt │ │ ├── aws_string_new_from_c_str_harness.c │ │ └── sea.yaml │ └── string_new_from_string │ │ ├── CMakeLists.txt │ │ ├── aws_string_new_from_string_harness.c │ │ └── sea.yaml ├── jobs2 │ ├── array_eq2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_eq_harness2.c │ │ └── sea.yaml │ ├── array_eq_c_str2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_eq_c_str_harness2.c │ │ └── sea.yaml │ ├── array_eq_c_str_ignore_case2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_eq_c_str_ignore_case_harness2.c │ │ └── sea.yaml │ ├── array_eq_ignore_case2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_eq_ignore_case_harness2.c │ │ └── sea.yaml │ ├── array_list_back2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_back_harness2.c │ │ └── sea.yaml │ ├── array_list_capacity2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_capacity_harness2.c │ │ └── sea.yaml │ ├── array_list_clear2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_clear_harness2.c │ │ └── sea.yaml │ ├── array_list_ensure_capacity2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_ensure_capacity_harness2.c │ │ └── sea.yaml │ ├── array_list_erase2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_erase_harness2.c │ │ └── sea.yaml │ ├── array_list_front2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_front_harness2.c │ │ └── sea.yaml │ ├── array_list_get_at2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_get_at_harness2.c │ │ └── sea.yaml │ ├── array_list_get_at_ptr2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_get_at_ptr_harness2.c │ │ └── sea.yaml │ ├── array_list_init_static2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_init_static_harness2.c │ │ └── sea.yaml │ ├── array_list_length2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_length_harness2.c │ │ └── sea.yaml │ ├── array_list_pop_back2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_pop_back_harness2.c │ │ └── sea.yaml │ ├── array_list_pop_front2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_pop_front_harness2.c │ │ └── sea.yaml │ ├── array_list_pop_front_n2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_pop_front_n_harness2.c │ │ └── sea.yaml │ ├── array_list_push_back2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_push_back_harness2.c │ │ └── sea.yaml │ ├── array_list_set_at2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_set_at_harness2.c │ │ └── sea.yaml │ ├── array_list_shrink_to_fit2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_shrink_to_fit_harness2.c │ │ └── sea.yaml │ ├── array_list_sort2 │ │ ├── CMakeLists.txt │ │ ├── aws_array_list_sort_harness2.c │ │ └── sea.yaml │ ├── byte_buf_advance2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_advance_harness2.c │ │ └── sea.yaml │ ├── byte_buf_append2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_append_harness2.c │ │ └── sea.yaml │ ├── byte_buf_append_dynamic2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_append_dynamic_harness2.c │ │ └── sea.yaml │ ├── byte_buf_append_with_lookup2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_append_with_lookup_harness2.c │ │ └── sea.yaml │ ├── byte_buf_cat2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_cat_harness2.c │ │ └── sea.yaml │ ├── byte_buf_eq2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_eq_harness2.c │ │ └── sea.yaml │ ├── byte_buf_eq_c_str2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_eq_c_str_harness2.c │ │ └── sea.yaml │ ├── byte_buf_eq_c_str_ignore_case2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_eq_c_str_ignore_case_harness2.c │ │ └── sea.yaml │ ├── byte_buf_eq_ignore_case2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_eq_ignore_case_harness2.c │ │ └── sea.yaml │ ├── byte_buf_init_copy2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_init_copy_harness2.c │ │ └── sea.yaml │ ├── byte_buf_write2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_write_harness2.c │ │ └── sea.yaml │ ├── byte_buf_write_be162 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_write_be16_harness2.c │ │ └── sea.yaml │ ├── byte_buf_write_be322 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_write_be32_harness2.c │ │ └── sea.yaml │ ├── byte_buf_write_be642 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_write_be64_harness2.c │ │ └── sea.yaml │ ├── byte_buf_write_from_whole_buffer2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_write_from_whole_buffer_harness2.c │ │ └── sea.yaml │ ├── byte_buf_write_from_whole_cursor2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_write_from_whole_cursor_harness2.c │ │ └── sea.yaml │ ├── byte_buf_write_from_whole_string2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_write_from_whole_string_harness2.c │ │ └── sea.yaml │ ├── byte_buf_write_u82 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_buf_write_u8_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_advance2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_advance_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_advance_nospec2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_advance_nospec_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_compare_lexical2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_compare_lexical_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_compare_lookup2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_compare_lookup_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_eq2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_eq_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_eq_byte_buf2 │ │ ├── .DS_Store │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_eq_byte_buf_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_eq_byte_buf_ignore_case2 │ │ ├── .DS_Store │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_eq_byte_buf_ignore_case_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_eq_c_str2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_eq_c_str_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_eq_c_str_ignore_case2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_eq_c_str_ignore_case_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_eq_ignore_case2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_eq_ignore_case_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_from_buf2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_from_buf_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_left_trim_pred2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_left_trim_pred_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_read2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_read_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_read_and_fill_buffer2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_read_and_fill_buffer_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_read_be16_2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_read_be16_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_read_be32_2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_read_be32_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_read_be64_2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_read_be64_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_read_u8_2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_read_u8_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_right_trim_pred2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_right_trim_pred_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_satisfies_pred2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_satisfies_pred_harness2.c │ │ └── sea.yaml │ ├── byte_cursor_trim_pred2 │ │ ├── CMakeLists.txt │ │ ├── aws_byte_cursor_trim_pred_harness2.c │ │ └── sea.yaml │ ├── hash_iter_begin2 │ │ ├── CMakeLists.txt │ │ ├── aws_hash_iter_begin_harness2.c │ │ └── sea.yaml │ ├── hash_iter_begin_done2 │ │ ├── CMakeLists.txt │ │ ├── aws_hash_iter_begin_done_harness2.c │ │ └── sea.yaml │ ├── hash_iter_done2 │ │ ├── CMakeLists.txt │ │ ├── aws_hash_iter_done_harness2.c │ │ └── sea.yaml │ ├── hash_iter_next2 │ │ ├── CMakeLists.txt │ │ ├── aws_hash_iter_next_harness2.c │ │ └── sea.yaml │ ├── hash_table_find2 │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_find_harness2.c │ │ └── sea.yaml │ ├── hash_table_get_entry_count2 │ │ ├── CMakeLists.txt │ │ ├── aws_hash_table_get_entry_count_harness2.c │ │ └── sea.yaml │ ├── ring_buffer_acquire2 │ │ ├── CMakeLists.txt │ │ ├── aws_ring_buffer_acquire_harness2.c │ │ └── sea.yaml │ ├── ring_buffer_acquire_up_to2 │ │ ├── CMakeLists.txt │ │ ├── aws_ring_buffer_acquire_up_to_harness2.c │ │ └── sea.yaml │ ├── ring_buffer_buf_belongs_to_pool2 │ │ ├── CMakeLists.txt │ │ ├── aws_ring_buffer_buf_belongs_to_pool_harness2.c │ │ └── sea.yaml │ └── ring_buffer_release2 │ │ ├── CMakeLists.txt │ │ ├── aws_ring_buffer_release_harness2.c │ │ └── sea.yaml ├── jobs_unsafe │ └── mem_realloc_unsafe │ │ ├── CMakeLists.txt │ │ └── aws_mem_realloc_unsafe_harness.c ├── lib │ ├── CMakeLists.txt │ ├── allocator_override.c │ ├── array_list_helper.c │ ├── bcmp.c │ ├── bounds.c │ ├── byte_buf_helper.c │ ├── error_override.c │ ├── fuzz_allocators.c │ ├── fuzz_array_list_helper.c │ ├── fuzz_byte_buf_helper.c │ ├── fuzz_hash_table_helper.c │ ├── fuzz_priority_queue_helper.c │ ├── fuzz_ring_buffer_helper.c │ ├── fuzz_string_helper.c │ ├── hash_table_helper.c │ ├── klee_allocators.c │ ├── klee_array_list_helper.c │ ├── klee_byte_buf_helper.c │ ├── klee_hash_table_helper.c │ ├── klee_priority_queue_helper.c │ ├── klee_ring_buffer_helper.c │ ├── klee_string_helper.c │ ├── klee_switch.c │ ├── linked_list_helper.c │ ├── nd_fuzz.c │ ├── nd_klee.c │ ├── nd_smack.c │ ├── nd_symbiotic.c │ ├── priority_queue_helper.c │ ├── proof_allocators.c │ ├── ring_buffer_helper.c │ ├── sea_allocators.c │ ├── sea_string.cc │ ├── smack_allocators.c │ ├── string_helper.c │ └── utils.c ├── scripts │ └── create_alloce_size_switch.py ├── sea.yaml ├── sea_base.yaml ├── sea_cex_base.yaml ├── sea_pcond.yaml └── sea_vac.yaml └── verify.py.in /.github/workflows/blacklist.cex-y2.txt: -------------------------------------------------------------------------------- 1 | # The following jobs fail with: 2 | # LLVM ERROR: encode_term: failed on const-array(bv(64), 0:bv(8)) 3 | # const-array term not supported in yices 4 | # This is blocked on https://github.com/SRI-CSL/yices2/issues/271 5 | array_list_shrink_to_fit2_unsat_test 6 | byte_buf_append_with_lookup2_unsat_test 7 | byte_buf_init_copy2_unsat_test 8 | array_list_pop_front_n2_unsat_test 9 | byte_buf_write_from_whole_string2_unsat_test 10 | ring_buffer_acquire2_unsat_test 11 | ring_buffer_acquire_up_to2_unsat_test 12 | # Following tests fail on LLVM14 with: 13 | # yices_solver_impl::add: yices_assert_formula failed: the context does not support lambda terms 14 | # select(store(const-array,..., ...), ...) does not seem to be supported on yices 15 | array_list_pop_back2_unsat_test 16 | array_list_push_back2_unsat_test 17 | array_list_set_at2_unsat_test 18 | byte_buf_advance2_unsat_test 19 | -------------------------------------------------------------------------------- /.github/workflows/blacklist.cex.txt: -------------------------------------------------------------------------------- 1 | byte_buf_write_from_whole_string_unsat_test 2 | byte_buf_write_from_whole_string2_unsat_test 3 | byte_buf_init_copy_unsat_test 4 | byte_buf_init_copy2_unsat_test 5 | linked_list_pop_back_unsat_test 6 | linked_list_swap_contents_unsat_test 7 | string_eq_unsat_test 8 | string_compare_unsat_test 9 | ring_buffer_clean_up_unsat_test 10 | linked_list_pop_front_unsat_test 11 | string_eq_c_str_unsat_test 12 | hash_table_create_unsat_test 13 | hash_table_remove_unsat_test 14 | hash_table_put_unsat_test 15 | hash_table_foreach_unsat_test 16 | -------------------------------------------------------------------------------- /.github/workflows/blacklist.df-coi.txt: -------------------------------------------------------------------------------- 1 | # spurious failure in CI 2 | nospec_mask_unsat_test 3 | -------------------------------------------------------------------------------- /.github/workflows/blacklist.smack.txt: -------------------------------------------------------------------------------- 1 | smack_byte_buf_cat_test 2 | smack_byte_buf_eq_ignore_case_test 3 | smack_byte_cursor_eq_byte_buf_ignore_case_test 4 | smack_byte_cursor_eq_ignore_case_test 5 | smack_is_power_of_two_test 6 | smack_round_up_to_power_of_two_test 7 | smack_array_eq_ignore_case_test 8 | smack_hash_iter_next_test 9 | smack_hash_iter_done_test 10 | smack_hash_table_eq_test 11 | smack_hash_table_create_test 12 | smack_hash_table_init_bounded_test 13 | smack_hash_table_init_unbounded_test 14 | smack_hash_table_put_test 15 | smack_hash_table_remove_test 16 | smack_linked_list_back_test 17 | smack_linked_list_begin_test 18 | smack_linked_list_end_test 19 | smack_linked_list_front_test 20 | smack_linked_list_swap_contents_test 21 | smack_linked_list_rbegin_test 22 | smack_linked_list_rend_test 23 | smack_string_eq_byte_buf_ignore_case_test 24 | smack_string_eq_byte_cursor_ignore_case_test 25 | smack_string_eq_ignore_case_test -------------------------------------------------------------------------------- /.github/workflows/blacklist.vac.txt: -------------------------------------------------------------------------------- 1 | ring_buffer_clean_up_unsat_test 2 | hash_table_foreach_unsat_test 3 | hash_table_eq_unsat_test 4 | # following test is a spurious intermittent failure in CI 5 | nospec_mask_unsat_test 6 | # folowing test is failed as expect because it is sat test 7 | mem_realloc_unsafe_sat_test -------------------------------------------------------------------------------- /.github/workflows/klee.yml: -------------------------------------------------------------------------------- 1 | # workflow to run KLEE tests 2 | name: KLEE CI 3 | # Controls when the action will run 4 | on: 5 | pull_request: 6 | branches: master 7 | push: 8 | branches: master 9 | schedule: 10 | - cron: 0 0 * * * # run every day at UTC 00:00 11 | 12 | jobs: 13 | build: 14 | runs-on: ubuntu-latest 15 | 16 | steps: 17 | - name: Check Out Repo 18 | uses: actions/checkout@v2 19 | 20 | - name: Docker 21 | run: docker build -t verify-c-common . --file docker/verify-c-common-klee.Dockerfile 22 | 23 | - name: Get number of Cores 24 | id: cores 25 | run: echo "::set-output name=num_cores::$(nproc --all)" 26 | 27 | - name: Run Tests 28 | run: docker run -t verify-c-common /bin/bash -c "cd build && ctest -j ${{steps.cores.outputs.num_cores}} -R klee_ --output-on-failure --timeout 2000" 29 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | build 2 | build_fuzz 3 | debug 4 | cex 5 | data 6 | exper 7 | aws-c-common/* 8 | compile_commands.json 9 | __pycache__ 10 | CMakeUserPresets.json -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: cpp 2 | dist: trusty 3 | os: linux 4 | cache: apt 5 | branches: 6 | only: 7 | - master 8 | matrix: 9 | include: 10 | - env: BUILD_TYPE=RelWithDebInfo 11 | script: 12 | - docker build -t verify-c-common -f docker/verify-c-common.Dockerfile . 13 | - | 14 | travis_wait 120 sleep infinity & 15 | docker run -t verify-c-common /bin/bash -c "cd build && ninja test" 16 | - | 17 | travis_wait 120 sleep infinity & 18 | docker run -t verify-c-common /bin/bash -c 'cd build && env VERIFY_FLAGS="--vac" ninja test' 19 | services: 20 | - docker 21 | 22 | install: true 23 | 24 | -------------------------------------------------------------------------------- /CMakePresets.json: -------------------------------------------------------------------------------- 1 | { 2 | "version": 6, 3 | "cmakeMinimumRequired": { 4 | "major": 3, 5 | "minor": 18, 6 | "patch": 4 7 | }, 8 | "configurePresets": [ 9 | { 10 | "name": "default-jammy", 11 | "generator": "Ninja", 12 | "binaryDir": "${sourceDir}/build", 13 | "cacheVariables": { 14 | "SEA_LINK": "llvm-link-14", 15 | "CMAKE_C_COMPILER": "clang-14", 16 | "CMAKE_CXX_COMPILER": "clang++-14", 17 | "SEAHORN_ROOT": "~/seahorn/build/run", 18 | "aws-c-common_DIR": "~/verify-c-common/aws-c-common/build/run/lib/aws-c-common/cmake" 19 | } 20 | } 21 | ], 22 | "buildPresets": [ 23 | { 24 | "name": "default-jammy", 25 | "configurePreset": "default-jammy" 26 | } 27 | ] 28 | } 29 | -------------------------------------------------------------------------------- /assets/arch.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/seahorn/verify-c-common/f561a743c20302759d6419173956880e2e92b1f8/assets/arch.png -------------------------------------------------------------------------------- /assets/fmcad2022.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/seahorn/verify-c-common/f561a743c20302759d6419173956880e2e92b1f8/assets/fmcad2022.pdf -------------------------------------------------------------------------------- /assets/paper_expanded.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/seahorn/verify-c-common/f561a743c20302759d6419173956880e2e92b1f8/assets/paper_expanded.pdf -------------------------------------------------------------------------------- /azure-pipelines.yml: -------------------------------------------------------------------------------- 1 | trigger: 2 | - master 3 | pr: 4 | - master 5 | 6 | resources: 7 | - repo: self 8 | 9 | variables: 10 | tag: '$(Build.BuildId)' 11 | jobs: 12 | - job: "LinuxDockerBuild" 13 | displayName: "Docker build - release" 14 | pool: 15 | vmImage: 'ubuntu-latest' 16 | steps: 17 | - script: docker build -t seahorn/verify-c-common:ci -f docker/verify-c-common.Dockerfile . 18 | - script: docker run -i seahorn/verify-c-common:ci /bin/bash -c "cd build && cmake --build . --target test" 19 | -------------------------------------------------------------------------------- /cmake/llvmir/SOURCE: -------------------------------------------------------------------------------- 1 | https://github.com/compor/llvm-ir-cmake-utils.git 2 | -------------------------------------------------------------------------------- /patch/README.md: -------------------------------------------------------------------------------- 1 | # Patches for aws-c-common 2 | 3 | This directory contains patches that fix bugs in aws-c-common but have not yet been merged into the main repository. 4 | 5 | ## Instructions 6 | 7 | From root of `verify-c-common` 8 | 9 | ``` 10 | $ cd aws-c-common 11 | $ git apply ../patch/PATCH_FILE 12 | ``` 13 | 14 | for every `PATCH_FILE` in the current directory 15 | -------------------------------------------------------------------------------- /scripts/metrics.yaml: -------------------------------------------------------------------------------- 1 | job_name: "job_name" 2 | Result: "result" 3 | bmc.circ_sz: "bmc_circuit_size" 4 | bmc.dag_sz: "bmc_dag_size" 5 | BMC: "bmc_time" 6 | BMC.solve: "bmc_solve_time" 7 | Control dependence analysis: "cda_time" 8 | Thinned Gate SSA transformation: "gssa_time" 9 | opsem.assert: "opsem_assert_time" 10 | opsem.simplify: "opsem_simp_time" 11 | seahorn_total: "seahorn_total_time" 12 | -------------------------------------------------------------------------------- /seahorn/aws-c-common-stubs/s_hash_for_override.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | uint64_t s_hash_for(struct hash_table_state *state, const void *key) { 5 | AWS_PRECONDITION(hash_table_state_is_valid(state)); 6 | 7 | if (key == NULL) { 8 | /* The best answer */ 9 | return 42; 10 | } 11 | 12 | #ifdef __SEAHORN__ 13 | uint64_t hash_code = nd_uint64_t(); 14 | #else 15 | uint64_t hash_code = state->hash_fn(key); 16 | #endif 17 | if (!hash_code) { 18 | hash_code = 1; 19 | } 20 | AWS_RETURN_WITH_POSTCONDITION(hash_code, hash_code != 0); 21 | } -------------------------------------------------------------------------------- /seahorn/aws-c-common-stubs/s_safe_eq_check_override.c: -------------------------------------------------------------------------------- 1 | /* 2 | Function stubed: s_safe_eq_check 3 | Indirect call toequals_fn is non-deterministic anyways so its fine to replace 4 | it with nd boolean function 5 | */ 6 | #include 7 | #include 8 | bool s_safe_eq_check(aws_hash_callback_eq_fn *equals_fn, const void *a, 9 | const void *b) { 10 | /* Short circuit if the pointers are the same */ 11 | if (a == b) { 12 | return true; 13 | } 14 | /* If one but not both are null, the objects are not equal */ 15 | if (a == NULL || b == NULL) { 16 | return false; 17 | } 18 | /* If both are non-null, call the underlying equals fn */ 19 | #ifdef __SEAHORN__ 20 | return nd_bool(); 21 | #else 22 | return equals_fn(a, b); 23 | #endif 24 | } -------------------------------------------------------------------------------- /seahorn/aws-c-common-stubs/s_sift_up_override.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 | * SPDX-License-Identifier: Apache-2.0. 4 | */ 5 | 6 | /** 7 | * FUNCTION: s_sift_up 8 | * 9 | * This function overrides the original implementation of the 10 | * s_sift_up function from priority_queue.h with a no_op. 11 | */ 12 | 13 | #include 14 | #include 15 | 16 | bool s_sift_up(struct aws_priority_queue *queue, size_t index) { 17 | AWS_PRECONDITION(aws_priority_queue_is_valid(queue)); 18 | AWS_PRECONDITION(index < queue->container.length); 19 | bool did_move = nd_bool(); 20 | AWS_POSTCONDITION(aws_priority_queue_is_valid(queue)); 21 | return did_move; 22 | } 23 | -------------------------------------------------------------------------------- /seahorn/include/array_list_helper.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | void initialize_array_list(struct aws_array_list *const list); 10 | 11 | /* 12 | * Initialize a bounded array list by given a max_initial_size 13 | */ 14 | void initialize_bounded_array_list(struct aws_array_list *const list); 15 | 16 | /* 17 | * Checks whether aws_array_list is bounded by max_initial_item_allocation and max_item_size 18 | */ 19 | bool aws_array_list_is_bounded( 20 | const struct aws_array_list *const list, 21 | const size_t max_initial_item_allocation, 22 | const size_t max_item_size); 23 | 24 | /** 25 | * Ensures the data member of an aws_array_list structure is correctly allocated 26 | */ 27 | void ensure_array_list_has_allocated_data_member(struct aws_array_list *const list); 28 | -------------------------------------------------------------------------------- /seahorn/include/aws/common/config.h: -------------------------------------------------------------------------------- 1 | /** 2 | * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 | * SPDX-License-Identifier: Apache-2.0. 4 | */ 5 | 6 | // Disable all compiler, and go to bare C 7 | #undef AWS_CRYPTOSDK_P_USE_X86_64_ASM 8 | #undef AWS_CRYPTOSDK_P_SPECTRE_MITIGATIONS 9 | #undef AWS_CRYPTOSDK_P_HAVE_BUILTIN_EXPECT 10 | 11 | // use gcc/clang builtins for arithmetic overflow checking opertions 12 | #define AWS_HAVE_GCC_OVERFLOW_MATH_EXTENSIONS 13 | -------------------------------------------------------------------------------- /seahorn/include/byte_buf_helper.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | void initialize_byte_buf(struct aws_byte_buf *const buf); 10 | void initialize_byte_cursor(struct aws_byte_cursor *const buf); 11 | void initialize_byte_cursor_aligned(struct aws_byte_cursor *const buf); 12 | 13 | bool aws_byte_buf_is_bounded(const struct aws_byte_buf *const buf, 14 | const size_t max_size); 15 | 16 | bool aws_byte_cursor_is_bounded(const struct aws_byte_cursor *const cursor, 17 | const size_t max_size); 18 | 19 | void ensure_byte_buf_has_allocated_buffer_member( 20 | struct aws_byte_buf *const buf); 21 | 22 | bool aws_byte_buf_has_allocator(const struct aws_byte_buf *const buf); 23 | 24 | bool byte_bufs_are_equal(struct aws_byte_buf *b1, struct aws_byte_buf *b2); 25 | -------------------------------------------------------------------------------- /seahorn/include/klee_switch.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | 8 | size_t alloc_size(size_t sz); -------------------------------------------------------------------------------- /seahorn/include/macros.h: -------------------------------------------------------------------------------- 1 | #ifdef __cplusplus 2 | # define SEAHORN_EXTERN_C_BEGIN extern "C" { 3 | # define SEAHORN_EXTERN_C_END } 4 | #else 5 | # define SEAHORN_EXTERN_C_BEGIN 6 | # define SEAHORN_EXTERN_C_END 7 | #endif /* __cplusplus */ 8 | -------------------------------------------------------------------------------- /seahorn/include/priority_queue_helper.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | void initialize_priority_queue(struct aws_priority_queue *queue); 10 | bool aws_priority_queue_is_bounded(struct aws_priority_queue *queue, 11 | const size_t max_initial_item_allocation, 12 | const size_t max_item_size); 13 | -------------------------------------------------------------------------------- /seahorn/include/ring_buffer_helper.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | void initialize_ring_buffer(struct aws_ring_buffer *ring_buf, 6 | const size_t size); 7 | 8 | void ensure_byte_buf_has_allocated_buffer_member_in_range( 9 | struct aws_byte_buf *buf, uint8_t *lo, uint8_t *hi); 10 | 11 | void ensure_byte_buf_has_allocated_buffer_member_in_ring_buf( 12 | struct aws_byte_buf *buf, struct aws_ring_buffer *ring_buf); 13 | 14 | bool ring_buffers_are_equal(struct aws_ring_buffer *r1, 15 | struct aws_ring_buffer *r2); 16 | -------------------------------------------------------------------------------- /seahorn/include/sea_mem_helper.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | size_t sea_get_alloc_size(void *ptr); 5 | 6 | bool sea_ptr_size_stored(void *ptr); 7 | 8 | bool sea_arr_len_stored(void *arr); 9 | 10 | size_t sea_get_arr_len(void *arr); 11 | 12 | size_t sea_maybe_store_arr_len(void *arr, size_t len); 13 | -------------------------------------------------------------------------------- /seahorn/include/sea_string.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | SEAHORN_EXTERN_C_BEGIN 7 | 8 | size_t sea_strlen(const char *str, size_t max_size); 9 | 10 | SEAHORN_EXTERN_C_END 11 | -------------------------------------------------------------------------------- /seahorn/include/string_helper.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | struct aws_string *ensure_string_is_allocated(size_t len); 6 | struct aws_string *ensure_string_is_allocated_nondet_length(void); 7 | struct aws_string *ensure_string_is_allocated_bounded_length(size_t max_size); 8 | 9 | 10 | // len is populated by this function 11 | const char *ensure_c_str_is_nd_allocated_safe(size_t max_size, size_t *len); 12 | const char *ensure_c_str_is_nd_allocated(size_t max_size, size_t *len); 13 | const char *ensure_c_str_is_nd_allocated_aligned(size_t max_size, size_t *len); 14 | 15 | const char *ensure_c_str_is_allocated(size_t max_size); 16 | -------------------------------------------------------------------------------- /seahorn/jobs/add_size_checked/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(add_size_checked aws_add_size_checked_harness.c) 2 | sea_attach_bc_link(add_size_checked) 3 | sea_add_unsat_test(add_size_checked) 4 | 5 | sea_add_fuzz(add_size_checked aws_add_size_checked_harness.c) 6 | 7 | # klee 8 | sea_add_klee(add_size_checked aws_add_size_checked_harness.c) 9 | 10 | # smack 11 | sea_add_smack(add_size_checked aws_add_size_checked_harness.c) 12 | 13 | # symbiotic 14 | sea_add_symbiotic(add_size_checked aws_add_size_checked_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/add_size_checked/aws_add_size_checked_harness.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | /** 6 | */ 7 | int main(void) { 8 | if (nd_bool()) { 9 | uint64_t a = nd_uint64_t(); 10 | uint64_t b = nd_uint64_t(); 11 | uint64_t r = nd_uint64_t(); 12 | int rval = aws_add_u64_checked(a, b, &r); 13 | if (!rval) { 14 | sassert(r == a + b); 15 | } else { 16 | sassert((b > 0) && (a > (UINT64_MAX - b))); 17 | } 18 | } else { 19 | uint32_t a = nd_uint32_t(); 20 | uint32_t b = nd_uint32_t(); 21 | uint32_t r = nd_uint32_t(); 22 | if (!aws_add_u32_checked(a, b, &r)) { 23 | sassert(r == a + b); 24 | } else { 25 | sassert((b > 0) && (a > (UINT32_MAX - b))); 26 | } 27 | } 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /seahorn/jobs/add_size_saturating/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(add_size_saturating 2 | aws_add_size_saturating_harness.c) 3 | sea_attach_bc_link(add_size_saturating) 4 | sea_add_unsat_test(add_size_saturating) 5 | 6 | sea_add_fuzz(add_size_saturating aws_add_size_saturating_harness.c) 7 | 8 | # klee 9 | sea_add_klee(add_size_saturating aws_add_size_saturating_harness.c) 10 | 11 | # smack 12 | sea_add_smack(add_size_saturating aws_add_size_saturating_harness.c) 13 | 14 | # symbiotic 15 | sea_add_symbiotic(add_size_saturating aws_add_size_saturating_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/add_size_saturating/aws_add_size_saturating_harness.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | /** 6 | */ 7 | int main() { 8 | if (nd_bool()) { 9 | uint64_t a = nd_uint64_t(); 10 | uint64_t b = nd_uint64_t(); 11 | uint64_t r = aws_add_u64_saturating(a, b); 12 | if ((b > 0) && (a > (UINT64_MAX - b))) { 13 | sassert(r == UINT64_MAX); 14 | } else { 15 | sassert(r == a + b); 16 | } 17 | } else { 18 | uint32_t a = nd_uint32_t(); 19 | uint32_t b = nd_uint32_t(); 20 | uint32_t r = aws_add_u32_saturating(a, b); 21 | if ((b > 0) && (a > (UINT32_MAX - b))) { 22 | sassert(r == UINT32_MAX); 23 | } else { 24 | sassert(r == a + b); 25 | } 26 | } 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /seahorn/jobs/array_eq/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_eq 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_array_eq_harness.c) 4 | sea_attach_bc_link(array_eq) 5 | 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(array_eq) 8 | 9 | # klee 10 | sea_add_klee(array_eq ${AWS_C_COMMON_ROOT}/source/byte_buf.c 11 | aws_array_eq_harness.c) 12 | 13 | # smack 14 | if(SEA_ENABLE_SMACK) 15 | sea_add_smack_bc(array_eq ${AWS_C_COMMON_ROOT}/source/byte_buf.c 16 | aws_array_eq_harness.c) 17 | sea_add_smack_test(array_eq --strings) 18 | endif() 19 | 20 | # symbiotic 21 | sea_add_symbiotic(array_eq ${AWS_C_COMMON_ROOT}/source/byte_buf.c 22 | aws_array_eq_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_eq/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/array_eq_c_str/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_eq_c_str 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_array_eq_c_str_harness.c) 4 | sea_attach_bc_link(array_eq_c_str) 5 | 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(array_eq_c_str) 8 | 9 | sea_add_fuzz(array_eq_c_str 10 | aws_array_eq_c_str_harness.c) 11 | 12 | # klee 13 | sea_add_klee(array_eq_c_str ${AWS_C_COMMON_ROOT}/source/byte_buf.c 14 | aws_array_eq_c_str_harness.c) 15 | 16 | # smack 17 | sea_add_smack(array_eq_c_str ${AWS_C_COMMON_ROOT}/source/byte_buf.c 18 | aws_array_eq_c_str_harness.c) 19 | 20 | # symbiotic 21 | sea_add_symbiotic(array_eq_c_str ${AWS_C_COMMON_ROOT}/source/byte_buf.c 22 | aws_array_eq_c_str_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_eq_c_str/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_STRING_LEN@ 3 | horn-bmc-logic: QF_ABV 4 | -------------------------------------------------------------------------------- /seahorn/jobs/array_eq_c_str_ignore_case/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_eq_c_str_ignore_case 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_array_eq_c_str_ignore_case_harness.c) 4 | sea_attach_bc_link(array_eq_c_str_ignore_case) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_eq_c_str_ignore_case) 7 | 8 | # klee 9 | sea_add_klee(array_eq_c_str_ignore_case ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_array_eq_c_str_ignore_case_harness.c) 11 | 12 | # smack 13 | sea_add_smack(array_eq_c_str_ignore_case ${AWS_C_COMMON_ROOT}/source/byte_buf.c 14 | aws_array_eq_c_str_ignore_case_harness.c) 15 | 16 | # symbiotic 17 | sea_add_symbiotic(array_eq_c_str_ignore_case ${AWS_C_COMMON_ROOT}/source/byte_buf.c 18 | aws_array_eq_c_str_ignore_case_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_eq_c_str_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/array_eq_ignore_case/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_eq_ignore_case 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_array_eq_ignore_case_harness.c) 4 | sea_attach_bc_link(array_eq_ignore_case) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_eq_ignore_case) 7 | 8 | # klee 9 | sea_add_klee(array_eq_ignore_case ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_array_eq_ignore_case_harness.c) 11 | 12 | # smack 13 | sea_add_smack(array_eq_ignore_case ${AWS_C_COMMON_ROOT}/source/byte_buf.c 14 | aws_array_eq_ignore_case_harness.c) 15 | 16 | # symbiotic 17 | sea_add_symbiotic(array_eq_ignore_case ${AWS_C_COMMON_ROOT}/source/byte_buf.c 18 | aws_array_eq_ignore_case_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_eq_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_back/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_back 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_back_harness.c) 4 | sea_attach_bc_link(array_list_back) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_back) 7 | 8 | # klee 9 | sea_add_klee(array_list_back ${AWS_C_COMMON_ROOT}/source/array_list.c 10 | aws_array_list_back_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(array_list_back aws_array_list_back_harness.c) 14 | 15 | # smack 16 | sea_add_smack(array_list_back ${AWS_C_COMMON_ROOT}/source/array_list.c 17 | aws_array_list_back_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(array_list_back ${AWS_C_COMMON_ROOT}/source/array_list.c 21 | aws_array_list_back_harness.c) 22 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_back/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_capacity/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_capacity 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_capacity_harness.c) 4 | sea_attach_bc_link(array_list_capacity) 5 | sea_add_unsat_test(array_list_capacity) 6 | 7 | # klee 8 | sea_add_klee(array_list_capacity ${AWS_C_COMMON_ROOT}/source/array_list.c 9 | aws_array_list_capacity_harness.c) 10 | 11 | sea_add_fuzz(array_list_capacity aws_array_list_capacity_harness.c) 12 | 13 | # smack 14 | sea_add_smack(array_list_capacity ${AWS_C_COMMON_ROOT}/source/array_list.c 15 | aws_array_list_capacity_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(array_list_capacity ${AWS_C_COMMON_ROOT}/source/array_list.c 19 | aws_array_list_capacity_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_clean_up/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_clean_up 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_clean_up_harness.c) 4 | sea_attach_bc_link(array_list_clean_up) 5 | sea_add_unsat_test(array_list_clean_up) 6 | 7 | # klee 8 | sea_add_klee(array_list_clean_up ${AWS_C_COMMON_ROOT}/source/array_list.c 9 | aws_array_list_clean_up_harness.c) 10 | 11 | sea_add_fuzz(array_list_clean_up aws_array_list_clean_up_harness.c) 12 | 13 | # smack 14 | sea_add_smack(array_list_clean_up ${AWS_C_COMMON_ROOT}/source/array_list.c 15 | aws_array_list_clean_up_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(array_list_clean_up ${AWS_C_COMMON_ROOT}/source/array_list.c 19 | aws_array_list_clean_up_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_clean_up/aws_array_list_clean_up_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | /** 10 | * Runtime: 4s 11 | */ 12 | int main() { 13 | /* data structure */ 14 | struct aws_array_list list; 15 | initialize_bounded_array_list(&list); 16 | 17 | /* assumptions */ 18 | assume(aws_array_list_is_valid(&list)); 19 | 20 | /* perform operation under verification */ 21 | aws_array_list_clean_up(&list); 22 | 23 | /* assertions */ 24 | sassert(AWS_IS_ZEROED(list)); 25 | 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_clear/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_clear 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_clear_harness.c) 4 | sea_attach_bc_link(array_list_clear) 5 | sea_add_unsat_test(array_list_clear) 6 | 7 | # klee 8 | sea_add_klee(array_list_clear ${AWS_C_COMMON_ROOT}/source/array_list.c 9 | aws_array_list_clear_harness.c) 10 | 11 | sea_add_fuzz(array_list_clear aws_array_list_clear_harness.c) 12 | 13 | # smack 14 | sea_add_smack(array_list_clear ${AWS_C_COMMON_ROOT}/source/array_list.c 15 | aws_array_list_clear_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(array_list_clear ${AWS_C_COMMON_ROOT}/source/array_list.c 19 | aws_array_list_clear_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_comparator_string/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bmc-tactic: smtfd 3 | bound: @MAX_BUFFER_SIZE@ 4 | 5 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_copy/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_copy 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_copy_harness.c) 4 | sea_attach_bc_link(array_list_copy) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_copy) 7 | 8 | # klee 9 | sea_add_klee(array_list_copy ${AWS_C_COMMON_ROOT}/source/array_list.c 10 | aws_array_list_copy_harness.c) 11 | 12 | sea_add_fuzz(array_list_copy aws_array_list_copy_harness.c) 13 | 14 | # smack 15 | sea_add_smack(array_list_copy ${AWS_C_COMMON_ROOT}/source/array_list.c 16 | aws_array_list_copy_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(array_list_copy ${AWS_C_COMMON_ROOT}/source/array_list.c 20 | aws_array_list_copy_harness.c) 21 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_copy/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_ensure_capacity/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_ensure_capacity 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_ensure_capacity_harness.c) 4 | sea_attach_bc_link(array_list_ensure_capacity) 5 | sea_add_unsat_test(array_list_ensure_capacity) 6 | 7 | # klee 8 | sea_add_klee(array_list_ensure_capacity ${AWS_C_COMMON_ROOT}/source/array_list.c 9 | aws_array_list_ensure_capacity_harness.c) 10 | 11 | sea_add_fuzz(array_list_ensure_capacity aws_array_list_ensure_capacity_harness.c) 12 | 13 | # smack 14 | sea_add_smack(array_list_ensure_capacity ${AWS_C_COMMON_ROOT}/source/array_list.c 15 | aws_array_list_ensure_capacity_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(array_list_ensure_capacity ${AWS_C_COMMON_ROOT}/source/array_list.c 19 | aws_array_list_ensure_capacity_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_erase/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_erase 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_erase_harness.c) 4 | sea_attach_bc_link(array_list_erase) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_erase) 7 | 8 | # klee 9 | sea_add_klee(array_list_erase ${AWS_C_COMMON_ROOT}/source/array_list.c 10 | aws_array_list_erase_harness.c) 11 | 12 | sea_add_fuzz(array_list_erase aws_array_list_erase_harness.c) 13 | 14 | # smack 15 | sea_add_smack(array_list_erase ${AWS_C_COMMON_ROOT}/source/array_list.c 16 | aws_array_list_erase_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(array_list_erase ${AWS_C_COMMON_ROOT}/source/array_list.c 20 | aws_array_list_erase_harness.c) 21 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_erase/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_front/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_front 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_front_harness.c) 4 | sea_attach_bc_link(array_list_front) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_front) 7 | 8 | # klee 9 | sea_add_klee(array_list_front ${AWS_C_COMMON_ROOT}/source/array_list.c 10 | aws_array_list_front_harness.c) 11 | 12 | sea_add_fuzz(array_list_front aws_array_list_front_harness.c) 13 | 14 | # smack 15 | sea_add_smack(array_list_front ${AWS_C_COMMON_ROOT}/source/array_list.c 16 | aws_array_list_front_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(array_list_front ${AWS_C_COMMON_ROOT}/source/array_list.c 20 | aws_array_list_front_harness.c) 21 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_front/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_get_at/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_get_at 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_get_at_harness.c) 4 | sea_attach_bc_link(array_list_get_at) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_get_at) 7 | 8 | # klee 9 | sea_add_klee(array_list_get_at ${AWS_C_COMMON_ROOT}/source/array_list.c 10 | aws_array_list_get_at_harness.c) 11 | 12 | sea_add_fuzz(array_list_get_at aws_array_list_get_at_harness.c) 13 | 14 | # smack 15 | sea_add_smack(array_list_get_at ${AWS_C_COMMON_ROOT}/source/array_list.c 16 | aws_array_list_get_at_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(array_list_get_at ${AWS_C_COMMON_ROOT}/source/array_list.c 20 | aws_array_list_get_at_harness.c) 21 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_get_at/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_get_at_ptr/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_get_at_ptr 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_get_at_ptr_harness.c) 4 | sea_attach_bc_link(array_list_get_at_ptr) 5 | sea_add_unsat_test(array_list_get_at_ptr) 6 | 7 | # klee 8 | sea_add_klee(array_list_get_at_ptr ${AWS_C_COMMON_ROOT}/source/array_list.c 9 | aws_array_list_get_at_ptr_harness.c) 10 | 11 | sea_add_fuzz(array_list_get_at_ptr aws_array_list_get_at_ptr_harness.c) 12 | 13 | # smack 14 | sea_add_smack(array_list_get_at_ptr ${AWS_C_COMMON_ROOT}/source/array_list.c 15 | aws_array_list_get_at_ptr_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(array_list_get_at_ptr ${AWS_C_COMMON_ROOT}/source/array_list.c 19 | aws_array_list_get_at_ptr_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_init_dynamic/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_init_dynamic 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_init_dynamic_harness.c) 4 | sea_attach_bc_link(array_list_init_dynamic) 5 | sea_add_unsat_test(array_list_init_dynamic) 6 | 7 | # klee 8 | sea_add_klee(array_list_init_dynamic ${AWS_C_COMMON_ROOT}/source/array_list.c 9 | aws_array_list_init_dynamic_harness.c) 10 | 11 | sea_add_fuzz(array_list_init_dynamic aws_array_list_init_dynamic_harness.c) 12 | 13 | # smack 14 | sea_add_smack(array_list_init_dynamic ${AWS_C_COMMON_ROOT}/source/array_list.c 15 | aws_array_list_init_dynamic_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(array_list_init_dynamic ${AWS_C_COMMON_ROOT}/source/array_list.c 19 | aws_array_list_init_dynamic_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_init_static/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_init_static 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_init_static_harness.c) 4 | sea_attach_bc_link(array_list_init_static) 5 | sea_add_unsat_test(array_list_init_static) 6 | 7 | # klee 8 | sea_add_klee(array_list_init_static ${AWS_C_COMMON_ROOT}/source/array_list.c 9 | aws_array_list_init_static_harness.c) 10 | 11 | sea_add_fuzz(array_list_init_static aws_array_list_init_static_harness.c) 12 | 13 | # smack 14 | sea_add_smack(array_list_init_static ${AWS_C_COMMON_ROOT}/source/array_list.c 15 | aws_array_list_init_static_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(array_list_init_static ${AWS_C_COMMON_ROOT}/source/array_list.c 19 | aws_array_list_init_static_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_length/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_length 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_length_harness.c) 4 | sea_attach_bc_link(array_list_length) 5 | sea_add_unsat_test(array_list_length) 6 | 7 | # klee 8 | sea_add_klee(array_list_length ${AWS_C_COMMON_ROOT}/source/array_list.c 9 | aws_array_list_length_harness.c) 10 | 11 | sea_add_fuzz(array_list_length aws_array_list_length_harness.c) 12 | 13 | # smack 14 | sea_add_smack(array_list_length ${AWS_C_COMMON_ROOT}/source/array_list.c 15 | aws_array_list_length_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(array_list_length ${AWS_C_COMMON_ROOT}/source/array_list.c 19 | aws_array_list_length_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_pop_back/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_pop_back 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_pop_back_harness.c) 4 | sea_attach_bc_link(array_list_pop_back) 5 | sea_add_unsat_test(array_list_pop_back) 6 | 7 | # klee 8 | sea_add_klee(array_list_pop_back ${AWS_C_COMMON_ROOT}/source/array_list.c 9 | aws_array_list_pop_back_harness.c) 10 | 11 | sea_add_fuzz(array_list_pop_back aws_array_list_pop_back_harness.c) 12 | 13 | # smack 14 | sea_add_smack(array_list_pop_back ${AWS_C_COMMON_ROOT}/source/array_list.c 15 | aws_array_list_pop_back_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(array_list_pop_back ${AWS_C_COMMON_ROOT}/source/array_list.c 19 | aws_array_list_pop_back_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_pop_front/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_pop_front 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_pop_front_harness.c) 4 | sea_attach_bc_link(array_list_pop_front) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_pop_front) 7 | 8 | # klee 9 | sea_add_klee(array_list_pop_front ${AWS_C_COMMON_ROOT}/source/array_list.c 10 | aws_array_list_pop_front_harness.c) 11 | 12 | sea_add_fuzz(array_list_pop_front aws_array_list_pop_front_harness.c) 13 | 14 | # smack 15 | sea_add_smack(array_list_pop_front ${AWS_C_COMMON_ROOT}/source/array_list.c 16 | aws_array_list_pop_front_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(array_list_pop_front ${AWS_C_COMMON_ROOT}/source/array_list.c 20 | aws_array_list_pop_front_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_pop_front/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_pop_front_n/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_pop_front_n 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_pop_front_n_harness.c) 4 | sea_attach_bc_link(array_list_pop_front_n) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_pop_front_n) 7 | 8 | # klee 9 | sea_add_klee(array_list_pop_front_n ${AWS_C_COMMON_ROOT}/source/array_list.c 10 | aws_array_list_pop_front_n_harness.c) 11 | 12 | sea_add_fuzz(array_list_pop_front_n aws_array_list_pop_front_n_harness.c) 13 | 14 | # smack 15 | sea_add_smack(array_list_pop_front_n ${AWS_C_COMMON_ROOT}/source/array_list.c 16 | aws_array_list_pop_front_n_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(array_list_pop_front_n ${AWS_C_COMMON_ROOT}/source/array_list.c 20 | aws_array_list_pop_front_n_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_pop_front_n/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_push_back/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_push_back 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_push_back_harness.c) 4 | sea_attach_bc_link(array_list_push_back) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_push_back) 7 | 8 | # klee 9 | sea_add_klee(array_list_push_back ${AWS_C_COMMON_ROOT}/source/array_list.c 10 | aws_array_list_push_back_harness.c) 11 | 12 | sea_add_fuzz(array_list_push_back aws_array_list_push_back_harness.c) 13 | 14 | # smack 15 | sea_add_smack(array_list_push_back ${AWS_C_COMMON_ROOT}/source/array_list.c 16 | aws_array_list_push_back_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(array_list_push_back ${AWS_C_COMMON_ROOT}/source/array_list.c 20 | aws_array_list_push_back_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_push_back/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | # smtfd tactic is best, but maybe buggy in --cex mode 3 | horn-bmc-tactic: smt 4 | horn-bv2-word-size: 1 5 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_push_front/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_push_front 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_push_front_harness.c) 4 | sea_attach_bc_link(array_list_push_front) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_push_front) 7 | 8 | # klee 9 | sea_add_klee(array_list_push_front ${AWS_C_COMMON_ROOT}/source/array_list.c 10 | aws_array_list_push_front_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(array_list_push_front aws_array_list_push_front_harness.c) 14 | 15 | # smack 16 | sea_add_smack(array_list_push_front ${AWS_C_COMMON_ROOT}/source/array_list.c 17 | aws_array_list_push_front_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(array_list_push_front ${AWS_C_COMMON_ROOT}/source/array_list.c 21 | aws_array_list_push_front_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_push_front/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | # smtfd tactic is best, but maybe buggy in --cex mode 3 | horn-bmc-tactic: smt 4 | horn-bv2-word-size: 1 5 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_set_at/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_set_at 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_set_at_harness.c) 4 | sea_attach_bc_link(array_list_set_at) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_set_at) 7 | 8 | # klee 9 | sea_add_klee(array_list_set_at ${AWS_C_COMMON_ROOT}/source/array_list.c 10 | aws_array_list_set_at_harness.c) 11 | 12 | sea_add_fuzz(array_list_set_at aws_array_list_set_at_harness.c) 13 | 14 | # smack 15 | sea_add_smack(array_list_set_at ${AWS_C_COMMON_ROOT}/source/array_list.c 16 | aws_array_list_set_at_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(array_list_set_at ${AWS_C_COMMON_ROOT}/source/array_list.c 20 | aws_array_list_set_at_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_set_at/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_shrink_to_fit/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_shrink_to_fit 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_shrink_to_fit_harness.c) 4 | sea_attach_bc_link(array_list_shrink_to_fit) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_shrink_to_fit) 7 | 8 | # klee 9 | sea_add_klee(array_list_shrink_to_fit ${AWS_C_COMMON_ROOT}/source/array_list.c 10 | aws_array_list_shrink_to_fit_harness.c) 11 | 12 | sea_add_fuzz(array_list_shrink_to_fit aws_array_list_shrink_to_fit_harness.c) 13 | 14 | # smack 15 | sea_add_smack(array_list_shrink_to_fit ${AWS_C_COMMON_ROOT}/source/array_list.c 16 | aws_array_list_shrink_to_fit_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(array_list_shrink_to_fit ${AWS_C_COMMON_ROOT}/source/array_list.c 20 | aws_array_list_shrink_to_fit_harness.c) 21 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_shrink_to_fit/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_sort/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_sort 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_sort_harness.c) 4 | sea_attach_bc_link(array_list_sort) 5 | sea_add_unsat_test(array_list_sort) 6 | 7 | # klee 8 | sea_add_klee(array_list_sort ${AWS_C_COMMON_ROOT}/source/array_list.c 9 | aws_array_list_sort_harness.c) 10 | 11 | sea_add_fuzz(array_list_sort aws_array_list_sort_harness.c) 12 | 13 | # smack 14 | sea_add_smack(array_list_sort ${AWS_C_COMMON_ROOT}/source/array_list.c 15 | aws_array_list_sort_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(array_list_sort ${AWS_C_COMMON_ROOT}/source/array_list.c 19 | aws_array_list_sort_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_swap/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_swap 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_swap_harness.c) 4 | configure_file(sea.yaml sea.yaml @ONLY) 5 | sea_attach_bc_link(array_list_swap) 6 | sea_add_unsat_test(array_list_swap) 7 | 8 | # klee 9 | sea_add_klee(array_list_swap ${AWS_C_COMMON_ROOT}/source/array_list.c 10 | aws_array_list_swap_harness.c) 11 | 12 | sea_add_fuzz(array_list_swap aws_array_list_swap_harness.c) 13 | 14 | # smack 15 | sea_add_smack(array_list_swap ${AWS_C_COMMON_ROOT}/source/array_list.c 16 | aws_array_list_swap_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(array_list_swap ${AWS_C_COMMON_ROOT}/source/array_list.c 20 | aws_array_list_swap_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/array_list_swap/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-explicit-sp0: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs/array_list_swap_contents/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_swap_contents 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_swap_contents_harness.c) 4 | sea_attach_bc_link(array_list_swap_contents) 5 | sea_add_unsat_test(array_list_swap_contents) 6 | 7 | # klee 8 | sea_add_klee(array_list_swap_contents ${AWS_C_COMMON_ROOT}/source/array_list.c 9 | aws_array_list_swap_contents_harness.c) 10 | 11 | sea_add_fuzz(array_list_swap_contents aws_array_list_swap_contents_harness.c) 12 | 13 | # smack 14 | sea_add_smack(array_list_swap_contents ${AWS_C_COMMON_ROOT}/source/array_list.c 15 | aws_array_list_swap_contents_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(array_list_swap_contents ${AWS_C_COMMON_ROOT}/source/array_list.c 19 | aws_array_list_swap_contents_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_advance/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_advance 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_advance_harness.c) 4 | sea_attach_bc_link(byte_buf_advance) 5 | sea_add_unsat_test(byte_buf_advance) 6 | 7 | # klee 8 | sea_add_klee(byte_buf_advance ${AWS_C_COMMON_ROOT}/source/byte_buf.c 9 | aws_byte_buf_advance_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(byte_buf_advance 13 | aws_byte_buf_advance_harness.c) 14 | 15 | # smack 16 | sea_add_smack(byte_buf_advance ${AWS_C_COMMON_ROOT}/source/byte_buf.c 17 | aws_byte_buf_advance_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(byte_buf_advance ${AWS_C_COMMON_ROOT}/source/byte_buf.c 21 | aws_byte_buf_advance_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_append/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_append 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_append_harness.c) 4 | sea_attach_bc_link(byte_buf_append) 5 | sea_add_unsat_test(byte_buf_append) 6 | 7 | # klee 8 | sea_add_klee(byte_buf_append ${AWS_C_COMMON_ROOT}/source/byte_buf.c 9 | aws_byte_buf_append_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(byte_buf_append aws_byte_buf_append_harness.c) 13 | 14 | # smack 15 | sea_add_smack(byte_buf_append ${AWS_C_COMMON_ROOT}/source/byte_buf.c 16 | aws_byte_buf_append_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(byte_buf_append ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_buf_append_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_append_dynamic/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_append_dynamic 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_append_dynamic_harness.c) 4 | target_compile_definitions(byte_buf_append_dynamic PUBLIC __SEA_AWS_ALLOCATOR__) 5 | sea_attach_bc_link(byte_buf_append_dynamic) 6 | sea_add_unsat_test(byte_buf_append_dynamic) 7 | 8 | # klee 9 | sea_add_klee(byte_buf_append_dynamic ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_buf_append_dynamic_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_buf_append_dynamic aws_byte_buf_append_dynamic_harness.c) 14 | 15 | # smack 16 | sea_add_smack(byte_buf_append_dynamic ${AWS_C_COMMON_ROOT}/source/byte_buf.c 17 | aws_byte_buf_append_dynamic_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(byte_buf_append_dynamic ${AWS_C_COMMON_ROOT}/source/byte_buf.c 21 | aws_byte_buf_append_dynamic_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_append_with_lookup/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_append_with_lookup 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_append_with_lookup_harness.c) 4 | sea_attach_bc_link(byte_buf_append_with_lookup) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_append_with_lookup) 7 | 8 | # klee 9 | sea_add_klee(byte_buf_append_with_lookup ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_buf_append_with_lookup_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_buf_append_with_lookup 14 | aws_byte_buf_append_with_lookup_harness.c) 15 | 16 | # smack 17 | sea_add_smack(byte_buf_append_with_lookup ${AWS_C_COMMON_ROOT}/source/byte_buf.c 18 | aws_byte_buf_append_with_lookup_harness.c) 19 | 20 | # symbiotic 21 | sea_add_symbiotic(byte_buf_append_with_lookup ${AWS_C_COMMON_ROOT}/source/byte_buf.c 22 | aws_byte_buf_append_with_lookup_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_append_with_lookup/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | bound: @MAX_BUFFER_SIZE@ 4 | 5 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_cat/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_cat 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_cat_harness.c) 4 | sea_attach_bc_link(byte_buf_cat) 5 | sea_add_unsat_test(byte_buf_cat) 6 | 7 | # klee 8 | # Klee will get timeout on this test 9 | # sea_add_klee(byte_buf_cat ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | # aws_byte_buf_cat_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_buf_cat aws_byte_buf_cat_harness.c) 14 | 15 | # smack 16 | sea_add_smack(byte_buf_cat ${AWS_C_COMMON_ROOT}/source/byte_buf.c 17 | aws_byte_buf_cat_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(byte_buf_cat ${AWS_C_COMMON_ROOT}/source/byte_buf.c 21 | aws_byte_buf_cat_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_cat/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_clean_up/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_clean_up 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_clean_up_harness.c) 4 | target_compile_definitions(byte_buf_clean_up PUBLIC __SEA_AWS_ALLOCATOR__) 5 | sea_attach_bc_link(byte_buf_clean_up) 6 | sea_add_unsat_test(byte_buf_clean_up) 7 | 8 | # klee 9 | sea_add_klee(byte_buf_clean_up ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_buf_clean_up_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_buf_clean_up aws_byte_buf_clean_up_harness.c) 14 | 15 | # smack 16 | sea_add_smack(byte_buf_clean_up ${AWS_C_COMMON_ROOT}/source/byte_buf.c 17 | aws_byte_buf_clean_up_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(byte_buf_clean_up ${AWS_C_COMMON_ROOT}/source/byte_buf.c 21 | aws_byte_buf_clean_up_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_clean_up/aws_byte_buf_clean_up_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | int main() { 11 | struct aws_byte_buf buf; 12 | initialize_byte_buf(&buf); 13 | 14 | assume(aws_byte_buf_is_valid(&buf)); 15 | 16 | aws_byte_buf_clean_up(&buf); 17 | sassert(buf.allocator == NULL); 18 | sassert(buf.buffer == NULL); 19 | sassert(buf.len == 0); 20 | sassert(buf.capacity == 0); 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_clean_up_secure/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_clean_up_secure 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_clean_up_secure_harness.c) 4 | sea_attach_bc_link(byte_buf_clean_up_secure) 5 | sea_add_unsat_test(byte_buf_clean_up_secure) 6 | 7 | # klee 8 | sea_add_klee(byte_buf_clean_up_secure ${AWS_C_COMMON_ROOT}/source/byte_buf.c 9 | ${AWS_C_COMMON_ROOT}/source/common.c 10 | aws_byte_buf_clean_up_secure_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_buf_clean_up_secure aws_byte_buf_clean_up_secure_harness.c) 14 | 15 | # smack 16 | sea_add_smack(byte_buf_clean_up_secure ${AWS_C_COMMON_ROOT}/source/byte_buf.c 17 | aws_byte_buf_clean_up_secure_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(byte_buf_clean_up_secure ${AWS_C_COMMON_ROOT}/source/byte_buf.c 21 | aws_byte_buf_clean_up_secure_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_clean_up_secure/aws_byte_buf_clean_up_secure_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | int main() { 11 | /* data structure */ 12 | struct aws_byte_buf buf; 13 | initialize_byte_buf(&buf); 14 | 15 | /* assumptions */ 16 | assume(aws_byte_buf_is_valid(&buf)); 17 | 18 | /* operation under verification */ 19 | aws_byte_buf_clean_up_secure(&buf); 20 | 21 | /* assertions */ 22 | sassert(buf.allocator == NULL); 23 | sassert(buf.buffer == NULL); 24 | sassert(buf.len == 0); 25 | sassert(buf.capacity == 0); 26 | 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_eq/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_eq 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_eq_harness.c) 4 | sea_attach_bc_link(byte_buf_eq) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_eq) 7 | 8 | # klee 9 | sea_add_klee(byte_buf_eq ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_buf_eq_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_buf_eq 14 | aws_byte_buf_eq_harness.c) 15 | 16 | # smack 17 | if(SEA_ENABLE_SMACK) 18 | sea_add_smack_bc(byte_buf_eq ${AWS_C_COMMON_ROOT}/source/byte_buf.c 19 | aws_byte_buf_eq_harness.c) 20 | sea_add_smack_test(byte_buf_eq --strings) 21 | endif() 22 | 23 | # symbiotic 24 | sea_add_symbiotic(byte_buf_eq ${AWS_C_COMMON_ROOT}/source/byte_buf.c 25 | aws_byte_buf_eq_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_eq/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_eq_c_str/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_eq_c_str 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_eq_c_str_harness.c) 4 | sea_attach_bc_link(byte_buf_eq_c_str) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_eq_c_str) 7 | 8 | sea_add_fuzz(byte_buf_eq_c_str 9 | aws_byte_buf_eq_c_str_harness.c) 10 | 11 | # klee 12 | sea_add_klee(byte_buf_eq_c_str ${AWS_C_COMMON_ROOT}/source/byte_buf.c 13 | aws_byte_buf_eq_c_str_harness.c) 14 | 15 | # smack 16 | sea_add_smack(byte_buf_eq_c_str ${AWS_C_COMMON_ROOT}/source/byte_buf.c 17 | aws_byte_buf_eq_c_str_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(byte_buf_eq_c_str ${AWS_C_COMMON_ROOT}/source/byte_buf.c 21 | aws_byte_buf_eq_c_str_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_eq_c_str/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_eq_c_str_ignore_case/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_eq_c_str_ignore_case 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_eq_c_str_ignore_case_harness.c) 4 | configure_file(sea.yaml sea.yaml @ONLY) 5 | sea_attach_bc_link(byte_buf_eq_c_str_ignore_case) 6 | sea_add_unsat_test(byte_buf_eq_c_str_ignore_case) 7 | 8 | # klee 9 | sea_add_klee(byte_buf_eq_c_str_ignore_case ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_buf_eq_c_str_ignore_case_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_buf_eq_c_str_ignore_case 14 | aws_byte_buf_eq_c_str_ignore_case_harness.c) 15 | 16 | # smack 17 | sea_add_smack(byte_buf_eq_c_str_ignore_case ${AWS_C_COMMON_ROOT}/source/byte_buf.c 18 | aws_byte_buf_eq_c_str_ignore_case_harness.c) 19 | 20 | # symbiotic 21 | sea_add_symbiotic(byte_buf_eq_c_str_ignore_case ${AWS_C_COMMON_ROOT}/source/byte_buf.c 22 | aws_byte_buf_eq_c_str_ignore_case_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_eq_c_str_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_eq_ignore_case/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_eq_ignore_case 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_eq_ignore_case_harness.c) 4 | sea_attach_bc_link(byte_buf_eq_ignore_case) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_eq_ignore_case) 7 | 8 | # fuzz 9 | sea_add_fuzz(byte_buf_eq_ignore_case 10 | aws_byte_buf_eq_ignore_case_harness.c) 11 | 12 | # smack 13 | sea_add_smack(byte_buf_eq_ignore_case ${AWS_C_COMMON_ROOT}/source/byte_buf.c 14 | aws_byte_buf_eq_ignore_case_harness.c) 15 | 16 | # symbiotic 17 | sea_add_symbiotic(byte_buf_eq_ignore_case ${AWS_C_COMMON_ROOT}/source/byte_buf.c 18 | aws_byte_buf_eq_ignore_case_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_eq_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_from_array/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_from_array 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_from_array_harness.c) 4 | sea_attach_bc_link(byte_buf_from_array) 5 | sea_add_unsat_test(byte_buf_from_array) 6 | 7 | # klee 8 | sea_add_klee(byte_buf_from_array ${AWS_C_COMMON_ROOT}/source/byte_buf.c 9 | aws_byte_buf_from_array_harness.c) 10 | 11 | sea_add_fuzz(byte_buf_from_array aws_byte_buf_from_array_harness.c) 12 | 13 | # smack 14 | sea_add_smack(byte_buf_from_array ${AWS_C_COMMON_ROOT}/source/byte_buf.c 15 | aws_byte_buf_from_array_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(byte_buf_from_array ${AWS_C_COMMON_ROOT}/source/byte_buf.c 19 | aws_byte_buf_from_array_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_from_array/aws_byte_buf_from_array_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int main() { 12 | /* parameters */ 13 | size_t length = nd_size_t(); 14 | KLEE_ASSUME(length <= KLEE_MAX_SIZE); 15 | uint8_t *array = bounded_malloc_havoc(length); 16 | 17 | /* operation under verification */ 18 | struct aws_byte_buf buf = aws_byte_buf_from_array(array, length); 19 | 20 | /* assertions */ 21 | sassert(aws_byte_buf_is_valid(&buf)); 22 | sassert(buf.len == length); 23 | sassert(buf.capacity == length); 24 | sassert(buf.allocator == NULL); 25 | if (buf.buffer) { 26 | assert_bytes_match(buf.buffer, array, buf.len); 27 | } 28 | 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_from_c_str/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_from_c_str 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_from_c_str_harness.c) 4 | sea_attach_bc_link(byte_buf_from_c_str) 5 | sea_add_unsat_test(byte_buf_from_c_str) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | 8 | # klee 9 | sea_add_klee(byte_buf_from_c_str ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_buf_from_c_str_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_buf_from_c_str aws_byte_buf_from_c_str_harness.c) 14 | 15 | # smack 16 | sea_add_smack(byte_buf_from_c_str ${AWS_C_COMMON_ROOT}/source/byte_buf.c 17 | aws_byte_buf_from_c_str_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(byte_buf_from_c_str ${AWS_C_COMMON_ROOT}/source/byte_buf.c 21 | aws_byte_buf_from_c_str_harness.c) 22 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_from_c_str/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bmc-logic: QF_ABV 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_from_empty_array/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_from_empty_array 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_from_empty_array_harness.c) 4 | sea_attach_bc_link(byte_buf_from_empty_array) 5 | sea_add_unsat_test(byte_buf_from_empty_array) 6 | 7 | # klee 8 | sea_add_klee(byte_buf_from_empty_array ${AWS_C_COMMON_ROOT}/source/byte_buf.c 9 | aws_byte_buf_from_empty_array_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(byte_buf_from_empty_array aws_byte_buf_from_empty_array_harness.c) 13 | 14 | # smack 15 | sea_add_smack(byte_buf_from_empty_array ${AWS_C_COMMON_ROOT}/source/byte_buf.c 16 | aws_byte_buf_from_empty_array_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(byte_buf_from_empty_array ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_buf_from_empty_array_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_from_empty_array/aws_byte_buf_from_empty_array_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int main() { 12 | size_t capacity = nd_size_t(); 13 | KLEE_ASSUME(capacity <= KLEE_MAX_SIZE); 14 | void *array = bounded_malloc_havoc(sizeof(*(array)) * (capacity)); 15 | 16 | struct aws_byte_buf buf = aws_byte_buf_from_empty_array(array, capacity); 17 | sassert(aws_byte_buf_is_valid(&buf)); 18 | sassert(buf.len == 0); 19 | sassert(buf.capacity == capacity); 20 | sassert(buf.allocator == NULL); 21 | if (buf.buffer) { 22 | assert_bytes_match(buf.buffer, array, capacity); 23 | } 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_init/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_init 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_init_harness.c) 4 | sea_attach_bc_link(byte_buf_init) 5 | sea_add_unsat_test(byte_buf_init) 6 | 7 | # klee 8 | sea_add_klee(byte_buf_init ${AWS_C_COMMON_ROOT}/source/byte_buf.c 9 | aws_byte_buf_init_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(byte_buf_init aws_byte_buf_init_harness.c) 13 | 14 | # smack 15 | sea_add_smack(byte_buf_init ${AWS_C_COMMON_ROOT}/source/byte_buf.c 16 | aws_byte_buf_init_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(byte_buf_init ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_buf_init_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_init/aws_byte_buf_init_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int main() { 12 | /* data structure */ 13 | struct aws_byte_buf buf; /* Precondition: buf is non-null */ 14 | initialize_byte_buf(&buf); 15 | 16 | /* parameters */ 17 | struct aws_allocator *allocator = sea_allocator(); /* Precondition: allocator is non-null */ 18 | size_t capacity = nd_size_t(); 19 | KLEE_ASSUME(capacity <= KLEE_MAX_SIZE); 20 | 21 | if (aws_byte_buf_init(&buf, allocator, capacity) == AWS_OP_SUCCESS) { 22 | /* assertions */ 23 | sassert(aws_byte_buf_is_valid(&buf)); 24 | sassert(buf.allocator == allocator); 25 | sassert(buf.len == 0); 26 | sassert(buf.capacity == capacity); 27 | } 28 | 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_init_copy/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_init_copy 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_init_copy_harness.c) 4 | sea_attach_bc_link(byte_buf_init_copy) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_init_copy) 7 | 8 | # klee 9 | sea_add_klee(byte_buf_init_copy ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_buf_init_copy_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_buf_init_copy aws_byte_buf_init_copy_harness.c) 14 | 15 | # smack 16 | sea_add_smack(byte_buf_init_copy ${AWS_C_COMMON_ROOT}/source/byte_buf.c 17 | aws_byte_buf_init_copy_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(byte_buf_init_copy ${AWS_C_COMMON_ROOT}/source/byte_buf.c 21 | aws_byte_buf_init_copy_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_init_copy/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_init_copy_from_cursor/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_init_copy_from_cursor 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_init_copy_from_cursor_harness.c) 4 | sea_attach_bc_link(byte_buf_init_copy_from_cursor) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_init_copy_from_cursor) 7 | 8 | # klee 9 | sea_add_klee(byte_buf_init_copy_from_cursor ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_buf_init_copy_from_cursor_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_buf_init_copy_from_cursor 14 | aws_byte_buf_init_copy_from_cursor_harness.c) 15 | 16 | # smack 17 | sea_add_smack(byte_buf_init_copy_from_cursor ${AWS_C_COMMON_ROOT}/source/byte_buf.c 18 | aws_byte_buf_init_copy_from_cursor_harness.c) 19 | 20 | # symbiotic 21 | sea_add_symbiotic(byte_buf_init_copy_from_cursor ${AWS_C_COMMON_ROOT}/source/byte_buf.c 22 | aws_byte_buf_init_copy_from_cursor_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_init_copy_from_cursor/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_reserve/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_reserve 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_reserve_harness.c) 4 | target_compile_definitions(byte_buf_reserve 5 | PUBLIC MAX_BUFFER_SIZE=${MAX_BUFFER_SIZE}) 6 | sea_attach_bc_link(byte_buf_reserve) 7 | configure_file(sea.yaml sea.yaml @ONLY) 8 | sea_add_unsat_test(byte_buf_reserve) 9 | 10 | # klee 11 | sea_add_klee(byte_buf_reserve ${AWS_C_COMMON_ROOT}/source/byte_buf.c 12 | aws_byte_buf_reserve_harness.c) 13 | 14 | # fuzz 15 | sea_add_fuzz(byte_buf_reserve aws_byte_buf_reserve_harness.c) 16 | 17 | # smack 18 | sea_add_smack(byte_buf_reserve ${AWS_C_COMMON_ROOT}/source/byte_buf.c 19 | aws_byte_buf_reserve_harness.c) 20 | 21 | # symbiotic 22 | sea_add_symbiotic(byte_buf_reserve ${AWS_C_COMMON_ROOT}/source/byte_buf.c 23 | aws_byte_buf_reserve_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_reserve/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_reserve_relative/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_reserve_relative 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_reserve_relative_harness.c) 4 | sea_attach_bc_link(byte_buf_reserve_relative) 5 | sea_add_unsat_test(byte_buf_reserve_relative) 6 | 7 | # klee 8 | sea_add_klee(byte_buf_reserve_relative ${AWS_C_COMMON_ROOT}/source/byte_buf.c 9 | aws_byte_buf_reserve_relative_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(byte_buf_reserve_relative aws_byte_buf_reserve_relative_harness.c) 13 | 14 | # smack 15 | sea_add_smack(byte_buf_reserve_relative ${AWS_C_COMMON_ROOT}/source/byte_buf.c 16 | aws_byte_buf_reserve_relative_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(byte_buf_reserve_relative ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_buf_reserve_relative_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_reset/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_reset 2 | ${AWS_C_COMMON_ROOT}/source/common.c 3 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 4 | aws_byte_buf_reset_harness.c) 5 | sea_attach_bc_link(byte_buf_reset) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_buf_reset) 8 | 9 | # klee 10 | sea_add_klee(byte_buf_reset 11 | ${AWS_C_COMMON_ROOT}/source/common.c 12 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 13 | aws_byte_buf_reset_harness.c) 14 | 15 | # fuzz 16 | sea_add_fuzz(byte_buf_reset aws_byte_buf_reset_harness.c) 17 | 18 | # smack 19 | sea_add_smack(byte_buf_reset ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | ${AWS_C_COMMON_ROOT}/source/common.c 21 | aws_byte_buf_reset_harness.c) 22 | 23 | # symbiotic 24 | sea_add_symbiotic(byte_buf_reset 25 | ${AWS_C_COMMON_ROOT}/source/common.c 26 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 27 | aws_byte_buf_reset_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_reset/aws_byte_buf_reset_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | int main() { 11 | struct aws_byte_buf buf; 12 | initialize_byte_buf(&buf); 13 | 14 | assume(aws_byte_buf_is_valid(&buf)); 15 | 16 | struct aws_byte_buf old = buf; 17 | bool zero_contents = nd_bool(); 18 | aws_byte_buf_reset(&buf, zero_contents); 19 | sassert(buf.len == 0); 20 | sassert(buf.allocator == old.allocator); 21 | sassert(buf.buffer == old.buffer); 22 | sassert(buf.capacity == old.capacity); 23 | if (zero_contents) { 24 | assert_all_bytes_are(buf.buffer, 0, buf.capacity); 25 | } 26 | 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_reset/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_secure_zero/aws_byte_buf_secure_zero_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | int main() { 11 | struct aws_byte_buf buf; 12 | initialize_byte_buf(&buf); 13 | assume(aws_byte_buf_is_valid(&buf)); 14 | 15 | /* operation under verification */ 16 | aws_byte_buf_secure_zero(&buf); 17 | 18 | sassert(aws_byte_buf_is_valid(&buf)); 19 | assert_all_zeroes(buf.buffer, buf.capacity); 20 | sassert(buf.len == 0); 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_secure_zero/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_write/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_write_harness.c) 4 | sea_attach_bc_link(byte_buf_write) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_write) 7 | 8 | # klee 9 | sea_add_klee(byte_buf_write ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_buf_write_harness.c) 11 | 12 | # smack 13 | sea_add_smack(byte_buf_write ${AWS_C_COMMON_ROOT}/source/byte_buf.c 14 | aws_byte_buf_write_harness.c) 15 | 16 | # symbiotic 17 | sea_add_symbiotic(byte_buf_write ${AWS_C_COMMON_ROOT}/source/byte_buf.c 18 | aws_byte_buf_write_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_write/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_write_be16/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write_be16 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_write_be16_harness.c) 4 | sea_attach_bc_link(byte_buf_write_be16) 5 | sea_add_unsat_test(byte_buf_write_be16) 6 | 7 | # klee 8 | sea_add_klee(byte_buf_write_be16 ${AWS_C_COMMON_ROOT}/source/byte_buf.c 9 | aws_byte_buf_write_be16_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(byte_buf_write_be16 aws_byte_buf_write_be16_harness.c) 13 | 14 | # smack 15 | sea_add_smack(byte_buf_write_be16 ${AWS_C_COMMON_ROOT}/source/byte_buf.c 16 | aws_byte_buf_write_be16_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(byte_buf_write_be16 ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_buf_write_be16_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_write_be32/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write_be32 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_write_be32_harness.c) 4 | sea_attach_bc_link(byte_buf_write_be32) 5 | sea_add_unsat_test(byte_buf_write_be32) 6 | 7 | # klee 8 | sea_add_klee(byte_buf_write_be32 ${AWS_C_COMMON_ROOT}/source/byte_buf.c 9 | aws_byte_buf_write_be32_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(byte_buf_write_be32 aws_byte_buf_write_be32_harness.c) 13 | 14 | # smack 15 | sea_add_smack(byte_buf_write_be32 ${AWS_C_COMMON_ROOT}/source/byte_buf.c 16 | aws_byte_buf_write_be32_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(byte_buf_write_be32 ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_buf_write_be32_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_write_be64/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write_be64 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_write_be64_harness.c) 4 | sea_attach_bc_link(byte_buf_write_be64) 5 | sea_add_unsat_test(byte_buf_write_be64) 6 | 7 | # klee 8 | sea_add_klee(byte_buf_write_be64 ${AWS_C_COMMON_ROOT}/source/byte_buf.c 9 | aws_byte_buf_write_be64_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(byte_buf_write_be64 aws_byte_buf_write_be64_harness.c) 13 | 14 | # smack 15 | sea_add_smack(byte_buf_write_be64 ${AWS_C_COMMON_ROOT}/source/byte_buf.c 16 | aws_byte_buf_write_be64_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(byte_buf_write_be64 ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_buf_write_be64_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_write_from_whole_buffer/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_write_from_whole_cursor/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_write_from_whole_string/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bmc-tactic: default 4 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_buf_write_u8/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write_u8 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_write_u8_harness.c) 4 | sea_attach_bc_link(byte_buf_write_u8) 5 | sea_add_unsat_test(byte_buf_write_u8) 6 | 7 | # klee 8 | sea_add_klee(byte_buf_write_u8 9 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_buf_write_u8_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_buf_write_u8 aws_byte_buf_write_u8_harness.c) 14 | 15 | # smack 16 | sea_add_smack(byte_buf_write_u8 ${AWS_C_COMMON_ROOT}/source/byte_buf.c 17 | aws_byte_buf_write_u8_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(byte_buf_write_u8 ${AWS_C_COMMON_ROOT}/source/byte_buf.c 21 | aws_byte_buf_write_u8_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_advance/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_advance 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_advance_harness.c) 4 | sea_attach_bc_link(byte_cursor_advance) 5 | sea_add_unsat_test(byte_cursor_advance) 6 | 7 | # klee 8 | sea_add_klee(byte_cursor_advance 9 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_cursor_advance_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_cursor_advance aws_byte_cursor_advance_harness.c) 14 | 15 | # smack 16 | sea_add_smack(byte_cursor_advance ${AWS_C_COMMON_ROOT}/source/byte_buf.c 17 | aws_byte_cursor_advance_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(byte_cursor_advance ${AWS_C_COMMON_ROOT}/source/byte_buf.c 21 | aws_byte_cursor_advance_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_advance_nospec/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_advance_nospec 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_advance_nospec_harness.c) 4 | sea_attach_bc_link(byte_cursor_advance_nospec) 5 | sea_add_unsat_test(byte_cursor_advance_nospec) 6 | 7 | # fuzz 8 | sea_add_fuzz(byte_cursor_advance_nospec 9 | aws_byte_cursor_advance_nospec_harness.c) 10 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_compare_lookup/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_compare_lookup 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_compare_lookup_harness.c) 4 | sea_attach_bc_link(byte_cursor_compare_lookup) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_compare_lookup) 7 | 8 | # klee 9 | sea_add_klee(byte_cursor_compare_lookup 10 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 11 | aws_byte_cursor_compare_lookup_harness.c) 12 | 13 | # fuzz 14 | sea_add_fuzz(byte_cursor_compare_lookup 15 | aws_byte_cursor_compare_lookup_harness.c) 16 | 17 | # smack 18 | sea_add_smack(byte_cursor_compare_lookup ${AWS_C_COMMON_ROOT}/source/byte_buf.c 19 | aws_byte_cursor_compare_lookup_harness.c) 20 | 21 | # symbiotic 22 | sea_add_symbiotic(byte_cursor_compare_lookup ${AWS_C_COMMON_ROOT}/source/byte_buf.c 23 | aws_byte_cursor_compare_lookup_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_compare_lookup/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_eq/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_eq 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_eq_harness.c) 4 | sea_attach_bc_link(byte_cursor_eq) 5 | sea_add_unsat_test(byte_cursor_eq) 6 | 7 | # klee 8 | sea_add_klee(byte_cursor_eq 9 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_cursor_eq_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_cursor_eq aws_byte_cursor_eq_harness.c) 14 | 15 | # smack 16 | if(SEA_ENABLE_SMACK) 17 | sea_add_smack_bc(byte_cursor_eq ${AWS_C_COMMON_ROOT}/source/byte_buf.c 18 | aws_byte_cursor_eq_harness.c) 19 | sea_add_smack_test(byte_cursor_eq --strings) 20 | endif() 21 | 22 | # symbiotic 23 | sea_add_symbiotic(byte_cursor_eq ${AWS_C_COMMON_ROOT}/source/byte_buf.c 24 | aws_byte_cursor_eq_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_eq_byte_buf/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/seahorn/verify-c-common/f561a743c20302759d6419173956880e2e92b1f8/seahorn/jobs/byte_cursor_eq_byte_buf/.DS_Store -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_eq_byte_buf/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_eq_byte_buf 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_eq_byte_buf_harness.c) 4 | sea_attach_bc_link(byte_cursor_eq_byte_buf) 5 | sea_add_unsat_test(byte_cursor_eq_byte_buf) 6 | 7 | # klee 8 | sea_add_klee(byte_cursor_eq_byte_buf 9 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_cursor_eq_byte_buf_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_cursor_eq_byte_buf aws_byte_cursor_eq_byte_buf_harness.c) 14 | 15 | # smack 16 | if(SEA_ENABLE_SMACK) 17 | sea_add_smack_bc(byte_cursor_eq_byte_buf ${AWS_C_COMMON_ROOT}/source/byte_buf.c 18 | aws_byte_cursor_eq_byte_buf_harness.c) 19 | sea_add_smack_test(byte_cursor_eq_byte_buf --strings) 20 | endif() 21 | 22 | # symbiotic 23 | sea_add_symbiotic(byte_cursor_eq_byte_buf ${AWS_C_COMMON_ROOT}/source/byte_buf.c 24 | aws_byte_cursor_eq_byte_buf_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_eq_byte_buf_ignore_case/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/seahorn/verify-c-common/f561a743c20302759d6419173956880e2e92b1f8/seahorn/jobs/byte_cursor_eq_byte_buf_ignore_case/.DS_Store -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_eq_byte_buf_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_eq_c_str/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_eq_c_str 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_eq_c_str_harness.c) 4 | sea_attach_bc_link(byte_cursor_eq_c_str) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_eq_c_str) 7 | 8 | # klee 9 | sea_add_klee(byte_cursor_eq_c_str 10 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 11 | aws_byte_cursor_eq_c_str_harness.c) 12 | 13 | # fuzz 14 | sea_add_fuzz(byte_cursor_eq_c_str 15 | aws_byte_cursor_eq_c_str_harness.c) 16 | 17 | # smack 18 | sea_add_smack(byte_cursor_eq_c_str 19 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_cursor_eq_c_str_harness.c) 21 | 22 | # symbiotic 23 | sea_add_symbiotic(byte_cursor_eq_c_str 24 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 25 | aws_byte_cursor_eq_c_str_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_eq_c_str/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_eq_c_str_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_eq_ignore_case/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_eq_ignore_case 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_eq_ignore_case_harness.c) 4 | sea_attach_bc_link(byte_cursor_eq_ignore_case) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_eq_ignore_case) 7 | 8 | # klee 9 | sea_add_klee(byte_cursor_eq_ignore_case 10 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 11 | aws_byte_cursor_eq_ignore_case_harness.c) 12 | 13 | # fuzz 14 | sea_add_fuzz(byte_cursor_eq_ignore_case 15 | aws_byte_cursor_eq_ignore_case_harness.c) 16 | 17 | # smack 18 | sea_add_smack(byte_cursor_eq_ignore_case 19 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_cursor_eq_ignore_case_harness.c) 21 | 22 | # symbiotic 23 | sea_add_symbiotic(byte_cursor_eq_ignore_case 24 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 25 | aws_byte_cursor_eq_ignore_case_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_eq_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_from_array/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_from_array 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_from_array_harness.c) 4 | sea_attach_bc_link(byte_cursor_from_array) 5 | sea_add_unsat_test(byte_cursor_from_array) 6 | 7 | # klee 8 | sea_add_klee(byte_cursor_from_array 9 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_cursor_from_array_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_cursor_from_array 14 | aws_byte_cursor_from_array_harness.c) 15 | 16 | # smack 17 | sea_add_smack(byte_cursor_from_array 18 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 19 | aws_byte_cursor_from_array_harness.c) 20 | 21 | # symbiotic 22 | sea_add_symbiotic(byte_cursor_from_array 23 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 24 | aws_byte_cursor_from_array_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_from_array/aws_byte_cursor_from_array_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int main() { 12 | /* parameters */ 13 | size_t length = nd_size_t(); 14 | KLEE_ASSUME(length <= KLEE_MAX_SIZE); 15 | uint8_t *array = bounded_malloc_havoc(length); 16 | 17 | /* operation under verification */ 18 | struct aws_byte_cursor cur = aws_byte_cursor_from_array(array, length); 19 | 20 | /* assertions */ 21 | sassert(aws_byte_cursor_is_valid(&cur)); 22 | sassert(cur.len == length); 23 | if (cur.ptr) { 24 | assert_bytes_match(cur.ptr, array, cur.len); 25 | } 26 | 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_from_buf/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_from_buf 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_from_buf_harness.c) 4 | sea_attach_bc_link(byte_cursor_from_buf) 5 | sea_add_unsat_test(byte_cursor_from_buf) 6 | 7 | # klee 8 | sea_add_klee(byte_cursor_from_buf 9 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 10 | aws_byte_cursor_from_buf_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(byte_cursor_from_buf 14 | aws_byte_cursor_from_buf_harness.c) 15 | 16 | # smack 17 | sea_add_smack(byte_cursor_from_buf 18 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 19 | aws_byte_cursor_from_buf_harness.c) 20 | 21 | # symbiotic 22 | sea_add_symbiotic(byte_cursor_from_buf 23 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 24 | aws_byte_cursor_from_buf_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_from_c_str/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_from_c_str 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_from_c_str_harness.c) 4 | sea_attach_bc_link(byte_cursor_from_c_str) 5 | sea_add_unsat_test(byte_cursor_from_c_str) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | 8 | # klee 9 | sea_add_klee(byte_cursor_from_c_str 10 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 11 | aws_byte_cursor_from_c_str_harness.c) 12 | 13 | # fuzz 14 | sea_add_fuzz(byte_cursor_from_c_str 15 | aws_byte_cursor_from_c_str_harness.c) 16 | 17 | # smack 18 | sea_add_smack(byte_cursor_from_c_str 19 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_cursor_from_c_str_harness.c) 21 | 22 | # symbiotic 23 | sea_add_symbiotic(byte_cursor_from_c_str 24 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 25 | aws_byte_cursor_from_c_str_harness.c) 26 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_from_c_str/aws_byte_cursor_from_c_str_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int main() { 13 | /* parameter */ 14 | size_t str_len; 15 | const char *c_str = ensure_c_str_is_nd_allocated(MAX_BUFFER_SIZE, &str_len); 16 | 17 | /* operation under verification */ 18 | struct aws_byte_cursor cur = aws_byte_cursor_from_c_str(c_str); 19 | 20 | /* assertions */ 21 | sassert(aws_byte_cursor_is_valid(&cur)); 22 | if (cur.ptr) { /* if ptr is NULL len shoud be 0, otherwise equal to c_str */ 23 | sassert(cur.len == str_len); 24 | assert_bytes_match(cur.ptr, (uint8_t *)c_str, cur.len); 25 | } else { 26 | sassert(cur.len == 0); 27 | } 28 | 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_from_c_str/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bmc-logic: QF_ABV 3 | horn-bmc-tactic: smtfd 4 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_from_string/aws_byte_cursor_from_string_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | int main() { 12 | struct aws_string *str = ensure_string_is_allocated_bounded_length(MAX_STRING_LEN); 13 | struct aws_byte_cursor cursor = aws_byte_cursor_from_string(str); 14 | sassert(aws_string_is_valid(str)); 15 | sassert(aws_byte_cursor_is_valid(&cursor)); 16 | sassert(cursor.len == str->len); 17 | sassert(cursor.ptr == str->bytes); 18 | assert_bytes_match(str->bytes, cursor.ptr, str->len); 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_from_string/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_left_trim_pred/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_left_trim_pred 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_left_trim_pred_harness.c) 4 | sea_attach_bc_link(byte_cursor_left_trim_pred) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_left_trim_pred) 7 | 8 | # klee 9 | sea_add_klee(byte_cursor_left_trim_pred 10 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 11 | aws_byte_cursor_left_trim_pred_harness.c) 12 | 13 | # fuzz 14 | sea_add_fuzz(byte_cursor_left_trim_pred 15 | aws_byte_cursor_left_trim_pred_harness.c) 16 | 17 | # smack 18 | sea_add_smack(byte_cursor_left_trim_pred 19 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_cursor_left_trim_pred_harness.c) 21 | 22 | # symbiotic 23 | sea_add_symbiotic(byte_cursor_left_trim_pred 24 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 25 | aws_byte_cursor_left_trim_pred_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_left_trim_pred/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_read/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_read 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_read_harness.c) 4 | sea_overlink_libraries(byte_cursor_read byte_cursor_advance_nospec_override.ir) 5 | sea_attach_bc_link(byte_cursor_read) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_cursor_read) 8 | 9 | # fuzz 10 | sea_add_fuzz(byte_cursor_read aws_byte_cursor_read_harness.c) 11 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_read/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_read_and_fill_buffer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_read_and_fill_buffer 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_read_and_fill_buffer_harness.c) 4 | sea_overlink_libraries(byte_cursor_read_and_fill_buffer byte_cursor_advance_nospec_override.ir) 5 | sea_attach_bc_link(byte_cursor_read_and_fill_buffer) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_cursor_read_and_fill_buffer) 8 | 9 | # fuzz 10 | sea_add_fuzz(byte_cursor_read_and_fill_buffer 11 | aws_byte_cursor_read_and_fill_buffer_harness.c) 12 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_read_and_fill_buffer/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_read_be16/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_read_be16 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_read_be16_harness.c) 4 | sea_overlink_libraries(byte_cursor_read_be16 byte_cursor_advance_nospec_override.ir) 5 | sea_attach_bc_link(byte_cursor_read_be16) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_cursor_read_be16) 8 | 9 | # fuzz 10 | sea_add_fuzz(byte_cursor_read_be16 11 | aws_byte_cursor_read_be16_harness.c) 12 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_read_be16/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_read_be32/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_read_be32 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_read_be32_harness.c) 4 | sea_overlink_libraries(byte_cursor_read_be32 byte_cursor_advance_nospec_override.ir) 5 | sea_attach_bc_link(byte_cursor_read_be32) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_cursor_read_be32) 8 | 9 | # fuzz 10 | sea_add_fuzz(byte_cursor_read_be32 11 | aws_byte_cursor_read_be32_harness.c) 12 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_read_be32/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_read_be64/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_read_be64 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_read_be64_harness.c) 4 | sea_overlink_libraries(byte_cursor_read_be64 byte_cursor_advance_nospec_override.ir) 5 | sea_attach_bc_link(byte_cursor_read_be64) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_cursor_read_be64) 8 | 9 | # fuzz 10 | sea_add_fuzz(byte_cursor_read_be64 11 | aws_byte_cursor_read_be64_harness.c) 12 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_read_be64/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_read_u8/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_read_u8 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_read_u8_harness.c) 4 | sea_overlink_libraries(byte_cursor_read_u8 byte_cursor_advance_nospec_override.ir) 5 | sea_attach_bc_link(byte_cursor_read_u8) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_cursor_read_u8) 8 | 9 | # fuzz 10 | sea_add_fuzz(byte_cursor_read_u8 11 | aws_byte_cursor_read_u8_harness.c) 12 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_read_u8/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_right_trim_pred/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_right_trim_pred 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_right_trim_pred_harness.c) 4 | sea_attach_bc_link(byte_cursor_right_trim_pred) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_right_trim_pred) 7 | 8 | # klee 9 | sea_add_klee(byte_cursor_right_trim_pred 10 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 11 | aws_byte_cursor_right_trim_pred_harness.c) 12 | 13 | # fuzz 14 | sea_add_fuzz(byte_cursor_right_trim_pred 15 | aws_byte_cursor_right_trim_pred_harness.c) 16 | 17 | # smack 18 | sea_add_smack(byte_cursor_right_trim_pred 19 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_cursor_right_trim_pred_harness.c) 21 | 22 | # symbiotic 23 | sea_add_symbiotic(byte_cursor_right_trim_pred 24 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 25 | aws_byte_cursor_right_trim_pred_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_right_trim_pred/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_satisfies_pred/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_satisfies_pred 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_satisfies_pred_harness.c) 4 | sea_attach_bc_link(byte_cursor_satisfies_pred) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_satisfies_pred) 7 | 8 | # klee 9 | sea_add_klee(byte_cursor_satisfies_pred 10 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 11 | aws_byte_cursor_satisfies_pred_harness.c) 12 | 13 | # fuzz 14 | sea_add_fuzz(byte_cursor_satisfies_pred 15 | aws_byte_cursor_satisfies_pred_harness.c) 16 | 17 | # smack 18 | sea_add_smack(byte_cursor_satisfies_pred 19 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 20 | aws_byte_cursor_satisfies_pred_harness.c) 21 | 22 | # symbiotic 23 | sea_add_symbiotic(byte_cursor_satisfies_pred 24 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 25 | aws_byte_cursor_satisfies_pred_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_satisfies_pred/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_trim_pred/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_trim_pred 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_trim_pred_harness.c) 4 | sea_attach_bc_link(byte_cursor_trim_pred) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_trim_pred) 7 | 8 | # klee 9 | sea_add_klee(byte_cursor_trim_pred 10 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 11 | aws_byte_cursor_trim_pred_harness.c) 12 | 13 | # fuzz 14 | sea_add_fuzz(byte_cursor_trim_pred aws_byte_cursor_trim_pred_harness.c) 15 | 16 | # smack 17 | sea_add_smack(byte_cursor_trim_pred 18 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 19 | aws_byte_cursor_trim_pred_harness.c) 20 | 21 | # symbiotic 22 | sea_add_symbiotic(byte_cursor_trim_pred 23 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 24 | aws_byte_cursor_trim_pred_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/byte_cursor_trim_pred/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ -------------------------------------------------------------------------------- /seahorn/jobs/hash_array_ignore_case/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(hash_array_ignore_case 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 4 | aws_hash_array_ignore_case_harness.c) 5 | sea_attach_bc_link(hash_array_ignore_case) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(hash_array_ignore_case) 8 | 9 | # klee 10 | sea_add_klee(hash_array_ignore_case 11 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 12 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 13 | aws_hash_array_ignore_case_harness.c) 14 | 15 | # smack 16 | sea_add_smack(hash_array_ignore_case 17 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 18 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 19 | aws_hash_array_ignore_case_harness.c) 20 | 21 | # symbiotic 22 | sea_add_symbiotic(hash_array_ignore_case 23 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 24 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 25 | aws_hash_array_ignore_case_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/hash_array_ignore_case/aws_hash_array_ignore_case_harness.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "utils.h" 4 | #include "proof_allocators.h" 5 | 6 | int main(void) { 7 | /* parameters */ 8 | size_t length = nd_size_t(); 9 | assume(length < MAX_BUFFER_SIZE); 10 | uint8_t *array = can_fail_malloc_havoc(length); 11 | assume(AWS_MEM_IS_READABLE(array, length)); 12 | 13 | /* operation under verification */ 14 | uint64_t rval = aws_hash_array_ignore_case(array, length); 15 | 16 | /* assertions */ 17 | sassert(AWS_MEM_IS_READABLE(array, length)); 18 | } -------------------------------------------------------------------------------- /seahorn/jobs/hash_array_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_byte_cursor_ptr/aws_hash_byte_cursor_ptr_harness.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | 6 | #include 7 | #include 8 | 9 | int main(void) { 10 | struct aws_byte_cursor cur; 11 | initialize_byte_cursor_aligned(&cur); 12 | 13 | assume(aws_byte_cursor_is_bounded(&cur, MAX_BUFFER_SIZE)); 14 | assume(aws_byte_cursor_is_valid(&cur)); 15 | 16 | /* This function has no pre or post conditions */ 17 | uint64_t rval = aws_hash_byte_cursor_ptr(&cur); 18 | 19 | sassert(aws_byte_cursor_is_valid(&cur)); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_byte_cursor_ptr/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_byte_cursor_ptr_ignore_case/aws_hash_byte_cursor_ptr_ignore_case_harness.c: -------------------------------------------------------------------------------- 1 | /** 2 | */ 3 | 4 | #include 5 | 6 | #include 7 | 8 | #include 9 | #include 10 | 11 | int main(void) { 12 | /* parameters */ 13 | struct aws_byte_cursor cur; 14 | initialize_byte_cursor(&cur); 15 | 16 | /* assumptions */ 17 | assume(aws_byte_cursor_is_bounded(&cur, MAX_BUFFER_SIZE)); 18 | assume(aws_byte_cursor_is_valid(&cur)); 19 | assume(AWS_MEM_IS_READABLE(cur.ptr, cur.len)); 20 | 21 | /* operation under verification */ 22 | aws_hash_byte_cursor_ptr_ignore_case(&cur); 23 | 24 | /* assertions */ 25 | sassert(aws_byte_cursor_is_valid(&cur)); 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_byte_cursor_ptr_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_c_string/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(hash_c_string 2 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 3 | aws_hash_c_string_harness.c) 4 | sea_attach_bc_link(hash_c_string) 5 | sea_add_unsat_test(hash_c_string) 6 | 7 | configure_file(sea.yaml sea.yaml @ONLY) 8 | # klee 9 | sea_add_klee(hash_c_string 10 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 11 | aws_hash_c_string_harness.c) 12 | 13 | # smack 14 | sea_add_smack(hash_c_string 15 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 16 | aws_hash_c_string_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(hash_c_string 20 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 21 | aws_hash_c_string_harness.c) 22 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_c_string/aws_hash_c_string_harness.c: -------------------------------------------------------------------------------- 1 | /** 2 | */ 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #include 9 | 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | int main(void) { 16 | size_t len; 17 | const char *str = ensure_c_str_is_nd_allocated_aligned(MAX_STRING_LEN, &len); 18 | 19 | #ifdef __KLEE__ 20 | if (!str) 21 | return 0; 22 | #endif 23 | assume(aws_c_string_is_valid(str)); 24 | 25 | uint64_t rval = aws_hash_c_string(str); 26 | (void)rval; 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_c_string/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bmc-tactic: smtfd 3 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_callback_c_str_eq/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@MAX_STRING_LEN@" 3 | horn-bmc-tactic: smtfd 4 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_callback_string_destroy/aws_hash_callback_string_destroy_harness.c: -------------------------------------------------------------------------------- 1 | /** 2 | */ 3 | 4 | #include 5 | 6 | #include 7 | #include 8 | 9 | #include 10 | 11 | #include 12 | #include 13 | #include 14 | #include 15 | 16 | int main(void) { 17 | struct aws_string *str = 18 | ensure_string_is_allocated_bounded_length(MAX_STRING_LEN); 19 | 20 | assume(aws_string_is_valid(str)); 21 | 22 | aws_hash_callback_string_destroy(str); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_callback_string_eq/aws_hash_callback_string_eq_harness.c: -------------------------------------------------------------------------------- 1 | /** 2 | */ 3 | 4 | #include 5 | 6 | #include 7 | #include 8 | 9 | #include 10 | 11 | #include 12 | #include 13 | #include 14 | 15 | int main(void) { 16 | const struct aws_string *str1 = 17 | ensure_string_is_allocated_bounded_length(MAX_STRING_LEN); 18 | const struct aws_string *str2 = 19 | nd_bool() ? str1 20 | : ensure_string_is_allocated_bounded_length(MAX_STRING_LEN); 21 | 22 | assume(aws_string_is_valid(str1)); 23 | assume(aws_string_is_valid(str2)); 24 | 25 | bool rval = aws_hash_callback_string_eq(str1, str2); 26 | if (rval) { 27 | sassert(str1->len == str2->len); 28 | assert_bytes_match(str1->bytes, str2->bytes, str1->len); 29 | } 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_callback_string_eq/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@MAX_STRING_LEN@" 3 | horn-bmc-tactic: smtfd 4 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_iter_begin/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@MAX_TABLE_SIZE@" 3 | horn-bmc-logic: QF_ABV 4 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_iter_begin_done/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@MAX_TABLE_SIZE@" 3 | horn-bmc-logic: QF_ABV 4 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_iter_delete/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable( 2 | hash_iter_delete 3 | ${AWS_C_COMMON_ROOT}/source/common.c 4 | aws_hash_iter_delete_harness.c 5 | ) 6 | sea_link_libraries(hash_iter_delete hash_table.opt.ir) 7 | sea_overlink_libraries(hash_iter_delete hash_table_state_is_valid_override.ir) 8 | sea_attach_bc_link(hash_iter_delete) 9 | configure_file(sea.yaml sea.yaml @ONLY) 10 | sea_add_unsat_test(hash_iter_delete) 11 | 12 | # fuzz 13 | sea_add_fuzz(hash_iter_delete aws_hash_iter_delete_harness.c) 14 | 15 | # smack 16 | sea_add_smack(hash_iter_delete 17 | ${AWS_C_COMMON_ROOT}/source/common.c 18 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 19 | aws_hash_iter_delete_harness.c) 20 | 21 | # symbiotic 22 | sea_add_symbiotic(hash_iter_delete 23 | ${AWS_C_COMMON_ROOT}/source/common.c 24 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 25 | aws_hash_iter_delete_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/hash_iter_delete/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@MAX_TABLE_SIZE@" 3 | horn-bmc-logic: QF_ABV 4 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_iter_next/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@MAX_TABLE_SIZE@" 3 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_ptr/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(hash_ptr 2 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 3 | aws_hash_ptr_harness.c) 4 | sea_attach_bc_link(hash_ptr) 5 | sea_add_unsat_test(hash_ptr) 6 | 7 | # klee 8 | sea_add_klee(hash_ptr 9 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 10 | aws_hash_ptr_harness.c) 11 | 12 | # fuzz 13 | sea_add_fuzz(hash_ptr aws_hash_ptr_harness.c) 14 | 15 | # smack 16 | sea_add_smack(hash_ptr 17 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 18 | aws_hash_ptr_harness.c) 19 | 20 | # symbiotic 21 | sea_add_symbiotic(hash_ptr 22 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 23 | aws_hash_ptr_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/hash_ptr/aws_hash_ptr_harness.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(void) { 6 | /* hash value of ptr itself only, so deref should be illegal */ 7 | void *ptr = nd_voidp(); 8 | /* This function has no pre or post conditions */ 9 | /* passively checks mem safety */ 10 | uint64_t rval = aws_hash_ptr(ptr); 11 | return 0; 12 | } -------------------------------------------------------------------------------- /seahorn/jobs/hash_string/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(hash_string 2 | ${AWS_C_COMMON_ROOT}/source/string.c 3 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 4 | aws_hash_string_harness.c) 5 | sea_attach_bc_link(hash_string) 6 | sea_add_unsat_test(hash_string) 7 | 8 | # klee 9 | sea_add_klee(hash_string 10 | ${AWS_C_COMMON_ROOT}/source/string.c 11 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 12 | aws_hash_string_harness.c) 13 | 14 | # fuzz 15 | sea_add_fuzz(hash_string aws_hash_string_harness.c) 16 | 17 | # smack 18 | sea_add_smack(hash_string 19 | ${AWS_C_COMMON_ROOT}/source/string.c 20 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 21 | aws_hash_string_harness.c) 22 | 23 | # symbiotic 24 | sea_add_symbiotic(hash_string 25 | ${AWS_C_COMMON_ROOT}/source/string.c 26 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 27 | aws_hash_string_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/hash_string/aws_hash_string_harness.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main(void) 7 | { 8 | /* hash value of ptr itself only, so deref should be illegal */ 9 | struct aws_string *str = ensure_string_is_allocated_bounded_length(MAX_BUFFER_SIZE); 10 | /* This function has no pre or post conditions */ 11 | /* passively checks mem safety */ 12 | uint64_t rval = aws_hash_string(str); 13 | return 0; 14 | } -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_clean_up/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@MAX_TABLE_SIZE@" 3 | horn-array-sym-memcpy-unroll-count: "@MEMCPY_UNROLL_BND@" 4 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_clear/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_TABLE_SIZE@ 3 | horn-array-sym-memcpy-unroll-count: "@MEMCPY_UNROLL_BND@" 4 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_create/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@UNROLL_BOUND@" 3 | horn-bmc-tactic: smtfd -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_eq/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@MAX_TABLE_SIZE@" 3 | horn-bmc-tactic: smtfd -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_find/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_TABLE_SIZE@ -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_foreach/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@UNROLL_BOUND@" 3 | horn-bmc-tactic: smtfd 4 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_foreach_deep_loose/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@UNROLL_BOUND@" 3 | horn-bmc-tactic: smtfd 4 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_foreach_deep_precise/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@UNROLL_BOUND@" 3 | horn-bmc-tactic: smtfd 4 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_init_bounded/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-array-sym-memcpy-unroll-count: "@MEMCPY_UNROLL_BND@" 3 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_init_unbounded/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-explicit-sp0: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_move/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(hash_table_move 2 | aws_hash_table_move_harness.c) 3 | sea_link_libraries(hash_table_move hash_table.opt.ir) 4 | sea_overlink_libraries(hash_table_move hash_table_state_is_valid_override.ir) 5 | sea_attach_bc_link(hash_table_move) 6 | sea_add_unsat_test(hash_table_move) 7 | 8 | # klee 9 | sea_add_klee(hash_table_move 10 | ${AWS_C_COMMON_ROOT}/source/common.c 11 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 12 | aws_hash_table_move_harness.c) 13 | 14 | # fuzz 15 | sea_add_fuzz(hash_table_move aws_hash_table_move_harness.c) 16 | 17 | # smack 18 | sea_add_smack(hash_table_move 19 | ${AWS_C_COMMON_ROOT}/source/common.c 20 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 21 | aws_hash_table_move_harness.c) 22 | 23 | # symbiotic 24 | sea_add_symbiotic(hash_table_move 25 | ${AWS_C_COMMON_ROOT}/source/common.c 26 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 27 | aws_hash_table_move_harness.c 28 | ) -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_put/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@UNROLL_BOUND@" 3 | horn-bmc-tactic: smtfd -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_remove/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@MAX_TABLE_SIZE@" 3 | horn-bmc-tactic: smtfd -------------------------------------------------------------------------------- /seahorn/jobs/hash_table_swap/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(hash_table_swap 2 | aws_hash_table_swap_harness.c) 3 | sea_link_libraries(hash_table_swap hash_table.opt.ir) 4 | sea_overlink_libraries(hash_table_swap hash_table_state_is_valid_override.ir) 5 | sea_attach_bc_link(hash_table_swap) 6 | sea_add_unsat_test(hash_table_swap) 7 | 8 | # klee 9 | sea_add_klee(hash_table_swap 10 | ${AWS_C_COMMON_ROOT}/source/common.c 11 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 12 | aws_hash_table_swap_harness.c) 13 | 14 | # fuzz 15 | sea_add_fuzz(hash_table_swap aws_hash_table_swap_harness.c) 16 | 17 | # smack 18 | sea_add_smack(hash_table_swap 19 | ${AWS_C_COMMON_ROOT}/source/common.c 20 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 21 | aws_hash_table_swap_harness.c) 22 | 23 | # symbiotic 24 | sea_add_symbiotic(hash_table_swap 25 | ${AWS_C_COMMON_ROOT}/source/common.c 26 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 27 | aws_hash_table_swap_harness.c 28 | ) -------------------------------------------------------------------------------- /seahorn/jobs/is_power_of_two/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(is_power_of_two 2 | aws_is_power_of_two_harness.c) 3 | sea_attach_bc_link(is_power_of_two) 4 | sea_add_unsat_test(is_power_of_two) 5 | 6 | # klee 7 | sea_add_klee(is_power_of_two 8 | aws_is_power_of_two_harness.c) 9 | 10 | # smack 11 | sea_add_smack(is_power_of_two 12 | aws_is_power_of_two_harness.c) 13 | 14 | # symbiotic 15 | sea_add_symbiotic(is_power_of_two 16 | aws_is_power_of_two_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/is_power_of_two/aws_is_power_of_two_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | */ 3 | 4 | #include 5 | 6 | #include 7 | #include 8 | 9 | int main() { 10 | size_t test_val = nd_size_t(); 11 | bool rval = aws_is_power_of_two(test_val); 12 | #if ULONG_MAX == SIZE_MAX 13 | int popcount = __builtin_popcountl(test_val); 14 | #elif ULLONG_MAX == SIZE_MAX 15 | int popcount = __builtin_popcountll(test_val); 16 | #else 17 | # error 18 | #endif 19 | sassert(rval == (popcount == 1)); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_back/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(linked_list_back 2 | aws_linked_list_back_harness.c) 3 | sea_attach_bc_link(linked_list_back) 4 | sea_add_unsat_test(linked_list_back) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | 7 | # klee 8 | sea_add_klee(linked_list_back 9 | aws_linked_list_back_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(linked_list_back 13 | aws_linked_list_back_harness.c) 14 | 15 | # smack 16 | sea_add_smack(linked_list_back 17 | aws_linked_list_back_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(linked_list_back 21 | aws_linked_list_back_harness.c) 22 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_back/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bmc-logic: QF_ABV 3 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_begin/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(linked_list_begin 2 | aws_linked_list_begin_harness.c) 3 | sea_attach_bc_link(linked_list_begin) 4 | sea_add_unsat_test(linked_list_begin) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | # klee 7 | sea_add_klee(linked_list_begin 8 | aws_linked_list_begin_harness.c) 9 | 10 | # fuzz 11 | sea_add_fuzz(linked_list_begin 12 | aws_linked_list_begin_harness.c) 13 | 14 | # smack 15 | sea_add_smack(linked_list_begin 16 | aws_linked_list_begin_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(linked_list_begin 20 | aws_linked_list_begin_harness.c) 21 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_begin/aws_linked_list_begin_harness.c: -------------------------------------------------------------------------------- 1 | 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | int main() { 8 | /* data structure */ 9 | struct aws_linked_list list; 10 | struct saved_aws_linked_list to_save = {0}; 11 | size_t size; 12 | 13 | sea_nd_init_aws_linked_list_from_head(&list, &size); 14 | struct aws_linked_list_node *start = &list.head; 15 | aws_linked_list_save_to_tail(&list, size, start, &to_save); 16 | 17 | /* perform operation under verification */ 18 | struct aws_linked_list_node *begin = aws_linked_list_begin(&list); 19 | 20 | /* assertions */ 21 | sassert(list.head.next == begin); 22 | sassert(is_aws_list_unchanged_to_tail(&list, &to_save)); 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_begin/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bmc-logic: QF_ABV 3 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_end/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # add head and tail to list size. 2 | add_executable(linked_list_end 3 | aws_linked_list_end_harness.c) 4 | target_compile_definitions(linked_list_end 5 | # We will use our own function for is_valid check hence AWS_DEEP_CHECK is off 6 | PUBLIC SEA_DEEP_CHECKS=0) 7 | sea_attach_bc_link(linked_list_end) 8 | sea_add_unsat_test(linked_list_end) 9 | 10 | # klee 11 | sea_add_klee(linked_list_end 12 | aws_linked_list_end_harness.c) 13 | 14 | # fuzz 15 | sea_add_fuzz(linked_list_end 16 | aws_linked_list_end_harness.c) 17 | 18 | # smack 19 | sea_add_smack(linked_list_end 20 | aws_linked_list_end_harness.c) 21 | 22 | # symbiotic 23 | sea_add_symbiotic(linked_list_end 24 | aws_linked_list_end_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_end/aws_linked_list_end_harness.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(void) { 6 | /* data structure */ 7 | struct aws_linked_list list; 8 | size_t length; 9 | struct saved_aws_linked_list to_save = {0}; 10 | 11 | sea_nd_init_aws_linked_list_from_tail(&list, &length); 12 | struct aws_linked_list_node *start = &list.tail; 13 | aws_linked_list_save_to_head(&list, length, start, &to_save); 14 | /* perform operation under verification */ 15 | const struct aws_linked_list_node *end = aws_linked_list_end(&list); 16 | 17 | sassert(end == &list.tail); 18 | sassert(is_aws_list_unchanged_to_head(&list, &to_save)); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_front/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(linked_list_front 2 | aws_linked_list_front_harness.c) 3 | sea_attach_bc_link(linked_list_front) 4 | sea_add_unsat_test(linked_list_front) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | 7 | # klee 8 | sea_add_klee(linked_list_front 9 | aws_linked_list_front_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(linked_list_front 13 | aws_linked_list_front_harness.c) 14 | 15 | # smack 16 | sea_add_smack(linked_list_front 17 | aws_linked_list_front_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(linked_list_front 21 | aws_linked_list_front_harness.c) 22 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_front/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bmc-logic: QF_ABV 3 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_init/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # add head and tail to list size. 2 | add_executable(linked_list_init 3 | aws_linked_list_init_harness.c) 4 | target_compile_definitions(linked_list_init 5 | # We will use our own function for is_valid check hence AWS_DEEP_CHECK is off 6 | PUBLIC SEA_DEEP_CHECKS=0) 7 | sea_attach_bc_link(linked_list_init) 8 | sea_add_unsat_test(linked_list_init) 9 | 10 | # klee 11 | sea_add_klee(linked_list_init 12 | aws_linked_list_init_harness.c) 13 | 14 | # fuzz 15 | sea_add_fuzz(linked_list_init 16 | aws_linked_list_init_harness.c) 17 | 18 | # smack 19 | sea_add_smack(linked_list_init 20 | aws_linked_list_init_harness.c) 21 | 22 | # symbiotic 23 | sea_add_symbiotic(linked_list_init 24 | aws_linked_list_init_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_init/aws_linked_list_init_harness.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(void) { 5 | /* data structure */ 6 | struct aws_linked_list list; 7 | 8 | /* Note: list is assumed to be a valid pointer in the function's 9 | * precondition */ 10 | 11 | /* perform operation under verification */ 12 | aws_linked_list_init(&list); 13 | 14 | /* assertions */ 15 | sassert(aws_linked_list_is_valid(&list)); 16 | 17 | return 0; 18 | } -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_insert_after/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(linked_list_insert_after 2 | aws_linked_list_insert_after_harness.c) 3 | sea_attach_bc_link(linked_list_insert_after) 4 | sea_add_unsat_test(linked_list_insert_after) 5 | 6 | # klee 7 | sea_add_klee(linked_list_insert_after 8 | aws_linked_list_insert_after_harness.c) 9 | 10 | # fuzz 11 | sea_add_fuzz(linked_list_insert_after 12 | aws_linked_list_insert_after_harness.c) 13 | 14 | # smack 15 | sea_add_smack(linked_list_insert_after 16 | aws_linked_list_insert_after_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(linked_list_insert_after 20 | aws_linked_list_insert_after_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_insert_before/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(linked_list_insert_before 2 | aws_linked_list_insert_before_harness.c) 3 | sea_attach_bc_link(linked_list_insert_before) 4 | sea_add_unsat_test(linked_list_insert_before) 5 | 6 | # klee 7 | sea_add_klee(linked_list_insert_before 8 | aws_linked_list_insert_before_harness.c) 9 | 10 | # fuzz 11 | sea_add_fuzz(linked_list_insert_before 12 | aws_linked_list_insert_before_harness.c) 13 | 14 | # smack 15 | sea_add_smack(linked_list_insert_before 16 | aws_linked_list_insert_before_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(linked_list_insert_before 20 | aws_linked_list_insert_before_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_next/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(linked_list_next 2 | aws_linked_list_next_harness.c) 3 | sea_attach_bc_link(linked_list_next) 4 | sea_add_unsat_test(linked_list_next) 5 | 6 | # klee 7 | sea_add_klee(linked_list_next 8 | aws_linked_list_next_harness.c) 9 | 10 | # fuzz 11 | sea_add_fuzz(linked_list_next 12 | aws_linked_list_next_harness.c) 13 | 14 | # smack 15 | sea_add_smack(linked_list_next 16 | aws_linked_list_next_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(linked_list_next 20 | aws_linked_list_next_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_next/aws_linked_list_next_harness.c: -------------------------------------------------------------------------------- 1 | #include "seahorn/seahorn.h" 2 | #include 3 | #include 4 | 5 | int main(void) { 6 | /* data structure */ 7 | struct aws_linked_list_node node; // Preconditions require node to not be NULL 8 | struct aws_linked_list_node 9 | after; // Preconditions require after to not be NULL 10 | 11 | /* Assume the preconditions */ 12 | aws_linked_list_attach_after(&node, &after, true); 13 | 14 | /* perform operation under verification */ 15 | struct aws_linked_list_node *rval = aws_linked_list_next(&node); 16 | 17 | /* assertions */ 18 | sassert(aws_linked_list_node_next_is_valid(&node)); 19 | sassert(aws_linked_list_node_prev_is_valid(rval)); 20 | sassert(rval == &after); 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_node_reset/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(linked_list_node_reset 2 | aws_linked_list_node_reset_harness.c) 3 | configure_file(sea.yaml sea.yaml @ONLY) 4 | sea_attach_bc_link(linked_list_node_reset) 5 | sea_add_unsat_test(linked_list_node_reset) 6 | 7 | # klee 8 | sea_add_klee(linked_list_node_reset 9 | aws_linked_list_node_reset_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(linked_list_node_reset 13 | aws_linked_list_node_reset_harness.c) 14 | 15 | # smack 16 | sea_add_smack(linked_list_node_reset 17 | aws_linked_list_node_reset_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(linked_list_node_reset 21 | aws_linked_list_node_reset_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_node_reset/aws_linked_list_node_reset_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | int main() { 10 | /* data structure */ 11 | struct aws_linked_list_node node; // Preconditions require node to not be NULL 12 | 13 | /* perform operation under verification */ 14 | aws_linked_list_node_reset(&node); 15 | 16 | /* assertions */ 17 | assert_all_zeroes((const uint8_t *)&node, 18 | sizeof(struct aws_linked_list_node)); 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_node_reset/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_pop_back/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # add head and tail to list size. 2 | MATH(EXPR UNROLL_BOUND "${MAX_LINKED_LIST_ITEM_ALLOCATION_SIZE} + 2") 3 | add_executable(linked_list_pop_back 4 | aws_linked_list_pop_back_harness.c) 5 | target_compile_definitions(linked_list_pop_back 6 | # We will use our own function for is_valid check hence AWS_DEEP_CHECK is off 7 | PUBLIC AWS_DEEP_CHECKS=0) 8 | sea_attach_bc_link(linked_list_pop_back) 9 | sea_add_unsat_test(linked_list_pop_back) 10 | 11 | # klee 12 | sea_add_klee(linked_list_pop_back 13 | aws_linked_list_pop_back_harness.c) 14 | 15 | # fuzz 16 | sea_add_fuzz(linked_list_pop_back 17 | aws_linked_list_pop_back_harness.c) 18 | 19 | # smack 20 | sea_add_smack(linked_list_pop_back 21 | aws_linked_list_pop_back_harness.c) 22 | 23 | # symbiotic 24 | sea_add_symbiotic(linked_list_pop_back 25 | aws_linked_list_pop_back_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_pop_front/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # add head and tail to list size. 2 | MATH(EXPR UNROLL_BOUND "${MAX_LINKED_LIST_ITEM_ALLOCATION_SIZE} + 2") 3 | add_executable(linked_list_pop_front 4 | aws_linked_list_pop_front_harness.c) 5 | target_compile_definitions(linked_list_pop_front 6 | # We will use our own function for is_valid check hence AWS_DEEP_CHECK is off 7 | PUBLIC AWS_DEEP_CHECKS=0) 8 | sea_attach_bc_link(linked_list_pop_front) 9 | sea_add_unsat_test(linked_list_pop_front) 10 | 11 | # klee 12 | sea_add_klee(linked_list_pop_front 13 | aws_linked_list_pop_front_harness.c) 14 | 15 | # fuzz 16 | sea_add_fuzz(linked_list_pop_front 17 | aws_linked_list_pop_front_harness.c) 18 | 19 | # smack 20 | sea_add_smack(linked_list_pop_front 21 | aws_linked_list_pop_front_harness.c) 22 | 23 | # symbiotic 24 | sea_add_symbiotic(linked_list_pop_front 25 | aws_linked_list_pop_front_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_prev/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(linked_list_prev 2 | aws_linked_list_prev_harness.c) 3 | sea_attach_bc_link(linked_list_prev) 4 | sea_add_unsat_test(linked_list_prev) 5 | 6 | # klee 7 | sea_add_klee(linked_list_prev 8 | aws_linked_list_prev_harness.c) 9 | 10 | # fuzz 11 | sea_add_fuzz(linked_list_prev 12 | aws_linked_list_prev_harness.c) 13 | 14 | # smack 15 | sea_add_smack(linked_list_prev 16 | aws_linked_list_prev_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(linked_list_prev 20 | aws_linked_list_prev_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_prev/aws_linked_list_prev_harness.c: -------------------------------------------------------------------------------- 1 | #include "seahorn/seahorn.h" 2 | #include 3 | #include 4 | 5 | int main(void) { 6 | /* data structure */ 7 | struct aws_linked_list_node node; // Preconditions require node to not be NULL 8 | struct aws_linked_list_node 9 | before; // Preconditions require before to not be NULL 10 | 11 | /* Assume the preconditions */ 12 | aws_linked_list_attach_after(&before, &node, true); 13 | 14 | /* perform operation under verification */ 15 | struct aws_linked_list_node *rval = aws_linked_list_prev(&node); 16 | 17 | /* assertions */ 18 | sassert(aws_linked_list_node_prev_is_valid(&node)); 19 | sassert(aws_linked_list_node_next_is_valid(rval)); 20 | sassert(rval == &before); 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_push_back/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # add head and tail to list size. 2 | add_executable(linked_list_push_back 3 | aws_linked_list_push_back_harness.c) 4 | sea_attach_bc_link(linked_list_push_back) 5 | sea_add_unsat_test(linked_list_push_back) 6 | 7 | # klee 8 | sea_add_klee(linked_list_push_back 9 | aws_linked_list_push_back_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(linked_list_push_back 13 | aws_linked_list_push_back_harness.c) 14 | 15 | # smack 16 | sea_add_smack(linked_list_push_back 17 | aws_linked_list_push_back_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(linked_list_push_back 21 | aws_linked_list_push_back_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_push_front/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(linked_list_push_front 2 | aws_linked_list_push_front_harness.c) 3 | sea_attach_bc_link(linked_list_push_front) 4 | sea_add_unsat_test(linked_list_push_front) 5 | 6 | # klee 7 | sea_add_klee(linked_list_push_front 8 | aws_linked_list_push_front_harness.c) 9 | 10 | # fuzz 11 | sea_add_fuzz(linked_list_push_front 12 | aws_linked_list_push_front_harness.c) 13 | 14 | # smack 15 | sea_add_smack(linked_list_push_front 16 | aws_linked_list_push_front_harness.c) 17 | 18 | # symbiotic 19 | sea_add_symbiotic(linked_list_push_front 20 | aws_linked_list_push_front_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_rbegin/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # add head and tail to list size. 2 | add_executable(linked_list_rbegin 3 | aws_linked_list_rbegin_harness.c) 4 | target_compile_definitions(linked_list_rbegin 5 | # We will use our own function for is_valid check hence AWS_DEEP_CHECK is off 6 | PUBLIC SEA_DEEP_CHECKS=0) 7 | sea_attach_bc_link(linked_list_rbegin) 8 | sea_add_unsat_test(linked_list_rbegin) 9 | configure_file(sea.yaml sea.yaml @ONLY) 10 | 11 | # klee 12 | sea_add_klee(linked_list_rbegin 13 | aws_linked_list_rbegin_harness.c) 14 | 15 | # fuzz 16 | sea_add_fuzz(linked_list_rbegin 17 | aws_linked_list_rbegin_harness.c) 18 | 19 | # smack 20 | sea_add_smack(linked_list_rbegin 21 | aws_linked_list_rbegin_harness.c) 22 | 23 | # symbiotic 24 | sea_add_symbiotic(linked_list_rbegin 25 | aws_linked_list_rbegin_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_rbegin/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-explicit-sp0: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_remove/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # add head and tail to list size. 2 | add_executable(linked_list_remove 3 | aws_linked_list_remove_harness.c) 4 | sea_attach_bc_link(linked_list_remove) 5 | sea_add_unsat_test(linked_list_remove) 6 | 7 | # klee 8 | sea_add_klee(linked_list_remove 9 | aws_linked_list_remove_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(linked_list_remove 13 | aws_linked_list_remove_harness.c) 14 | 15 | # smack 16 | sea_add_smack(linked_list_remove 17 | aws_linked_list_remove_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(linked_list_remove 21 | aws_linked_list_remove_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_rend/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # add head and tail to list size. 2 | add_executable(linked_list_rend 3 | aws_linked_list_rend_harness.c) 4 | configure_file(sea.yaml sea.yaml @ONLY) 5 | target_compile_definitions(linked_list_rend 6 | # We will use our own function for is_valid check hence AWS_DEEP_CHECK is off 7 | PUBLIC SEA_DEEP_CHECKS=0) 8 | sea_attach_bc_link(linked_list_rend) 9 | sea_add_unsat_test(linked_list_rend) 10 | 11 | # klee 12 | sea_add_klee(linked_list_rend 13 | aws_linked_list_rend_harness.c) 14 | 15 | # fuzz 16 | sea_add_fuzz(linked_list_rend 17 | aws_linked_list_rend_harness.c) 18 | 19 | # smack 20 | sea_add_smack(linked_list_rend 21 | aws_linked_list_rend_harness.c) 22 | 23 | # symbiotic 24 | sea_add_symbiotic(linked_list_rend 25 | aws_linked_list_rend_harness.c) 26 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_rend/aws_linked_list_rend_harness.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main(void) { 6 | /* data structure */ 7 | struct aws_linked_list list; 8 | size_t length; 9 | struct saved_aws_linked_list to_save = {0}; 10 | 11 | sea_nd_init_aws_linked_list_from_head(&list, &length); 12 | struct aws_linked_list_node *start = &list.head; 13 | aws_linked_list_save_to_tail(&list, length, start, &to_save); 14 | 15 | /* perform operation under verification */ 16 | struct aws_linked_list_node const *rend = aws_linked_list_rend(&list); 17 | sassert(rend == &list.head); 18 | sassert(aws_linked_list_node_next_is_valid(rend)); 19 | sassert(is_aws_list_unchanged_to_tail(&list, &to_save)); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_rend/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bmc-logic: QF_ABV 3 | -------------------------------------------------------------------------------- /seahorn/jobs/linked_list_swap_contents/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # add head and tail to list size. 2 | add_executable(linked_list_swap_contents 3 | aws_linked_list_swap_contents_harness.c) 4 | sea_attach_bc_link(linked_list_swap_contents) 5 | sea_add_unsat_test(linked_list_swap_contents) 6 | 7 | # klee 8 | sea_add_klee(linked_list_swap_contents 9 | aws_linked_list_swap_contents_harness.c) 10 | 11 | # fuzz 12 | sea_add_fuzz(linked_list_swap_contents 13 | aws_linked_list_swap_contents_harness.c) 14 | 15 | # smack 16 | sea_add_smack(linked_list_swap_contents 17 | aws_linked_list_swap_contents_harness.c) 18 | 19 | # symbiotic 20 | sea_add_symbiotic(linked_list_swap_contents 21 | aws_linked_list_swap_contents_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/mul_size_checked/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(mul_size_checked 2 | aws_mul_size_checked_harness.c) 3 | sea_attach_bc_link(mul_size_checked) 4 | sea_add_unsat_test(mul_size_checked) 5 | 6 | # klee 7 | sea_add_klee(mul_size_checked 8 | aws_mul_size_checked_harness.c) 9 | 10 | # fuzz 11 | sea_add_fuzz(mul_size_checked aws_mul_size_checked_harness.c) 12 | 13 | # smack 14 | sea_add_smack(mul_size_checked aws_mul_size_checked_harness.c) 15 | 16 | # symbiotic 17 | sea_add_symbiotic(mul_size_checked aws_mul_size_checked_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/mul_size_saturating/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(mul_size_saturating 2 | aws_mul_size_saturating_harness.c) 3 | sea_attach_bc_link(mul_size_saturating) 4 | sea_add_unsat_test(mul_size_saturating) 5 | 6 | # klee 7 | sea_add_klee(mul_size_saturating 8 | aws_mul_size_saturating_harness.c) 9 | 10 | # fuzz 11 | sea_add_fuzz(mul_size_saturating aws_mul_size_saturating_harness.c) 12 | 13 | # smack 14 | sea_add_smack(mul_size_saturating aws_mul_size_saturating_harness.c) 15 | 16 | # symbiotic 17 | sea_add_symbiotic(mul_size_saturating aws_mul_size_saturating_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/nospec_mask/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(nospec_mask 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_nospec_mask_harness.c) 4 | sea_attach_bc_link(nospec_mask) 5 | sea_add_unsat_test(nospec_mask) 6 | 7 | sea_add_fuzz(nospec_mask aws_nospec_mask_harness.c) 8 | -------------------------------------------------------------------------------- /seahorn/jobs/nospec_mask/aws_nospec_mask_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | */ 3 | 4 | #include 5 | #include 6 | 7 | #include 8 | #include 9 | 10 | int main() { 11 | /* parameters */ 12 | size_t index = nd_size_t(); 13 | size_t bound = nd_size_t(); 14 | 15 | /* operation under verification */ 16 | size_t rval = aws_nospec_mask(index, bound); 17 | 18 | /* assertions */ 19 | if (rval == 0) { 20 | sassert((index >= bound) || (bound > (SIZE_MAX / 2)) || (index > (SIZE_MAX / 2))); 21 | } else { 22 | sassert(rval == UINTPTR_MAX); 23 | sassert(!((index >= bound) || (bound > (SIZE_MAX / 2)) || (index > (SIZE_MAX / 2)))); 24 | } 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /seahorn/jobs/priority_queue_init_dynamic/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound : 5 3 | -------------------------------------------------------------------------------- /seahorn/jobs/priority_queue_init_static/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound : 5 3 | -------------------------------------------------------------------------------- /seahorn/jobs/priority_queue_push/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | 4 | -------------------------------------------------------------------------------- /seahorn/jobs/priority_queue_push_ref/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | 4 | -------------------------------------------------------------------------------- /seahorn/jobs/priority_queue_s_remove_node/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bmc-tactic: 'smtfd' 4 | # switch to true for faster verification times 5 | horn-explicit-sp0: true 6 | 7 | -------------------------------------------------------------------------------- /seahorn/jobs/priority_queue_s_sift_down/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bmc-tactic: 'smtfd' 4 | # switch to true for faster verification times 5 | horn-explicit-sp0: true 6 | # this benchmark uses AWS_ZEROED() which has undefined behavior 7 | # in this case, TBAA cannot be trusted 8 | horn-shadow-mem-use-tbaa: false 9 | bound: 5 10 | 11 | -------------------------------------------------------------------------------- /seahorn/jobs/priority_queue_s_sift_either/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bmc-tactic: 'smtfd' 4 | # switch to true for faster verification times 5 | horn-explicit-sp0: true 6 | # this benchmark uses AWS_ZEROED() which has undefined behavior 7 | # in this case, TBAA cannot be trusted 8 | horn-shadow-mem-use-tbaa: false 9 | # 5 is sufficient for proving all back-edge assertions 10 | # bound: 5 11 | 12 | -------------------------------------------------------------------------------- /seahorn/jobs/priority_queue_s_sift_up/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bmc-tactic: 'smtfd' 4 | # switch to true for faster verification times 5 | horn-explicit-sp0: true 6 | # this benchmark uses AWS_ZEROED() which has undefined behavior 7 | # in this case, TBAA cannot be trusted 8 | horn-shadow-mem-use-tbaa: false 9 | # 5 is sufficient for proving all back-edge assertions 10 | bound: 5 11 | 12 | -------------------------------------------------------------------------------- /seahorn/jobs/priority_queue_s_swap/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | # switch to true for faster verification times 4 | horn-explicit-sp0: true 5 | -------------------------------------------------------------------------------- /seahorn/jobs/ptr_eq/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(ptr_eq 2 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 3 | aws_ptr_eq_harness.c) 4 | sea_attach_bc_link(ptr_eq) 5 | sea_add_unsat_test(ptr_eq) 6 | 7 | # klee 8 | sea_add_klee(ptr_eq 9 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 10 | aws_ptr_eq_harness.c) 11 | 12 | # smack 13 | sea_add_smack(ptr_eq 14 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 15 | aws_ptr_eq_harness.c) 16 | 17 | # symbiotic 18 | sea_add_symbiotic(ptr_eq 19 | ${AWS_C_COMMON_ROOT}/source/hash_table.c 20 | aws_ptr_eq_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/ptr_eq/aws_ptr_eq_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | */ 3 | 4 | #include 5 | 6 | #include 7 | #include 8 | 9 | int main() { 10 | void *p1 = nd_voidp(); 11 | void *p2 = nd_voidp(); 12 | bool rval = aws_ptr_eq(p1, p2); 13 | sassert(rval == (p1 == p2)); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /seahorn/jobs/ring_buffer_acquire_up_to/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-explicit-sp0: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs/ring_buffer_init/aws_ring_buffer_init_harness.c: -------------------------------------------------------------------------------- 1 | /** 2 | */ 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | int main(void) { 11 | /* parameters */ 12 | struct aws_ring_buffer ring_buf; 13 | struct aws_allocator *allocator = sea_allocator(); 14 | size_t size; 15 | size = nd_size_t(); 16 | assume(size > 0); /* Precondition */ 17 | KLEE_ASSUME(size <= KLEE_MAX_SIZE); 18 | 19 | if (aws_ring_buffer_init(&ring_buf, allocator, size) == AWS_OP_SUCCESS) { 20 | /* assertions */ 21 | sassert(aws_ring_buffer_is_valid(&ring_buf)); 22 | sassert(ring_buf.allocator == allocator); 23 | sassert(ring_buf.allocation_end - ring_buf.allocation == size); 24 | } 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /seahorn/jobs/ring_buffer_release/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | # switch to true for faster verification times 3 | horn-explicit-sp0: true 4 | 5 | -------------------------------------------------------------------------------- /seahorn/jobs/round_up_to_power_of_two/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(round_up_to_power_of_two 2 | aws_round_up_to_power_of_two_harness.c) 3 | sea_attach_bc_link(round_up_to_power_of_two) 4 | sea_add_unsat_test(round_up_to_power_of_two) 5 | 6 | # klee 7 | sea_add_klee(round_up_to_power_of_two 8 | aws_round_up_to_power_of_two_harness.c) 9 | 10 | # smack 11 | sea_add_smack(round_up_to_power_of_two 12 | aws_round_up_to_power_of_two_harness.c) 13 | 14 | # symbiotic 15 | sea_add_symbiotic(round_up_to_power_of_two 16 | aws_round_up_to_power_of_two_harness.c) -------------------------------------------------------------------------------- /seahorn/jobs/round_up_to_power_of_two/aws_round_up_to_power_of_two_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | */ 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | int main() { 9 | size_t test_val = nd_size_t(); 10 | size_t result; 11 | int rval = aws_round_up_to_power_of_two(test_val, &result); 12 | 13 | #if ULONG_MAX == SIZE_MAX 14 | int popcount = __builtin_popcountl(result); 15 | #elif ULLONG_MAX == SIZE_MAX 16 | int popcount = __builtin_popcountll(result); 17 | #else 18 | # error 19 | #endif 20 | if (rval == AWS_OP_SUCCESS) { 21 | sassert(popcount == 1); 22 | sassert(test_val <= result); 23 | sassert(test_val >= result >> 1); 24 | } else { 25 | // Only fail if rounding up would cause us to overflow. 26 | sassert(test_val > ((SIZE_MAX >> 1) + 1)); 27 | } 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /seahorn/jobs/string_bytes/aws_string_bytes_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int main() { 13 | struct aws_string *str = ensure_string_is_allocated_nondet_length(); 14 | //struct aws_string *str = ensure_string_is_allocated_bounded_length(SIZE_MAX - 1 - sizeof(struct aws_string)); 15 | sassert(aws_string_bytes(str) == str->bytes); 16 | sassert(aws_string_is_valid(str)); 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /seahorn/jobs/string_destroy/aws_string_destroy_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int main(void) { 13 | struct aws_string *str = 14 | nd_bool() ? ensure_string_is_allocated_nondet_length() : NULL; 15 | aws_string_destroy(str); 16 | 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /seahorn/jobs/string_destroy_secure/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-array-sym-memcpy-unroll-count: "@MAX_STRING_LEN@" 4 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq/aws_string_eq_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int main() { 13 | struct aws_string *str_a = nd_bool() ? 14 | ensure_string_is_allocated_bounded_length(MAX_BUFFER_SIZE) : NULL; 15 | struct aws_string *str_b = nd_bool() ? 16 | str_a : ensure_string_is_allocated_bounded_length(MAX_BUFFER_SIZE); 17 | if (aws_string_eq(str_a, str_b) && str_a && str_b) { 18 | sassert(str_a->len == str_b->len); 19 | assert_bytes_match(str_a->bytes, str_b->bytes, str_a->len); 20 | sassert(aws_string_is_valid(str_a)); 21 | sassert(aws_string_is_valid(str_b)); 22 | } 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq_byte_buf/aws_string_eq_byte_buf_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int main() { 13 | struct aws_string *str = nd_bool() ? 14 | ensure_string_is_allocated_bounded_length(MAX_STRING_LEN) : 15 | NULL; 16 | struct aws_byte_buf buf; 17 | initialize_byte_buf(&buf); 18 | 19 | assume(aws_byte_buf_is_valid(&buf)); 20 | 21 | if (aws_string_eq_byte_buf(str, nd_bool() ? &buf : NULL) && str) { 22 | sassert(str->len == buf.len); 23 | assert_bytes_match(str->bytes, buf.buffer, str->len); 24 | sassert(aws_string_is_valid(str)); 25 | } 26 | 27 | sassert(aws_byte_buf_is_valid(&buf)); 28 | 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq_byte_buf/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bmc-logic: QF_ABV 3 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq_byte_buf_ignore_case/aws_string_eq_byte_buf_ignore_case_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int main() { 13 | struct aws_string *str = nd_bool() ? 14 | ensure_string_is_allocated_bounded_length(MAX_STRING_LEN) : 15 | NULL; 16 | struct aws_byte_buf buf; 17 | initialize_byte_buf(&buf); 18 | 19 | assume(aws_byte_buf_is_valid(&buf)); 20 | 21 | bool nondet_parameter = nd_bool(); 22 | if (aws_string_eq_byte_buf_ignore_case(str, nondet_parameter ? &buf : NULL) && str) { 23 | sassert(aws_string_is_valid(str)); 24 | if (nondet_parameter) { 25 | sassert(str->len == buf.len); 26 | } 27 | } 28 | 29 | sassert(aws_byte_buf_is_valid(&buf)); 30 | 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq_byte_buf_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq_byte_cursor/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bmc-logic: QF_ABV 3 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq_byte_cursor_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_STRING_LEN@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq_c_str/aws_string_eq_c_str_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int main() { 13 | struct aws_string *str = 14 | nd_bool() ? ensure_string_is_allocated_bounded_length(MAX_STRING_LEN) 15 | : NULL; 16 | size_t c_str_strlen = 0; 17 | const char *c_str = 18 | ensure_c_str_is_nd_allocated(MAX_STRING_LEN, &c_str_strlen); 19 | if (aws_string_eq_c_str(str, c_str) && str && c_str) { 20 | sassert(aws_string_is_valid(str)); 21 | sassert(aws_c_string_is_valid(c_str)); 22 | sassert(str->len == c_str_strlen); 23 | assert_bytes_match(str->bytes, (uint8_t *)c_str, str->len); 24 | } 25 | 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq_c_str/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_STRING_LEN@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq_c_str_ignore_case/aws_string_eq_c_str_ignore_case_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int main() { 13 | struct aws_string *str = nd_bool() 14 | ? ensure_string_is_allocated_bounded_length( 15 | MAX_STRING_LEN /* max size */) 16 | : NULL; 17 | 18 | size_t c_strlen = 0; 19 | const char *c_str = ensure_c_str_is_nd_allocated(MAX_STRING_LEN, &c_strlen); 20 | 21 | if (aws_string_eq_c_str_ignore_case(str, c_str) && str && c_str) { 22 | sassert(aws_string_is_valid(str)); 23 | sassert(aws_c_string_is_valid(c_str)); 24 | sassert(str->len == c_strlen); 25 | } 26 | 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq_c_str_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_STRING_LEN@ 3 | horn-bmc-tactic: 'smtfd' # to use SAT solver 4 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq_ignore_case/aws_string_eq_ignore_case_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | int main() { 13 | struct aws_string *str_a = nd_bool() ? 14 | ensure_string_is_allocated_bounded_length(MAX_STRING_LEN) : 15 | NULL; 16 | struct aws_string *str_b = nd_bool() ? 17 | (nd_bool() ? str_a : NULL) : 18 | ensure_string_is_allocated_bounded_length(MAX_STRING_LEN); 19 | if (aws_string_eq_ignore_case(str_a, str_b) && str_a && str_b) { 20 | sassert(aws_string_is_valid(str_a)); 21 | sassert(aws_string_is_valid(str_b)); 22 | sassert(str_a->len == str_b->len); 23 | } 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /seahorn/jobs/string_eq_ignore_case/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_STRING_LEN@ 3 | -------------------------------------------------------------------------------- /seahorn/jobs/string_new_from_array/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | # This needs to go to MEM_BLOCK=4096. 4 | # Arbitrary amount of memory is copied. 5 | # Not a problem for lambdas, but gets very hard for arrays 6 | horn-array-sym-memcpy-unroll-count: @MAX_STRING_LEN@ 7 | # switching to lambads due to above comment 8 | horn-bv2-lambdas: true 9 | -------------------------------------------------------------------------------- /seahorn/jobs/string_new_from_c_str/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-array-sym-memcpy-unroll-count: @MAX_STRING_LEN@ 4 | horn-bmc-logic: QF_ABV 5 | -------------------------------------------------------------------------------- /seahorn/jobs/string_new_from_string/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-array-sym-memcpy-unroll-count: @MAX_STRING_LEN@ 4 | horn-bmc-tactic: 'smtfd' 5 | horn-bv2-lambdas: true 6 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_eq2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_eq2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_array_eq_harness2.c) 4 | sea_attach_bc_link(array_eq2) 5 | 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(array_eq2) 8 | 9 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_eq2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_eq_c_str2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_eq_c_str2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_array_eq_c_str_harness2.c) 4 | sea_attach_bc_link(array_eq_c_str2) 5 | 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(array_eq_c_str2) 8 | 9 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_eq_c_str2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_STRING_LEN@ 3 | horn-bv2-tracking-mem: true 4 | horn-bmc-logic: QF_ABV 5 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_eq_c_str_ignore_case2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_eq_c_str_ignore_case2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_array_eq_c_str_ignore_case_harness2.c) 4 | sea_attach_bc_link(array_eq_c_str_ignore_case2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_eq_c_str_ignore_case2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_eq_c_str_ignore_case2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_eq_ignore_case2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_eq_ignore_case2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_array_eq_ignore_case_harness2.c) 4 | sea_attach_bc_link(array_eq_ignore_case2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_eq_ignore_case2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_eq_ignore_case2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_back2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_back2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_back_harness2.c) 4 | sea_attach_bc_link(array_list_back2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_back2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_back2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | horn-bv2-word-size: 1 5 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_capacity2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_capacity2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_capacity_harness2.c) 4 | sea_attach_bc_link(array_list_capacity2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_capacity2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_capacity2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_clear2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_clear2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_clear_harness2.c) 4 | sea_attach_bc_link(array_list_clear2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_clear2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_clear2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_ensure_capacity2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_ensure_capacity2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_ensure_capacity_harness2.c) 4 | sea_attach_bc_link(array_list_ensure_capacity2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_ensure_capacity2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_ensure_capacity2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_erase2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_erase2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_erase_harness2.c) 4 | sea_attach_bc_link(array_list_erase2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_erase2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_erase2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_front2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_front2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_front_harness2.c) 4 | sea_attach_bc_link(array_list_front2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_front2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_front2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | horn-bv2-word-size: 1 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_get_at2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_get_at2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_get_at_harness2.c) 4 | sea_attach_bc_link(array_list_get_at2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_get_at2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_get_at2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | horn-bv2-word-size: 1 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_get_at_ptr2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_get_at_ptr2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_get_at_ptr_harness2.c) 4 | sea_attach_bc_link(array_list_get_at_ptr2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_get_at_ptr2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_get_at_ptr2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_init_static2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_init_static2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_init_static_harness2.c) 4 | sea_attach_bc_link(array_list_init_static2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_init_static2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_init_static2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_length2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_length2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_length_harness2.c) 4 | sea_attach_bc_link(array_list_length2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_length2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_length2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_pop_back2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_pop_back2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_pop_back_harness2.c) 4 | sea_attach_bc_link(array_list_pop_back2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_pop_back2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_pop_back2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | horn-bv2-word-size: 1 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_pop_front2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_pop_front2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_pop_front_harness2.c) 4 | sea_attach_bc_link(array_list_pop_front2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_pop_front2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_pop_front2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_pop_front_n2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_pop_front_n2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_pop_front_n_harness2.c) 4 | sea_attach_bc_link(array_list_pop_front_n2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_pop_front_n2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_pop_front_n2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bv2-tracking-mem: true 4 | horn-bmc-logic: ALL 5 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_push_back2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_push_back2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_push_back_harness2.c) 4 | sea_attach_bc_link(array_list_push_back2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_push_back2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_push_back2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | # smtfd tactic is best, but maybe buggy in --cex mode 3 | horn-bmc-tactic: smt 4 | horn-bv2-tracking-mem: true 5 | horn-bv2-word-size: 1 6 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_set_at2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_set_at2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_set_at_harness2.c) 4 | sea_attach_bc_link(array_list_set_at2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_set_at2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_set_at2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_shrink_to_fit2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_shrink_to_fit2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_shrink_to_fit_harness2.c) 4 | sea_attach_bc_link(array_list_shrink_to_fit2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_shrink_to_fit2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_shrink_to_fit2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bmc-logic: ALL 4 | horn-bv2-tracking-mem: true 5 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_sort2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(array_list_sort2 2 | ${AWS_C_COMMON_ROOT}/source/array_list.c 3 | aws_array_list_sort_harness2.c) 4 | sea_attach_bc_link(array_list_sort2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(array_list_sort2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/array_list_sort2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_advance2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_advance2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_advance_harness2.c) 4 | sea_attach_bc_link(byte_buf_advance2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_advance2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_advance2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_append2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_append2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_append_harness2.c) 4 | sea_attach_bc_link(byte_buf_append2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_append2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_append2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_append_dynamic2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_append_dynamic2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_append_dynamic_harness2.c) 4 | target_compile_definitions(byte_buf_append_dynamic2 PUBLIC __SEA_AWS_ALLOCATOR__) 5 | sea_attach_bc_link(byte_buf_append_dynamic2) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_buf_append_dynamic2) 8 | 9 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_append_dynamic2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_append_with_lookup2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_append_with_lookup2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_append_with_lookup_harness2.c) 4 | sea_attach_bc_link(byte_buf_append_with_lookup2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_append_with_lookup2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_append_with_lookup2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | bound: @MAX_BUFFER_SIZE@ 4 | horn-bv2-tracking-mem: true 5 | horn-bmc-logic: ALL 6 | 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_cat2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_cat2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_cat_harness2.c) 4 | sea_attach_bc_link(byte_buf_cat2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_cat2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_cat2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_eq2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_eq2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_eq_harness2.c) 4 | sea_attach_bc_link(byte_buf_eq2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_eq2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_eq2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | 5 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_eq_c_str2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_eq_c_str2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_eq_c_str_harness2.c) 4 | sea_attach_bc_link(byte_buf_eq_c_str2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_eq_c_str2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_eq_c_str2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_eq_c_str_ignore_case2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_eq_c_str_ignore_case2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_eq_c_str_ignore_case_harness2.c) 4 | configure_file(sea.yaml sea.yaml @ONLY) 5 | sea_attach_bc_link(byte_buf_eq_c_str_ignore_case2) 6 | sea_add_unsat_test(byte_buf_eq_c_str_ignore_case2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_eq_c_str_ignore_case2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_eq_ignore_case2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_eq_ignore_case2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_eq_ignore_case_harness2.c) 4 | sea_attach_bc_link(byte_buf_eq_ignore_case2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_eq_ignore_case2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_eq_ignore_case2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_init_copy2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_init_copy2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_init_copy_harness2.c) 4 | sea_attach_bc_link(byte_buf_init_copy2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_init_copy2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_init_copy2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_write_harness2.c) 4 | sea_attach_bc_link(byte_buf_write2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_write2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_be162/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write_be162 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_write_be16_harness2.c) 4 | sea_attach_bc_link(byte_buf_write_be162) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_write_be162) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_be162/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_be322/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write_be322 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_write_be32_harness2.c) 4 | sea_attach_bc_link(byte_buf_write_be322) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_write_be322) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_be322/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_be642/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write_be642 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_write_be64_harness2.c) 4 | sea_attach_bc_link(byte_buf_write_be642) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_write_be642) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_be642/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_from_whole_buffer2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write_from_whole_buffer2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_write_from_whole_buffer_harness2.c) 4 | sea_attach_bc_link(byte_buf_write_from_whole_buffer2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_write_from_whole_buffer2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_from_whole_buffer2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_from_whole_cursor2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write_from_whole_cursor2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_write_from_whole_cursor_harness2.c) 4 | sea_attach_bc_link(byte_buf_write_from_whole_cursor2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_write_from_whole_cursor2) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_from_whole_cursor2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_from_whole_string2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write_from_whole_string2 2 | ${AWS_C_COMMON_ROOT}/source/string.c 3 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 4 | aws_byte_buf_write_from_whole_string_harness2.c) 5 | sea_attach_bc_link(byte_buf_write_from_whole_string2) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_buf_write_from_whole_string2) 8 | 9 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_from_whole_string2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bmc-tactic: default 4 | horn-bv2-tracking-mem: true 5 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_u82/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_buf_write_u82 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_buf_write_u8_harness2.c) 4 | sea_attach_bc_link(byte_buf_write_u82) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_buf_write_u82) 7 | 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_buf_write_u82/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_advance2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_advance2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_advance_harness2.c) 4 | sea_attach_bc_link(byte_cursor_advance2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_advance2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_advance2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_advance_nospec2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_advance_nospec2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_advance_nospec_harness2.c) 4 | sea_attach_bc_link(byte_cursor_advance_nospec2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_advance_nospec2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_advance_nospec2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_compare_lexical2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_compare_lexical2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_compare_lexical_harness2.c) 4 | sea_attach_bc_link(byte_cursor_compare_lexical2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_compare_lexical2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_compare_lexical2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_compare_lookup2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_compare_lookup2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_compare_lookup_harness2.c) 4 | sea_attach_bc_link(byte_cursor_compare_lookup2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_compare_lookup2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_compare_lookup2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_eq2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_eq_harness2.c) 4 | sea_attach_bc_link(byte_cursor_eq2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_eq2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq_byte_buf2/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/seahorn/verify-c-common/f561a743c20302759d6419173956880e2e92b1f8/seahorn/jobs2/byte_cursor_eq_byte_buf2/.DS_Store -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq_byte_buf2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_eq_byte_buf2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_eq_byte_buf_harness2.c) 4 | sea_attach_bc_link(byte_cursor_eq_byte_buf2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_eq_byte_buf2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq_byte_buf2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq_byte_buf_ignore_case2/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/seahorn/verify-c-common/f561a743c20302759d6419173956880e2e92b1f8/seahorn/jobs2/byte_cursor_eq_byte_buf_ignore_case2/.DS_Store -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq_byte_buf_ignore_case2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_eq_byte_buf_ignore_case2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_eq_byte_buf_ignore_case_harness2.c) 4 | sea_attach_bc_link(byte_cursor_eq_byte_buf_ignore_case2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_eq_byte_buf_ignore_case2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq_byte_buf_ignore_case2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq_c_str2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_eq_c_str2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_eq_c_str_harness2.c) 4 | sea_attach_bc_link(byte_cursor_eq_c_str2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_eq_c_str2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq_c_str2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq_c_str_ignore_case2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_eq_c_str_ignore_case2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_eq_c_str_ignore_case_harness2.c) 4 | sea_attach_bc_link(byte_cursor_eq_c_str_ignore_case2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_eq_c_str_ignore_case2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq_c_str_ignore_case2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq_ignore_case2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_eq_ignore_case2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_eq_ignore_case_harness2.c) 4 | sea_attach_bc_link(byte_cursor_eq_ignore_case2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_eq_ignore_case2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_eq_ignore_case2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_from_buf2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_from_buf2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_from_buf_harness2.c) 4 | sea_attach_bc_link(byte_cursor_from_buf2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_from_buf2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_from_buf2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_left_trim_pred2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_left_trim_pred2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_left_trim_pred_harness2.c) 4 | sea_attach_bc_link(byte_cursor_left_trim_pred2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_left_trim_pred2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_left_trim_pred2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_read2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_read2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_read_harness2.c) 4 | sea_overlink_libraries(byte_cursor_read2 byte_cursor_advance_nospec_override.ir) 5 | sea_attach_bc_link(byte_cursor_read2) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_cursor_read2) 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_read2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_read_and_fill_buffer2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_read_and_fill_buffer2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_read_and_fill_buffer_harness2.c) 4 | sea_overlink_libraries(byte_cursor_read_and_fill_buffer2 byte_cursor_advance_nospec_override.ir) 5 | sea_attach_bc_link(byte_cursor_read_and_fill_buffer2) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_cursor_read_and_fill_buffer2) 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_read_and_fill_buffer2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_read_be16_2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_read_be16_2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_read_be16_harness2.c) 4 | sea_overlink_libraries(byte_cursor_read_be16_2 byte_cursor_advance_nospec_override.ir) 5 | sea_attach_bc_link(byte_cursor_read_be16_2) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_cursor_read_be16_2) 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_read_be16_2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_read_be32_2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_read_be32_2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_read_be32_harness2.c) 4 | sea_overlink_libraries(byte_cursor_read_be32_2 byte_cursor_advance_nospec_override.ir) 5 | sea_attach_bc_link(byte_cursor_read_be32_2) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_cursor_read_be32_2) 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_read_be32_2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_read_be64_2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_read_be64_2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_read_be64_harness2.c) 4 | sea_overlink_libraries(byte_cursor_read_be64_2 byte_cursor_advance_nospec_override.ir) 5 | sea_attach_bc_link(byte_cursor_read_be64_2) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_cursor_read_be64_2) 8 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_read_be64_2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_read_u8_2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_read_u8_2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_read_u8_harness2.c) 4 | sea_overlink_libraries(byte_cursor_read_u8_2 byte_cursor_advance_nospec_override.ir) 5 | sea_attach_bc_link(byte_cursor_read_u8_2) 6 | configure_file(sea.yaml sea.yaml @ONLY) 7 | sea_add_unsat_test(byte_cursor_read_u8_2) 8 | 9 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_read_u8_2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-word-size: 1 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_right_trim_pred2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_right_trim_pred2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_right_trim_pred_harness2.c) 4 | sea_attach_bc_link(byte_cursor_right_trim_pred2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_right_trim_pred2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_right_trim_pred2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_satisfies_pred2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_satisfies_pred2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_satisfies_pred_harness2.c) 4 | sea_attach_bc_link(byte_cursor_satisfies_pred2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_satisfies_pred2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_satisfies_pred2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_trim_pred2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(byte_cursor_trim_pred2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | aws_byte_cursor_trim_pred_harness2.c) 4 | sea_attach_bc_link(byte_cursor_trim_pred2) 5 | configure_file(sea.yaml sea.yaml @ONLY) 6 | sea_add_unsat_test(byte_cursor_trim_pred2) 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/byte_cursor_trim_pred2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_BUFFER_SIZE@ 3 | horn-bv2-tracking-mem: true -------------------------------------------------------------------------------- /seahorn/jobs2/hash_iter_begin2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable( 2 | hash_iter_begin2 3 | ${AWS_C_COMMON_ROOT}/source/common.c 4 | aws_hash_iter_begin_harness2.c 5 | ) 6 | set(MAX_TABLE_SIZE 32) 7 | target_compile_definitions(hash_iter_begin2 PUBLIC MAX_TABLE_SIZE=${MAX_TABLE_SIZE}) 8 | sea_link_libraries(hash_iter_begin2 hash_table.opt.ir) 9 | sea_overlink_libraries(hash_iter_begin2 hash_table_state_is_valid_override.ir) 10 | sea_attach_bc_link(hash_iter_begin2) 11 | configure_file(sea.yaml sea.yaml @ONLY) 12 | sea_add_unsat_test(hash_iter_begin2) 13 | -------------------------------------------------------------------------------- /seahorn/jobs2/hash_iter_begin2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@MAX_TABLE_SIZE@" 3 | horn-bv2-tracking-mem: true 4 | horn-bmc-logic: QF_ABV 5 | -------------------------------------------------------------------------------- /seahorn/jobs2/hash_iter_begin_done2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable( 2 | hash_iter_begin_done2 3 | ${AWS_C_COMMON_ROOT}/source/common.c 4 | aws_hash_iter_begin_done_harness2.c 5 | ) 6 | set(MAX_TABLE_SIZE 32) 7 | target_compile_definitions(hash_iter_begin_done2 PUBLIC MAX_TABLE_SIZE=${MAX_TABLE_SIZE}) 8 | sea_link_libraries(hash_iter_begin_done2 hash_table.opt.ir) 9 | sea_overlink_libraries(hash_iter_begin_done2 hash_table_state_is_valid_override.ir) 10 | sea_attach_bc_link(hash_iter_begin_done2) 11 | configure_file(sea.yaml sea.yaml @ONLY) 12 | sea_add_unsat_test(hash_iter_begin_done2) 13 | -------------------------------------------------------------------------------- /seahorn/jobs2/hash_iter_begin_done2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@MAX_TABLE_SIZE@" 3 | horn-bv2-tracking-mem: true 4 | horn-bmc-logic: QF_ABV 5 | -------------------------------------------------------------------------------- /seahorn/jobs2/hash_iter_done2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable( 2 | hash_iter_done2 3 | ${AWS_C_COMMON_ROOT}/source/common.c 4 | aws_hash_iter_done_harness2.c 5 | ) 6 | target_compile_definitions(hash_iter_done2 PUBLIC MAX_TABLE_SIZE=SIZE_MAX) 7 | sea_link_libraries(hash_iter_done2 hash_table.opt.ir) 8 | sea_overlink_libraries(hash_iter_done2 hash_table_state_is_valid_override.ir) 9 | sea_attach_bc_link(hash_iter_done2) 10 | configure_file(sea.yaml sea.yaml @ONLY) 11 | sea_add_unsat_test(hash_iter_done2) 12 | -------------------------------------------------------------------------------- /seahorn/jobs2/hash_iter_done2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true -------------------------------------------------------------------------------- /seahorn/jobs2/hash_iter_next2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable( 2 | hash_iter_next2 3 | ${AWS_C_COMMON_ROOT}/source/common.c 4 | aws_hash_iter_next_harness2.c 5 | ) 6 | set(MAX_TABLE_SIZE 8) 7 | target_compile_definitions(hash_iter_next2 PUBLIC MAX_TABLE_SIZE=${MAX_TABLE_SIZE}) 8 | sea_link_libraries(hash_iter_next2 hash_table.opt.ir) 9 | sea_overlink_libraries(hash_iter_next2 hash_table_state_is_valid_override.ir) 10 | sea_attach_bc_link(hash_iter_next2) 11 | configure_file(sea.yaml sea.yaml @ONLY) 12 | sea_add_unsat_test(hash_iter_next2) 13 | -------------------------------------------------------------------------------- /seahorn/jobs2/hash_iter_next2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: "@MAX_TABLE_SIZE@" 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/hash_table_find2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(hash_table_find2 2 | ${AWS_C_COMMON_ROOT}/source/common.c 3 | aws_hash_table_find_harness2.c) 4 | set(MAX_TABLE_SIZE 8) 5 | target_compile_definitions(hash_table_find2 6 | PUBLIC 7 | MAX_TABLE_SIZE=${MAX_TABLE_SIZE}) 8 | sea_link_libraries(hash_table_find2 hash_table.opt.ir) 9 | sea_overlink_libraries(hash_table_find2 safe_eq_check_override.ir) 10 | sea_overlink_libraries(hash_table_find2 hash_for_override.ir) 11 | sea_overlink_libraries(hash_table_find2 hash_table_state_is_valid_override.ir) 12 | sea_attach_bc_link(hash_table_find2) 13 | configure_file(sea.yaml sea.yaml @ONLY) 14 | sea_add_unsat_test(hash_table_find2) 15 | -------------------------------------------------------------------------------- /seahorn/jobs2/hash_table_find2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | bound: @MAX_TABLE_SIZE@ 3 | horn-bv2-tracking-mem: true 4 | -------------------------------------------------------------------------------- /seahorn/jobs2/hash_table_get_entry_count2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(hash_table_get_entry_count2 2 | ${AWS_C_COMMON_ROOT}/source/common.c 3 | aws_hash_table_get_entry_count_harness2.c) 4 | sea_link_libraries(hash_table_get_entry_count2 hash_table.opt.ir) 5 | sea_overlink_libraries(hash_table_get_entry_count2 hash_table_state_is_valid_override.ir) 6 | sea_attach_bc_link(hash_table_get_entry_count2) 7 | configure_file(sea.yaml sea.yaml @ONLY) 8 | sea_add_unsat_test(hash_table_get_entry_count2) 9 | -------------------------------------------------------------------------------- /seahorn/jobs2/hash_table_get_entry_count2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/ring_buffer_acquire2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable( 2 | ring_buffer_acquire2 3 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 4 | ${AWS_C_COMMON_ROOT}/source/ring_buffer.c 5 | aws_ring_buffer_acquire_harness2.c 6 | ) 7 | sea_attach_bc_link(ring_buffer_acquire2) 8 | configure_file(sea.yaml sea.yaml @ONLY) 9 | sea_add_unsat_test(ring_buffer_acquire2) 10 | 11 | -------------------------------------------------------------------------------- /seahorn/jobs2/ring_buffer_acquire2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | # switch to true for faster verification times 3 | horn-explicit-sp0: true 4 | horn-bv2-tracking-mem: true 5 | horn-bmc-logic: ALL 6 | 7 | -------------------------------------------------------------------------------- /seahorn/jobs2/ring_buffer_acquire_up_to2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable( 2 | ring_buffer_acquire_up_to2 3 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 4 | ${AWS_C_COMMON_ROOT}/source/ring_buffer.c 5 | aws_ring_buffer_acquire_up_to_harness2.c 6 | ) 7 | sea_attach_bc_link(ring_buffer_acquire_up_to2) 8 | configure_file(sea.yaml sea.yaml @ONLY) 9 | sea_add_unsat_test(ring_buffer_acquire_up_to2) 10 | -------------------------------------------------------------------------------- /seahorn/jobs2/ring_buffer_acquire_up_to2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-explicit-sp0: true 3 | horn-bv2-tracking-mem: true 4 | horn-bmc-logic: ALL 5 | 6 | -------------------------------------------------------------------------------- /seahorn/jobs2/ring_buffer_buf_belongs_to_pool2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable( 2 | ring_buffer_buf_belongs_to_pool2 3 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 4 | ${AWS_C_COMMON_ROOT}/source/ring_buffer.c 5 | aws_ring_buffer_buf_belongs_to_pool_harness2.c 6 | ) 7 | sea_attach_bc_link(ring_buffer_buf_belongs_to_pool2) 8 | configure_file(sea.yaml sea.yaml @ONLY) 9 | sea_add_unsat_test(ring_buffer_buf_belongs_to_pool2) 10 | -------------------------------------------------------------------------------- /seahorn/jobs2/ring_buffer_buf_belongs_to_pool2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-bv2-tracking-mem: true 3 | -------------------------------------------------------------------------------- /seahorn/jobs2/ring_buffer_release2/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(ring_buffer_release2 2 | ${AWS_C_COMMON_ROOT}/source/byte_buf.c 3 | ${AWS_C_COMMON_ROOT}/source/ring_buffer.c 4 | aws_ring_buffer_release_harness2.c 5 | ) 6 | sea_attach_bc_link(ring_buffer_release2) 7 | configure_file(sea.yaml sea.yaml @ONLY) 8 | sea_add_unsat_test(ring_buffer_release2) 9 | -------------------------------------------------------------------------------- /seahorn/jobs2/ring_buffer_release2/sea.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | horn-explicit-sp0: true 3 | horn-bv2-tracking-mem: true 4 | 5 | -------------------------------------------------------------------------------- /seahorn/jobs_unsafe/mem_realloc_unsafe/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(mem_realloc_unsafe 2 | ${AWS_C_COMMON_ROOT}/source/allocator.c 3 | ${SEA_LIB}/bcmp.c 4 | ${SEA_LIB}/proof_allocators.c 5 | ${SEA_LIB}/sea_allocators.c 6 | aws_mem_realloc_unsafe_harness.c) 7 | 8 | sea_link_libraries(mem_realloc_unsafe sea_bounds.ir) 9 | sea_attach_bc(mem_realloc_unsafe) 10 | # This proof is sat because there is a bug in aws-c-commons 11 | # aws_mem_realloc can be failed by calling mem_cpy 12 | # Since there are no preconditions for the void **ptr and size oldsize. 13 | # The *ptr could be a NULL and the oldsize > 0. 14 | sea_add_sat_test(mem_realloc_unsafe) -------------------------------------------------------------------------------- /seahorn/jobs_unsafe/mem_realloc_unsafe/aws_mem_realloc_unsafe_harness.c: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | */ 4 | 5 | #include 6 | #include 7 | #include "proof_allocators.h" 8 | #include "nondet.h" 9 | 10 | int main() { 11 | 12 | struct aws_allocator *allocator = nd_bool() ? sea_allocator() : sea_allocator_with_realloc(); 13 | 14 | void *data = NULL; 15 | 16 | size_t old_size = nd_size_t(); 17 | 18 | size_t new_size = nd_size_t(); 19 | 20 | aws_mem_realloc(allocator, (void **)&data, old_size, new_size); 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /seahorn/lib/bounds.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | size_t sea_max_buffer_size(void) { return MAX_BUFFER_SIZE; } 5 | size_t sea_max_string_len(void) { return MAX_STRING_LEN; } 6 | size_t klee_max_memory_size(void) { return KLEE_MAX_SIZE; } 7 | size_t sea_max_array_list_item_size(void) { return MAX_ITEM_SIZE; } 8 | size_t sea_max_array_list_len(void) { return MAX_INITIAL_ITEM_ALLOCATION; } 9 | size_t fuzz_max_array_list_len(void) { return MAX_INITIAL_ITEM_ALLOCATION_FUZZ; } 10 | size_t fuzz_max_array_list_item_size(void) { return MAX_ITEM_SIZE_FUZZ; } 11 | size_t sea_max_table_size(void) { return MAX_TABLE_SIZE; } -------------------------------------------------------------------------------- /seahorn/lib/error_override.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | static AWS_THREAD_LOCAL int tl_last_error = 0; 4 | 5 | void aws_raise_error_private(int err) { 6 | tl_last_error = err; 7 | } 8 | 9 | int aws_last_error(void) { 10 | return tl_last_error; 11 | } 12 | -------------------------------------------------------------------------------- /seahorn/sea.yaml: -------------------------------------------------------------------------------- 1 | sea_base.yaml -------------------------------------------------------------------------------- /seahorn/sea_vac.yaml: -------------------------------------------------------------------------------- 1 | verify_options: 2 | # Unify all assumes - needed for Vacuity check 3 | horn-unify-assumes: true 4 | # don't ignore control flow 5 | horn-vcgen-only-dataflow: false 6 | # don't reduce by data dependence 7 | horn-bmc-coi: false 8 | horn-bv2-vacuity-check: "all" 9 | # unwinding assertions 10 | # Note: checked only by the incremental checking during vacuity 11 | assert-on-backedge: true 12 | # evaluate branch sentinel intrinsic 13 | eval-branch-sentinel: '' 14 | --------------------------------------------------------------------------------