int
fn_disassemble_xed(xed_syntax_enum_t syntax,
                   char* buf,
                   int buflen,
                   xed_decoded_inst_t* xedd,
                   xed_uint64_t runtime_instruction_address,
                   void* caller_data)
{

    /* the caller_data is for symbolic disam */

    char buffer[XED_TMP_BUF_LEN];
    int blen = buflen;
    int ok = xed_format_context(syntax, xedd,
                                buffer, XED_TMP_BUF_LEN,
                                runtime_instruction_address, caller_data);
    if(ok)
        blen = xed_strncpy(buf, buffer, buflen);
    else
    {
        blen = buflen;
        blen = xed_strncpy(buf, "Error disassembling ", blen);
        blen = xed_strncat(buf, xed_syntax_enum_t2str(syntax), blen);
        blen = xed_strncat(buf, " syntax.", blen);
    }
    return blen;
}
void xed_dot_graph_add_instruction(
    xed_dot_graph_supp_t* gg,
    xed_decoded_inst_t* xedd,
    xed_uint64_t runtime_instr_addr,
    void* caller_data)
{
    /*
      make a new node
      
      for each operand:
        if read:
          make edge from src node for that reg to the new node
      for each operand:
        if write:
          install this node as the writer

      what about partial writes?
      what about register nesting?
     */
    char disasm_str[XED_DOT_TMP_BUF_LEN];
    char* p = 0;
    size_t alen = 0;
    int ok;
    xed_dot_node_t* n = 0;
    xed_uint32_t remaining_buffer_bytes = XED_DOT_TMP_BUF_LEN;
    
    // put addr on separate line in node label
#if defined(XED_WINDOWS)
    ok = sprintf_s(disasm_str,
                   XED_DOT_TMP_BUF_LEN,
                   XED_FMT_LX "\\n",
                   runtime_instr_addr);
#else
    ok = sprintf(disasm_str,
                 XED_FMT_LX "\\n",
                 runtime_instr_addr);

#endif
    assert(ok > 0);
    alen = strlen(disasm_str);
    p = disasm_str + alen;
    remaining_buffer_bytes -= XED_CAST(xed_uint32_t, alen);

    ok = xed_format_context(gg->syntax,
                            xedd, 
                            p,
                            remaining_buffer_bytes,
                            runtime_instr_addr,
                            caller_data);
    if (!ok) {
        (void)xed_strncpy(disasm_str,"???", XED_DOT_TMP_BUF_LEN);
    }
    
    n = xed_dot_node(gg->g, disasm_str);
    add_read_operands(gg,xedd,n);
    add_write_operands(gg,xedd,n);    
}
Esempio n. 3
0
static char* append3(const char* s1, const char* s2, const char* s3) {
    xed_uint_t  n = 1;
    char* p = 0;
    if (s1)    n += xed_strlen(s1);
    if (s2)    n += xed_strlen(s2);
    if (s3)    n += xed_strlen(s3);
    p = (char*) malloc(sizeof(char)*n);
    if (s1) n=xed_strncpy(p,s1,n);
    if (s2) n=xed_strncat(p,s2,n);
    if (s3) n=xed_strncat(p,s3,n);
    return p;
}
Esempio n. 4
0
bool dbg_help_client_t::get_symbol(DWORD64 address, char* symbol_name, 
                                   int sym_name_buflen, DWORD64* offset) 
{
    DWORD64  displacement;
    ULONG64 n = (sizeof(SYMBOL_INFO) +
                 sym_name_buflen*sizeof(TCHAR) +
                 sizeof(ULONG64) - 1) / sizeof(ULONG64);
    ULONG64* buffer = new ULONG64[n];
    PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;
            
    pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
    pSymbol->MaxNameLen = sym_name_buflen;
    
    if (SymFromAddr(hProcess, address, &displacement, pSymbol))    {
        if (offset)
            *offset = displacement;
        if (offset  || displacement == 0) {
            //printf("Name is [%s]\n", pSymbol->Name);
            xed_strncpy(symbol_name, pSymbol->Name, sym_name_buflen);
            // force a null. WINDOWS doesn't have strlcpy()
            symbol_name[sym_name_buflen-1] = 0; 
            delete [] buffer;
            return 0;
        }
        else {
            /* not at the beginning of a symbol and no offset was supplied */
            /* printf("Ignoring. Not at the beginning of a symbol [%s]\n",
             * pSymbol->Name); */
            delete [] buffer;
            return 1;
        }
    }
    else    {
        error = GetLastError();
        printf("SymFromAddr returned error : %d 0x%x for address %llx\n", 
               error, error, address);
        delete [] buffer;
        return 1;
    }
}
xed_uint_t disas_decode_encode_binary(const xed_state_t* dstate,
                                      const xed_uint8_t* decode_text_binary,
                                      const unsigned int bytes,
                                      xed_decoded_inst_t* xedd,
                                      xed_uint64_t runtime_address)
{
    // decode then encode
    unsigned int retval_olen = 0;
    // decode it...
    xed_bool_t decode_okay =  disas_decode_binary(dstate, decode_text_binary,
                              bytes, xedd,
                              runtime_address);
    if(decode_okay)
    {
        xed_error_enum_t encode_okay;
        xed_uint64_t t1, t2;
        unsigned int enc_olen, ilen = XED_MAX_INSTRUCTION_BYTES;
        xed_uint8_t array[XED_MAX_INSTRUCTION_BYTES];
        // they are basically the same now
        xed_encoder_request_t* enc_req = xedd;
        // convert decode structure to proper encode structure
        xed_encoder_request_init_from_decode(xedd);

        // encode it again...
        t1 = xed_get_time();
        encode_okay =  xed_encode(enc_req, array, ilen, &enc_olen);
        t2 = xed_get_time();
        if(encode_okay != XED_ERROR_NONE)
        {
            if(CLIENT_VERBOSE)
            {
                char buf[XED_TMP_BUF_LEN];
                char buf2[XED_TMP_BUF_LEN];
                int blen = XED_TMP_BUF_LEN;
                xed_encode_request_print(enc_req, buf, XED_TMP_BUF_LEN);
                blen = xed_strncpy(buf2, "Could not re-encode: ", blen);
                blen = xed_strncat(buf2, buf, blen);
                blen = xed_strncat(buf2, "\nError code was: ", blen);
                blen = xed_strncat(buf2,
                                   xed_error_enum_t2str(encode_okay), blen);
                blen = xed_strncat(buf2, "\n", blen);
                xedex_dwarn(buf2);
            }
        }
        else
        {
            retval_olen = enc_olen;
            // See if it matched the original...
            if(CLIENT_VERBOSE)
            {
                char buf[XED_HEX_BUFLEN];
                xed_uint_t dec_length;
                xed_print_hex_line(buf, array, enc_olen, XED_HEX_BUFLEN);
                printf("Encodable! %s\n", buf);
                xed_decode_stats_reset(&xed_enc_stats, t1, t2);
                dec_length = xed_decoded_inst_get_length(xedd);
                if((enc_olen != dec_length ||
                        memcmp(decode_text_binary, array, enc_olen)))
                {
                    char buf2[XED_TMP_BUF_LEN];
                    char buf3[XED_TMP_BUF_LEN];
                    printf("Discrepenacy after re-encoding. dec_len= "
                           XED_FMT_U " ", dec_length);
                    xed_print_hex_line(buf, decode_text_binary,
                                       dec_length, XED_HEX_BUFLEN);
                    printf("[%s] ", buf);
                    printf("enc_olen= " XED_FMT_U "", enc_olen);
                    xed_print_hex_line(buf, array, enc_olen, XED_HEX_BUFLEN);
                    printf(" [%s] ", buf);
                    printf("for instruction: ");
                    xed_decoded_inst_dump(xedd, buf3, XED_TMP_BUF_LEN);
                    printf("%s\n", buf3);
                    printf("vs Encode  request: ");
                    xed_encode_request_print(enc_req, buf2, XED_TMP_BUF_LEN);
                    printf("%s\n", buf2);
                }
                else
                    printf("Identical re-encoding\n");
            }
        }
    }
    return retval_olen;
}