From 597d4819e7d361e39470d1dd338b5aeac8bae3d1 Mon Sep 17 00:00:00 2001 From: Linda Njau Date: Wed, 26 Jun 2024 13:59:43 +0300 Subject: [PATCH 1/8] Add inputs to Hashtabl --- src/sail_json_backend/json.ml | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/sail_json_backend/json.ml b/src/sail_json_backend/json.ml index b65cdc157..5213ce55e 100644 --- a/src/sail_json_backend/json.ml +++ b/src/sail_json_backend/json.ml @@ -80,6 +80,7 @@ let sigs = Hashtbl.create 997 let names = Hashtbl.create 997 let descriptions = Hashtbl.create 997 let operands = Hashtbl.create 997 +let inputs = Hashtbl.create 997 let encodings = Hashtbl.create 997 let assembly = Hashtbl.create 997 let assembly_clean = Hashtbl.create 997 @@ -230,6 +231,7 @@ let parse_encdec i mc format = end end | _ -> assert false + let add_assembly app_id p = let x = string_list_of_mpat p in @@ -242,9 +244,10 @@ let parse_assembly_mpat mp pb = match mp with | MP_aux (MP_app (app_id, mpl), _) -> debug_print ("MP_app " ^ string_of_id app_id); - let operandl = List.concat (List.map string_list_of_mpat mpl) in + let inputl = List.concat (List.map string_list_of_mpat mpl) in + Hashtbl.add inputs (string_of_id app_id) inputl; begin - List.iter debug_print operandl; + List.iter debug_print inputl; debug_print "MCL_bidir (right part)"; match pb with | MPat_aux (MPat_pat p, _) -> From 8a4b5fbfca8c2f24a1a4dd03c6ed6896a55ddc4a Mon Sep 17 00:00:00 2001 From: Linda Njau Date: Wed, 26 Jun 2024 14:31:25 +0300 Subject: [PATCH 2/8] Fix order of operands --- src/sail_json_backend/json.ml | 60 +++++++++++++++++++++++++++++------ 1 file changed, 51 insertions(+), 9 deletions(-) diff --git a/src/sail_json_backend/json.ml b/src/sail_json_backend/json.ml index 5213ce55e..08083f371 100644 --- a/src/sail_json_backend/json.ml +++ b/src/sail_json_backend/json.ml @@ -232,12 +232,55 @@ let parse_encdec i mc format = end | _ -> assert false +let extract_operands k = + let components = Hashtbl.find assembly k in + let regex = Str.regexp ".+(\\(.*\\))" in + let rec pre_filter acc = function + | [] -> List.rev acc + | hd :: tl -> + if String.trim hd = "spc" then + tl + else + pre_filter ( hd :: acc ) tl + in + let filtered_components = pre_filter [] components in + let rec extract acc = function + | [] -> List.rev acc + | hd :: tl -> + if Str.string_match regex hd 0 then + let operand = Str.matched_group 1 hd in + let trimmed_operand = + try + let comma_index = String.index operand ',' in + let trimmed = String.sub operand 0 comma_index in + debug_print ("Trimmed operand using comma: " ^ trimmed); + trimmed + with Not_found -> + debug_print ("No comma found in operand: " ^ operand); + operand + in + debug_print ("Final trimmed operand: " ^ trimmed_operand); + extract (trimmed_operand :: acc) tl + else + extract acc tl + in + let operandl = extract [] filtered_components in + let opmap = List.combine (Hashtbl.find inputs k) (Hashtbl.find sigs k) in + let operand_with_type = List.map (fun op -> + match List.find_opt (fun (name,_) -> String.equal name op) opmap with + | Some (_, t) -> (op, t) + | None -> (op, "") + ) operandl in + debug_print ("Adding to operands hashtable: " ^ k ^ " -> " ^ + String.concat ", " (List.map (fun (op, t) -> Printf.sprintf "(%s, %s)" op t) operand_with_type)); + Hashtbl.add operands k operand_with_type let add_assembly app_id p = let x = string_list_of_mpat p in begin debug_print ("assembly.add " ^ string_of_id app_id ^ " : " ^ List.hd x); - Hashtbl.add assembly (string_of_id app_id) x + Hashtbl.add assembly (string_of_id app_id) x; + extract_operands (string_of_id app_id) end let parse_assembly_mpat mp pb = @@ -396,9 +439,8 @@ let parse_funcl fcl = Hashtbl.add functions id source_code | Pat_exp (P_aux (P_app (i, pl), _), e) | Pat_when (P_aux (P_app (i, pl), _), e, _) -> debug_print ("FCL_funcl execute " ^ string_of_id i); - let operandl = List.concat (List.map string_list_of_pat pl) in - if not (String.equal (List.hd operandl) "()") then Hashtbl.add operands (string_of_id i) operandl; - Hashtbl.add executes (string_of_id i) (extract_source_code (Ast_util.exp_loc e)) + let source_code = extract_source_code (Ast_util.exp_loc e) in + Hashtbl.add executes (string_of_id i) source_code | _ -> () end | _ -> debug_print "FCL_funcl other" @@ -536,7 +578,7 @@ let default_operand optional opt_operand = let json_of_operand k op = debug_print ("json_of_operand " ^ k ^ ":" ^ op); - let opmap = List.combine (Hashtbl.find operands k) (Hashtbl.find sigs k) in + let opmap = Hashtbl.find operands k in let opplus = remove_identity_funcs op in let opname = List.hd (String.split_on_char ',' opplus) in let optional, opt_operand = optional_operand k op in @@ -555,9 +597,9 @@ let json_of_operands k = | Some ops -> String.concat "," (List.map - (fun op -> json_of_operand k op) + (fun (op, _) -> json_of_operand k op) (List.filter - (fun s -> not (String.equal s "(" || String.equal s ")" || String.equal s "spc" || String.equal s "sep")) + (fun (s, _) -> not (String.equal s "(" || String.equal s ")" || String.equal s "spc" || String.equal s "sep")) ops ) ) @@ -595,7 +637,7 @@ let rec string_of_sizeof_field k f = ) else begin (* match operand names to function signature types *) - let opmap = List.combine (Hashtbl.find operands k) (Hashtbl.find sigs k) in + let opmap = Hashtbl.find operands k in begin (* find matching operand type *) match List.assoc_opt f opmap with @@ -746,7 +788,7 @@ let defs { defs; _ } = debug_print "DESCRIPTIONS"; Hashtbl.iter (fun k v -> debug_print (k ^ ":" ^ v)) descriptions; debug_print "OPERANDS"; - Hashtbl.iter (fun k v -> debug_print (k ^ ":" ^ Util.string_of_list ", " (fun x -> x) v)) operands; + Hashtbl.iter (fun k v -> debug_print (k ^ ":" ^ Util.string_of_list ", " (fun (op, t) -> "(" ^ op ^ ", " ^ t ^ ")") v)) operands; debug_print "ENCODINGS"; Hashtbl.iter (fun k v -> debug_print (k ^ ":" ^ Util.string_of_list ", " (fun x -> x) v)) encodings; debug_print "ASSEMBLY"; From b3771266872457b9b3e0c4af71cf43d17584b7ae Mon Sep 17 00:00:00 2001 From: Linda Njau Date: Thu, 27 Jun 2024 14:36:30 +0300 Subject: [PATCH 3/8] Extract embedded functions --- src/sail_json_backend/json.ml | 88 +++++++++++++++++++---------------- 1 file changed, 49 insertions(+), 39 deletions(-) diff --git a/src/sail_json_backend/json.ml b/src/sail_json_backend/json.ml index 08083f371..c463daf0f 100644 --- a/src/sail_json_backend/json.ml +++ b/src/sail_json_backend/json.ml @@ -231,48 +231,54 @@ let parse_encdec i mc format = end end | _ -> assert false - -let extract_operands k = - let components = Hashtbl.find assembly k in - let regex = Str.regexp ".+(\\(.*\\))" in - let rec pre_filter acc = function + +let filter_non_operands components = + let rec aux acc = function | [] -> List.rev acc - | hd :: tl -> - if String.trim hd = "spc" then - tl - else - pre_filter ( hd :: acc ) tl + | hd :: tl -> if String.trim hd = "spc" then tl else aux (hd :: acc) tl in - let filtered_components = pre_filter [] components in - let rec extract acc = function + aux [] components + +let extract_operands regex components = + let rec aux acc = function | [] -> List.rev acc | hd :: tl -> - if Str.string_match regex hd 0 then - let operand = Str.matched_group 1 hd in - let trimmed_operand = - try - let comma_index = String.index operand ',' in - let trimmed = String.sub operand 0 comma_index in - debug_print ("Trimmed operand using comma: " ^ trimmed); - trimmed - with Not_found -> - debug_print ("No comma found in operand: " ^ operand); - operand - in - debug_print ("Final trimmed operand: " ^ trimmed_operand); - extract (trimmed_operand :: acc) tl - else - extract acc tl + if Str.string_match regex hd 0 then ( + let operand = Str.matched_group 1 hd in + let trimmed_operand = + try + let comma_index = String.index operand ',' in + debug_print ("Operand before trimming: " ^ operand); + let trimmed = String.sub operand 0 comma_index in + debug_print ("Final trimmed operand: " ^ trimmed); + trimmed + with Not_found -> operand + in + aux (trimmed_operand :: acc) tl + ) + else aux acc tl in - let operandl = extract [] filtered_components in + aux [] components + +let extract_and_map_operands k = + let components = Hashtbl.find assembly k in + let regex = Str.regexp ".+(\\(.*\\))" in + let filtered_components = filter_non_operands components in + let operandl = extract_operands regex filtered_components in let opmap = List.combine (Hashtbl.find inputs k) (Hashtbl.find sigs k) in - let operand_with_type = List.map (fun op -> - match List.find_opt (fun (name,_) -> String.equal name op) opmap with - | Some (_, t) -> (op, t) - | None -> (op, "") - ) operandl in - debug_print ("Adding to operands hashtable: " ^ k ^ " -> " ^ - String.concat ", " (List.map (fun (op, t) -> Printf.sprintf "(%s, %s)" op t) operand_with_type)); + let operand_with_type = + List.map + (fun op -> + match List.find_opt (fun (name, _) -> String.equal name op) opmap with + | Some (_, t) -> (op, t) + | None -> (op, "") + ) + operandl + in + debug_print + ("Adding to operands hashtable: " ^ k ^ " -> " + ^ String.concat ", " (List.map (fun (op, t) -> Printf.sprintf "(%s, %s)" op t) operand_with_type) + ); Hashtbl.add operands k operand_with_type let add_assembly app_id p = @@ -280,7 +286,7 @@ let add_assembly app_id p = begin debug_print ("assembly.add " ^ string_of_id app_id ^ " : " ^ List.hd x); Hashtbl.add assembly (string_of_id app_id) x; - extract_operands (string_of_id app_id) + extract_and_map_operands (string_of_id app_id) end let parse_assembly_mpat mp pb = @@ -599,7 +605,9 @@ let json_of_operands k = (List.map (fun (op, _) -> json_of_operand k op) (List.filter - (fun (s, _) -> not (String.equal s "(" || String.equal s ")" || String.equal s "spc" || String.equal s "sep")) + (fun (s, _) -> + not (String.equal s "(" || String.equal s ")" || String.equal s "spc" || String.equal s "sep") + ) ops ) ) @@ -788,7 +796,9 @@ let defs { defs; _ } = debug_print "DESCRIPTIONS"; Hashtbl.iter (fun k v -> debug_print (k ^ ":" ^ v)) descriptions; debug_print "OPERANDS"; - Hashtbl.iter (fun k v -> debug_print (k ^ ":" ^ Util.string_of_list ", " (fun (op, t) -> "(" ^ op ^ ", " ^ t ^ ")") v)) operands; + Hashtbl.iter + (fun k v -> debug_print (k ^ ":" ^ Util.string_of_list ", " (fun (op, t) -> "(" ^ op ^ ", " ^ t ^ ")") v)) + operands; debug_print "ENCODINGS"; Hashtbl.iter (fun k v -> debug_print (k ^ ":" ^ Util.string_of_list ", " (fun x -> x) v)) encodings; debug_print "ASSEMBLY"; From 69ad76781712632cadba33fb0300749c52a262b1 Mon Sep 17 00:00:00 2001 From: Linda Njau Date: Mon, 1 Jul 2024 18:08:23 +0300 Subject: [PATCH 4/8] Add cross-checking for trimmed operands --- src/sail_json_backend/json.ml | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/src/sail_json_backend/json.ml b/src/sail_json_backend/json.ml index c463daf0f..d2213866e 100644 --- a/src/sail_json_backend/json.ml +++ b/src/sail_json_backend/json.ml @@ -239,22 +239,20 @@ let filter_non_operands components = in aux [] components -let extract_operands regex components = +let extract_operands k regex components = let rec aux acc = function | [] -> List.rev acc | hd :: tl -> if Str.string_match regex hd 0 then ( let operand = Str.matched_group 1 hd in - let trimmed_operand = - try - let comma_index = String.index operand ',' in - debug_print ("Operand before trimming: " ^ operand); - let trimmed = String.sub operand 0 comma_index in - debug_print ("Final trimmed operand: " ^ trimmed); - trimmed - with Not_found -> operand - in - aux (trimmed_operand :: acc) tl + try + let comma_index = String.index operand ',' in + debug_print ("Operand before trimming: " ^ operand); + let trimmed = String.sub operand 0 comma_index in + debug_print ("Final trimmed operand: " ^ trimmed); + let inputl = Hashtbl.find inputs k in + if List.mem trimmed inputl then aux (trimmed :: acc) tl else aux acc tl + with Not_found -> aux (operand :: acc) tl ) else aux acc tl in @@ -264,7 +262,7 @@ let extract_and_map_operands k = let components = Hashtbl.find assembly k in let regex = Str.regexp ".+(\\(.*\\))" in let filtered_components = filter_non_operands components in - let operandl = extract_operands regex filtered_components in + let operandl = extract_operands k regex filtered_components in let opmap = List.combine (Hashtbl.find inputs k) (Hashtbl.find sigs k) in let operand_with_type = List.map From 300079a9ea56614f49507d2b8a1c9e1083d21bce Mon Sep 17 00:00:00 2001 From: Linda Njau Date: Fri, 26 Jul 2024 16:35:44 +0300 Subject: [PATCH 5/8] Update add_assembly to pass components --- src/sail_json_backend/json.ml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/sail_json_backend/json.ml b/src/sail_json_backend/json.ml index d2213866e..f2cf8c076 100644 --- a/src/sail_json_backend/json.ml +++ b/src/sail_json_backend/json.ml @@ -258,8 +258,7 @@ let extract_operands k regex components = in aux [] components -let extract_and_map_operands k = - let components = Hashtbl.find assembly k in +let extract_and_map_operands k components = let regex = Str.regexp ".+(\\(.*\\))" in let filtered_components = filter_non_operands components in let operandl = extract_operands k regex filtered_components in @@ -284,7 +283,7 @@ let add_assembly app_id p = begin debug_print ("assembly.add " ^ string_of_id app_id ^ " : " ^ List.hd x); Hashtbl.add assembly (string_of_id app_id) x; - extract_and_map_operands (string_of_id app_id) + extract_and_map_operands (string_of_id app_id) x end let parse_assembly_mpat mp pb = From 5908e189b2dfae5cc313bdb07de1baa1c1a47fa5 Mon Sep 17 00:00:00 2001 From: Linda Njau Date: Thu, 1 Aug 2024 14:55:05 +0300 Subject: [PATCH 6/8] Update operand validation --- src/sail_json_backend/json.ml | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/src/sail_json_backend/json.ml b/src/sail_json_backend/json.ml index f2cf8c076..13e9f0847 100644 --- a/src/sail_json_backend/json.ml +++ b/src/sail_json_backend/json.ml @@ -239,29 +239,31 @@ let filter_non_operands components = in aux [] components -let extract_operands k regex components = +let extract_operands k components = let rec aux acc = function | [] -> List.rev acc | hd :: tl -> - if Str.string_match regex hd 0 then ( + if Str.string_match (Str.regexp ".+(\\(.*\\))") hd 0 then ( let operand = Str.matched_group 1 hd in + let elements = Str.split (Str.regexp ",") operand in try - let comma_index = String.index operand ',' in - debug_print ("Operand before trimming: " ^ operand); - let trimmed = String.sub operand 0 comma_index in - debug_print ("Final trimmed operand: " ^ trimmed); let inputl = Hashtbl.find inputs k in if List.mem trimmed inputl then aux (trimmed :: acc) tl else aux acc tl with Not_found -> aux (operand :: acc) tl + let acc = + List.fold_left (fun acc element -> if List.mem element inputl then element :: acc else acc) acc elements + in + + aux acc tl + with Not_found -> aux acc tl ) else aux acc tl in aux [] components let extract_and_map_operands k components = - let regex = Str.regexp ".+(\\(.*\\))" in let filtered_components = filter_non_operands components in - let operandl = extract_operands k regex filtered_components in + let operandl = extract_operands k filtered_components in let opmap = List.combine (Hashtbl.find inputs k) (Hashtbl.find sigs k) in let operand_with_type = List.map From ed19dba6bf349dc44d791578ffc041eed61627d6 Mon Sep 17 00:00:00 2001 From: Linda Njau Date: Fri, 2 Aug 2024 14:29:11 +0300 Subject: [PATCH 7/8] Refactor pattern matching in filter_non_operands and extract_operands. --- src/sail_json_backend/json.ml | 49 +++++++++++++++-------------------- 1 file changed, 21 insertions(+), 28 deletions(-) diff --git a/src/sail_json_backend/json.ml b/src/sail_json_backend/json.ml index 13e9f0847..26b817669 100644 --- a/src/sail_json_backend/json.ml +++ b/src/sail_json_backend/json.ml @@ -232,34 +232,27 @@ let parse_encdec i mc format = end | _ -> assert false -let filter_non_operands components = - let rec aux acc = function - | [] -> List.rev acc - | hd :: tl -> if String.trim hd = "spc" then tl else aux (hd :: acc) tl - in - aux [] components - -let extract_operands k components = - let rec aux acc = function - | [] -> List.rev acc - | hd :: tl -> - if Str.string_match (Str.regexp ".+(\\(.*\\))") hd 0 then ( - let operand = Str.matched_group 1 hd in - let elements = Str.split (Str.regexp ",") operand in - try - let inputl = Hashtbl.find inputs k in - if List.mem trimmed inputl then aux (trimmed :: acc) tl else aux acc tl - with Not_found -> aux (operand :: acc) tl - let acc = - List.fold_left (fun acc element -> if List.mem element inputl then element :: acc else acc) acc elements - in - - aux acc tl - with Not_found -> aux acc tl - ) - else aux acc tl - in - aux [] components +let rec filter_non_operands components = + match components with + | [] -> [] + | hd :: tl when String.trim hd = "spc" -> tl + | _ -> filter_non_operands (List.tl components) + +let rec extract_operands k filtered_components = + match filtered_components with + | [] -> [] + | hd :: tl -> + if Str.string_match (Str.regexp ".+(\\(.*\\))") hd 0 then ( + let operand = Str.matched_group 1 hd in + let elements = Str.split (Str.regexp ",") operand in + let filtered_elements = + match Hashtbl.find_opt inputs k with + | None -> [] + | Some inputl -> List.filter (fun element -> List.mem element inputl) elements + in + filtered_elements @ extract_operands k tl + ) + else extract_operands k tl let extract_and_map_operands k components = let filtered_components = filter_non_operands components in From aab5e63ce93c890e42d477211c31425dbe32769e Mon Sep 17 00:00:00 2001 From: Linda Njau Date: Wed, 7 Aug 2024 11:48:07 +0300 Subject: [PATCH 8/8] Add comment for operand search; rename 'operand' to 'elements' --- src/sail_json_backend/json.ml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/sail_json_backend/json.ml b/src/sail_json_backend/json.ml index 26b817669..29bee37c9 100644 --- a/src/sail_json_backend/json.ml +++ b/src/sail_json_backend/json.ml @@ -239,12 +239,12 @@ let rec filter_non_operands components = | _ -> filter_non_operands (List.tl components) let rec extract_operands k filtered_components = + (*This looks for operands embedded within functions like "funct(op1 @ op2 @ 0b00)" *) match filtered_components with | [] -> [] | hd :: tl -> if Str.string_match (Str.regexp ".+(\\(.*\\))") hd 0 then ( - let operand = Str.matched_group 1 hd in - let elements = Str.split (Str.regexp ",") operand in + let elements = Str.split (Str.regexp ",") (Str.matched_group 1 hd) in let filtered_elements = match Hashtbl.find_opt inputs k with | None -> []