X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?p=palacios.git;a=blobdiff_plain;f=misc%2Fdecoder_test%2FXED2%2Fexamples%2Fxed-examples-util.c;fp=misc%2Fdecoder_test%2FXED2%2Fexamples%2Fxed-examples-util.c;h=0000000000000000000000000000000000000000;hp=a5a4be40da6f5c5f331331804720f7e34075b32a;hb=7a6cd49101201e207daf7113a9048193835cebaf;hpb=320320a1c8681f2d8258a03dd087b3aed18b48a1

diff --git a/misc/decoder_test/XED2/examples/xed-examples-util.c b/misc/decoder_test/XED2/examples/xed-examples-util.c
deleted file mode 100644
index a5a4be4..0000000
--- a/misc/decoder_test/XED2/examples/xed-examples-util.c
+++ /dev/null
@@ -1,960 +0,0 @@
-/*BEGIN_LEGAL 
-Intel Open Source License 
-
-Copyright (c) 2002-2007 Intel Corporation 
-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
-the Intel Corporation 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 THE INTEL OR
-ITS 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.
-END_LEGAL */
-/// @file xed-examples-util.cpp
-/// @author Mark Charney   <mark.charney@intel.com>
-
-#include "xed-interface.h"
-#include "xed-examples-util.h"
-#include <string.h> //strlen, memcmp, memset
-#if defined(__APPLE__) || defined(__linux__) || defined(__linux)
-# include <unistd.h>
-# include <sys/mman.h>
-# include <sys/types.h>
-# include <sys/stat.h>
-# include <fcntl.h>
-#endif
-#include <ctype.h>
-#include <stdlib.h>
-#include "xed-portability.h"
-#include "xed-util.h"
-
-
-void xed_decode_file_info_init(xed_decode_file_info_t* p,
-                               const xed_state_t* arg_dstate,
-                               int arg_ninst,
-                               int arg_decode_only) {
-    p->dstate = *arg_dstate;
-    p->ninst = arg_ninst;
-    p->decode_only = arg_decode_only;
-}
-
-typedef struct {
-    xed_uint64_t  total_time ;
-    xed_uint64_t  total_insts ;
-    xed_uint64_t  total_ilen ;
-    xed_uint64_t  total_olen ;
-    xed_uint64_t  total_shorter ;
-    xed_uint64_t  total_longer ;
-    xed_uint64_t  bad_times ;
-    xed_uint64_t  reset_counter;
-} xed_decode_stats_t;
-
-void xed_decode_stats_reset(xed_decode_stats_t* p, xed_uint64_t t1, xed_uint64_t t2) {
-    if (t2 > t1) 
-        p->total_time += (t2-t1);
-    else
-        p->bad_times++;
-    p->total_insts++;
-    p->reset_counter++;
-    if (p->reset_counter == 50) {
-        if (CLIENT_VERBOSE1) 
-            printf("\n\nRESETTING STATS\n\n");
-        // to ignore startup transients paging everything in.
-        p->total_insts=0;
-        p->total_time=0;
-    }
-}
-
-void xed_decode_stats_zero(xed_decode_stats_t* p)    {
-    p->total_time = 0;
-    p->total_insts = 0;
-    p->total_ilen = 0;
-    p->total_olen = 0;
-    p->total_shorter = 0;
-    p->total_longer = 0;
-    p->bad_times = 0;
-    p->reset_counter = 0;
-}
-
-static xed_decode_stats_t xed_stats;
-int xed_syntax = 0;
-int intel_syntax = 1;
-int att_syntax = 0;
-int client_verbose=0; 
-
-////////////////////////////////////////////////////////////////////////////
-
-static char xed_toupper(char c) {
-    if (c >= 'a' && c <= 'z')
-        return c-'a'+'A';
-    return c;
-}
-
-char* xed_upcase_buf(char* s) {
-    xed_uint_t len = STATIC_CAST(xed_uint_t,strlen(s));
-    xed_uint_t i;
-    for(i=0 ; i < len ; i++ ) 
-        s[i] = STATIC_CAST(char,xed_toupper(s[i]));
-    return s;
-}
-
-static xed_uint8_t convert_nibble(xed_uint8_t x) {
-    // convert ascii nibble to hex
-    xed_uint8_t rv = 0;
-    if (x >= '0' && x <= '9') 
-        rv = x - '0';
-    else if (x >= 'A' && x <= 'F') 
-        rv = x - 'A' + 10;
-    else if (x >= 'a' && x <= 'f') 
-        rv = x - 'a' + 10;
-    else    {
-        printf("Error converting hex digit. Nibble value 0x%x\n", x);
-        exit(1);
-    }
-    return rv;
-}
-
-
-xed_int64_t xed_atoi_hex(char* buf) {
-    xed_int64_t o=0;
-    xed_uint_t i;
-    xed_uint_t len = STATIC_CAST(xed_uint_t,strlen(buf));
-    for(i=0; i<len ; i++) 
-        o = o*16 + convert_nibble(buf[i]);
-    return o;
-}
-
-xed_int64_t xed_atoi_general(char* buf, int mul) {
-    /*      mul should be 1000 or 1024     */
-    char* q;
-    xed_int64_t b;
-
-    char* p = buf;
-    while(*p && isspace(*p))
-    {
-        p++;
-    }
-    // exclude hex; octal works just fine
-    q = p;
-    if (*q == '-' || *q == '+')
-    {
-        q++;
-    }
-    if (*q=='0' && (q[1]=='x' || q[1]=='X'))
-    {
-        return xed_strtoll(buf,0);
-    }
-
-    b = xed_strtoll(buf,0);
-    if (p)
-    {
-        while(*p && (*p == '-' || *p == '+'))
-        {
-            p++;
-        }
-        while(*p && isdigit(*p))
-        {
-            p++;
-        }
-
-        if (*p != 0)
-        {
-            if (*p == 'k' || *p == 'K')
-            {
-                b = b * mul;
-            }
-            else if (*p == 'm' || *p == 'M')
-            {
-                b = b * mul * mul;
-            }
-            else if (*p == 'g' || *p == 'G' || *p == 'b' || *p == 'B')
-            {
-                b = b * mul * mul * mul;
-            }
-        }
-    }
-    return b;
-}
-
-static char nibble_to_ascii_hex(xed_uint8_t i) {
-    if (i<10) return i+'0';
-    if (i<16) return i-10+'A';
-    return '?';
-}
-void xed_print_hex_line(char* buf, const xed_uint8_t* array, const int length) {
-  int n = length;
-  int i=0;
-  if (length == 0)
-      n = XED_MAX_INSTRUCTION_BYTES;
-  for( i=0 ; i< n; i++)     {
-      buf[2*i+0] = nibble_to_ascii_hex(array[i]>>4);
-      buf[2*i+1] = nibble_to_ascii_hex(array[i]&0xF);
-  }
-  buf[2*i]=0;
-}
-
-void xed_print_hex_lines(char* buf, const xed_uint8_t* array, const int length) {
-  int n = length;
-  int i=0,j=0;
-  char* b = buf;
-  for( i=0 ; i< n; i++)     {
-      *b++ = nibble_to_ascii_hex(array[i]>>4);
-      *b++ = nibble_to_ascii_hex(array[i]&0xF);
-      j++;
-      if (j == 16) {
-	j = 0;
-        *b++ = '\n';
-      }
-  }
-  *b++ = '\n';
-  *b = '0';
-}
-
-
-
-
-void xedex_derror(const char* s) {
-    printf("[XED CLIENT ERROR] %s\n",s);
-    exit(1);
-}
-
-void xedex_dwarn(const char* s) {
-    printf("[XED CLIENT WARNING] %s\n",s);
-}
-
-
-////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////
-
-
-
-
-void xed_print_decode_stats()
-{
-    double cpi;
-    xed_int64_t growth;
-    printf("#Total decode cycles:        " XED_FMT_LU "\n", xed_stats.total_time);
-    printf("#Total instructions decoded: " XED_FMT_LU "\n", xed_stats.total_insts);
-#if defined(_MSC_VER) 
-#  if  _MSC_VER==1200
-#    define XCAST(x) STATIC_CAST(xed_int64_t,x)
-#  else 
-#    define XCAST(x) (x)
-#  endif
-#else
-# define XCAST(x) (x)
-#endif
-    cpi  =  1.0 * XCAST(xed_stats.total_time) / XCAST(xed_stats.total_insts);
-    printf("#Total cycles/instructions decoded: %f\n" , cpi);
-
-    printf("#Bad times: " XED_FMT_LU "\n", xed_stats.bad_times);
-    printf("#Total input length bytes: " XED_FMT_LU "\n", xed_stats.total_ilen );
-    printf("#Total output length bytes: " XED_FMT_LU "\n", xed_stats.total_olen );
-    printf("#Growth bytes: " XED_FMT_LU "\n", xed_stats.total_longer );
-    printf("#Shrinkage bytes: " XED_FMT_LU "\n", xed_stats.total_shorter );
-    growth = xed_stats.total_olen - xed_stats.total_ilen;
-    printf("#Growth/Shrinkage  bytes: " XED_FMT_LD "\n", growth );
-    if (xed_stats.total_ilen)    {
-        double pct_growth = 100.0 * growth / (double) XCAST(xed_stats.total_ilen);
-        printf("#Code size growth percent: %f\n", pct_growth);
-    }
-}
-
-
-void
-xed_map_region(const char* path,
-               void** start,
-               unsigned int* length)
-{
-#if defined(_WIN32) 
-    FILE* f;
-    size_t t,ilen;
-    xed_uint8_t* p;
-#if defined(XED_MSVC8)
-    errno_t err;
-    fprintf(stderr,"#Opening %s\n", path);
-    err = fopen_s(&f,path,"rb");
-#else
-    int err=0;
-    fprintf(stderr,"#Opening %s\n", path);
-    f = fopen(path,"rb");
-    err = (f==0);
-#endif
-    if (err != 0) {
-        fprintf(stderr,"ERROR: Could not open %s\n", path);
-        exit(1);
-    }
-    err =  fseek(f, 0, SEEK_END);
-    if (err != 0) {
-        fprintf(stderr,"ERROR: Could not fseek %s\n", path);
-        exit(1);
-    }
-    ilen = ftell(f);
-    fprintf(stderr,"#Trying to read " XED_FMT_SIZET "\n", ilen);
-    p = (xed_uint8_t*)malloc(ilen);
-    t=0;
-    err = fseek(f,0, SEEK_SET);
-    if (err != 0) {
-        fprintf(stderr,"ERROR: Could not fseek to start of file %s\n", path);
-        exit(1);
-    }
-    
-    while(t < ilen) {
-        size_t n;
-        if (feof(f)) {
-            fprintf(stderr, "#Read EOF. Stopping.\n");
-            break;
-        }
-        n = fread(p+t, 1, ilen-t,f);
-        t = t+n;
-        fprintf(stderr,"#Read " XED_FMT_SIZET " of %d bytes\n", t, ilen);
-        if (ferror(f)) {
-            fprintf(stderr, "Error in file read. Stopping.\n");
-            break;
-        }
-    }
-    fclose(f);
-    *start = p;
-    *length = (unsigned int)ilen;
-    
-#else 
-    int ilen,fd;
-    fd = open(path, O_RDONLY);
-    if (fd == -1)   {
-        printf("Could not open file: %s\n" , path);
-        exit(1);
-    }
-    ilen = lseek(fd, 0, SEEK_END); // find the size.
-    if (ilen == -1)
-        xedex_derror("lseek failed");
-    else 
-        *length = (unsigned int) ilen;
-
-    lseek(fd, 0, SEEK_SET); // go to the beginning
-    *start = mmap(0,
-                  *length,
-                  PROT_READ|PROT_WRITE,
-                  MAP_PRIVATE,
-                  fd,
-                  0);
-    if (*start == (void*) -1)
-        xedex_derror("could not map region");
-#endif
-    if (CLIENT_VERBOSE1)
-        printf("Mapped " XED_FMT_U " bytes!\n", *length);
-}
-
-
-////////////////////////////////////////////////////////////////////////////
-
-static int all_zeros(xed_uint8_t* p, unsigned int len) {
-    unsigned int i;
-    for( i=0;i<len;i++) 
-        if (p[i]) 
-            return 0;
-    return 1;
-}
-
-int
-fn_disassemble_xed(xed_syntax_enum_t syntax,
-                   char* buf,
-                   int buflen,
-                   xed_decoded_inst_t* xedd, 
-                   xed_uint64_t runtime_instruction_address) {   
-#define BUFLEN 1000
-    char buffer[BUFLEN];
-    int blen= buflen;
-    //memset(buffer,0,BUFLEN);
-    int ok = xed_format(syntax, xedd, buffer, BUFLEN,runtime_instruction_address);
-#undef BUFLEN
-    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 disassemble(char* buf,
-                 int buflen,
-                 xed_decoded_inst_t* xedd,
-                 xed_uint64_t runtime_instruction_address)
-{
-    int blen = buflen;
-    if (xed_syntax)    {
-        blen = fn_disassemble_xed(XED_SYNTAX_XED, buf, blen, xedd, runtime_instruction_address);
-        if (att_syntax || intel_syntax)
-            blen = xed_strncat(buf, " | ",blen);
-    }
-    if (att_syntax)    {
-        char* xbuf = buf+strlen(buf);
-        blen = fn_disassemble_xed(XED_SYNTAX_ATT, xbuf, blen, xedd, runtime_instruction_address);
-        if (intel_syntax)
-            blen = xed_strncat(buf, " | ",blen);
-    }
-    if (intel_syntax) {
-        char* ybuf = buf+strlen(buf);
-        blen = fn_disassemble_xed(XED_SYNTAX_INTEL, ybuf, blen, xedd, runtime_instruction_address);
-    }
-}
-
-void xed_decode_error(xed_uint64_t offset, const xed_uint8_t* ptr, xed_error_enum_t xed_error) {
-    char buf[200];
-    printf("ERROR: %s Could not decode at offset 0x" XED_FMT_LX ": [", 
-           xed_error_enum_t2str(xed_error),
-           offset);
-    xed_print_hex_line(buf, ptr, 15);
-    printf("%s]\n",buf);
-}
-
-///////////////////////////////////////////////////////////////////////////
-// 2007-07-02
-
-static void print_hex_line(const xed_uint8_t* p, unsigned int length) {
-        char buf[128];
-        unsigned int lim = 128;
-        if (length < lim)
-            lim = length;
-        xed_print_hex_line(buf,p, lim); 
-        printf("%s\n", buf);
-}
-
-xed_uint_t disas_decode_binary(const xed_state_t* dstate,
-                           const xed_uint8_t* hex_decode_text,
-                           const unsigned int bytes,
-                           xed_decoded_inst_t* xedd) {
-    xed_uint64_t t1,t2;
-    xed_error_enum_t xed_error;
-    xed_bool_t okay;
-
-    if (CLIENT_VERBOSE) {
-        print_hex_line(hex_decode_text, bytes);
-    }
-    t1 = get_time();
-    xed_error = xed_decode(xedd, hex_decode_text, bytes);
-    t2 = get_time();
-    okay = (xed_error == XED_ERROR_NONE);
-    if (CLIENT_VERBOSE3) {
-        xed_uint64_t delta = t2-t1;
-        printf("Decode time = " XED_FMT_LU "\n", delta);
-    }
-    if (okay)     {
-#define TBUF_LEN (1024*3)
-        if (CLIENT_VERBOSE1) {
-            char tbuf[TBUF_LEN];
-            xed_decoded_inst_dump(xedd,tbuf,TBUF_LEN);
-            printf("%s\n",tbuf);
-        }
-        if (CLIENT_VERBOSE) {
-            char buf[TBUF_LEN];
-            if (xed_decoded_inst_valid(xedd)) {
-                printf( "ICLASS: %s   CATEGORY: %s   EXTENSION: %s\n", 
-                        xed_iclass_enum_t2str(xed_decoded_inst_get_iclass(xedd)),
-                        xed_category_enum_t2str(xed_decoded_inst_get_category(xedd)),
-                        xed_extension_enum_t2str(xed_decoded_inst_get_extension(xedd)));
-            }
-            memset(buf,0,TBUF_LEN);
-            disassemble(buf,TBUF_LEN, xedd,0);
-            printf("SHORT: %s\n", buf);
-        }
-        return 1;
-    }
-    else {
-        xed_decode_error(0, hex_decode_text, xed_error);
-        return 0;
-    }
-    (void) dstate; // pacify compiler
-}
-
-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)   {
-    // decode then encode
-    unsigned int retval_olen = 0;
-    // decode it...
-    xed_bool_t decode_okay =  disas_decode_binary(dstate, decode_text_binary, bytes, xedd);
-    if (decode_okay)     {
-        xed_error_enum_t encode_okay;
-        unsigned int enc_olen, ilen = XED_MAX_INSTRUCTION_BYTES;
-        xed_uint8_t array[XED_MAX_INSTRUCTION_BYTES];
-        xed_encoder_request_t* enc_req = xedd;  // they are basically the same now
-        // convert decode structure to proper encode structure
-        xed_encoder_request_init_from_decode(xedd);
-        
-        // encode it again...
-        encode_okay =  xed_encode(enc_req, array, ilen, &enc_olen);
-        if (encode_okay != XED_ERROR_NONE) {
-            if (CLIENT_VERBOSE) {
-                char buf[5000];
-                char buf2[5000];
-                int blen=5000;
-                xed_encode_request_print(enc_req, buf, 5000);
-                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[100];
-                xed_uint_t dec_length; 
-                xed_print_hex_line(buf,array, enc_olen);
-                printf("Encodable! %s\n",buf);
-                dec_length = xed_decoded_inst_get_length(xedd);
-                if ((enc_olen != dec_length || memcmp(decode_text_binary, array, enc_olen)  )) {
-                    char buf2[5000];
-                    char buf3[5000];
-                    printf("Discrepenacy after re-encoding. dec_len= " XED_FMT_U " ", dec_length);
-                    xed_print_hex_line(buf, decode_text_binary, dec_length);
-                    printf("[%s] ", buf);
-                    printf("enc_olen= " XED_FMT_U "", enc_olen);
-                    xed_print_hex_line(buf, array, enc_olen);
-                    printf(" [%s] ", buf);
-                    printf("for instruction: ");
-                    xed_decoded_inst_dump(xedd, buf3,5000);
-                    printf("%s\n", buf3);
-                    printf("vs Encode  request: ");
-                    xed_encode_request_print(enc_req, buf2, 5000);
-                    printf("%s\n", buf2);
-                }
-                else 
-                    printf("Identical re-encoding\n");
-            }
-        }
-    }
-    return retval_olen;
-}
-
-
-
-///////////////////////////////////////////////////////////////////////////
-
-void
-xed_disas_test(const xed_state_t* dstate,
-               unsigned char* s, // start of image
-               unsigned char* a, // start of instructions to decode region
-               unsigned char* q, // end of region
-               int ninst,
-               xed_uint64_t runtime_vaddr, // where this region would live at runtime
-               int decode_only,
-               char* (*symfn)(xed_uint64_t)) // a function to convert addresses to symbols
-{
-    static int first = 1;
-    xed_uint64_t errors = 0;
-    unsigned int m;
-    unsigned char* z;
-    unsigned int len;
-    
-    int skipping;
-    int last_all_zeros;
-    unsigned int i;
-
-    int okay;
-    xed_decoded_inst_t xedd;
-    unsigned int length;
-
-    xed_uint64_t runtime_instruction_address;
-
-    if (first) {
-        xed_decode_stats_zero(&xed_stats);
-        first = 0;
-    }
-
-    // print some stuff in hex from the text segment.
-    // unsigned char* p = a;
-    //xed_uint64_t tlen = q-p;
-    //if (tlen > 1024 ) 
-    //    tlen = 1024;
-    //xed_print_hex_line(p,tlen);
-  
-    m = ninst; // number of things to decode
-    z = a;
-    len = 15; //FIXME
-  
-    // for skipping long strings of zeros
-    skipping = 0;
-    last_all_zeros = 0;
-    for( i=0; i<m;i++) 
-    {
-        if (z >= q) {
-            printf("# end of text section.\n");
-            break;
-        }
-        if (CLIENT_VERBOSE3) {
-            printf("\n==============================================\n");
-            printf("Decoding instruction " XED_FMT_U "\n", i);
-            printf("==============================================\n");
-        }
-    
-        // if we get two full things of 0's in a row, start skipping.
-        if (all_zeros((xed_uint8_t*) z, 15)) 
-        {
-            if (skipping) {
-                z = z + 15;
-                continue;
-            }
-            else if (last_all_zeros) { 
-                printf("...\n");
-                z = z + 15;
-                skipping = 1;
-                continue;
-            }
-            else
-                last_all_zeros = 1;
-        }
-        else
-        {
-            skipping = 0;
-            last_all_zeros = 0;
-        }
-
-        runtime_instruction_address =  ((xed_uint64_t)(z-a)) + runtime_vaddr;
-         
-        if (CLIENT_VERBOSE3) {
-            char tbuf[200];
-            printf("Runtime Address " XED_FMT_LX ,runtime_instruction_address);
-            xed_print_hex_line(tbuf, (xed_uint8_t*) z, 15);
-            printf(" [%s]\n", tbuf);
-        }
-        okay = 0;
-        xed_decoded_inst_zero_set_mode(&xedd, dstate);
-        length = 0;
-        if ( decode_only )
-        {
-            xed_uint64_t t1 = get_time();
-            xed_uint64_t t2;
-            
-            xed_error_enum_t xed_error = xed_decode(&xedd, 
-                                                    REINTERPRET_CAST(const xed_uint8_t*,z),
-                                                    len);
-            t2 = get_time();
-            okay = (xed_error == XED_ERROR_NONE);
-            xed_decode_stats_reset(&xed_stats, t1, t2);
-           
-            length = xed_decoded_inst_get_length(&xedd);
-            if (okay && length == 0) {
-                printf("Zero length on decoded instruction!\n");
-                xed_decode_error( z-a, z, xed_error);
-                xedex_derror("Dieing");
-            }
-            xed_stats.total_ilen += length;
-
-            if (okay)  {
-                if (CLIENT_VERBOSE1) {
-                    char tbuf[1024*3];
-                    xed_decoded_inst_dump(&xedd,tbuf, 1024*3);
-                    printf("%s\n",tbuf);
-                }
-                if (CLIENT_VERBOSE)  {
-                    char buffer[200];
-                    unsigned int dec_len;
-                    unsigned int sp;
-                    if (symfn) {
-                        char* name = (*symfn)(runtime_instruction_address);
-                        if (name) 
-                            printf("\nSYM %s:\n", name);
-                    }
-                    printf("XDIS " XED_FMT_LX ": ", runtime_instruction_address);
-                    printf("%-8s ", xed_category_enum_t2str(xed_decoded_inst_get_category(&xedd)));
-                    printf("%-4s ", xed_extension_enum_t2str(xed_decoded_inst_get_extension(&xedd)));
-		    dec_len = xed_decoded_inst_get_length(&xedd);
-                    xed_print_hex_line(buffer, (xed_uint8_t*) z, dec_len);
-                    printf("%s",buffer);
-                    // pad out the instruction bytes
-                    for ( sp=dec_len; sp < 12; sp++) {
-                        printf("  ");
-                    }
-                    printf(" ");
-		    memset(buffer,0,200);
-                    disassemble(buffer,200, &xedd, runtime_instruction_address);
-                    printf( "%s\n",buffer);
-                }
-            }
-            else {
-                errors++;
-                xed_decode_error( z-a, z, xed_error);
-                // just give a length of 1B to see if we can restart decode...
-                length = 1;
-            }
-        }
-        else
-        {
-            xed_uint64_t t1 = get_time();
-            xed_uint64_t t2;
-            unsigned int olen  = 0;
-            olen  = disas_decode_encode_binary(dstate, 
-                                                REINTERPRET_CAST(const xed_uint8_t*,z),
-                                                len,
-                                                &xedd);
-            t2=get_time();
-            okay = (olen != 0);
-            xed_decode_stats_reset(&xed_stats, t1, t2);
-            if (!okay)  {
-                errors++;
-                printf("-- Could not decode/encode at offset: %d\n" ,(int)(z-a));
-                // just give a length of 1B to see if we can restart decode...
-                length = 1;
-                //exit(1);
-            }        
-            else {
-                length = xed_decoded_inst_get_length(&xedd);
-                xed_stats.total_ilen += length;
-                xed_stats.total_olen += olen;
-                if (length > olen)
-                    xed_stats.total_shorter += (length - olen);
-                else
-                    xed_stats.total_longer += (olen - length);
-            }
-
-        }
-
-        z = z + length;
-    }
-    
-    printf( "# Errors: " XED_FMT_LU "\n", errors);
-    (void) s;
-}
-       
-#if defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 810  && !defined(_M_IA64)
-#  include <ia32intrin.h>
-#   if __INTEL_COMPILER < 1000
-#     pragma intrinsic(__rdtsc)
-#   endif
-#endif
-#if defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(_M_IA64) /* MSVS8 and later */
-#  include <intrin.h>
-#  pragma intrinsic(__rdtsc)
-#endif
-
-xed_uint64_t  get_time()
-{
-   xed_uint64_t ticks;
-   xed_uint32_t lo,hi;
-#if defined(__GNUC__)
-# if defined(__i386__) || defined(i386) || defined(i686) || defined(__x86_64__)
-   //asm volatile("rdtsc" : "=A" (ticks) );
-   //asm volatile("rdtsc" : "=A" (ticks) :: "edx");
-   asm volatile("rdtsc" : "=a" (lo), "=d" (hi));
-   ticks = hi;
-   ticks <<=32;
-   ticks |=lo;
-#  define FOUND_RDTSC
-# endif
-#endif
-#if defined(__INTEL_COMPILER) &&  __INTEL_COMPILER>=810 && !defined(_M_IA64)
-   ticks = __rdtsc();
-#  define FOUND_RDTSC
-#endif
-#if !defined(FOUND_RDTSC) && defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(_M_IA64) /* MSVS7, 8 */
-   ticks = __rdtsc();
-#  define FOUND_RDTSC
-#endif
-#if !defined(FOUND_RDTSC)
-   ticks = 0;
-#endif
-   return ticks;
-   (void)hi; (void)lo;
-}
-
-
-xed_uint8_t
-convert_ascii_nibble(char c)
-{
-  if (c >= '0' && c <= '9') {
-    return c-'0';
-  }
-  else if (c >= 'a' && c <= 'f') {
-    return c-'a' + 10;
-  }
-  else if (c >= 'A' && c <= 'F') {
-    return c-'A' + 10;
-  }
-  else {
-      char buffer[200];
-      char* x;
-      xed_strcpy(buffer,"Invalid character in hex string: ");
-      x= buffer+strlen(buffer);
-      *x++ = c;
-      *x++ = 0;
-      xedex_derror(buffer);
-      return 0;
-  }
-}
-
-
-
-xed_uint64_t convert_ascii_hex_to_int(const char* s) {
-    xed_uint64_t retval = 0;
-    const char* p = s;
-    while (*p) {
-        retval  =  (retval << 4) + convert_ascii_nibble(*p);
-        p++;
-    }
-    return retval;
-}
-
-
-xed_uint8_t convert_ascii_nibbles(char c1, char c2) {
-    xed_uint8_t a = convert_ascii_nibble(c1) * 16 + convert_ascii_nibble(c2);
-    return a;
-}
-
-unsigned int
-xed_convert_ascii_to_hex(const char* src, xed_uint8_t* dst, unsigned int max_bytes)
-{
-    unsigned int j;
-    unsigned int p = 0;
-    unsigned int i = 0;
-
-    const unsigned int len = STATIC_CAST(unsigned int,strlen(src));
-    if ((len & 1) != 0) 
-        xedex_derror("test string was not an even number of nibbles");
-    
-    if (len > (max_bytes * 2) ) 
-        xedex_derror("test string was too long");
-
-    for( j=0;j<max_bytes;j++) 
-        dst[j] = 0;
-
-    for(;i<len/2;i++) {
-        if (CLIENT_VERBOSE3) 
-            printf("Converting %c & %c\n", src[p], src[p+1]);
-        dst[i] = convert_ascii_nibbles(src[p], src[p+1]);
-        p=p+2;
-    }
-    return i;
-}
-
-#if defined(_WIN32) && !defined(__GNUC__)
-static xed_int64_t
-convert_base10(const char* buf)
-{
-    xed_int64_t v = 0;
-    xed_int64_t sign = 1;
-    int len = STATIC_CAST(int,strlen(buf));
-    int i; 
-    for(i=0;i<len;i++)
-    {
-        char c = buf[i];
-        if (i == 0 && c == '-')
-        {
-            sign = -1;
-        }
-        else if (c >= '0' && c <= '9')
-        {
-            unsigned int digit = c - '0';
-            v = v*10 + digit;
-        }
-        else
-        {
-            break;
-        }
-    }
-    return v*sign;
-}
-
-static xed_int64_t
-convert_base16(const char* buf)
-{
-    xed_int64_t v = 0;
-    int len = STATIC_CAST(int,strlen(buf));
-    int start =0 ;
-    int i;
-    if (len > 2 && buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X'))
-    {
-        start = 2;
-    }
-    for(i=start;i<len;i++)
-    {
-        char c = buf[i];
-        if (c >= '0' && c <= '9')
-        {
-            unsigned int digit = c - '0';
-            v = v*16 + digit;
-        }
-        else if (c >= 'A' && c <= 'F')
-        {
-            unsigned int digit = c - 'A' + 10;
-            v = v*16 + digit;
-        }
-        else if (c >= 'a' && c <= 'f')
-        {
-            unsigned int digit = c - 'a' + 10;
-            v = v*16 + digit;
-        }
-        else
-        {
-            break;
-        }
-    }
-    return v;
-}
-
-static xed_int64_t
-xed_internal_strtoll(const char* buf, int base)
-{
-    switch(base)
-    {
-      case 0:
-        if (strlen(buf) > 2 && buf[0] == '0' && 
-            (buf[1] == 'x' || buf[1] == 'X'))
-        {
-            return convert_base16(buf);
-        }
-        return convert_base10(buf);
-      case 10:
-        return convert_base10(buf);
-      case 16:
-        return convert_base16(buf);
-      default:
-        xed_assert(0);
-    }
-    return 0;
-}
-
-#endif
-
-xed_int64_t xed_strtoll(const char* buf, int base)
-{
-#if defined(_WIN32) && !defined(__GNUC__)
-    // 64b version missing on some MS compilers
-    return xed_internal_strtoll(buf,base);
-#else
-    return strtoll(buf,0,base);
-#endif
-}
-
-
-
-////////////////////////////////////////////////////////////////////////////
-//Local Variables:
-//pref: "xed-examples-util.H"
-//End: