X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?p=palacios.git;a=blobdiff_plain;f=misc%2Fdecoder_test%2FXED2%2Fexamples%2Fxed.cpp;fp=misc%2Fdecoder_test%2FXED2%2Fexamples%2Fxed.cpp;h=cd9679182d613e166ccb4b48cc53a62df5016ecd;hp=0000000000000000000000000000000000000000;hb=ddc16b0737cf58f7aa90a69c6652cdf4090aec51;hpb=626595465a2c6987606a6bc697df65130ad8c2d3

diff --git a/misc/decoder_test/XED2/examples/xed.cpp b/misc/decoder_test/XED2/examples/xed.cpp
new file mode 100644
index 0000000..cd96791
--- /dev/null
+++ b/misc/decoder_test/XED2/examples/xed.cpp
@@ -0,0 +1,560 @@
+/*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.cpp
+/// @author Mark Charney   <mark.charney@intel.com>
+
+
+////////////////////////////////////////////////////////////////////////////
+extern "C" {
+#include "xed-interface.h"
+#include "xed-immdis.h"
+#include "xed-portability.h"
+#include "xed-examples-util.h"
+//void xed_decode_traverse_dump_profile();
+}
+
+#include "xed-disas-elf.H"
+#include "xed-disas-macho.H"
+#include "xed-disas-pecoff.H"
+#include "xed-disas-raw.H"
+#include "xed-enc-lang.H"
+
+#include <vector>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+
+using namespace std;
+
+
+int main(int argc, char** argv);
+
+////////////////////////////////////////////////////////////////////////////
+
+static xed_uint_t disas_decode(const xed_state_t* dstate,
+                           const char* decode_text,
+                           xed_decoded_inst_t* xedd) {
+    xed_uint8_t hex_decode_text[XED_MAX_INSTRUCTION_BYTES];
+    xed_uint_t bytes = xed_convert_ascii_to_hex(decode_text, hex_decode_text,XED_MAX_INSTRUCTION_BYTES);
+    return  disas_decode_binary(dstate, hex_decode_text, bytes, xedd);
+}
+
+
+static unsigned int disas_decode_encode(const xed_state_t* dstate,
+                                        const char* decode_text,
+                                        xed_decoded_inst_t* xedd) {
+    xed_uint8_t hex_decode_text[XED_MAX_INSTRUCTION_BYTES];
+    xed_uint_t bytes = xed_convert_ascii_to_hex(decode_text,
+                                            hex_decode_text, 
+                                            XED_MAX_INSTRUCTION_BYTES);
+    return disas_decode_encode_binary(dstate, hex_decode_text, bytes, xedd);
+}
+
+static unsigned int disas_encode(const xed_state_t* dstate,
+                                 const char* encode_text) {
+    unsigned int olen=0;
+    ascii_encode_request_t areq;
+    areq.dstate = *dstate;
+    areq.command = encode_text;
+    xed_encoder_request_t req = parse_encode_request(areq);
+    char buf[5000];
+    xed_encode_request_print(&req, buf, 5000);
+    printf("Request: %s", buf);
+
+    
+    //for(xed_uint_t i=0;i< xed_encoder_request_operand_order_entries(&req);i++)
+    //   printf("REQUEST OPERAND ORDER ARRAY %d %s\n", 
+    //           i, xed_operand_enum_t2str( xed_encoder_request_get_operand_order(&req,i) ) );
+    xed_uint8_t array[XED_MAX_INSTRUCTION_BYTES];
+    unsigned int ilen = XED_MAX_INSTRUCTION_BYTES;
+    xed_error_enum_t r = xed_encode(&req, array, ilen, &olen);
+    if (r != XED_ERROR_NONE)     {
+        printf("Could not encode: %s\n", encode_text);
+        printf("Error code was: %s\n", xed_error_enum_t2str(r));
+        xedex_derror("Dieing");
+    }
+    else if (CLIENT_VERBOSE)   {
+        char buf2[100];
+        xed_print_hex_line(buf2,array, olen);
+        printf("Encodable! %s\n", buf2);
+    }
+    return olen;
+}
+
+static void no_comments(char* buf) {
+    size_t len = strlen(buf);
+    for(size_t i=0;i<len;i++) {
+        if (buf[i] == ';' || buf[i] == '#') {
+            buf[i]= 0; // stomp on it
+            return;
+        }
+    }
+}
+
+
+#include <fstream>
+static void xed_assemble(const xed_state_t* dstate,
+                         const char* encode_file_name) {
+    ifstream infile(encode_file_name);
+    if (!infile) {
+        printf("Could not open %s\n", encode_file_name);
+        xedex_derror("Dieing");
+    }
+    char buf[1024];
+    while(infile.getline(buf,sizeof(buf))) {
+        printf("; %s\n",buf);
+        no_comments(buf);
+        if (strlen(buf) == 0)
+            continue;
+        unsigned int olen=0;
+        ascii_encode_request_t areq;
+        areq.dstate = *dstate;
+        areq.command = buf;
+        xed_encoder_request_t req = parse_encode_request(areq);
+ 
+        xed_uint8_t array[XED_MAX_INSTRUCTION_BYTES];
+        unsigned int ilen = XED_MAX_INSTRUCTION_BYTES;
+        xed_error_enum_t r = xed_encode(&req, array, ilen, &olen);
+        if (r != XED_ERROR_NONE)     {
+            printf("Could not encode: %s\n", buf);
+            printf("Error code was: %s\n", xed_error_enum_t2str(r));
+            xedex_derror("Dieing");
+        }
+        printf("      .byte ");
+        for(unsigned int i=0;i<olen;i++) {
+            if (i > 0)
+                printf(", ");
+            printf("0x%02x",array[i]);
+        }
+        printf("\n");
+    }
+}
+
+static void usage(char* prog) {
+    unsigned int i;
+    static const char* usage_msg[] = {
+      "One of the following is required:",
+      "\t-i input_file             (decode file)",
+      "\t-ir raw_input_file        (decode a raw unformatted binary file)",
+      "\t-ide input_file           (decode/encode file)",
+      "\t-d hex-string             (decode one instruction, must be last)",
+      "\t-e instruction            (encode, must be last)",
+      "\t-ie file-to-assemble      (assemble the contents of the file)",
+      "\t-de hex-string            (decode-then-encode, must be last)",
+      " ",
+      "Optional arguments:",
+      "\t-v verbosity  (0=quiet, 1=errors, 2=useful-info, 3=trace, 5=very verbose)",
+      "\t-xv xed-engine-verbosity  (0...99)",
+      "\t-s target section for file disassembly (PECOFF and ELF formats only)",
+
+      "\t-n number-of-instructions-to-decode (default 100M, accepts K/M/G qualifiers)",
+      "\t-I            (Intel syntax for disassembly)",
+      "\t-A            (ATT SYSV syntax for disassembly)",
+      "\t-16           (for LEGACY_16 mode)",
+      "\t-32           (for LEGACY_32 mode, default)",
+      "\t-64           (for LONG_64 mode w/64b addressing -- optional on windows/linux)",
+      "\t-a32          (32b addressing, default, not in LONG_64 mode)",
+      "\t-a16          (16b addressing, not in LONG_64 mode)",
+      "\t-s32          (32b stack addressing, default, not in LONG_64 mode)",
+      "\t-s16          (16b stack addressing, not in LONG_64 mode)",
+//    " ",
+//    "\t-nofeedback   (turn off feedback for builds that actually use feedback)",
+      " ",
+      0
+    };      
+
+    cerr << "Usage: " << prog << " [options]" << endl;
+    for(i=0; usage_msg[i]  ; i++)
+        cerr << "\t" << usage_msg[i] << endl;
+}
+ 
+#if 1
+void test_immdis() {
+    char buf[1000];
+    xed_int64_t sv;
+    xed_immdis_t i;
+    xed_uint64_t v = 0x11223344;
+    xed_uint32_t uv =0;
+
+    xed_immdis_init(&i,8);
+    xed_immdis_add_shortest_width_signed(&i,v,4);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+
+    xed_immdis_zero(&i);
+    xed_immdis_add_shortest_width_unsigned(&i,uv,5);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+
+    xed_immdis_zero(&i);
+
+    sv = 0x90;
+    xed_immdis_add_shortest_width_signed(&i,sv,5);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+    xed_immdis_zero(&i);
+
+    sv = -128;
+    xed_immdis_add_shortest_width_signed(&i,sv,5);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+    xed_immdis_zero(&i);
+
+    sv = -127;
+    xed_immdis_add_shortest_width_signed(&i,sv,5);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+    xed_immdis_zero(&i);
+    uv = 0x80000000;
+    xed_immdis_add_shortest_width_unsigned(&i,uv,5);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+#if !defined(_MSC_VER) // MSVS6 VC98 chokes on the LL. Just punt on MS compilers
+    xed_immdis_zero(&i);
+
+    sv = 0xffffffff81223344LL;
+    xed_immdis_add_shortest_width_signed(&i,sv,4);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+        v = 0x1122334455667788ULL;
+    xed_immdis_zero(&i);
+    xed_immdis_add_shortest_width_signed(&i,sv,4);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    #endif
+
+    v = 0x11223344;
+    xed_immdis_zero(&i);
+    xed_immdis_add_shortest_width_signed(&i,v,4);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+    v = 0x112233;
+    xed_immdis_zero(&i);
+    xed_immdis_add_shortest_width_signed(&i,v,4);
+
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+    v = 0x1122;
+    xed_immdis_zero(&i);
+    xed_immdis_add_shortest_width_signed(&i,v,4);
+
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+    v = 0x11;
+    xed_immdis_zero(&i);
+    xed_immdis_add_shortest_width_signed(&i,v,4);
+
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+
+    v = 0x1122;
+    xed_immdis_zero(&i);
+    xed_immdis_add_shortest_width_signed(&i,v,3);
+
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+    v = 0xffff;
+    xed_immdis_zero(&i);
+    xed_immdis_add_shortest_width_signed(&i,v,2);
+
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+    v = 0xff00;
+    xed_immdis_zero(&i);
+    xed_immdis_add_shortest_width_signed(&i,v,2);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+
+    v = 0xff77;
+    xed_immdis_zero(&i);
+    xed_immdis_add_shortest_width_signed(&i,v,7);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+    v = 0xff7777;
+    xed_immdis_zero(&i);
+    xed_immdis_add_shortest_width_signed(&i,v,5);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+    v = 0xff8000;
+    xed_immdis_zero(&i);
+    xed_immdis_add_shortest_width_signed(&i,v,7);
+    xed_immdis_print(&i,buf,1000);
+    printf("%s\n",buf);
+    
+    exit(1);
+}
+#endif
+
+
+void remove_spaces(string& s) {
+    string::size_type i,p=0,len = s.size();
+    for(i=0;i<len;i++)
+        if (s[i] != ' ')
+            s[p++]=s[i];
+    s = s.substr(0,p);
+}
+
+void test_argc(int i, int argc) {
+    if (i+1 >= argc)
+        xedex_derror("Need more arguments. Use \"xed -help\" for usage.");
+}
+
+int main(int argc,     char** argv) {
+    xed_bool_t sixty_four_bit = false;
+    xed_bool_t decode_only = true;
+    char* input_file_name = 0;
+    string decode_text("");
+    string encode_text("");
+    xed_state_t dstate;
+    xed_bool_t encode = false;
+    unsigned int ninst = 100*1000*1000; // FIXME: should use maxint...
+    xed_bool_t decode_encode = false;
+    int i,j;
+    unsigned int loop_decode = 0;
+    xed_bool_t decode_raw = false;
+    xed_bool_t assemble  = false;
+    char* target_section = 0;
+    xed_state_init(&dstate,
+                   XED_MACHINE_MODE_LEGACY_32,
+                   XED_ADDRESS_WIDTH_32b, 
+                   XED_ADDRESS_WIDTH_32b);
+
+
+    client_verbose = 3;
+    xed_set_verbosity( client_verbose );
+    for( i=1;i<argc;i++)    {
+        if (strcmp(argv[i],"-d")==0)         {
+            test_argc(i,argc);
+            for(j=i+1; j< argc;j++) 
+                decode_text = decode_text + argv[j];
+            break; // leave the i=1...argc loop
+        }
+        else if (strcmp(argv[i],"-de")==0)        {
+            test_argc(i,argc);
+            decode_encode = true;
+            for(j=i+1; j< argc;j++) 
+                decode_text = decode_text + argv[j];
+            break; // leave the i=1...argc loop
+        }
+        else if (strcmp(argv[i],"-i")==0)        {
+            test_argc(i,argc);
+            input_file_name = argv[i+1];
+            i++;
+        }
+        else if (strcmp(argv[i],"-s")==0)        {
+            test_argc(i,argc);
+            target_section = argv[i+1];
+            i++;
+        }
+        else if (strcmp(argv[i],"-ir")==0)        {
+            test_argc(i,argc);
+            input_file_name = argv[i+1];
+            decode_raw = true;
+            i++;
+        }
+        else if (strcmp(argv[i],"-ie")==0)        {
+            test_argc(i,argc);
+            input_file_name = argv[i+1];
+            assemble = true;
+            i++;
+        }
+        else if (strcmp(argv[i],"-ide")==0)        {
+            test_argc(i,argc);
+            input_file_name = argv[i+1];
+            decode_only = false;
+            i++;
+        }
+        else if (strcmp(argv[i],"-n") ==0)         {
+            test_argc(i,argc);
+            ninst = STATIC_CAST(unsigned int,xed_atoi_general(argv[i+1],1000));
+            i++;
+        }
+        else if (strcmp(argv[i],"-loop") ==0)         {
+            test_argc(i,argc);
+            loop_decode = STATIC_CAST(unsigned int,xed_atoi_general(argv[i+1],1000));
+            i++;
+        }
+        else if (strcmp(argv[i],"-v") ==0)         {
+            test_argc(i,argc);
+            client_verbose = STATIC_CAST(int,xed_atoi_general(argv[i+1],1000));
+            xed_set_verbosity(client_verbose);
+
+            i++;
+        }
+        else if (strcmp(argv[i],"-xv") ==0)        {
+            test_argc(i,argc);
+            unsigned int xed_engine_verbose = STATIC_CAST(unsigned int,xed_atoi_general(argv[i+1],1000));
+            xed_set_verbosity(xed_engine_verbose);
+            i++;
+        }
+        else if (strcmp(argv[i],"-A")==0)        {
+            att_syntax = true;
+            xed_syntax = intel_syntax = false;
+        }
+        else if (strcmp(argv[i],"-I")==0)        {
+            intel_syntax = true;
+            xed_syntax = att_syntax = false;
+        }
+        else if (strcmp(argv[i],"-X") == 0)  {  // undocumented
+            xed_syntax = true;
+            intel_syntax = true;
+            att_syntax = true;
+        }
+        else if (strcmp(argv[i],"-16")==0)         {
+            sixty_four_bit = false;
+            dstate.mmode = XED_MACHINE_MODE_LEGACY_16;
+        }
+        else if (strcmp(argv[i],"-32")==0) { // default
+            sixty_four_bit = false;
+            dstate.mmode = XED_MACHINE_MODE_LEGACY_32;
+        }
+        else if (strcmp(argv[i],"-64")==0)         {
+            sixty_four_bit = true;
+            dstate.mmode = XED_MACHINE_MODE_LONG_64;
+            dstate.addr_width = XED_ADDRESS_WIDTH_64b;
+        }
+        else if (strcmp(argv[i],"-a32")==0) 
+            dstate.addr_width = XED_ADDRESS_WIDTH_32b;
+        else if (strcmp(argv[i],"-a16")==0) 
+            dstate.addr_width = XED_ADDRESS_WIDTH_16b;
+        else if (strcmp(argv[i],"-s32")==0) 
+            dstate.stack_addr_width = XED_ADDRESS_WIDTH_32b;
+        else if (strcmp(argv[i],"-s16")==0) 
+            dstate.stack_addr_width = XED_ADDRESS_WIDTH_16b;
+        else if (strcmp(argv[i],"-ti") ==0)        {
+            client_verbose = 5;
+            xed_set_verbosity(5);
+            test_immdis();
+            exit(1);
+        }
+        else if (strcmp(argv[i],"-e") ==0)         {
+            encode = true;
+            test_argc(i,argc);
+            // merge the rest of the args in to the encode_text string.
+            for( j = i+1; j< argc; j++ ) 
+                encode_text = encode_text + argv[j] + " ";
+            break;  // leave the loop
+        }
+        else          {
+            usage(argv[0]);
+            exit(1);
+        }
+    }
+    if (!encode)     {
+        if (input_file_name == 0 && decode_text == "")        {
+            cerr << "ERROR: required argument(s) were missing" << endl;
+            usage(argv[0]);
+            exit(1);
+        }
+    }
+    if (CLIENT_VERBOSE2)
+        printf("Initializing XED tables...\n");
+    xed_tables_init();
+    if (CLIENT_VERBOSE2)
+        printf("Done initialing XED tables.\n");
+
+    printf("#XED version: [%s]\n", xed_get_version());
+    xed_decoded_inst_t xedd;
+    xed_decoded_inst_zero_set_mode(&xedd, &dstate);
+
+    xed_uint_t retval_okay = 1;
+    unsigned int obytes=0;
+    if (assemble) {
+        xed_assemble(&dstate, input_file_name);
+    }
+    else if (decode_encode)     {
+        obytes = disas_decode_encode(&dstate, decode_text.c_str(), &xedd);
+        retval_okay = (obytes != 0) ? 1 : 0;
+    }
+    else if (encode) 
+        obytes = disas_encode(&dstate, encode_text.c_str());
+    else if (decode_text != "") {
+        if (loop_decode) {
+            unsigned int k;
+            for(k=0;k<loop_decode;k++) {
+                retval_okay = disas_decode(&dstate, decode_text.c_str(), &xedd);
+                xed_decoded_inst_zero_set_mode(&xedd, &dstate);
+                //xed_decode_traverse_dump_profile();
+            }
+        }
+        else {
+            remove_spaces(decode_text);
+            const char* p = decode_text.c_str();
+            int remaining = static_cast<int>(decode_text.size() / 2); // 2 bytes per nibble
+            do {
+                retval_okay = disas_decode(&dstate, p, &xedd);
+                unsigned int  len = xed_decoded_inst_get_length(&xedd);
+                p+=len*2;
+                remaining -= len;
+            }
+            while(retval_okay && remaining > 0);
+        }
+    }
+    else if (decode_raw) {
+        xed_disas_raw(input_file_name, &dstate, ninst, sixty_four_bit, decode_only);
+    }
+    else     {
+
+#if defined(XED_MAC_OSX_FILE_READER)
+        xed_disas_macho(input_file_name, &dstate, ninst, sixty_four_bit, decode_only);
+#elif defined(XED_ELF_READER)
+        xed_disas_elf(input_file_name, &dstate, ninst, sixty_four_bit, decode_only, 
+                      target_section);
+#elif defined(XED_PECOFF_FILE_READER)
+        xed_disas_pecoff(input_file_name, &dstate, ninst, sixty_four_bit, decode_only, 
+                         target_section);
+#else
+        xedex_derror("No PECOFF, ELF or MACHO support compiled in");
+#endif
+    }
+    //xed_decode_traverse_dump_profile();
+
+    if (retval_okay==0) 
+        exit(1);
+    return 0;
+    (void) obytes;
+}
+ 
+
+////////////////////////////////////////////////////////////////////////////