Refactor RzConfig

librz/arch/analysis.c

@@ -27,17 +27,48 @@ RZ_API ut32 rz_analysis_guessed_mem_access_width(RZ_NONNULL const RzAnalysis *an
 	return analysis->bits / 8;
 }
 
-RZ_API void rz_analysis_set_limits(RzAnalysis *analysis, ut64 from, ut64 to) {
-	free(analysis->limit);
-	analysis->limit = RZ_NEW0(RzAnalysisRange);
-	if (analysis->limit) {
-		analysis->limit->from = from;
-		analysis->limit->to = to;
+/**
+ * \brief      Sets the limits of the analysis range [from : to]
+ *
+ * \param      analysis  The current RzAnalysis in use.
+ * \param[in]  from      The from address to set
+ * \param[in]  to        The to address to set
+ */
+RZ_API void rz_analysis_set_limits(RZ_NONNULL RzAnalysis *analysis, ut64 from, ut64 to) {
+	rz_return_if_fail(analysis);
+	if (from > to) {
+		RZ_LOG_WARN("analysis: invalid limits from (%" PFMT64x ") > to (%" PFMT64x ")\n", from, to);
+	}
+
+	analysis->limit.from = from;
+	analysis->limit.to = to;
+}
+
+/**
+ * \brief      Sets the limits of the analysis range [from : to]
+ *
+ * \param      analysis  The current RzAnalysis in use.
+ * \param[in]  from      The from address to get.
+ * \param[in]  to        The to address to get.
+ */
+RZ_API void rz_analysis_get_limits(RZ_NONNULL RzAnalysis *analysis, RZ_NULLABLE ut64 *from, RZ_NULLABLE ut64 *to) {
+	rz_return_if_fail(analysis);
+	if (from) {
+		*from = analysis->limit.from;
+	}
+	if (to) {
+		*to = analysis->limit.to;
 	}
 }
 
-RZ_API void rz_analysis_unset_limits(RzAnalysis *analysis) {
-	RZ_FREE(analysis->limit);
+RZ_API void rz_analysis_enable_limits(RZ_NONNULL RzAnalysis *analysis, bool enabled) {
+	rz_return_if_fail(analysis);
+	analysis->limit.enabled = enabled;
+}
+
+RZ_API bool rz_analysis_are_limits_enabled(RZ_NONNULL RzAnalysis *analysis) {
+	rz_return_val_if_fail(analysis, false);
+	return analysis->limit.enabled;
 }
 
 static void meta_unset_for(RzEvent *ev, int type, void *user, void *data) {
@@ -104,15 +135,45 @@ RZ_API RzAnalysis *rz_analysis_new(RZ_NULLABLE const char *sdb_types_path) {
 	analysis->ht_name_fun = ht_sp_new(HT_STR_DUP, NULL, NULL);
 	analysis->os = rz_str_dup(RZ_SYS_OS);
 	analysis->esil_goto_limit = RZ_ANALYSIS_ESIL_GOTO_LIMIT;
-	analysis->opt.nopskip = true; // skip nops in code analysis
-	analysis->opt.hpskip = false; // skip `mov reg,reg` and `lea reg,[reg]`
 	analysis->gp = 0LL;
 	analysis->sdb = sdb_new0();
 	analysis->cpp_abi = RZ_ANALYSIS_CPP_ABI_ITANIUM;
-	analysis->opt.depth = 32;
+	analysis->recursive_noreturn = false;
+	analysis->maxreflines = 0; // maximum number of reflines to be analyzed
+	analysis->pcalign = 1; // instruction alignment (must be a power of 2).
+	analysis->lineswidth = 7; // number of columns for program flow arrows
+	// RzAnalysisOptions
+	analysis->opt.afterjmp = true; // continue analysis after jmp/ujmp
+	analysis->opt.aftertrap = false; // continue analysis after trap instructions
+	analysis->opt.armthumb = false; // computes arm/thumb changes
+	analysis->opt.bb_max_size = RZ_ANALYSIS_BLOCK_MAX_SIZE; // maximum basic block size
+	analysis->opt.cjmpref = false; // create references for conditional jumps
+	analysis->opt.delay = true; // delay slot analysis when supported by the arch
+	analysis->opt.depth = 64; // max depth at code analysis
+	analysis->opt.fcn_max_size = 256 * 1024; // maximum function size
+	analysis->opt.followbrokenfcnsrefs = false; // follow function references even if function analysis has failed
+	analysis->opt.followdatarefs = false; // follow data references for code coverage
+	analysis->opt.graph_depth = 256; // max depth for path search
+	analysis->opt.hpskip = false; // skip `mov reg,reg` and `lea reg,[reg]`
+	analysis->opt.ignbithints = false; // ignore the ahb hints (only obey asm.bits)
+	analysis->opt.ijmp = false; // follow the indirect jumps in function analysis
+	analysis->opt.jmpabove = true; // jump above function pointer
+	analysis->opt.jmpmid = true; // continue analysis after jump to middle of instruction (x86 only)
+	analysis->opt.jmpref = true; // create references for unconditional jumps
+	analysis->opt.jmptbl = true; // analyze jump tables in switch statements
+	analysis->opt.jmptbl_maxcount = 512; // maximum amount of entries to analyze in jump tables
+	analysis->opt.jmptbl_maxoffset = 4096; // maximum offset from the jump table jump instruction to consider it valid
+	analysis->opt.loads = false; // define as dword/string/qword when analyzing load instructions
 	analysis->opt.noncode = false; // do not analyze data by default
-	analysis->opt.bb_max_size = RZ_ANALYSIS_BLOCK_MAX_SIZE;
-	analysis->opt.fcn_max_size = 256 * 1024;
+	analysis->opt.nonull = 0; // do not analyze regions of N null bytes (0 is disabled)
+	analysis->opt.nopskip = true; // skip nops in code analysis
+	analysis->opt.norevisit = false; // do not visit function analysis twice
+	analysis->opt.pushret = false; // analyze push+ret as jmp
+	analysis->opt.recont = false; // end block after splitting a basic block instead of error
+	analysis->opt.retpoline = true; // analyze retpoline
+	analysis->opt.searchstringrefs = false; // search string references in data references
+	analysis->opt.trycatch = false; // honor `try.X.Y.{from,to,catch}` flags
+	analysis->opt.vars = true; // analyze local variables and arguments
 	rz_spaces_init(&analysis->meta_spaces, "CS");
 	rz_event_hook(analysis->meta_spaces.event, RZ_SPACE_EVENT_UNSET, meta_unset_for, NULL);
 	rz_event_hook(analysis->meta_spaces.event, RZ_SPACE_EVENT_COUNT, meta_count_for, NULL);
@@ -161,6 +222,12 @@ RZ_API RzAnalysis *rz_analysis_new(RZ_NULLABLE const char *sdb_types_path) {
 	analysis->lea_jmptbl_ip = UT64_MAX;
 	analysis->gnu_thumb1_case_uqi_addr = 0;
 	analysis->ht_virtual_xrefs = ht_sp_new(HT_STR_DUP, NULL, (HtSPFreeValue)rz_set_u_free);
+
+	// default settings.
+	rz_analysis_enable_limits(analysis, false);
+	rz_analysis_set_limits(analysis, UT64_MAX, UT64_MAX);
+	rz_analysis_set_triplet(analysis, RZ_SYS_OS, RZ_SYS_ARCH, (RZ_SYS_BITS << 3));
+	rz_analysis_set_cpu(analysis, RZ_SYS_ARCH);
 	return analysis;
 }
 
@@ -389,9 +456,11 @@ RZ_API int rz_analysis_get_address_bits(RzAnalysis *analysis) {
 }
 
 RZ_API void rz_analysis_set_cpu(RzAnalysis *analysis, const char *cpu) {
-	if (RZ_STR_EQ(cpu, analysis->cpu)) {
+	rz_return_if_fail(analysis);
+	if (cpu && analysis->cpu && RZ_STR_EQ(cpu, analysis->cpu)) {
 		return;
 	}
+
 	free(analysis->cpu);
 	analysis->cpu = rz_str_dup(cpu);
 	int v = rz_analysis_archinfo(analysis, RZ_ANALYSIS_ARCHINFO_TEXT_ALIGN);

librz/arch/asm.c

@@ -280,8 +280,11 @@ RZ_API RzAsm *rz_asm_new(void) {
 	if (!a) {
 		return NULL;
 	}
+	a->pseudo = false; // show pseudo syntax
+	a->immdisp = true; // hides hashtag (#) for immediates in archs
+	a->invhex = false; // show invalid instructions as hexadecimal numbers
+	a->pcalign = 1; // instruction alignment (must be a power of 2).
 	a->dataalign = 1;
-	a->bits = RZ_SYS_BITS;
 	a->bitshift = 0;
 	a->syntax = RZ_ASM_SYNTAX_INTEL;
 	a->sdb_opcodes_path = rz_path_new();
@@ -304,6 +307,8 @@ RZ_API RzAsm *rz_asm_new(void) {
 		}
 		rz_asm_plugin_add(a, plugin);
 	}
+
+	rz_asm_set_arch(a, RZ_SYS_ARCH, (RZ_SYS_BITS << 3));
 	return a;
 }
 
@@ -432,7 +437,6 @@ RZ_API bool rz_asm_use_assembler(RzAsm *a, const char *name) {
  */
 static void set_plugin_configs(RZ_BORROW RzCore *core, const char *plugin_name, RZ_OWN RzConfig *pcfg) {
 	rz_return_if_fail(pcfg && core);
-	rz_config_lock(pcfg, 1);
 	if (!ht_sp_insert(core->plugin_configs, plugin_name, pcfg)) {
 		RZ_LOG_WARN("Plugin '%s' was already added.\n", plugin_name);
 	}
@@ -518,6 +522,15 @@ RZ_DEPRECATE RZ_API void rz_asm_set_cpu(RzAsm *a, const char *cpu) {
 	}
 }
 
+RZ_API RZ_OWN RzList /*<char *>*/ *rz_asm_get_cpus(RZ_NONNULL RzAsm *a) {
+	rz_return_val_if_fail(a, NULL);
+	if (!a->cur || !a->cur->cpus) {
+		return NULL;
+	}
+
+	return rz_str_split_duplist(a->cur->cpus, ",", true);
+}
+
 static bool has_bits(RzAsmPlugin *h, int bits) {
 	return (h && h->bits && (bits & h->bits));
 }

librz/arch/cc.c

@@ -270,7 +270,7 @@ static bool filter_cc(void *user, const SdbKv *kv) {
 }
 
 RZ_API RzList /*<char *>*/ *rz_analysis_calling_conventions(RzAnalysis *analysis) {
-	RzList *ccl = rz_list_new();
+	RzList *ccl = rz_list_newf(free);
 	void **iter;
 	RzPVector *items = sdb_get_items_filter(analysis->sdb_cc, filter_cc, NULL, true);
 	rz_pvector_foreach (items, iter) {

librz/arch/fcn.c

@@ -618,9 +618,6 @@ static RzAnalysisBBEndCause run_basic_block_analysis(RzAnalysisTaskItem *item, R
 		rz_analysis_task_item_new(analysis, tasks, fcn, bb, addr, sp);
 		return RZ_ANALYSIS_RET_END;
 	}
-	if (analysis->sleep) {
-		rz_sys_usleep(analysis->sleep);
-	}
 
 	// check if address is readable
 	if (!analysis->iob.is_valid_offset(analysis->iob.io, addr, 0)) {
@@ -677,7 +674,7 @@ static RzAnalysisBBEndCause run_basic_block_analysis(RzAnalysisTaskItem *item, R
 	bool last_is_mov_lr_pc = false;
 	bool last_is_add_lr_pc = false;
 	ut64 last_push_addr = UT64_MAX;
-	if (analysis->limit && addr + idx < analysis->limit->from) {
+	if (analysis->limit.enabled && addr + idx < analysis->limit.from) {
 		gotoBeach(RZ_ANALYSIS_RET_END);
 	}
 	RzAnalysisFunction *tmp_fcn = rz_analysis_get_fcn_in(analysis, addr, 0);
@@ -717,7 +714,7 @@ static RzAnalysisBBEndCause run_basic_block_analysis(RzAnalysisTaskItem *item, R
 			free(last_reg_mov_lea_name);
 			last_reg_mov_lea_name = NULL;
 		}
-		if (analysis->limit && analysis->limit->to <= addr + idx) {
+		if (analysis->limit.enabled && analysis->limit.to <= addr + idx) {
 			break;
 		}
 	repeat:

librz/arch/isa/hexagon/hexagon.h

@@ -270,6 +270,11 @@ typedef struct {
 	RzPVector /*<RzAsmTokenPattern *>*/ *token_patterns; ///< PVector with token patterns. Priority ordered.
 	bool utf8_enabled; ///< If set, print UTF-8 characters.
 	bool might_have_jumped; ///< Is set if a previous IL packet was a branch. Indicates the next decoded packet is valid.
+
+	bool imm_hash; ///< Display ## before 32bit immediates and # before immidiates with other width.
+	bool imm_sign; ///< True: Print them with sign. False: Print signed immediates in unsigned representation.
+	bool sdk; ///< Print packet syntax in objdump style.
+	bool reg_alias; ///< Print the alias of registers (Alias from C0 = SA0).
 } HexState;
 
 /**

librz/arch/isa/hexagon/hexagon_arch.c

@@ -537,7 +537,7 @@ static void hex_set_pkt_info(RZ_INOUT HexInsnContainer *hic, const HexPkt *pkt,
 	rz_return_if_fail(hic && pkt && state);
 	bool is_first = (k == 0);
 	HexPktInfo *hi_pi = &hic->pkt_info;
-	bool sdk_form = rz_config_get_b(state->cfg, "plugins.hexagon.sdk");
+	bool sdk_form = state->sdk;
 
 	strncpy(hi_pi->text_postfix, "", 16);
 	// Parse instr. position in pkt

librz/arch/isa/hexagon/hexagon_disas.c

@@ -34030,9 +34030,9 @@ static int get_jmp_target_imm_op_index(const HexInsnTemplate *tpl) {
 }
 
 static void hex_disasm_with_templates(const HexInsnTemplate *tpl, HexState *state, ut32 hi_u32, RZ_INOUT HexInsn *hi, HexInsnContainer *hic, ut64 addr, HexPkt *pkt) {
-	bool print_reg_alias = rz_config_get_b(state->cfg, "plugins.hexagon.reg.alias");
-	bool show_hash = rz_config_get_b(state->cfg, "plugins.hexagon.imm.hash");
-	bool sign_nums = rz_config_get_b(state->cfg, "plugins.hexagon.imm.sign");
+	bool print_reg_alias = state->reg_alias;
+	bool show_hash = state->imm_hash;
+	bool sign_nums = state->imm_sign;
 	char signed_imm[HEX_MAX_OPERANDS][32];
 	// Find the right template
 	for (; tpl->id; tpl++) {

librz/arch/jmptbl.c

@@ -137,8 +137,8 @@ RZ_API bool rz_analysis_walkthrough_casetbl(RZ_NONNULL RzAnalysis *analysis, RZ_
 				break;
 			}
 		}
-		if (analysis->limit) {
-			if (jmpptr < analysis->limit->from || jmpptr > analysis->limit->to) {
+		if (analysis->limit.enabled) {
+			if (jmpptr < analysis->limit.from || jmpptr > analysis->limit.to) {
 				break;
 			}
 		}
@@ -235,8 +235,8 @@ RZ_API bool rz_analysis_walkthrough_jmptbl(RZ_NONNULL RzAnalysis *analysis, RZ_N
 				break;
 			}
 		}
-		if (analysis->limit) {
-			if (jmpptr < analysis->limit->from || jmpptr > analysis->limit->to) {
+		if (analysis->limit.enabled) {
+			if (jmpptr < analysis->limit.from || jmpptr > analysis->limit.to) {
 				break;
 			}
 		}

librz/arch/p/asm/asm_hexagon.c

@@ -98,53 +98,60 @@ static RZ_OWN RzPVector /*<RzAsmTokenPattern *>*/ *get_token_patterns() {
 	return pvec;
 }
 
-/**
- * \brief Setter for the plugins RzConfig nodes.
- *
- * \param user The user of the RzConfig node. If this callback is called by Core \p user = RzCore.
- * If it is called by the plugins config setup \p user = HexState.
- * \param data The node to set. Again, if called by RzCore \p date = Node from RzCore config.
- * If it is called by the plugins config setup \p data = a plugins config node.
- * \return bool True if the config was set. False otherwise.
- */
-static bool hex_cfg_set(void *user, void *data) {
-	rz_return_val_if_fail(user && data, false);
-	HexState *state = user;
-	RzConfig *pcfg = state->cfg;
-
-	RzConfigNode *cnode = (RzConfigNode *)data; // Config node from core.
-	RzConfigNode *pnode = rz_config_node_get(pcfg, cnode->name); // Config node of plugin.
-	if (pnode == cnode) {
-		return true;
-	}
-	if (cnode) {
-		pnode->i_value = cnode->i_value;
-		free(pnode->value);
-		pnode->value = rz_str_dup(cnode->value);
-		return true;
-	}
-	return false;
-}
-
 static bool hexagon_fini(void *user) {
 	hexagon_state_fini(user);
 	free(user);
 	return true;
 }
 
+#define hexagon_getter_config(name, variable) \
+	static bool hexagon_##name(void *user, void *data) { \
+		bool *value = data; \
+		HexState *state = user; \
+		if (!state) { \
+			return false; \
+		} \
+		*value = state->variable; \
+		return true; \
+	}
+
+#define hexagon_setter_config(name, variable) \
+	static bool hexagon_##name(void *user, const void *data) { \
+		const bool *value = data; \
+		HexState *state = user; \
+		if (!state) { \
+			return false; \
+		} \
+		state->variable = *value; \
+		return true; \
+	}
+
+#define hexagon_config_callbacks(variable) \
+	hexagon_setter_config(config_##variable##_set, variable); \
+	hexagon_getter_config(config_##variable##_get, variable)
+
+hexagon_config_callbacks(imm_hash);
+hexagon_config_callbacks(imm_sign);
+hexagon_config_callbacks(sdk);
+hexagon_config_callbacks(reg_alias);
+
 static bool hexagon_init(void **plugin_data) {
 	HexState *state = hexagon_state_new();
 	rz_return_val_if_fail(state, false);
 
-	state->cfg = rz_config_new(state);
-	rz_return_val_if_fail(state->cfg, false);
+	state->imm_hash = true;
+	state->imm_sign = true;
+	state->sdk = false;
+	state->reg_alias = true;
+
+	RzConfig *cfg = state->cfg = rz_config_new(state);
+	rz_return_val_if_fail(cfg, false);
 
-	RzConfig *cfg = state->cfg; // Rename for SETCB macros.
 	// Add nodes
-	SETCB("plugins.hexagon.imm.hash", "true", &hex_cfg_set, "Display ## before 32bit immediates and # before immidiates with other width.");
-	SETCB("plugins.hexagon.imm.sign", "true", &hex_cfg_set, "True: Print them with sign. False: Print signed immediates in unsigned representation.");
-	SETCB("plugins.hexagon.sdk", "false", &hex_cfg_set, "Print packet syntax in objdump style.");
-	SETCB("plugins.hexagon.reg.alias", "true", &hex_cfg_set, "Print the alias of registers (Alias from C0 = SA0).");
+	rz_config_add_b_bind(cfg, "plugins.hexagon.imm.hash", "Display ## before 32bit immediates and # before immidiates with other width.", hexagon_config_imm_hash_get, hexagon_config_imm_hash_set);
+	rz_config_add_b_bind(cfg, "plugins.hexagon.imm.sign", "True: Print them with sign. False: Print signed immediates in unsigned representation.", hexagon_config_imm_sign_get, hexagon_config_imm_sign_set);
+	rz_config_add_b_bind(cfg, "plugins.hexagon.sdk", "Print packet syntax in objdump style.", hexagon_config_sdk_get, hexagon_config_sdk_set);
+	rz_config_add_b_bind(cfg, "plugins.hexagon.reg.alias", "Print the alias of registers (Alias from C0 = SA0).", hexagon_config_reg_alias_get, hexagon_config_reg_alias_set);
 
 	if (!state->token_patterns) {
 		state->token_patterns = get_token_patterns();

librz/arch/parse.c

@@ -23,8 +23,8 @@ RZ_API RzParse *rz_parse_new(void) {
 	p->flagspace = NULL;
 	p->pseudo = false;
 	p->subrel = false;
-	p->subtail = false;
-	p->minval = 0x100;
+	p->subtail = false; // Replace addresses with prefix .. syntax
+	p->minval = 0x100; // minimum value to substitute in instructions
 	p->localvar_only = false;
 
 	const size_t n_plugins = rz_arch_get_n_plugins();