rewrites x86 abi using the new infrastructure

Makefile

@@ -55,7 +55,7 @@ testsuite:
 	git clone https://github.com/BinaryAnalysisPlatform/bap-testsuite.git testsuite
 
 check: testsuite
-	make REVISION=c40b332290bab -C testsuite
+	make REVISION=f0043aaa2cc -C testsuite
 
 .PHONY: indent check-style status-clean
 

lib/bap_c/bap_c_abi.ml

@@ -527,14 +527,14 @@ module Arg = struct
 
   let concat = List.reduce_exn ~f:Bil.concat
 
-  let registers ?limit file t =
+  let registers ?(rev=false) ?limit file t =
     let* s = Arg.get () in
     let* bits = size t in
     let* regs_needed = registers_needed file bits in
     let limit = Option.value limit ~default:regs_needed in
     require (regs_needed <= limit) >>= fun () ->
     let* args = Arena.popn ~n:regs_needed s file in
-    push_arg t @@ concat args
+    push_arg t @@ concat (if rev then List.rev args else args)
 
   let align_even file =
     let* s = Arg.get () in
@@ -556,15 +556,7 @@ module Arg = struct
 
   let reference file t =
     with_hidden @@ fun () ->
-    register file (`Pointer C.Type.Spec.{
-        t;
-        attrs = [];
-        qualifier = C.Type.Qualifier.{
-            const = false;
-            volatile = false;
-            restrict = false;
-          }
-      })
+    register file (C.Type.pointer t)
 
   let update_stack f =
     let* s = Arg.get () in
@@ -583,8 +575,16 @@ module Arg = struct
     let* bits = size t in
     update_stack @@ Stack.add t (data s.ruler t) bits
 
+  let hidden t =
+    with_hidden @@ fun () ->
+    memory (C.Type.pointer t)
+
   let skip_memory bits = update_stack @@ Stack.skip bits
 
+  let rebase slots =
+    let* {target} = Arg.get () in
+    skip_memory (slots * Theory.Target.data_addr_size target)
+
   let load t bits sp base =
     let mem = Var.reify (Theory.Target.data t) in
     let width = Theory.Target.data_addr_size t in
@@ -698,12 +698,9 @@ end
 
 let define target ruler pass =
   let open Bap_core_theory in
-  let target_name = Theory.Target.name target in
-  let abi_name =
-    let abi = Theory.Target.abi target in
-    if Theory.Abi.(abi = unknown)
-    then Format.asprintf "%a-unknown" KB.Name.pp target_name
-    else Format.asprintf "%a" KB.Name.pp target_name in
+  let abi = Theory.Target.abi target in
+  let abi_name = Format.asprintf "%s"
+      (KB.Name.unqualified (Theory.Abi.name abi)) in
   let abi_processor = {
     apply_attrs = (fun _ x -> x);
     insert_args = fun _ attrs proto ->

lib/bap_c/bap_c_abi.mli

@@ -270,8 +270,13 @@ module Arg : sig
       Rejects the computation if [arena] doesn't have the necessary
       number of registers; the number of required registers is greater
       than [limit]; or if the size of [t] is unknown.
+
+      If [rev] is true, then the allocated registers will be used in
+      the reversed order.
+
+      @since 2.5.0 accepts the optional [rev] parameter.
   *)
-  val registers : ?limit:int -> arena -> ctype -> unit t
+  val registers : ?rev:bool -> ?limit:int -> arena -> ctype -> unit t
 
 
   (** [align_even arena] ensures that the first available register in
@@ -312,6 +317,15 @@ module Arg : sig
       pointer role. The size of [t] is not required. *)
   val reference : arena -> ctype -> unit t
 
+
+  (** [hidden t] passes the argument of type [t] as a pointer
+      to [t] via the first available stack slot.
+
+      The computation is rejected if the target doesn't have a stack.
+
+      @since 2.5.0  *)
+  val hidden : ctype -> unit t
+
   (** [memory t] passes the argument of type [t] in the next
       available stack slot.
 
@@ -333,6 +347,11 @@ module Arg : sig
   *)
   val memory : ctype -> unit t
 
+  (** [rebase off] rebases the stack position by [n] words.
+
+      @since 2.5.0
+  *)
+  val rebase : int -> unit t
 
   (** [split a1 a2 t] passes the lower half of the value
       via registers in the arena [a1] and the higher via the registers
@@ -387,12 +406,12 @@ module Arg : sig
 
   (** [size t] is the size in bits of an object of type [t].
 
-      The computation is rejected if the size is unknown.
+      The computation is rejected if the size is unknown, i.e., the
+      type is incomplete.
 
       @since 2.5.0 *)
   val size : ctype -> int t
 
-
   (** [require cnd] rejects the computation if [cnd] doesn't hold.
 
       @since 2.5.0  *)

lib/bap_c/bap_c_type.ml

@@ -174,6 +174,8 @@ let is_restrict : t -> Bool.t = function
   | `Pointer {qualifier={restrict}} -> restrict
 
 
+let is_void = function `Void -> true | _ -> false
+
 let qualifier ?(const=false) ?(volatile=false) restrict =
   Qualifier.{const; volatile; restrict}
 

lib/bap_c/bap_c_type.mli

@@ -161,6 +161,10 @@ val is_volatile : t -> Bool.t
 val is_restrict : t -> Bool.t
 
 
+(** [is_void t] true iff [t] is [`Void]  *)
+val is_void : t -> Bool.t
+
+
 (** {2 Basic Types} *)
 
 (** [basic x] constructs a basic type.

lib/x86_cpu/.merlin

@@ -0,0 +1,2 @@
+REC
+B ../bap_demangle