i#6662 public traces, part 1: synthetic ISA

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/synthetic/encode.c
+  ir/synthetic/decode.c
   ir/disassemble_shared.c
   ir/${ARCH_NAME}/disassemble.c
   ir/ir_utils_shared.c

core/ir/encode_api.h

@@ -51,6 +51,7 @@ 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). */
+    DR_ISA_SYNTH,             /**< Synthetic ISA for public traces. */
 } dr_isa_mode_t;
 
 DR_API

core/ir/instr.h

@@ -215,6 +215,12 @@ enum {
 #endif
     /* PR 267260: distinguish our own mangling from client-added instrs */
     INSTR_OUR_MANGLING = 0x80000000,
+    /*
+     * Synthetic ISA mode.
+     * TOFIX: we're exceeding 4 bytes, this is an issue on 32 bits arch
+     * where uint flags of instr_t is only 4 bytes.
+     */
+    INSTR_SYNTH_MODE = 0x100000000,
 };
 
 #define DR_TUPLE_TYPE_BITS 4

core/ir/synthetic/decode.c

@@ -0,0 +1,93 @@
+/* **********************************************************
+ * Copyright (c) 2011-2024 Google, Inc.  All rights reserved.
+ * Copyright (c) 2001-2010 VMware, Inc.  All rights reserved.
+ * **********************************************************/
+
+/*
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of VMware, Inc. nor the names of its contributors may be
+ *   used to endorse or promote products derived from this software without
+ *   specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL VMWARE, INC. OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+/* Copyright (c) 2003-2007 Determina Corp. */
+/* Copyright (c) 2001-2003 Massachusetts Institute of Technology */
+/* Copyright (c) 2001 Hewlett-Packard Company */
+
+/* decode.c -- a decoder for DR synthetic IR */
+
+#include "encode.h"
+#include "decode.h"
+
+#include "../globals.h"
+#include "instr_api.h"
+
+#define CATEGORY_BITS 22
+#define FLAGS_BITS 2
+#define NUM_OPND_BITS 4
+
+void
+decode_from_synth(dcontext_t *dcontext, byte *encoded_instr, instr_t *instr)
+{
+    uint encoding = 0;
+    uint shift = 0;
+
+    /*
+     * Copy encoded_instr in a uint for easy retrieving of values.
+     */
+    memcpy(&encoding, encoded_instr, sizeof(uint));
+
+    /*
+     * Decode synthetic opcode as instruction category.
+     */
+    uint category_mask = (1U << CATEGORY_BITS) - 1;
+    uint category = encoding & category_mask;
+    instr_set_category(instr, category);
+    shift += CATEGORY_BITS;
+
+    /*
+     * Decode flags.
+     */
+    // Commented to avoid unused variable error.
+    // uint flags_mask = ((1U << FLAGS_BITS) - 1) << shift;
+    // uint flags = encoding & flags_mask;
+    // TOFIX: set all arithmetic flags of instr_t?
+    shift += FLAGS_BITS;
+
+    /*
+     * Decode number of source operands.
+     */
+    uint num_srcs_mask = ((1U << NUM_OPND_BITS) - 1) << shift;
+    uint num_srcs = encoding & num_srcs_mask;
+    shift += NUM_OPND_BITS;
+
+    /*
+     * Decode number of destination operands.
+     */
+    uint num_dsts_mask = ((1U << NUM_OPND_BITS) - 1) << shift;
+    uint num_dsts = encoding & num_dsts_mask;
+
+    instr_set_num_opnds(dcontext, instr, num_dsts, num_srcs);
+
+    return;
+}

core/ir/synthetic/decode.h

@@ -0,0 +1,9 @@
+#ifndef _SYNTHETIC_DECODE_H_
+#define _SYNTHETIC_DECODE_H_ 1
+
+#include "../globals.h"
+
+void
+decode_from_synth(dcontext_t *dcontext, byte *encoded_instr, instr_t *instr);
+
+#endif /* _SYNTHETIC_DECODE_H_ */

core/ir/synthetic/encode.c

@@ -0,0 +1,91 @@
+/* **********************************************************
+ * Copyright (c) 2011-2024 Google, Inc.  All rights reserved.
+ * Copyright (c) 2001-2010 VMware, Inc.  All rights reserved.
+ * **********************************************************/
+
+/*
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice,
+ *   this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of VMware, Inc. nor the names of its contributors may be
+ *   used to endorse or promote products derived from this software without
+ *   specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL VMWARE, INC. OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ */
+/* Copyright (c) 2003-2007 Determina Corp. */
+/* Copyright (c) 2001-2003 Massachusetts Institute of Technology */
+/* Copyright (c) 2001 Hewlett-Packard Company */
+
+/* encode.c -- an encoder for DR synthetic IR */
+
+#include "encode.h"
+
+#include "../globals.h"
+
+#define CATEGORY_BITS 22
+#define FLAGS_BITS 2
+#define NUM_OPND_BITS 4
+
+void
+encode_to_synth(dcontext_t *dcontext, instr_t *instr, byte *encoded_instr)
+{
+    uint encoding = 0;
+    uint shift = 0;
+
+    /*
+     * Encode category as synthetic opcode.
+     */
+    uint category = instr_get_category(instr);
+    encoding |= category;
+    shift += CATEGORY_BITS;
+
+    /*
+     * Encode flags.
+     */
+    // TOFIX: this is probably not the right way to look at arithmetic flags of an instr_t
+    uint flags = (uint)instr_arith_flags_valid(instr);
+    encoding |= (flags << shift);
+    shift += FLAGS_BITS;
+
+    /*
+     * Encode number of source operands.
+     */
+    uint num_srcs = (uint)instr_num_srcs(instr);
+    encoding |= (num_srcs << shift);
+    shift += NUM_OPND_BITS;
+
+    /*
+     * Encode number of destination operands.
+     */
+    uint num_dsts = (uint)instr_num_dsts(instr);
+    encoding |= (num_dsts << shift);
+
+    /*
+     * TODO: Encode registers.
+     */
+
+    /*
+     * Copy result to output encoded_instr.
+     */
+    memcpy(encoded_instr, &encoding, sizeof(uint));
+
+    return;
+}

core/ir/synthetic/encode.h

@@ -0,0 +1,9 @@
+#ifndef _SYNTHETIC_ENCODE_H_
+#define _SYNTHETIC_ENCODE_H_ 1
+
+#include "../globals.h"
+
+void
+encode_to_synth(dcontext_t *dcontext, instr_t *instr, byte *encoded_instr);
+
+#endif /* _SYNTHETIC_ENCODE_H_ */

core/ir/x86/decode.c

@@ -38,6 +38,7 @@
 /* decode.c -- a full x86 decoder */
 
 #include "../globals.h"
+#include "../synthetic/decode.h"
 #include "arch.h"
 #include "instr.h"
 #include "decode.h"
@@ -2579,6 +2580,16 @@ check_is_variable_size(opnd_t op)
 static byte *
 decode_common(dcontext_t *dcontext, byte *pc, byte *orig_pc, instr_t *instr)
 {
+    /*
+     * If we're dealing with decoding from synthetic ISA, we don't care about returning
+     * the pc of the next instruction (?), so we just write the encoding in final_pc and
+     * return it.
+     */
+    if (instr_get_isa_mode(instr) == DR_ISA_SYNTH) {
+        decode_from_synth(dcontext, orig_pc, instr);
+        return orig_pc;
+    }
+
     const instr_info_t *info;
     decode_info_t di;
     byte *next_pc;

core/ir/x86/encode.c

@@ -37,6 +37,7 @@
 /* encode.c -- an x86 encoder */
 
 #include "../globals.h"
+#include "../synthetic/encode.h"
 #include "arch.h"
 #include "instr.h"
 #include "decode.h"
@@ -2759,6 +2760,16 @@ instr_encode_arch(dcontext_t *dcontext, instr_t *instr, byte *copy_pc, byte *fin
                   bool *has_instr_opnds /*OUT OPTIONAL*/
                       _IF_DEBUG(bool assert_reachable))
 {
+    /*
+     * If we're dealing with encoding to synthetic ISA, we don't care about returning
+     * the pc of the next instruction (?), so we just write the encoding in final_pc and
+     * return it.
+     */
+    if (instr_get_isa_mode(instr) == DR_ISA_SYNTH) {
+        encode_to_synth(dcontext, instr, final_pc);
+        return final_pc;
+    }
+
     const instr_info_t *info;
     decode_info_t di;
 

core/ir/x86/instr.c

@@ -40,6 +40,7 @@
 #include "instr.h"
 #include "decode.h"
 #include "decode_private.h"
+#include "encode_api.h"
 #include "instr_create_shared.h"
 
 #ifdef X64
@@ -70,6 +71,10 @@ instr_get_x86_mode(instr_t *instr)
 bool
 instr_set_isa_mode(instr_t *instr, dr_isa_mode_t mode)
 {
+    if (mode == DR_ISA_SYNTH) {
+        instr->flags |= INSTR_SYNTH_MODE;
+        return true;
+    }
 #ifdef X64
     if (mode == DR_ISA_IA32)
         instr_set_x86_mode(instr, true);
@@ -87,6 +92,9 @@ instr_set_isa_mode(instr_t *instr, dr_isa_mode_t mode)
 dr_isa_mode_t
 instr_get_isa_mode(instr_t *instr)
 {
+    if (TEST(INSTR_SYNTH_MODE, instr->flags)) {
+        return DR_ISA_SYNTH;
+    }
 #ifdef X64
     return TEST(INSTR_X86_MODE, instr->flags) ? DR_ISA_IA32 : DR_ISA_AMD64;
 #else

suite/tests/api/ir_x86.c

@@ -787,6 +787,46 @@ test_instr_encode_and_decode(void *dc, instr_t *instr, uint len_expect,
     instr_destroy(dc, decin);
 }
 
+bool
+instr_same_synthetic(instr_t *inst1, instr_t *inst2)
+{
+    if (instr_num_srcs(inst1) != instr_num_srcs(inst2))
+        return false;
+
+    if (instr_num_dsts(inst1) != instr_num_dsts(inst2))
+        return false;
+
+    if (instr_get_isa_mode(inst1) != instr_get_isa_mode(inst2))
+        return false;
+
+    return true;
+}
+
+static void
+test_instr_encode_decode_synthetic(void *dc, instr_t *instr, byte *bytes)
+{
+    instr_t *instr_copy;
+    instr_set_isa_mode(instr, DR_ISA_SYNTH);
+    instr_encode(dc, instr, bytes);
+    instr_copy = instr_create(dc);
+    instr_set_isa_mode(instr_copy, DR_ISA_SYNTH);
+    decode(dc, bytes, instr_copy);
+    ASSERT(instr_same_synthetic(instr, instr_copy));
+    instr_destroy(dc, instr);
+    instr_destroy(dc, instr_copy);
+}
+
+static void
+test_instr_create_encode_decode_synthetic(void *dc)
+{
+    instr_t *instr;
+    opnd_t abs_addr = opnd_create_abs_addr((void *)0xdeadbeefdeadbeef, OPSZ_8);
+
+    instr = INSTR_CREATE_mov_ld(dc, opnd_create_reg(DR_REG_RAX), abs_addr);
+    byte bytes[8];
+    test_instr_encode_decode_synthetic(dc, instr, bytes);
+}
+
 static void
 test_indirect_cti(void *dc)
 {
@@ -2879,6 +2919,8 @@ main(int argc, char *argv[])
     dr_mutex_destroy(x);
 #endif
 
+    test_instr_create_encode_decode_synthetic(dcontext);
+
     test_all_opcodes_0(dcontext);
 #ifndef STANDALONE_DECODER /* speed up compilation */
     test_all_opcodes_1(dcontext);