i#6662 public traces, part 1: synthetic ISA

api/docs/release.dox

@@ -217,6 +217,10 @@ Further non-compatibility-affecting changes include:
    is set to true by default to match the existing behavior of the invariant checker.
  - Added a new instr API instr_is_xrstor() that tells whether an instruction is any
    variant of the x86 xrstor opcode.
+ - Added a new #dr_isa_mode_t: #DR_ISA_REGDEPS, which is a synthetic ISA with the main
+   purpose of preserving register dependencies.
+ - Added instr_convert_to_isa_regdeps() API that converts an #instr_t from a real ISA
+   (e.g., #DR_ISA_AMD64) to the #DR_ISA_REGDEPS synthetic ISA.
 
 **************************************************
 <hr>

core/CMakeLists.txt

@@ -279,6 +279,8 @@ set(DECODER_SRCS
   ir/${ARCH_NAME}/decode.c
   ir/encode_shared.c
   ir/${ARCH_NAME}/encode.c
+  ir/isa_regdeps/encode.c
+  ir/isa_regdeps/decode.c
   ir/disassemble_shared.c
   ir/${ARCH_NAME}/disassemble.c
   ir/ir_utils_shared.c

core/ir/aarch64/codec.c

@@ -40,9 +40,11 @@
 
 #include <stdint.h>
 #include "../globals.h"
+#include "../isa_regdeps/decode.h"
 #include "arch.h"
 #include "decode.h"
 #include "disassemble.h"
+#include "encode_api.h"
 #include "instr.h"
 #include "instr_create_shared.h"
 
@@ -9717,6 +9719,14 @@ decode_category(uint encoding, instr_t *instr)
 byte *
 decode_common(dcontext_t *dcontext, byte *pc, byte *orig_pc, instr_t *instr)
 {
+    /* #DR_ISA_REGDEPS synthetic ISA has its own decoder.
+     * XXX i#1684: when DR can be built with full dynamic architecture selection we won't
+     * need to pollute the decoding of other architectures with this synthetic ISA special
+     * case.
+     */
+    if (dr_get_isa_mode(dcontext) == DR_ISA_REGDEPS)
+        return decode_isa_regdeps(dcontext, pc, instr);
+
     byte *next_pc = pc + 4;
     uint enc = *(uint *)pc;
     uint eflags = 0;

core/ir/aarch64/decode.c

@@ -32,6 +32,7 @@
  */
 
 #include "../globals.h"
+#include "encode_api.h"
 #include "instr.h"
 #include "decode.h"
 #include "decode_fast.h" /* ensure we export decode_next_pc, decode_sizeof */
@@ -41,7 +42,7 @@
 bool
 is_isa_mode_legal(dr_isa_mode_t mode)
 {
-    return (mode == DR_ISA_ARM_A64);
+    return (mode == DR_ISA_ARM_A64 || mode == DR_ISA_REGDEPS);
 }
 
 app_pc

core/ir/aarch64/instr.c

@@ -45,9 +45,9 @@
 bool
 instr_set_isa_mode(instr_t *instr, dr_isa_mode_t mode)
 {
-    if (mode != DR_ISA_ARM_A64)
+    if (mode != DR_ISA_ARM_A64 && mode != DR_ISA_REGDEPS)
         return false;
-    instr->isa_mode = DR_ISA_ARM_A64;
+    instr->isa_mode = mode;
     return true;
 }
 

core/ir/arm/decode.c

@@ -31,6 +31,8 @@
  */
 
 #include "../globals.h"
+#include "../isa_regdeps/decode.h"
+#include "encode_api.h"
 #include "instr.h"
 #include "decode.h"
 #include "decode_private.h"
@@ -172,7 +174,7 @@ decode_in_it_block(decode_state_t *state, app_pc pc, decode_info_t *di)
 bool
 is_isa_mode_legal(dr_isa_mode_t mode)
 {
-    return (mode == DR_ISA_ARM_THUMB || DR_ISA_ARM_A32);
+    return (mode == DR_ISA_ARM_THUMB || mode == DR_ISA_ARM_A32 || mode == DR_ISA_REGDEPS);
 }
 
 /* We need to call canonicalize_pc_target() on all next_tag-writing
@@ -2428,6 +2430,14 @@ decode_opcode(dcontext_t *dcontext, byte *pc, instr_t *instr)
 static byte *
 decode_common(dcontext_t *dcontext, byte *pc, byte *orig_pc, instr_t *instr)
 {
+    /* #DR_ISA_REGDEPS synthetic ISA has its own decoder.
+     * XXX i#1684: when DR can be built with full dynamic architecture selection we won't
+     * need to pollute the decoding of other architectures with this synthetic ISA special
+     * case.
+     */
+    if (dr_get_isa_mode(dcontext) == DR_ISA_REGDEPS)
+        return decode_isa_regdeps(dcontext, pc, instr);
+
     const instr_info_t *info = &invalid_instr;
     decode_info_t di;
     byte *next_pc;

core/ir/arm/instr.c

@@ -43,7 +43,7 @@
 bool
 instr_set_isa_mode(instr_t *instr, dr_isa_mode_t mode)
 {
-    if (mode != DR_ISA_ARM_THUMB && mode != DR_ISA_ARM_A32) {
+    if (mode != DR_ISA_ARM_THUMB && mode != DR_ISA_ARM_A32 && mode != DR_ISA_REGDEPS) {
         return false;
     }
     instr->isa_mode = mode;

core/ir/encode_api.h

@@ -51,6 +51,52 @@ typedef enum _dr_isa_mode_t {
     DR_ISA_ARM_THUMB,         /**< Thumb (ARM T32). */
     DR_ISA_ARM_A64,           /**< ARM A64 (AArch64). */
     DR_ISA_RV64IMAFDC,        /**< RISC-V (rv64imafdc). */
+                              /**
+                               * This is a synthetic ISA that has the purpose of
+                               * preserving register dependencies and giving hints on the
+                               * type of operations each instruction is performing.
+                               *
+                               * For this reason some operations that work on instructions
+                               * coming from an actual ISA (e.g., #DR_ISA_AMD64) are not
+                               * supported.
+                               *
+                               * Currently we support:
+                               * - instr_convert_to_isa_regdeps(), which converts an
+                               *   #instr_t of an actual ISA to a #DR_ISA_REGDEPS
+                               *   instruction.
+                               * - instr_encode() and instr_encode_to_copy(), to encode a
+                               *   #DR_ISA_REGDEPS #instr_t into a sequence of contiguous
+                               *   bytes.
+                               * - decode() and decode_from_copy(), to decode an encoded
+                               *   #DR_ISA_REGDEPS instruction into an #instr_t.
+                               *
+                               * A #DR_ISA_REGDEPS #instr_t has the following information:
+                               * - categories (composed by #dr_instr_category_t values),
+                               *   to indicate the type of operation performed (e.g.,load,
+                               *   store, floating point math operation, branch, etc.).
+                               *   Note that more than one category can be set.
+                               * - arithmetic flags, with no distinction between different
+                               *   flags, we only report if at least one arithmetic flag
+                               *   was read and/or written.
+                               * - number of source and destination register operands.
+                               * - source operation size, which is the largest source
+                               *   operand the instruction operates on.
+                               * - list of register operand identifiers (contained in
+                               *   #opnd_t), separated in source and destination.
+                               *   Note that these #reg_id_t identifiers are virtual and
+                               *   they should not be assumed to be equal to any DR_REG_
+                               *   enum values of any specific architecture, they are
+                               *   meant for tracking dependencies with respect to other
+                               *   #DR_ISA_REGDEPS instructions only.
+                               * - ISA mode, which is #DR_ISA_REGDEPS.
+                               *
+                               * Querying additional #instr_t related information outside
+                               * of those described above (e.g., the instruction opcode)
+                               * will return the corresponding zeroed value set by
+                               * instr_create() or instr_init().
+                               */
+    DR_ISA_REGDEPS,
+
 } dr_isa_mode_t;
 
 DR_API

core/ir/encode_shared.c

@@ -38,6 +38,7 @@
 /* encode_shared.c -- cross-platform encodingn routines */
 
 #include "../globals.h"
+#include "isa_regdeps/encode.h"
 #include "arch.h"
 #include "instr.h"
 #include "decode.h"
@@ -111,28 +112,46 @@ get_encoding_info(instr_t *instr)
     return info;
 }
 
+static byte *
+instr_encode_common(dcontext_t *dcontext, instr_t *instr, byte *copy_pc, byte *final_pc,
+                    bool check_reachable,
+                    bool *has_instr_opnds /*OUT OPTIONAL*/
+                        _IF_DEBUG(bool assert_reachable))
+{
+    /* #DR_ISA_REGDEPS synthetic ISA has its own encoder.
+     * XXX i#1684: when DR can be built with full dynamic architecture selection we won't
+     * need to pollute the encoding of other architectures with this synthetic ISA special
+     * case.
+     */
+    if (instr_get_isa_mode(instr) == DR_ISA_REGDEPS)
+        return encode_isa_regdeps(dcontext, instr, copy_pc);
+
+    return instr_encode_arch(dcontext, instr, copy_pc, final_pc, check_reachable,
+                             has_instr_opnds _IF_DEBUG(assert_reachable));
+}
+
 /* completely ignores reachability and predication failures */
 byte *
 instr_encode_ignore_reachability(dcontext_t *dcontext, instr_t *instr, byte *pc)
 {
-    return instr_encode_arch(dcontext, instr, pc, pc, false, NULL _IF_DEBUG(false));
+    return instr_encode_common(dcontext, instr, pc, pc, false, NULL _IF_DEBUG(false));
 }
 
 /* just like instr_encode but doesn't assert on reachability or predication failures */
 byte *
 instr_encode_check_reachability(dcontext_t *dcontext, instr_t *instr, byte *pc,
                                 bool *has_instr_opnds /*OUT OPTIONAL*/)
 {
-    return instr_encode_arch(dcontext, instr, pc, pc, true,
-                             has_instr_opnds _IF_DEBUG(false));
+    return instr_encode_common(dcontext, instr, pc, pc, true,
+                               has_instr_opnds _IF_DEBUG(false));
 }
 
 byte *
 instr_encode_to_copy(void *drcontext, instr_t *instr, byte *copy_pc, byte *final_pc)
 {
     dcontext_t *dcontext = (dcontext_t *)drcontext;
-    return instr_encode_arch(dcontext, instr, copy_pc, final_pc, true,
-                             NULL _IF_DEBUG(true));
+    return instr_encode_common(dcontext, instr, copy_pc, final_pc, true,
+                               NULL _IF_DEBUG(true));
 }
 
 byte *

core/ir/instr_api.h

@@ -298,10 +298,19 @@ struct _instr_t {
 
     uint opcode;
 
+    union {
 #    ifdef X86
-    /* PR 251479: offset into instr's raw bytes of rip-relative 4-byte displacement */
-    byte rip_rel_pos;
+        /* PR 251479: offset into instr's raw bytes of rip-relative 4-byte displacement.
+         * This field is valid when instr_t isa_mode is DR_ISA_X86.
+         */
+        byte rip_rel_pos;
 #    endif
+        /* PR #6691: size of source data (i.e., read) an instruction operates on.
+         * This field is valid when instr_t isa_mode is DR_ISA_REGDEPS.
+         * Note that opnd_size_t is an alias of byte.
+         */
+        opnd_size_t operation_size;
+    };
 
     /* we dynamically allocate dst and src arrays b/c x86 instrs can have
      * up to 8 of each of them, but most have <=2 dsts and <=3 srcs, and we
@@ -2095,6 +2104,21 @@ DR_API
 instr_t *
 instr_convert_short_meta_jmp_to_long(void *drcontext, instrlist_t *ilist, instr_t *instr);
 
+DR_API
+/**
+ * Converts a real ISA (e.g., #DR_ISA_AMD64) instruction \p instr_real_isa into a
+ * #DR_ISA_REGDEPS instruction and stores it into \p instr_regdeps_isa.
+ * Assumes \p instr_regdeps_isa has been allocated by the caller (e.g., using
+ * instr_create()).
+ * Assumes \p instr_real_isa is a fully-decoded or synthesized instruction of a real ISA
+ * with valid operand information.
+ * \note \p instr_regdeps_isa will contain only the information of a #DR_ISA_REGDEPS
+ * synthetic instruction.
+ */
+void
+instr_convert_to_isa_regdeps(void *drcontext, instr_t *instr_real_isa,
+                             instr_t *instr_regdeps_isa);
+
 DR_API
 /**
  * Given \p eflags, returns whether or not the conditional branch, \p