Merge pull request #101 from AjayBrahmakshatriya/master

Support for general types inside static_var

Author: AjayBrahmakshatriya

include/blocks/label_inserter.h

@@ -16,7 +16,7 @@ class label_creator : public block_visitor {
 public:
 	using block_visitor::visit;
 	std::vector<tracer::tag> collected_labels;
-	std::unordered_map<std::string, label::Ptr> offset_to_label;
+	std::unordered_map<tracer::tag, label::Ptr> offset_to_label;
 	int current_label = 0;
 	virtual void visit(stmt_block::Ptr);
 };
@@ -27,10 +27,10 @@ class label_inserter : public block_visitor {
 	// The main table to hold static tag to label mapping
 	// this table holds the jump target that is in the parent of the
 	// jump statement
-	std::unordered_map<std::string, label::Ptr> offset_to_label;
+	std::unordered_map<tracer::tag, label::Ptr> offset_to_label;
 	// A backup table which has atleast one label that we can jump to
 	// Only used when feature_unstructured is used
-	std::unordered_map<std::string, label::Ptr> backup_offset_to_label;
+	std::unordered_map<tracer::tag, label::Ptr> backup_offset_to_label;
 
 	bool feature_unstructured;
 

include/blocks/var_namer.h

@@ -11,20 +11,20 @@ namespace block {
 class var_gather_escapes : public block_visitor {
 public:
 	using block_visitor::visit;
-	std::vector<std::string> &escaping_tags;
-	var_gather_escapes(std::vector<std::string> &e) : escaping_tags(e) {}
+	std::vector<tracer::tag> &escaping_tags;
+	var_gather_escapes(std::vector<tracer::tag> &e) : escaping_tags(e) {}
 	virtual void visit(decl_stmt::Ptr) override;
 };
 
 class var_namer : public block_visitor {
 public:
 	using block_visitor::visit;
 	int var_counter = 0;
-	std::map<std::string, var::Ptr> collected_decls;
-	std::map<std::string, decl_stmt::Ptr> decls_to_hoist;
-	std::vector<std::string> decl_tags_to_hoist;
+	std::unordered_map<tracer::tag, var::Ptr> collected_decls;
+	std::unordered_map<tracer::tag, decl_stmt::Ptr> decls_to_hoist;
+	std::vector<tracer::tag> decl_tags_to_hoist;
 
-	std::vector<std::string> escaping_tags;
+	std::vector<tracer::tag> escaping_tags;
 
 	virtual void visit(decl_stmt::Ptr) override;
 
@@ -34,9 +34,9 @@ class var_namer : public block_visitor {
 class var_replacer : public block_visitor {
 public:
 	using block_visitor::visit;
-	std::map<std::string, var::Ptr> &collected_decls;
-	std::vector<std::string> &escaping_tags;
-	var_replacer(std::map<std::string, var::Ptr> &d, std::vector<std::string> &e)
+	std::unordered_map<tracer::tag, var::Ptr> &collected_decls;
+	std::vector<tracer::tag> &escaping_tags;
+	var_replacer(std::unordered_map<tracer::tag, var::Ptr> &d, std::vector<tracer::tag> &e)
 	    : collected_decls(d), escaping_tags(e) {}
 
 	virtual void visit(var_expr::Ptr) override;
@@ -45,9 +45,9 @@ class var_replacer : public block_visitor {
 class var_hoister : public block_replacer {
 public:
 	using block_replacer::visit;
-	std::map<std::string, decl_stmt::Ptr> &decls_to_hoist;
-	std::vector<std::string> &escaping_tags;
-	var_hoister(std::map<std::string, decl_stmt::Ptr> &d, std::vector<std::string> &e)
+	std::unordered_map<tracer::tag, decl_stmt::Ptr> &decls_to_hoist;
+	std::vector<tracer::tag> &escaping_tags;
+	var_hoister(std::unordered_map<tracer::tag, decl_stmt::Ptr> &d, std::vector<tracer::tag> &e)
 	    : decls_to_hoist(d), escaping_tags(e) {}
 	virtual void visit(decl_stmt::Ptr) override;
 };

include/builder/block_type_extractor.h

@@ -3,6 +3,7 @@
 
 
 #include "builder/forward_declarations.h"
+#include "util/mtp_utils.h"
 #include "builder/generics.h"
 #include <algorithm>
 
@@ -13,8 +14,6 @@ struct custom_type_base;
 template <typename T>
 struct external_type_namer;
 
-
-
 extern int type_naming_counter;
 
 template <typename T, typename V=void>
@@ -41,7 +40,7 @@ member or a external_namer specialization */
 template <typename T, typename V=void>
 struct has_type_name: public std::false_type {};
 template <typename T>
-struct has_type_name<T, typename check_valid_type<decltype(T::type_name)>::type>: public std::true_type {};
+struct has_type_name<T, typename utils::check_valid_type<decltype(T::type_name)>::type>: public std::true_type {};
 
 template <typename T>
 struct type_namer<T, typename std::enable_if<has_type_name<external_type_namer<T>>::value>::type> {
@@ -66,14 +65,14 @@ struct type_template {
 };
 
 template <typename T>
-struct type_template<T, typename check_valid_type<decltype(T::get_template_arg_types)>::type> {
+struct type_template<T, typename utils::check_valid_type<decltype(T::get_template_arg_types)>::type> {
 	static std::vector<block::type::Ptr> get_templates() {
 		return T::get_template_arg_types();
 	}
 };
 
 template <typename T>
-struct type_template<T, typename check_valid_type<decltype(external_type_namer<T>::get_template_arg_types)>::type> {
+struct type_template<T, typename utils::check_valid_type<decltype(external_type_namer<T>::get_template_arg_types)>::type> {
 	static std::vector<block::type::Ptr> get_templates() {
 		return external_type_namer<T>::get_template_arg_types();
 	}

include/builder/builder_context.h

@@ -18,31 +18,10 @@ block::expr::Ptr create_foreign_expr(const T t);
 template <typename T>
 builder create_foreign_expr_builder(const T t);
 
-class static_var_base;
-
-class tracking_tuple {
-public:
-	const unsigned char *ptr;
-	uint32_t size;
-	static_var_base *var_ref;
-
-	tracking_tuple(const unsigned char *_ptr, uint32_t _size, static_var_base *_var_ref)
-	    : ptr(_ptr), size(_size), var_ref(_var_ref) {}
-
-	std::string snapshot(void) {
-		std::string output_string;
-		char temp[4];
-		for (unsigned int i = 0; i < size; i++) {
-			sprintf(temp, "%02x", ptr[i]);
-			output_string += temp;
-		}
-		return output_string;
-	}
-};
 
 class tag_map {
 public:
-	std::unordered_map<std::string, block::stmt_block::Ptr> map;
+	std::unordered_map<tracer::tag, block::stmt_block::Ptr> map;
 };
 
 void lambda_wrapper(std::function<void(void)>);
@@ -67,21 +46,21 @@ class builder_context {
 	block::stmt::Ptr ast;
 	block::stmt_block::Ptr current_block_stmt;
 	std::vector<bool> bool_vector;
-	std::unordered_set<std::string> visited_offsets;
+	std::unordered_set<tracer::tag> visited_offsets;
 	std::vector<block::expr::Ptr> expr_sequence;
 	unsigned long long expr_counter = 0;
 	std::string current_label;
 
-	std::vector<tracking_tuple> static_var_tuples;
-	std::vector<tracking_tuple> deferred_static_var_tuples;
+	std::vector<static_var_base*> static_var_tuples;
+	std::vector<static_var_base*> deferred_static_var_tuples;
 
 	// Run shared state
 	tag_map _internal_tags;
 	tag_map *memoized_tags;
 
 	// State shared across non-deterministic failures
-	std::unordered_map<std::string, std::shared_ptr<nd_var_gen_base>> *nd_state_map = nullptr;
-	std::unordered_map<std::string, std::shared_ptr<nd_var_gen_base>> _nd_state_map;
+	std::unordered_map<tracer::tag, std::shared_ptr<nd_var_gen_base>> *nd_state_map = nullptr;
+	std::unordered_map<tracer::tag, std::shared_ptr<nd_var_gen_base>> _nd_state_map;
 
 	void reset_for_nd_failure();
 

include/builder/dyn_var.h

@@ -3,6 +3,7 @@
 
 #include "builder/builder.h"
 #include "util/var_finder.h"
+#include "util/mtp_utils.h"
 namespace builder {
 
 namespace options {
@@ -125,7 +126,7 @@ class dyn_var_impl : public var {
 			dyn_var->var_type = create_block_type();
 			block_var = dyn_var;
 			// Don't try to obtain preferred names for objects created without context
-			// dyn_var->preferred_name = util::find_variable_name(this);
+			// dyn_var->preferred_name = utils::find_variable_name(this);
 			return;
 		}
 		assert(builder_context::current_builder_context != nullptr);
@@ -134,7 +135,7 @@ class dyn_var_impl : public var {
 		block::var::Ptr dyn_var = std::make_shared<block::var>();
 		dyn_var->var_type = create_block_type();
 		tracer::tag offset = get_offset_in_function();
-		dyn_var->preferred_name = util::find_variable_name_cached(this, offset.stringify());
+		dyn_var->preferred_name = utils::find_variable_name_cached(this, offset);
 		block_var = dyn_var;
 		dyn_var->static_offset = offset;
 		block_decl_stmt = nullptr;
@@ -363,7 +364,7 @@ struct dyn_var_deref_provider {
 };
 
 template <typename T>
-struct dyn_var_deref_provider<T, typename check_valid_type<typename T::dereference_type>::type> {
+struct dyn_var_deref_provider<T, typename utils::check_valid_type<typename T::dereference_type>::type> {
 	dyn_var_mimic<typename T::dereference_type> operator[] (const builder& b) {
 		return (cast)(static_cast<dyn_var<T>*>(this)->dyn_var_impl<T>::operator[](b));
 	}

include/builder/forward_declarations.h

@@ -16,6 +16,8 @@ using is_builder_type = typename std::is_same<builder, T>;
 template <typename T>
 using if_builder = typename std::enable_if<is_builder_type<T>::value, T>::type;
 
+class static_var_base;
+
 template <typename T>
 class static_var;
 
@@ -60,11 +62,6 @@ struct with_name {
 	with_name(const std::string &n, bool wd = false) : name(n), with_decl(wd) {}
 };
 
-template <typename T>
-struct check_valid_type {
-	typedef void type;
-};
-
 // Generator states for non-deterministic values
 struct nd_var_gen_base;
 

include/builder/nd_var.h

@@ -28,15 +28,13 @@ struct nd_var_gen<bool>: public nd_var_gen_base {
 
 template <typename T>
 std::shared_ptr<nd_var_gen<T>> get_or_create_generator(tracer::tag req_tag) {
-	std::string tag_name = req_tag.stringify();
-
-	if (builder_context::current_builder_context->nd_state_map->find(tag_name) ==
+	if (builder_context::current_builder_context->nd_state_map->find(req_tag) ==
 		builder_context::current_builder_context->nd_state_map->end()) {
-		(*(builder_context::current_builder_context->nd_state_map))[tag_name] = std::make_shared<nd_var_gen<T>>();
+		(*(builder_context::current_builder_context->nd_state_map))[req_tag] = std::make_shared<nd_var_gen<T>>();
 	}
 
 	return std::static_pointer_cast<nd_var_gen<T>>(
-		(*(builder_context::current_builder_context->nd_state_map))[tag_name]);
+		(*(builder_context::current_builder_context->nd_state_map))[req_tag]);
 }
 
 /* contstraints on bool types