libintel64asm/drd64_intel64_asm.c

   1 /*DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64
   2
   3                          D r . D e a m o n  6 4
   4                         for INTEL64(R), AMD64(R)
   5
   6    Copyright(C) 2007-2009 Koine Yuusuke(koinec). All rights reserved.
   7
   8 Redistribution and use in source and binary forms, with or without
   9 modification, are permitted provided that the following conditions are met:
  10
  11  1. Redistributions of source code must retain the above copyright notice,
  12     this list of conditions and the following disclaimer.
  13  2. Redistributions in binary form must reproduce the above copyright
  14     notice, this list of conditions and the following disclaimer in the
  15     documentation and/or other materials provided with the distribution.
  16
  17 THIS SOFTWARE IS PROVIDED BY Koine Yuusuke(koinec) ``AS IS'' AND ANY
  18 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 DISCLAIMED. IN NO EVENT SHALL Koine Yuusuke(koinec) OR CONTRIBUTORS BE
  21 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  27 OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64*/
  30
  31 /* File Info -----------------------------------------------------------
  32 File: drd64_intel64_asm.c
  33 Function: Intel64 Line Assembler Main Module
  34 Comment:  none
  35 ----------------------------------------------------------------------*/
  36
  37 #include"drd64_intel64.h"
  38 #define DRD64_SRC_LIBINTEL64ASM_FUNC
  39 #include"../include/libintel64asm.h"
  40
  41
  42 /*----------------------------------------------------------------------
  43 ----------------------------------------------------------------------*/
  44 int
  45         Drd64_Intel64_CarveStringBlock(
  46                 Drd64_Intel64_AssemblePacket *p_assemble,
  47                 char    *p_src)
  48 {
  49         char    *p_now;
  50         char    *p_temp;
  51         char    *p_end;
  52
  53         p_now   = p_src;
  54         do      {
  55                 if(( '\r' == *p_now ) || ( '\n' == *p_now ))
  56                         { *p_now        = '\0'; }
  57         }while( '\0' != *(p_now++ + 1) );
  58
  59
  60         p_now   = p_src;
  61
  62         /* Carve Instruction String --- */
  63         do      {
  64                 if(( '\t' != *p_now ) && ( ' ' != *p_now))      { break; }
  65         }while( '\0' != *(p_now++ + 1) );
  66         p_temp  = p_now;
  67
  68         do      {
  69                 if(( '\t' == *p_now ) || ( ' ' == *p_now))      { break; }
  70                 *p_now  = tolower( *p_now );
  71         }while( '\0' != *(p_now++ + 1) );
  72
  73         strncpy( p_assemble->str_instruction, p_temp, (p_now - p_temp));
  74
  75         /* Carve Destination String --- */
  76         do      {
  77                 if(( '\t' != *p_now ) && ( ' ' != *p_now))      { break; }
  78         }while( '\0' != *(p_now++ + 1) );
  79
  80         if( '\0' != *p_now )    {
  81                 p_temp  = p_now;
  82                 do      {
  83                         if( ',' == *p_now )     { break; }
  84                         *p_now  = tolower( *p_now );
  85                 }while( '\0' != *(p_now++ + 1) );
  86
  87                 if( p_temp == p_now )   { return 0xff; }
  88
  89                 p_end   = p_now;
  90                 do      {
  91                         if(( '\t' != *(p_end - 1)) && ( ' ' != *(p_end - 1)))   { break; }
  92                 }while( p_temp <= --p_end );
  93                 strncpy( p_assemble->str_destination, p_temp, (p_end - p_temp));
  94                 if( ',' == *p_now )             { p_now++; }
  95         }
  96
  97         /* Carve Source String --- */
  98         do      {
  99                 if(( '\t' != *p_now ) && ( ' ' != *p_now))      { break; }
 100         }while( '\0' != *(p_now++ + 1) );
 101
 102         if( '\0' != *p_now )    {
 103                 p_temp  = p_now;
 104                 do      {
 105                         if( ',' == *p_now )     { break; }
 106                         *p_now  = tolower( *p_now );
 107                 }while( '\0' != *(p_now++ + 1) );
 108
 109                 if( p_temp == p_now )   { return 0xff; }
 110
 111                 p_end   = p_now;
 112                 do      {
 113                         if(( '\t' != *(p_end - 1)) && ( ' ' != *(p_end - 1)))   { break; }
 114                 }while( p_temp <= --p_end );
 115                 strncpy( p_assemble->str_source, p_temp, (p_end - p_temp));
 116                 if( ',' == *p_now )             { p_now++; }
 117         }
 118
 119         /* Carve Option String --- */
 120         do      {
 121                 if(( '\t' != *p_now ) && ( ' ' != *p_now))      { break; }
 122         }while( '\0' != *(p_now++ + 1) );
 123
 124         if( '\0' != *p_now )    {
 125                 p_temp  = p_now;
 126                 do      {
 127                         *p_now  = tolower( *p_now );
 128                 }while( '\0' != *(p_now++ + 1) );
 129
 130                 p_end   = p_now;
 131                 do      {
 132                         if(( '\t' != *(p_end - 1)) && ( ' ' != *(p_end - 1)))   { break; }
 133                 }while( p_temp <= --p_end );
 134                 strncpy( p_assemble->str_option, p_temp, (p_now - p_temp));
 135         }
 136
 137         return 0x00;
 138 }
 139
 140
 141 /*----------------------------------------------------------------------
 142 ----------------------------------------------------------------------*/
 143 Drd64_Intel64_OperandNode       *
 144         Drd64_Intel64_ConstructOperand_RPNChain(
 145                 char    *pstr_operand)
 146 {
 147         char    *pstr_now;
 148         char    str_buffer[MAX_OPERAND];
 149         char    *pstr_bufpos;
 150         /* i_mode : 0=> Ignore  1=> Calc Mode.  2=>Data Stock. */
 151         int             i_mode;
 152         int             i_datas;
 153
 154         Drd64_Intel64_OperandNode       *p_stack;
 155         Drd64_Intel64_OperandNode       *p_chain;
 156         Drd64_Intel64_OperandNode       *p_cnow;
 157
 158         Drd64_Intel64_OperandNode       *p_data;
 159         Drd64_Intel64_OperandNode       *p_operator;
 160         Drd64_Intel64_OperandNode       *p_temp;
 161
 162         pstr_now        = pstr_operand - 1;
 163         i_mode          = 0x00;
 164         i_datas         = 0;
 165
 166         p_chain         = NULL;
 167         p_cnow          = NULL;
 168         p_stack         = NULL;
 169         p_data          = NULL;
 170         p_operator      = NULL;
 171         p_temp          = NULL;
 172         pstr_bufpos     = str_buffer;
 173         memset( str_buffer, 0x00, MAX_OPERAND );
 174
 175         while( '\0' != *(++pstr_now) )  {
 176                 /* Pattern 1 - Ignore Chr. --- */
 177                 if(( ' ' == *pstr_now ) || ( '\t' == *pstr_now ))
 178                         { continue; }
 179                 /* Pattern 2 - Calc. Chr. --- */
 180                 else if(( '[' == *pstr_now ) || ( ']' == *pstr_now ) ||
 181                                 ( '+' == *pstr_now ) || ( '*' == *pstr_now ) ||
 182                                 ( '-' == *pstr_now ) || ( ':' == *pstr_now ))   {
 183
 184                         /* if Data Stock Mode => Proc. Data Ending ---*/
 185                         if( 0x02 == i_mode )    {
 186                                 p_data  = Drd64_Intel64_AllocOperandNode();
 187                                 if( NULL == p_data )    { return NULL;  }
 188                                 strncpy( p_data->str_data, str_buffer, MAX_OPERAND );
 189                                 pstr_bufpos     = str_buffer;
 190                                 memset( str_buffer, 0x00, MAX_OPERAND );
 191
 192                                 /* Chain Data ---*/
 193                                 if( NULL == p_chain )   {
 194                                         p_chain = p_data;
 195                                         p_cnow  = p_chain;
 196                                 }
 197                                 p_cnow->p_next          = p_data;
 198                                 p_data->p_before        = p_cnow;
 199                                 p_cnow                          = (void *)p_data;
 200                         }
 201
 202                         i_mode  = 0x01;
 203                         p_operator      = Drd64_Intel64_AllocOperandNode();
 204                         if( NULL == p_operator )        { return NULL;  }
 205                         p_operator->str_data[0] = *pstr_now;
 206
 207                         /* Check Stack in Primery Operator ---*/
 208                         if( NULL != p_stack )   {
 209                                 p_temp  = p_stack;
 210                                 do      {
 211                                         if((( '+' == p_operator->str_data[0] ) ||
 212                                                         ( '-' == p_operator->str_data[0] ) ||
 213                                                         ( '*' == p_operator->str_data[0] )) &&
 214                                                         ( ':' == p_temp->str_data[0]))  {
 215                                                 p_cnow->p_next          = p_temp;
 216                                                 p_temp->p_before        = p_cnow;
 217                                                 p_cnow                          = p_temp;
 218                                                 p_stack                         = p_temp->p_next;
 219                                         }
 220                                         else if((( '+' == p_operator->str_data[0] ) ||
 221                                                         ( '-' == p_operator->str_data[0] )) &&
 222                                                         ( '*' == p_temp->str_data[0]))  {
 223                                                 p_cnow->p_next          = p_temp;
 224                                                 p_temp->p_before        = p_cnow;
 225                                                 p_cnow                          = p_temp;
 226                                                 p_stack                         = p_temp->p_next;
 227                                         }
 228                                         else if(( '+' == p_operator->str_data[0] ) &&
 229                                                         ( '-' == p_temp->str_data[0]))  {
 230                                                 p_cnow->p_next          = p_temp;
 231                                                 p_temp->p_before        = p_cnow;
 232                                                 p_cnow                          = p_temp;
 233                                                 p_stack                         = p_temp->p_next;
 234                                         }
 235                                         else if((( '[' == p_operator->str_data[0] ) ||
 236                                                          ( ']' == p_operator->str_data[0] )) &&
 237                                                         (( '+' == p_temp->str_data[0]) ||
 238                                                          ( '-' == p_temp->str_data[0]) ||
 239                                                          ( '*' == p_temp->str_data[0]) ||
 240                                                          ( ':' == p_temp->str_data[0])))        {
 241                                                 p_cnow->p_next          = p_temp;
 242                                                 p_temp->p_before        = p_cnow;
 243                                                 p_cnow                          = p_temp;
 244                                                 p_stack                         = p_temp->p_next;
 245                                         }
 246                                         else
 247                                                 { break; }
 248                                         p_temp  = p_temp->p_next;
 249                                 }while( NULL != p_temp );
 250                         }
 251
 252                         /* Push Stack Operator --- */
 253                         if( NULL != p_stack )   { p_stack->p_before     = p_operator; }
 254                         p_operator->p_next      = p_stack;
 255                         p_stack                         = (void *)p_operator;
 256                 }
 257                 /* Pattern 3 - Data Chr. --- */
 258                 else    {
 259                         *pstr_bufpos++  = *pstr_now;
 260                         i_mode                  = 0x02;
 261                 }
 262         }
 263
 264         if( 0x02 == i_mode )    {
 265                 p_data  = Drd64_Intel64_AllocOperandNode();
 266                 if( NULL == p_data )    { return NULL;  }
 267                 strncpy( p_data->str_data, str_buffer, MAX_OPERAND );
 268                 pstr_bufpos     = str_buffer;
 269                 memset( str_buffer, 0x00, MAX_OPERAND );
 270
 271                 /* Chain Data ---*/
 272                 if( NULL == p_chain )   {
 273                         p_chain = p_data;
 274                         p_cnow  = p_chain;
 275                 }
 276                 else    {
 277                         p_cnow->p_next          = p_data;
 278                 }
 279                 p_data->p_before        = p_cnow;
 280                 p_cnow                          = (void *)p_data;
 281         }
 282
 283         /* Flash Stack Operaters --- */
 284         if( NULL != p_stack )   {
 285                 p_temp  = p_stack;
 286                 do      {
 287                         p_cnow->p_next          = p_temp;
 288                         p_temp->p_before        = p_cnow;
 289                         p_cnow                          = p_temp;
 290                         p_stack                         = p_temp->p_next;
 291                         p_temp  = p_temp->p_next;
 292                 }while( NULL != p_temp );
 293         }
 294
 295         Drd64_Intel64_Debug_Asm_PrintOperandChain( p_chain );
 296
 297         return p_chain;
 298 }
 299
 300
 301 Drd64_Intel64_OperandNode *
 302         Drd64_Intel64_CarveOperandSizePrefix(
 303                 Drd64_Intel64_OperandNode *p_chain)
 304 {
 305         Drd64_Intel64_OperandNode       *p_ret;
 306
 307         p_ret   = p_chain;
 308         if( !strncmp( p_chain->str_data, "byte", MAX_OPERAND ))
 309                 { p_chain->i_operandsize        = 1; }
 310         else if( !strncmp( p_chain->str_data, "word", MAX_OPERAND ))
 311                 { p_chain->i_operandsize        = 2; }
 312         else if( !strncmp( p_chain->str_data, "dword", MAX_OPERAND ))
 313                 { p_chain->i_operandsize        = 4; }
 314         else if( !strncmp( p_chain->str_data, "qword", MAX_OPERAND ))
 315                 { p_chain->i_operandsize        = 8; }
 316         else if( !strncmp( p_chain->str_data, "dqword", MAX_OPERAND ))
 317                 { p_chain->i_operandsize        = 16; }
 318
 319         p_chain->w_typeid       = OPTYPE_BASE_DATA_IMMEDIATE_MEMSIZE;
 320
 321         if( 0 < p_chain->i_operandsize )        {
 322                 p_ret   = p_chain->p_next;
 323         }
 324
 325         return p_ret;
 326 }
 327
 328
 329 int
 330         Drd64_Intel64_CheckMemoryOperandFormat(
 331                 Drd64_Intel64_OperandNode *p_chain)
 332 {
 333         Drd64_Intel64_OperandNode       *p_now;
 334         Drd64_Intel64_OperandNode       *p_temp[2];
 335         int             i_ret;
 336
 337         i_ret   = 0x00;
 338
 339         p_now   =       p_chain;
 340         do      {
 341                 p_temp[0]       = p_now->p_next;
 342
 343                 if( NULL != p_temp[0] ) {
 344                         if( ']' == p_temp[0]->str_data[0] )     {
 345                                 p_temp[1]       = p_temp[0]->p_next;
 346                                 if( NULL == p_temp[1] )
 347                                         { return -1; }
 348                                 if( '[' != p_temp[1]->str_data[0] )
 349                                         { return -2; }
 350                                 if( NULL != p_temp[1]->p_next )
 351                                         { return -3; }
 352
 353                                 i_ret   = 1;
 354                                 p_now->p_next   = NULL;
 355                         }
 356                 }
 357
 358                 p_now   = p_now->p_next;
 359         }while( NULL != p_now );
 360
 361         if( 0 < i_ret )         {
 362                 p_now   = p_chain;
 363                 do      {
 364                         p_now->b_flag_addr      = 0x01;
 365                         p_now   = p_now->p_next;
 366                 }while( NULL != p_now );
 367         }
 368
 369         return i_ret;
 370 }
 371
 372
 373
 374 Drd64_Intel64_OperandNode       *
 375         Drd64_Intel64_ConstructOperandTree(
 376                 Drd64_Intel64_OperandNode *p_chain)
 377 {
 378         Drd64_Intel64_OperandNode       *p_root;
 379         Drd64_Intel64_OperandNode       *p_temp;
 380         Drd64_Intel64_OperandNode       *p_value[3];
 381         char    *pstr_temp;
 382
 383         p_temp  = p_chain;
 384         do{
 385                 if(( '+' == p_temp->str_data[0] ) ||
 386                                 ( '*' == p_temp->str_data[0] ) ||
 387                                 ( ':' == p_temp->str_data[0] ) ||
 388                                 ( '-' == p_temp->str_data[0] )) {
 389                         p_value[1]      = p_temp->p_before;
 390                         assert( NULL != p_value[1] );
 391                         p_value[0]      = p_value[1]->p_before;
 392                         assert( NULL != p_value[0] );
 393
 394                         p_value[0]->p_parent    = p_temp;
 395                         p_value[1]->p_parent    = p_temp;
 396                         p_temp->p_left                  = p_value[0];
 397                         p_temp->p_right                 = p_value[1];
 398
 399                         p_temp->p_before                = p_value[0]->p_before;
 400                         p_value[2]                              = p_value[0]->p_before;
 401                         if( NULL != p_value[2] )
 402                                 { p_value[2]->p_next    = p_temp; }
 403
 404                         p_value[0]->p_before    = NULL;
 405                         p_value[0]->p_next              = NULL;
 406                         p_value[1]->p_before    = NULL;
 407                         p_value[1]->p_next              = NULL;
 408
 409                         /* Proc Minus */
 410                         if( '-' == p_temp->str_data[0] )        {
 411                                 if( '*' == p_value[1]->str_data[0] )    {
 412                                         p_root  = NULL;
 413                                         break;
 414                                 }
 415
 416                                 pstr_temp       = p_value[1]->str_data + MAX_OPERAND;
 417                                 do      {
 418                                         *pstr_temp      = *(pstr_temp - 1);
 419                                 }while( p_value[1]->str_data != --pstr_temp );
 420                                 *pstr_temp      = '-';
 421                                 p_temp->str_data[0]     = '+';
 422                         }
 423
 424                 }
 425
 426                 if( NULL == p_temp->p_next )    { p_root        = p_temp; }
 427                 p_temp  = p_temp->p_next;
 428         }while( NULL != p_temp );
 429
 430         return p_root;
 431 }
 432
 433
 434
 435 int
 436         Drd64_Intel64_ConvAsciiToValue(
 437                 QWord   *pqw_value,
 438                 int             *i_size,
 439                 char *pstr_value )
 440 {
 441         char    *pstr_src;
 442         int             i_flag_minus;
 443         int             i_base;
 444         int             i_flag_zero;
 445         int             i_len;
 446         int             i_pos;
 447         int             i_num;
 448         int             i_err;
 449         QWord   qw_temp;
 450
 451         i_flag_minus    = 0x00;
 452         i_flag_zero             = 0x00;
 453         i_err                   = 0x00;
 454         i_base                  = 10;
 455         i_pos                   = 0;
 456         qw_temp                 = 0;
 457         pstr_src                = pstr_value;
 458
 459         /* Check 1 : Check String Length */
 460         i_len   = strlen( pstr_value );
 461         if( 0 == i_len )        { return 0x01; }
 462
 463         /* Check 2 : Check Hexical Value? */
 464         if( 'h' == *(pstr_value + i_len - 1) )          {
 465                 i_base                  = 16;
 466                 i_len--;
 467         }
 468
 469         /* Check 3 : Check Minus Value? */
 470         if( '-' == *(pstr_value + 0) )  {
 471                 i_flag_minus    = 0x01;
 472                 pstr_src++;
 473                 i_len--;
 474         }
 475
 476         do      {
 477                 if( isdigit( *pstr_src ) )      {
 478                         if(( '0' == *pstr_src ) && ( 0x00 == i_flag_zero ))             {
 479                                 i_pos++;
 480                                 continue;
 481                         }
 482                         else    {
 483                                 i_flag_zero     = 0x01;
 484                                 /* XXX : Ascii Code Only! */
 485                                 qw_temp         = (qw_temp * i_base) + (*pstr_src - 0x30);
 486                                 i_pos++;
 487                         }
 488                 }
 489                 else if( 16 == i_base )         {
 490                         if( 'a' == *pstr_src )                  { i_num = 10; }
 491                         else if( 'b' == *pstr_src )             { i_num = 11; }
 492                         else if( 'c' == *pstr_src )             { i_num = 12; }
 493                         else if( 'd' == *pstr_src )             { i_num = 13; }
 494                         else if( 'e' == *pstr_src )             { i_num = 14; }
 495                         else if( 'f' == *pstr_src )             { i_num = 15; }
 496                         else    {
 497                                 i_err   = 0x02;
 498                                 break;
 499                         }
 500
 501                         qw_temp         = (qw_temp * i_base) + i_num;
 502                         i_flag_zero     = 0x01;
 503                         i_pos++;
 504
 505                 }
 506                 else    {
 507                         i_err   = 0x03;
 508                         break;
 509                 }
 510         }while(( '\0' != *pstr_src++ ) && ( --i_len > 0 ));
 511
 512         if( 0x00 != i_err )
 513                 { goto goto_Drd64_Intel64_ConvAsciiToValue_err; }
 514
 515         if(  2 >= i_pos )               { *i_size       = 1; }
 516         else if(  4 >= i_pos )  { *i_size       = 2; }
 517         else if(  8 >= i_pos )  { *i_size       = 4; }
 518         else if( 16 >= i_pos )  { *i_size       = 8; }
 519         else if( 16 <  i_pos )  { i_err = 0x03; }
 520
 521         if( 0x00 != i_err )
 522                 { goto goto_Drd64_Intel64_ConvAsciiToValue_err; }
 523
 524         if( 0x01 == i_flag_minus )      {
 525                 if(( *i_size == 1 ) && ( 0x7f < qw_temp ))
 526                         { i_err = 0x04; }
 527                 else if(( *i_size == 2 ) && ( 0x7fff < qw_temp ))
 528                         { i_err = 0x04; }
 529                 else if(( *i_size == 4 ) && ( 0x7fffffff < qw_temp ))
 530                         { i_err = 0x04; }
 531                 else if(( *i_size == 8 ) && ( 0x7fffffffffffffff < qw_temp ))
 532                         { i_err = 0x04; }
 533
 534                 if( 0x00 == i_err )     {
 535                         qw_temp = (~qw_temp) + 1;
 536                 }
 537         }
 538
 539         if( 0x00 != i_err )
 540                 { goto goto_Drd64_Intel64_ConvAsciiToValue_err; }
 541
 542         *pqw_value      = qw_temp;
 543 goto_Drd64_Intel64_ConvAsciiToValue_err:
 544         return i_err;
 545 }
 546
 547
 548 int
 549         Drd64_Intel64_SetOperandNodeInfo(
 550                 Drd64_Intel64_OperandNode *p_now)
 551 {
 552         int     i_err;
 553
 554         i_err   = 0x00;
 555
 556         if( 0x00 < i_err )       { return i_err; }
 557
 558         if( NULL != p_now->p_left )             {
 559                 i_err   = Drd64_Intel64_SetOperandNodeInfo( p_now->p_left );
 560                 if( 0x00 < i_err )       { return i_err; }
 561         }
 562
 563         if( NULL != p_now->p_right )    {
 564                 i_err = Drd64_Intel64_SetOperandNodeInfo( p_now->p_right );
 565                 if( 0x00 < i_err )       { return i_err; }
 566         }
 567
 568         /* Set Info. My Node ---*/
 569         if(( '*' != p_now->str_data[0] ) &&
 570                         ( ':' != p_now->str_data[0] ) &&
 571                         ( '+' != p_now->str_data[0] ))          {
 572
 573                 /* Check 1 : String Is Register ? --- */
 574                 p_now->w_typeid
 575                         =       Drd64_Intel64db_GetRegisterCode( p_now->str_data );
 576                 if( OPTYPE_REG_INVAILD != p_now->w_typeid )     {
 577                         if( isBitFlag(p_now->w_typeid, OPTYPE_BASE_REG_64BIT))
 578                                 { p_now->i_operandsize  = 8; }
 579                         else if( isBitFlag(p_now->w_typeid, OPTYPE_BASE_REG_32BIT))
 580                                 { p_now->i_operandsize  = 4; }
 581                         else if( isBitFlag(p_now->w_typeid, OPTYPE_BASE_REG_16BIT))
 582                                 { p_now->i_operandsize  = 2; }
 583                         else if( isBitFlag(p_now->w_typeid, OPTYPE_BASE_REG_8BIT))
 584                                 { p_now->i_operandsize  = 1; }
 585                         else if( isBitFlag(p_now->w_typeid, OPTYPE_BASE_REG_8BIT))
 586                                 { p_now->i_operandsize  = 1; }
 587                         else if( isRegType(p_now->w_typeid, OPTYPE_BASE_REG_MMX))
 588                                 { p_now->i_operandsize  = 8; }
 589                         else if( isRegType(p_now->w_typeid, OPTYPE_BASE_REG_SSE))
 590                                 { p_now->i_operandsize  = 16; }
 591                         else if( isRegType(p_now->w_typeid, OPTYPE_BASE_REG_CONTROL))
 592                                 { p_now->i_operandsize  = 8; }
 593                         else if( isRegType(p_now->w_typeid, OPTYPE_BASE_REG_DEBUG))
 594                                 { p_now->i_operandsize  = 8; }
 595                         else if( isRegType(p_now->w_typeid, OPTYPE_BASE_REG_SEGMENT))
 596                                 { p_now->i_operandsize  = 2; }
 597                         else
 598                                 { p_now->i_operandsize  = -1; }
 599                 }
 600                 /* Check 2 : String Is Value ? --- */
 601                 else    {
 602                         i_err   = Drd64_Intel64_ConvAsciiToValue(
 603                                                 &(p_now->v_val.val.val64),
 604                                                 &(p_now->v_val.i_bytes),
 605                                                 p_now->str_data );
 606                         if( 0x00 == i_err )             {
 607                                 p_now->w_typeid = OPTYPE_BASE_DATA_IMMEDIATE_IMM;
 608                                 p_now->i_operandsize    = p_now->v_val.i_bytes;
 609                         }
 610                 }
 611         }
 612         else    {
 613                 p_now->w_typeid = OPTYPE_BASE_DATA_IMMEDIATE_OPERATOR;
 614         }
 615
 616         return i_err;
 617 }
 618
 619
 620 Drd64_Intel64_OperandNode *
 621         Drd64_Intel64_CarveSegmentPrefix_Sub(
 622                 Drd64_Intel64_OperandNode *p_now)
 623 {
 624         Drd64_Intel64_OperandNode *p_ret;
 625
 626         p_ret   = NULL;
 627
 628         if( NULL == p_now )             { return NULL; }
 629
 630         p_ret   = Drd64_Intel64_CarveSegmentPrefix_Sub( p_now->p_left );
 631         if( NULL != p_ret )             { return p_ret; }
 632
 633         p_ret   = Drd64_Intel64_CarveSegmentPrefix_Sub( p_now->p_right );
 634         if( NULL != p_ret )             { return p_ret; }
 635
 636
 637         if( ':' == p_now->str_data[0] ) {
 638                 assert( NULL != p_now->p_left );
 639                 assert( NULL != p_now->p_right );
 640
 641                 if( isRegType(
 642                                 ((Drd64_Intel64_OperandNode *)(p_now->p_left))->w_typeid,
 643                                 OPTYPE_BASE_REG_SEGMENT))       {
 644
 645                         p_ret   = p_now->p_left;
 646
 647                         memcpy( p_now, p_now->p_right, sizeof(Drd64_Intel64_OperandNode));
 648                 }
 649                 else    {
 650                         p_ret   = p_now;
 651                 }
 652         }
 653
 654         return p_ret;
 655 }
 656
 657
 658 int
 659         Drd64_Intel64_CarveSegmentPrefix(
 660                 Drd64_Intel64_AssemblePacket *p_assemble,
 661                 Drd64_Intel64_OperandNode *p_now)
 662 {
 663         Drd64_Intel64_OperandNode *p_ret;
 664
 665         p_ret   = Drd64_Intel64_CarveSegmentPrefix_Sub( p_now );
 666
 667         if( NULL != p_ret )     {
 668                 if( ':' == p_ret->str_data[0] )
 669                         { return 0x01; }
 670                 else
 671                         { p_assemble->p_segment = p_ret; }
 672         }
 673
 674         return 0x00;
 675 }
 676
 677 int
 678         Drd64_Intel64_CheckOperandNode_Operator(
 679                 Drd64_Intel64_OperandNode *p_now,
 680                 int *pi_plus,
 681                 int     *pi_accum,
 682                 int     *pi_imm)
 683 {
 684         int     i_err;
 685
 686         if( NULL == p_now)
 687                 { return 0x00;  }
 688
 689         i_err   = Drd64_Intel64_CheckOperandNode_Operator(
 690                                 p_now->p_left, pi_plus, pi_accum, pi_imm );
 691         if( 0x00 != i_err )             { return i_err; }
 692
 693         i_err   = Drd64_Intel64_CheckOperandNode_Operator(
 694                                 p_now->p_right, pi_plus, pi_accum, pi_imm );
 695         if( 0x00 != i_err )             { return i_err; }
 696
 697         if( '+' == p_now->str_data[0] )
 698                 { (*pi_plus)++; }
 699         else if( '*' == p_now->str_data[0] ) {
 700
 701                 (*pi_accum)++;
 702
 703                 assert( NULL != p_now->p_left );
 704                 assert( NULL != p_now->p_right );
 705
 706                 if( isBitFlag(
 707                                 ((Drd64_Intel64_OperandNode *)(p_now->p_left))->w_typeid,
 708                                 OPTYPE_BASE_DATA_IMMEDIATE_OPERATOR))   {
 709                         return 0xfd;
 710                 }
 711
 712                 if( isBitFlag(
 713                                 ((Drd64_Intel64_OperandNode *)(p_now->p_right))->w_typeid,
 714                                 OPTYPE_BASE_DATA_IMMEDIATE_OPERATOR))   {
 715                         return 0xfc;
 716                 }
 717         }
 718         else if( isBitFlag( p_now->w_typeid, OPTYPE_BASE_DATA_IMMEDIATE_IMM ))  {
 719                 (*pi_imm)++;
 720         }
 721
 722         return 0x00;
 723 }
 724
 725
 726 int
 727         Drd64_Intel64_ExchangeChildOperandNode(
 728                 Drd64_Intel64_OperandNode *p_root )
 729 {
 730         Drd64_Intel64_OperandNode       *p_temp[2];
 731         Drd64_Intel64_OperandNode       *p_bak;
 732         Word    w_type[2];
 733
 734         if(( NULL == p_root->p_left ) && ( NULL == p_root->p_right ))   {
 735                 return 0x00;
 736         }
 737         else if(( NULL == p_root->p_left ) || ( NULL == p_root->p_right ))      {
 738                 return 0x01;
 739         }
 740
 741         p_temp[0]       = p_root->p_left;
 742         w_type[0]       = p_temp[0]->w_typeid;
 743
 744         p_temp[1]       = p_root->p_right;
 745         w_type[1]       = p_temp[1]->w_typeid;
 746
 747         if((( !isBitFlag(w_type[0],OPTYPE_BASE_DATA_IMMEDIATE_OPERATOR)) &&
 748                  ( isBitFlag(w_type[1],OPTYPE_BASE_DATA_IMMEDIATE_OPERATOR))) ||
 749                 (( '*' == p_temp[0]->str_data[0] ) &&
 750                  ( '+' == p_temp[1]->str_data[0] )) ||
 751                 (( isBitFlag(w_type[0],OPTYPE_BASE_DATA_IMMEDIATE_IMM) ) &&
 752                  ( !isBitFlag(w_type[1],OPTYPE_BASE_DATA))))    {
 753                 p_bak   = p_root->p_left;
 754                 p_root->p_left  = p_root->p_right;
 755                 p_root->p_right = p_bak;
 756         }
 757
 758         return 0x00;
 759 }
 760
 761
 762 int
 763         Drd64_Intel64_SortOperandNode(
 764                 Drd64_Intel64_OperandNode *p_root )
 765 {
 766         Drd64_Intel64_OperandNode       *p_temp;
 767         Drd64_Intel64_OperandNode       *p_bak;
 768         Word    w_type;
 769         int             i_err;
 770
 771         i_err   = Drd64_Intel64_ExchangeChildOperandNode( p_root );
 772         if( 0x00 != i_err )             { return 0x01;  }
 773
 774         /* Level 1 - Right */
 775         p_temp  = p_root->p_right;
 776         if( NULL != p_temp )    {
 777                 w_type  = p_temp->w_typeid;
 778                 if( OPTYPE_BASE_DATA_IMMEDIATE_OPERATOR == w_type )             {
 779                         i_err   = Drd64_Intel64_ExchangeChildOperandNode( p_temp );
 780                         if( 0x00 != i_err )             { return 0x01;  }
 781                 }
 782         }
 783
 784         /* Level 1 - Left */
 785         p_temp  = p_root->p_left;
 786         if( NULL != p_temp )    {
 787                 w_type  = p_temp->w_typeid;
 788                 if( OPTYPE_BASE_DATA_IMMEDIATE_OPERATOR == w_type )             {
 789                         i_err   = Drd64_Intel64_ExchangeChildOperandNode( p_temp );
 790                         if( 0x00 != i_err )             { return 0x01;  }
 791                 }
 792
 793                 /* Level 2 - Left */
 794                 p_temp  = p_temp->p_left;
 795                 if( NULL != p_temp )    {
 796                         w_type  = p_temp->w_typeid;
 797                         if( OPTYPE_BASE_DATA_IMMEDIATE_OPERATOR == w_type)      {
 798                                 i_err   = Drd64_Intel64_ExchangeChildOperandNode( p_temp );
 799                                 if( 0x00 != i_err )             { return 0x01;  }
 800                         }
 801                 }
 802         }
 803
 804         return 0x00;
 805 }
 806
 807
 808 void
 809         Drd64_Intel64_CalcOperandSize_AddressMode(
 810                 Drd64_Intel64_OperandNode *p_now )
 811 {
 812         if( NULL == p_now)       { return;      }
 813
 814         Drd64_Intel64_CalcOperandSize_AddressMode( p_now->p_left );
 815
 816         Drd64_Intel64_CalcOperandSize_AddressMode( p_now->p_right );
 817
 818         if( isBitFlag( p_now->w_typeid, OPTYPE_BASE_DATA_IMMEDIATE_OPERATOR ))  {
 819                 assert( NULL != p_now->p_left );
 820                 assert( NULL != p_now->p_right );
 821
 822                 if( ((Drd64_Intel64_OperandNode *)p_now->p_left)->i_operandsize <
 823                                 ((Drd64_Intel64_OperandNode *)p_now->p_right)->i_operandsize ) {
 824                         p_now->i_operandsize    =
 825                                 ((Drd64_Intel64_OperandNode *)p_now->p_right)->i_operandsize;
 826                 }
 827                 else    {
 828                         p_now->i_operandsize    =
 829                                 ((Drd64_Intel64_OperandNode *)p_now->p_left)->i_operandsize;
 830                 }
 831         }
 832
 833         return;
 834 }
 835
 836
 837 void
 838         Drd64_Intel64_CalcAddressSize_AddressMode(
 839                 Drd64_Intel64_OperandNode *p_now )
 840 {
 841         if( NULL == p_now)       { return;      }
 842
 843         if( NULL != p_now->p_parent )   {
 844                 p_now->i_addressize     =
 845                         ((Drd64_Intel64_OperandNode *)p_now->p_parent)->i_addressize;
 846         }
 847
 848         Drd64_Intel64_CalcAddressSize_AddressMode( p_now->p_left );
 849         Drd64_Intel64_CalcAddressSize_AddressMode( p_now->p_right );
 850
 851         return;
 852 }
 853
 854
 855 int
 856         Drd64_Intel64_CheckRegister_AddressMode(
 857                 Drd64_Intel64_OperandNode *p_now )
 858 {
 859         int             i_err;
 860
 861         if( NULL == p_now)       { return 0x00; }
 862
 863         i_err   = Drd64_Intel64_CheckRegister_AddressMode( p_now->p_left );
 864         if( 0x00 != i_err )             { return i_err; }
 865
 866         i_err   = Drd64_Intel64_CheckRegister_AddressMode( p_now->p_right );
 867         if( 0x00 != i_err )             { return i_err; }
 868
 869         if( !isBitFlag( p_now->w_typeid, OPTYPE_BASE_DATA ))    {
 870                 if( (p_now->w_typeid & OPTYPE_BASE_REG_TYPEMASK)
 871                                 != OPTYPE_BASE_REG_GENERIC )    {
 872                         /* Rip */
 873                         if( ((Word)p_now->w_typeid) != OPTYPE_REG_RIP ) {
 874                                 return 0x01;
 875                         }
 876                 }
 877                 if(( !isBitFlag( p_now->w_typeid, OPTYPE_BASE_REG_64BIT )) &&
 878                                 ( !isBitFlag( p_now->w_typeid, OPTYPE_BASE_REG_32BIT )))        {
 879                         return 0x02;
 880                 }
 881         }
 882
 883         return 0x00;
 884 }
 885
 886
 887 int
 888         Drd64_Intel64_CheckOperandNode(
 889                 Drd64_Intel64_OperandNode *p_now)
 890 {
 891         int     i_plus_num;
 892         int     i_accum_num;
 893         int     i_imm_num;
 894         int     i_err;
 895         Drd64_Intel64_OperandNode       *p_leaf[3];
 896         Drd64_Intel64_OperandNode       *p_left;
 897
 898         i_plus_num      = 0;
 899         i_accum_num     = 0;
 900         i_imm_num       = 0;
 901
 902         i_err   = Drd64_Intel64_CheckOperandNode_Operator(
 903                                         p_now, &i_plus_num, &i_accum_num, &i_imm_num );
 904         if( 0x00 != i_err )             { return i_err; }
 905
 906         /* Value Mode --- */
 907         if( 0x00 == p_now->b_flag_addr )        {
 908                 if( 0 < i_plus_num )    { return 0x04; }
 909                 if( 0 < i_accum_num )   { return 0x05; }
 910
 911                 assert( NULL == p_now->p_left );
 912                 assert( NULL == p_now->p_right );
 913
 914         }
 915         /* Address Mode ---*/
 916         else    {
 917                 if( 2 < i_plus_num )    { return 0x02; }
 918                 if( 1 < i_accum_num )   { return 0x03; }
 919
 920                 i_err   = Drd64_Intel64_SortOperandNode( p_now );
 921                 if( 0x00 != i_err )             { return i_err; }
 922
 923                 if( 2 == i_plus_num )   {
 924                         p_left          = p_now->p_left;
 925                         p_leaf[0]       = p_left->p_left;
 926                         p_leaf[1]       = p_left->p_right;
 927                         p_leaf[2]       = p_now->p_right;
 928
 929                         assert( NULL != p_leaf[0] );
 930                         assert( NULL != p_leaf[1] );
 931                         assert( NULL != p_leaf[2] );
 932
 933                         /* XXX */
 934                         if( (1 + i_accum_num) < i_imm_num )     { return 0x04; }
 935
 936                         if( 0 == i_imm_num )    { return 0x05; }
 937
 938                         if( isBitFlag( p_leaf[1]->w_typeid,
 939                                                 OPTYPE_BASE_DATA_IMMEDIATE_IMM ))       {
 940                                 p_left->p_right = p_leaf[2];
 941                                 p_now->p_right  = p_leaf[1];
 942
 943                                 i_err   = Drd64_Intel64_SortOperandNode( p_now );
 944                                 if( 0x00 != i_err )             { return i_err; }
 945                         }
 946                 }
 947
 948
 949                 /* Check Register is Generic? */
 950                 i_err   = Drd64_Intel64_CheckRegister_AddressMode( p_now );
 951                 if( 0x00 != i_err )             { return i_err; }
 952
 953                 /* Check Accumlate Operator */
 954                 if( 0 < i_accum_num )   {
 955                         if( 0 == i_plus_num )   {
 956                                 p_left  = p_now;
 957                         }
 958                         else if( 1 == i_plus_num )      {
 959                                 p_left  = p_now->p_left;
 960                                 assert( NULL != p_left );
 961                         }
 962                         else if( 2 == i_plus_num )      {
 963                                 p_left  = p_now->p_left;
 964                                 assert( NULL != p_left );
 965                                 p_left  = p_left->p_left;
 966                                 assert( NULL != p_left );
 967                         }
 968
 969                         assert( '*' == p_left->str_data[0] );
 970
 971                         p_left  = p_left->p_right;
 972                         assert( NULL != p_left );
 973                         if( !isBitFlag( p_left->w_typeid, OPTYPE_BASE_DATA_IMMEDIATE_IMM ))
 974                                 { return 0x06; }
 975                         if(( '2' != p_left->str_data[0] ) &&
 976                                         ( '4' != p_left->str_data[0] ) &&
 977                                         ( '8' != p_left->str_data[0] ))         {
 978                                 return 0x07;
 979                         }
 980                         /* XXX : '1' is Break Node */
 981                 }
 982         }
 983
 984         return i_err;
 985 }
 986
 987
 988 Drd64_Intel64_OperandNode *
 989         Drd64_Intel64_CheckOperand(
 990                 char    *pstr_operand,
 991                 Drd64_Intel64_AssemblePacket *p_assemble )
 992 {
 993         int             i_err;
 994         int             i_operand_pattern;
 995         Drd64_Intel64_OperandNode       *p_chain;
 996         Drd64_Intel64_OperandNode       *p_root;
 997         Drd64_Intel64_OperandNode       *p_temp;
 998         Drd64_Intel64_OperandNode       *p_opesize_prefix;
 999
1000         /* Phase 1 : Construct Reverse Poland Chain ---*/
1001         p_chain = Drd64_Intel64_ConstructOperand_RPNChain( pstr_operand );
1002         if( NULL == p_chain )   { return NULL; }
1003
1004         /* Phase 2 : Carve Operand Size Prefix --- */
1005         p_opesize_prefix        = NULL;
1006         p_temp  = Drd64_Intel64_CarveOperandSizePrefix(p_chain);
1007         if( p_temp != p_chain )         {
1008                 p_opesize_prefix        = p_chain;
1009                 p_chain                         = p_temp;
1010         }
1011
1012         /* Phase 3 : Check Memory Format ---*/
1013         i_operand_pattern       = Drd64_Intel64_CheckMemoryOperandFormat( p_chain );
1014         if( 0 > i_operand_pattern )             {
1015                 return NULL;
1016         }
1017
1018         /* Phase 4 : Construct Operand Tree from RPN Chain --- */
1019         p_root  = Drd64_Intel64_ConstructOperandTree( p_chain );
1020         if( NULL == p_root )    { return NULL; }
1021
1022         i_err   = Drd64_Intel64_SetOperandNodeInfo( p_root );
1023         if( 0x00 != i_err )             { return NULL; }
1024
1025         i_err   = Drd64_Intel64_CarveSegmentPrefix( p_assemble, p_root );
1026         if( 0x00 != i_err )             { return NULL; }
1027
1028         i_err   = Drd64_Intel64_CheckOperandNode( p_root );
1029         if( 0x00 != i_err )             { return NULL; }
1030
1031         /* Calc Operand Size */
1032         Drd64_Intel64_CalcOperandSize_AddressMode( p_root );
1033         p_root->i_addressize    = p_root->i_operandsize;
1034
1035         /* Calc Address Size */
1036         Drd64_Intel64_CalcAddressSize_AddressMode( p_root );
1037
1038         /* */
1039         if( 0x00 != p_root->b_flag_addr )       {
1040                 if( NULL == p_opesize_prefix )          {
1041                         p_opesize_prefix        = Drd64_Intel64_AllocOperandNode();
1042                         if( NULL == p_opesize_prefix )  { return NULL; }
1043                         p_opesize_prefix->w_typeid      = OPTYPE_BASE_DATA_IMMEDIATE_MEMSIZE;
1044                         p_opesize_prefix->i_operandsize = 8;
1045                 }
1046
1047                 p_opesize_prefix->i_addressize  = p_root->i_addressize;
1048                 p_opesize_prefix->p_left                = p_root;
1049                 p_root                                                  = p_opesize_prefix;
1050         }
1051
1052         return p_root;
1053 }
1054
1055
1056 int
1057         Drd64_Intel64_SetAnalyzePacket_OperandMemory(
1058                 Drd64_Intel64_AnalyzePacket             *p_analyze,
1059                 Drd64_Intel64_OperandNode               *p_head,
1060                 Word    w_typeid,
1061                 Word    w_sizeid)
1062 {
1063         Drd64_Intel64_OperandNode       *p_root;
1064         Drd64_Intel64_OperandNode       *p_base;
1065         Drd64_Intel64_OperandNode       *p_index;
1066         Drd64_Intel64_OperandNode       *p_scale;
1067         Drd64_Intel64_OperandNode       *p_disp;
1068         Drd64_Intel64_OperandNode       *p_temp[4];
1069         Word    w_temp;
1070
1071         p_root  = p_head->p_left;
1072         assert( NULL != p_root );
1073
1074         p_base  = NULL;
1075         p_index = NULL;
1076         p_scale = NULL;
1077         p_disp  = NULL;
1078
1079         /* Pattern 3 : IndexReg + Scale */
1080         if( '*' == p_root->str_data[0] )        {
1081                 p_index = p_root->p_left;
1082                 p_scale = p_root->p_right;
1083
1084                 p_analyze->i_sib_bytes  = 1;
1085         }
1086         else if( '+' == p_root->str_data[0] )   {
1087                 p_temp[0]       = p_root->p_left;
1088                 p_temp[1]       = p_root->p_right;
1089
1090                 /* Level 1 right */
1091                 if( isRegType( p_temp[1]->w_typeid, OPTYPE_BASE_REG_GENERIC ) ) {
1092                         p_base  = p_temp[1];
1093                 }
1094                 else if( OPTYPE_BASE_DATA_IMMEDIATE_IMM
1095                                                 == p_temp[1]->w_typeid )        {
1096                         p_disp  = p_temp[1];
1097                 }
1098
1099                 /* Level 1 left */
1100                 /* Pattern 6 : Index * Scale + Disp */
1101                 if( '*' == p_temp[0]->str_data[0] )     {
1102                         p_index = p_temp[0]->p_left;
1103                         p_scale = p_temp[0]->p_right;
1104
1105                         p_analyze->i_sib_bytes  = 1;
1106                 }
1107                 else if( '+' == p_temp[0]->str_data[0] )        {
1108                         p_temp[2]       = p_temp[0]->p_left;
1109                         p_temp[3]       = p_temp[0]->p_right;
1110
1111                         assert( NULL == p_base );
1112                         p_base = p_temp[3];
1113                         assert( NULL != p_disp );
1114
1115                         /* Pattern 5 : Index * Scale + Base + Disp */
1116                         if( '*' == p_temp[2]->str_data[0] )     {
1117                                 p_index = p_temp[2]->p_left;
1118                                 p_scale = p_temp[2]->p_right;
1119
1120                                 p_analyze->i_sib_bytes  = 1;
1121                         }
1122                         /* Pattern 4 : Index + Base + Disp */
1123                         else if( isRegType( p_temp[2]->w_typeid,
1124                                                 OPTYPE_BASE_REG_GENERIC ))      {
1125                                 p_index = p_temp[2];
1126
1127                                 /* p_scale      = *1 */
1128                                 p_scale = Drd64_Intel64_AllocOperandNode();
1129                                 if( NULL == p_scale )   { return 0x01; }
1130                                 p_scale->str_data[0]    = '1';
1131                                 p_scale->v_val.val.val64        = 1;
1132                                 p_scale->v_val.i_bytes          = 1;
1133                                 p_scale->w_typeid       = OPTYPE_BASE_DATA_IMMEDIATE_IMM;
1134                                 p_scale->b_flag_addr    = 0xff;
1135                                 p_scale->i_operandsize  = 1;
1136                                 p_scale->i_addressize   = 1;
1137
1138                                 p_analyze->i_sib_bytes  = 1;
1139                         }
1140                 }
1141                 else if( isRegType( p_temp[0]->w_typeid,
1142                                                 OPTYPE_BASE_REG_GENERIC ))      {
1143                         /* Pattern 2-1 : Base + Disp */
1144                         if( NULL == p_base )    {
1145                                 p_base  = p_temp[0];
1146                         }
1147                         /* Pattern 2-2 : Index * 1 + Base */
1148                         else    {
1149                                 p_index = p_temp[0];
1150
1151                                 /* p_scale      = *1 */
1152                                 p_scale = Drd64_Intel64_AllocOperandNode();
1153                                 if( NULL == p_scale )   { return 0x01; }
1154                                 p_scale->str_data[0]    = '1';
1155                                 p_scale->v_val.val.val64        = 1;
1156                                 p_scale->v_val.i_bytes          = 1;
1157                                 p_scale->w_typeid       = OPTYPE_BASE_DATA_IMMEDIATE_IMM;
1158                                 p_scale->b_flag_addr    = 0xff;
1159                                 p_scale->i_operandsize  = 1;
1160                                 p_scale->i_addressize   = 1;
1161
1162                                 p_analyze->i_sib_bytes  = 1;
1163                         }
1164                 }
1165                 else if( ((Word)p_temp[0]->w_typeid) == OPTYPE_REG_RIP )        {
1166                         if( NULL != p_base )    { return 0x02; }
1167                         p_base  = p_temp[0];
1168                 }
1169         }
1170         /* Pattern 1-2 : Disp. Only */
1171         /* XXX
1172                 else if( (unsigned int)OPTYPE_BASE_DATA_IMMEDIATE_IMM
1173                         == p_root->w_typeid )   { */
1174         else if( isBitFlag(p_root->w_typeid, OPTYPE_BASE_DATA_IMMEDIATE_IMM))   {
1175                 p_disp  = p_root;
1176
1177                 p_analyze->i_sib_bytes  = 1;
1178         }
1179         /* Pattern 1-1 : Reg. Only */
1180         else if( !isBitFlag( p_root->w_typeid, OPTYPE_BASE_DATA) )      {
1181                 p_base  = p_root;
1182
1183                 /* Support [?BP] => p_disp      = 0 */
1184                 /* XXX
1185                         if( (((Word)p_base->w_typeid) & OPTYPE_BASE_REG_GENERIC_IDMASK )
1186                                 == OPTYPE_BASE_REG_GENERIC_BP ) { */
1187                 if( isRegType( p_base->w_typeid, OPTYPE_BASE_REG_GENERIC ))     {
1188                         if((isRegGenericID(p_base->w_typeid,
1189                                                 OPTYPE_BASE_REG_GENERIC_BP)) ||
1190                                         (isRegGenericID(p_base->w_typeid,
1191                                                 OPTYPE_BASE_REG_GENERIC_R13)))  {
1192
1193                                 p_disp = Drd64_Intel64_AllocOperandNode();
1194                                 if( NULL == p_disp )    { return 0x01; }
1195
1196                                 p_disp->str_data[0]     = '0';
1197                                 p_disp->v_val.val.val64 = 0;
1198                                 p_disp->v_val.i_bytes           = 1;
1199                                 p_disp->w_typeid        = OPTYPE_BASE_DATA_IMMEDIATE_IMM;
1200                                 p_disp->b_flag_addr     = 0xff;
1201                                 p_disp->i_operandsize   = 1;
1202                                 p_disp->i_addressize    = 1;
1203
1204                                 p_analyze->i_sib_bytes  = 1;
1205                         }
1206                 }
1207         }
1208         /* Illegal Pattern */
1209         else    {
1210                 return 0x02;
1211         }
1212
1213         /* Set Displacement */
1214         if( NULL != p_disp )    {
1215                 assert( 0 == p_analyze->v_disp.i_bytes );
1216
1217                 p_analyze->v_disp.i_bytes       = p_disp->v_val.i_bytes;
1218                 p_analyze->v_disp.val.val64     = p_disp->v_val.val.val64;
1219         }
1220
1221         /* [RIP + disp] Support Code */
1222         if( NULL != p_temp[0] ) {
1223                 if( ((Word)p_temp[0]->w_typeid) == OPTYPE_REG_RIP )     {
1224                         p_analyze->modrm.modrm.mod      = 0x00;
1225                         p_analyze->modrm.modrm.rm       = 0x05;
1226
1227                         p_analyze->v_disp.i_bytes       = 4;
1228
1229                         goto    goto_Drd64_Intel64_SetAnalyzePacket_OperandMemory_post;
1230                 }
1231         }
1232         // 2020/01/31 - Temporary fix. VVVV
1233         //else  {
1234                 /* Support [?SP + disp?] => SiB = 1Bytes */
1235                 if( NULL != p_base )    {
1236                         if( isRegType( p_base->w_typeid, OPTYPE_BASE_REG_GENERIC ))     {
1237                                 if((isRegGenericID( p_base->w_typeid,
1238                                                         OPTYPE_BASE_REG_GENERIC_SP )) ||
1239                                                 (isRegGenericID( p_base->w_typeid,
1240                                                         OPTYPE_BASE_REG_GENERIC_R12 )))
1241                                         { p_analyze->i_sib_bytes        = 1; }
1242                         }
1243                 }
1244
1245                 /* Mod */
1246                 if( NULL == p_disp )
1247                         { p_analyze->modrm.modrm.mod    = 0x00; }
1248                 else if( 1 == p_disp->i_operandsize )
1249                         { p_analyze->modrm.modrm.mod    = 0x01; }
1250                 else
1251                         { p_analyze->modrm.modrm.mod    = 0x02; }
1252
1253
1254                 /* R/M */
1255                 /* SiB */
1256                 if( 0 < p_analyze->i_sib_bytes )        {
1257                         /* index */
1258                         if( NULL != p_index )   {
1259                                 w_temp = ( p_index->w_typeid & OPTYPE_BASE_REG_IDMASK ) >> 8;
1260                                 p_analyze->sib.sib.index        = w_temp & 0x0007;
1261                                 p_analyze->rex.rex.x            = (w_temp & 0x0008) >> 3;
1262                         }
1263                         else    {
1264                                 p_analyze->sib.sib.index        = 0x0004;
1265                         }
1266
1267                         /* Scale */
1268                         if( NULL != p_scale )   {
1269                                 if(( 0x00 != p_analyze->rex.rex.x )
1270                                                 || ( 0x0004 != p_analyze->sib.sib.index ))      {
1271                                         if( 1 == p_scale->v_val.val.val64 )
1272                                                 { p_analyze->sib.sib.scale      = 0x00; }
1273                                         else if( 2 == p_scale->v_val.val.val64 )
1274                                                 { p_analyze->sib.sib.scale      = 0x01; }
1275                                         else if( 4 == p_scale->v_val.val.val64 )
1276                                                 { p_analyze->sib.sib.scale      = 0x02; }
1277                                         else if( 8 == p_scale->v_val.val.val64 )
1278                                                 { p_analyze->sib.sib.scale      = 0x03; }
1279                                 }
1280                         }
1281
1282                         /* Base */
1283                         if( NULL != p_base )    {
1284                                 w_temp  = ( p_base->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1285                                 p_analyze->sib.sib.base         = w_temp & 0x0007;
1286                                 p_analyze->rex.rex.b            = (w_temp & 0x0008) >> 3;
1287
1288                         }
1289                         else    {
1290                                 p_analyze->sib.sib.base = 0x05;
1291
1292                                 if(( NULL == p_scale ) && ( NULL != p_disp ))
1293                                         { p_analyze->modrm.modrm.mod    = 0x00; }
1294                         }
1295
1296                         p_analyze->modrm.modrm.rm       = 0x04;
1297                 }
1298                 else    {
1299                         if( NULL != p_base )    {
1300                                 w_temp  = ( p_base->w_typeid & OPTYPE_BASE_REG_IDMASK ) >> 8;
1301                                 p_analyze->modrm.modrm.rm       = w_temp & 0x0007;
1302                                 p_analyze->rex.rex.b            = (w_temp & 0x0008) >> 3;
1303                         }
1304                 }
1305         //}
1306
1307 goto_Drd64_Intel64_SetAnalyzePacket_OperandMemory_post:
1308         /* Debug Print */
1309         Drd64_Intel64_Debug_Asm_PrintMemoryOperand(
1310                                                 p_index, p_scale, p_base, p_disp);
1311
1312         return 0x00;
1313 }
1314
1315
1316 int
1317         Drd64_Intel64_SetAnalyzePacket_Operand(
1318                 Drd64_Intel64_AnalyzePacket             *p_analyze,
1319                 Drd64_Intel64_OperandNode               *p_root,
1320                 Word    w_typeid,
1321                 Word    w_sizeid)
1322 {
1323         Word    w_temp;
1324         Byte    b_temp;
1325
1326         /* T : [ModR/M:reg] Test Reg. ( Reserved ) */
1327         /* C : [ModR/M:reg] Control Reg.  */
1328         if( OPTYPE_DATA_METHOD_C == w_typeid )  {
1329                 w_temp  = (p_root->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1330                 p_analyze->modrm.modrm.reg      = (w_temp & 0x0007);
1331                 p_analyze->rex.rex.r            = (w_temp & 0x0008) >> 3;
1332         }
1333         /* D : [ModR/M:reg] Debug Reg. */
1334         else if( OPTYPE_DATA_METHOD_D == w_typeid )     {
1335                 w_temp  = (p_root->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1336                 p_analyze->modrm.modrm.reg      = (w_temp & 0x0007);
1337                 p_analyze->rex.rex.r            = (w_temp & 0x0008) >> 3;
1338         }
1339         /* G : [ModR/M:reg] General Reg. */
1340         else if( OPTYPE_DATA_METHOD_G == w_typeid )     {
1341                 w_temp  = (p_root->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1342                 p_analyze->modrm.modrm.reg      = (w_temp & 0x0007);
1343                 p_analyze->rex.rex.r            = (w_temp & 0x0008) >> 3;
1344         }
1345         /* R : [ModR/M:R/M] refer to General Reg by R/M Field */
1346         else if( OPTYPE_DATA_METHOD_R == w_typeid )     {
1347                 w_temp  = (p_root->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1348                 p_analyze->modrm.modrm.rm       = (w_temp & 0x0007);
1349                 p_analyze->rex.rex.b            = (w_temp & 0x0008) >> 3;
1350                 p_analyze->modrm.modrm.mod      = 0x03;
1351         }
1352         /* P : [ModR/M:reg] Packed-QuadWord MMX Reg. */
1353         else if( OPTYPE_DATA_METHOD_P == w_typeid )     {
1354                 w_temp  = (p_root->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1355                 p_analyze->modrm.modrm.reg      = (w_temp & 0x0007);
1356                 p_analyze->rex.rex.r            = (w_temp & 0x0008) >> 3;
1357         }
1358         /* N : [ModR/M:R/M] Packed-QuadWord MMX Reg. */
1359         else if( OPTYPE_DATA_METHOD_N == w_typeid )     {
1360                 w_temp  = (p_root->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1361                 p_analyze->modrm.modrm.rm       = (w_temp & 0x0007);
1362                 p_analyze->rex.rex.b            = (w_temp & 0x0008) >> 3;
1363                 p_analyze->modrm.modrm.mod      = 0x03;
1364         }
1365         /* V : [ModR/M:reg] 128bit XMM Reg. */
1366         else if( OPTYPE_DATA_METHOD_V == w_typeid )     {
1367                 w_temp  = (p_root->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1368                 p_analyze->modrm.modrm.reg      = (w_temp & 0x0007);
1369                 p_analyze->rex.rex.r            = (w_temp & 0x0008) >> 3;
1370         }
1371         /* U : [ModR/M:R/M] 128bit XMM Reg. */
1372         else if( OPTYPE_DATA_METHOD_U == w_typeid )     {
1373                 w_temp  = (p_root->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1374                 p_analyze->modrm.modrm.rm       = (w_temp & 0x0007);
1375                 p_analyze->rex.rex.b            = (w_temp & 0x0008) >> 3;
1376                 p_analyze->modrm.modrm.mod      = 0x03;
1377         }
1378         /* S : [ModR/M:reg] Segment Reg. */
1379         else if( OPTYPE_DATA_METHOD_S == w_typeid )     {
1380                 w_temp  = (p_root->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1381                 p_analyze->modrm.modrm.reg      = (w_temp & 0x0007);
1382                 p_analyze->rex.rex.r            = (w_temp & 0x0008) >> 3;
1383         }
1384         /* E : [ModR/M] Memory & Reg. */
1385         else if( OPTYPE_DATA_METHOD_E == w_typeid )     {
1386                 /* General Reg. */
1387                 if( isRegType( p_root->w_typeid, OPTYPE_BASE_REG_GENERIC ) )    {
1388                         w_temp  = (p_root->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1389                         p_analyze->modrm.modrm.rm       = (w_temp & 0x0007);
1390                         p_analyze->rex.rex.b            = (w_temp & 0x0008) >> 3;
1391                         p_analyze->modrm.modrm.mod      = 0x03;
1392                 }
1393                 /* Memory Address */
1394                 else    {
1395                         Drd64_Intel64_SetAnalyzePacket_OperandMemory(
1396                                         p_analyze, p_root, w_typeid, w_sizeid);
1397                 }
1398         }
1399         /* W : [ModR/M] 128bit XMM Reg. or Memory Address
1400         ( Memory Address calculated by Seg.Reg. BaseReg. IndexReg.
1401             ScalingFactor, Displacement */
1402         else if( OPTYPE_DATA_METHOD_W == w_typeid )     {
1403                 /* XMM Reg. */
1404                 if( isRegType( p_root->w_typeid, OPTYPE_BASE_REG_SSE ) )        {
1405                         w_temp  = (p_root->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1406                         p_analyze->modrm.modrm.rm       = (w_temp & 0x0007);
1407                         p_analyze->rex.rex.b            = (w_temp & 0x0008) >> 3;
1408                         p_analyze->modrm.modrm.mod      = 0x03;
1409                 }
1410                 /* Memory Address */
1411                 else    {
1412                         Drd64_Intel64_SetAnalyzePacket_OperandMemory(
1413                                         p_analyze, p_root, w_typeid, w_sizeid);
1414                 }
1415         }
1416         /* Q : [ModR/M] MMX reg. or Memory Address
1417         ( Memory Address calced by Seg.Reg, BaseReg. IndexReg.
1418             ScalingFactor, Displacement */
1419         else if( OPTYPE_DATA_METHOD_Q == w_typeid )     {
1420                 /* MMX Reg. */
1421                 if( isRegType( p_root->w_typeid, OPTYPE_BASE_REG_MMX ) )        {
1422                         w_temp  = (p_root->w_typeid & OPTYPE_BASE_REG_IDMASK) >> 8;
1423                         p_analyze->modrm.modrm.rm       = (w_temp & 0x0007);
1424                         p_analyze->rex.rex.b            = (w_temp & 0x0008) >> 3;
1425                         p_analyze->modrm.modrm.mod      = 0x03;
1426                 }
1427                 /* Memory Address */
1428                 else    {
1429                         Drd64_Intel64_SetAnalyzePacket_OperandMemory(
1430                                         p_analyze, p_root, w_typeid, w_sizeid);
1431                 }
1432         }
1433         /* M : Memory Access (by ModR/M) (NO!!: Reg. Indicate by ModR/M) */
1434         else if( OPTYPE_DATA_METHOD_M == w_typeid )     {
1435                 Drd64_Intel64_SetAnalyzePacket_OperandMemory(
1436                                 p_analyze, p_root, w_typeid, w_sizeid);
1437         }
1438         /* A : Direct Address (NO!!: ModR/M, BaseReg, IndexReg, ScalingFactor) */
1439         /* else if( OPTYPE_DATA_METHOD_A == w_typeid )  { } */
1440         /* I : Immediate Data (NO!!: ModR/M) */
1441         else if( OPTYPE_DATA_METHOD_I == w_typeid )     {
1442                 p_analyze->v_imm.val.val64      = p_root->v_val.val.val64;
1443                 p_analyze->v_imm.i_bytes        = p_root->i_operandsize;
1444
1445                 /* Size */
1446                 if(( OPSIZE_W == w_sizeid ) && ( 1 == p_root->i_operandsize ))  {
1447                         p_root->i_operandsize   = 2;
1448                 }
1449                 else if(( OPSIZE_D == w_sizeid ) && ( 2 >= p_root->i_operandsize ))     {
1450                         p_root->i_operandsize   = 4;
1451                 }
1452                 else if(( OPSIZE_Q == w_sizeid ) && ( 4 >= p_root->i_operandsize ))     {
1453                         p_root->i_operandsize   = 8;
1454                 }
1455                 else if( OPSIZE_V == w_sizeid ) {
1456                         p_root->i_operandsize   = p_analyze->i_operandsize;
1457                 }
1458                 else if( OPSIZE_Z == w_sizeid ) {
1459                         if(( 2 == p_analyze->i_operandsize)
1460                                         && ( 1 == p_root->i_operandsize ))      {
1461                                 p_root->i_operandsize   = 2;
1462                         }
1463                         else    {
1464                                 if( 2 >= p_root->i_operandsize )        {
1465                                         p_root->i_operandsize   = 4;
1466                                 }
1467                         }
1468                 }
1469
1470                 if( p_root->i_operandsize > p_analyze->v_imm.i_bytes )  {
1471                         Drd64_Intel64_Common_ExtendValueBit(
1472                                 &(p_analyze->v_imm), p_root->i_operandsize,
1473                                         p_root->b_flag_addr);
1474                 }
1475         }
1476         /* J : IP relative Address (NO!!: ModR/M) */
1477         else if( OPTYPE_DATA_METHOD_J == w_typeid )     {
1478                 p_analyze->v_imm.val.val64      = p_root->v_val.val.val64;
1479                 p_analyze->v_imm.i_bytes        = p_root->i_operandsize;
1480         }
1481         /* O : Word of DWord Data
1482                 (NO!!: ModR/M, BaseReg. IndexReg, ScalingFactor */
1483         else if( OPTYPE_DATA_METHOD_O == w_typeid )     {
1484                 p_analyze->v_imm.val.val64      = p_root->v_val.val.val64;
1485                 p_analyze->v_imm.i_bytes        = p_root->i_operandsize;
1486         }
1487         /* F : EFLAGS / RFLAGS Reg. (NO!!: ModR/M)  */
1488         /* else if( OPTYPE_DATA_METHOD_F == w_typeid )  { } */
1489         /* X : DS:rSI (Memory Address) */
1490         /* else if( OPTYPE_DATA_METHOD_X == w_typeid )  { } */
1491         /* Y : ES:rDI (Memory Address) */
1492         /* else if( OPTYPE_DATA_METHOD_Y == w_typeid )  { } */
1493         /* 1 : 0x01 Data (Immediate Data) */
1494         /* else if( OPTYPE_DATA_METHOD_1 == w_typeid )  { } */
1495         /* - : Illegal Instruction by DrDeamon64 Assembler System */
1496         else if( OPTYPE_DATA_METHOD_ILLEGAL == w_typeid )       {
1497                 return 0x01;
1498         }
1499
1500         return 0x00;
1501 }
1502
1503 int
1504         Drd64_Intel64_SetAnalyzePacket(
1505                 Drd64_Intel64_AnalyzePacket     *p_analyze,
1506                 Drd64_Intel64_AssemblePacket    *p_assemble )
1507 {
1508         /* Proc. ModR/M Extension */
1509         /* Operand */
1510         Drd64_Intel64_SetAnalyzePacket_Operand(
1511                 p_analyze, p_assemble->p_desttree,
1512                 p_analyze->w_desttype, p_analyze->w_destsize);
1513
1514         Drd64_Intel64_SetAnalyzePacket_Operand(
1515                 p_analyze, p_assemble->p_srctree,
1516                 p_analyze->w_srctype, p_analyze->w_srcsize);
1517
1518         Drd64_Intel64_SetAnalyzePacket_Operand(
1519                 p_analyze, p_assemble->p_optiontree,
1520                 p_analyze->w_optiontype, p_analyze->w_optionsize);
1521
1522         return 0x00;
1523 }
1524
1525
1526 int
1527         Drd64_Intel64_CalcDefaultAddressSize(
1528                 Drd64_Intel64_AnalyzePacket *p_analyze,
1529                 Drd64_Intel64_AssemblePacket *p_assemble )
1530 {
1531         Drd64_Intel64_OperandNode       *p_node;
1532
1533         /* Address Size */
1534         p_node  = p_assemble->p_desttree;
1535         if( NULL != p_node )    {
1536                 if( isBitFlag(p_node->w_typeid,
1537                                                 OPTYPE_BASE_DATA_IMMEDIATE_MEMSIZE))    {
1538                         if( 0 == p_analyze->i_addresssize )     {
1539                                 p_analyze->i_addresssize        = p_node->i_addressize;
1540                         }
1541                 }
1542         }
1543
1544         p_node  = p_assemble->p_srctree;
1545         if( NULL != p_node )    {
1546                 if( isBitFlag(p_node->w_typeid,
1547                                                 OPTYPE_BASE_DATA_IMMEDIATE_MEMSIZE))    {
1548                         if( 0 == p_analyze->i_addresssize )     {
1549                                 p_analyze->i_addresssize        = p_node->i_addressize;
1550                         }
1551                         else if( p_node->i_addressize != p_analyze->i_addresssize )     {
1552                                 return 0x01;
1553                         }
1554                 }
1555         }
1556
1557         p_node  = p_assemble->p_optiontree;
1558         if( NULL != p_node )    {
1559                 if( isBitFlag(p_node->w_typeid,
1560                                                 OPTYPE_BASE_DATA_IMMEDIATE_MEMSIZE))    {
1561                         if( 0 == p_analyze->i_addresssize )     {
1562                                 p_analyze->i_addresssize        = p_node->i_addressize;
1563                         }
1564                         else if( p_node->i_addressize != p_analyze->i_addresssize )     {
1565                                 return 0x01;
1566                         }
1567                 }
1568         }
1569
1570         return 0x00;
1571 }
1572
1573
1574 int
1575         Drd64_Intel64_ConstructModRM(
1576                 Drd64_Intel64_AnalyzePacket *p_analyze )
1577 {
1578         /* reg Field */
1579         if( 0x08 > p_analyze->b_regtype )       {
1580                 p_analyze->modrm.modrm.reg      = (p_analyze->b_regtype & 0x07);
1581         }
1582
1583         /* r/m Field */
1584         if( 0x08 > p_analyze->b_rmtype )        {
1585                 p_analyze->modrm.modrm.rm       = (p_analyze->b_rmtype & 0x07);
1586         }
1587
1588         /* Mod Field */
1589         if( 0x04 > p_analyze->b_modtype )       {
1590                 p_analyze->modrm.modrm.mod      = (p_analyze->b_modtype & 0x03);
1591         }
1592
1593         return 0x00;
1594 }
1595
1596
1597 int
1598         Drd64_Intel64_CalcDefaultOperandSize(
1599                 Drd64_Intel64_AnalyzePacket *p_analyze,
1600                 Drd64_Intel64_AssemblePacket *p_assemble )
1601 {
1602         int             i_destsize;
1603         int             i_srcsize;
1604         int             i_optionsize;
1605         int             i_defaultsize;
1606         Drd64_Intel64_OperandNode       *p_node;
1607
1608         i_defaultsize   = 0;
1609         i_destsize      = 0;
1610         p_node  = p_assemble->p_desttree;
1611         if( NULL != p_node )    {
1612                 if( OPSIZE_V == p_analyze->w_destsize ) {
1613                         /* XXX : MMX/SSE/Debug/Ctrl Reg. */
1614                         i_destsize      = p_node->i_operandsize;
1615                 }
1616                 /* else if( OPSIZE_Z == p_analyze->w_destsize ) { } */
1617                 /* else if( OPSIZE_P == p_analyze->w_destsize ) { } */
1618                 else if( OPSIZE_ILLEGAL == p_analyze->w_destsize )      {
1619                         if( isRegType( p_node->w_typeid,
1620                                                                 OPTYPE_BASE_REG_GENERIC ))      {
1621                                 i_destsize      = p_node->i_operandsize;
1622                         }
1623                 }
1624         }
1625
1626         i_srcsize       = 0;
1627         p_node  = p_assemble->p_srctree;
1628         if( NULL != p_node )    {
1629                 if( OPSIZE_V == p_analyze->w_srcsize )  {
1630                         /* XXX : MMX/SSE/Debug/Ctrl Reg. */
1631                         i_srcsize       = p_node->i_operandsize;
1632                 }
1633                 /* else if( OPSIZE_Z == p_analyze->w_srcsize )  { } */
1634                 /* else if( OPSIZE_P == p_analyze->w_srcsize )  { } */
1635                 else if( OPSIZE_ILLEGAL == p_analyze->w_srcsize )       {
1636                         if( isRegType( p_node->w_typeid,
1637                                                                 OPTYPE_BASE_REG_GENERIC ))      {
1638                                 i_srcsize       = p_node->i_operandsize;
1639                         }
1640                 }
1641         }
1642
1643         i_optionsize    = 0;
1644         p_node  = p_assemble->p_optiontree;
1645         if( NULL != p_node )    {
1646                 if( OPSIZE_V == p_analyze->w_optionsize )       {
1647                         /* XXX : MMX/SSE/Debug/Ctrl Reg. */
1648                         i_optionsize    = p_node->i_operandsize;
1649                 }
1650                 /* else if( OPSIZE_Z == p_analyze->w_optionsize )       { } */
1651                 /* else if( OPSIZE_P == p_analyze->w_optionsize )       { } */
1652                 else if( OPSIZE_ILLEGAL == p_analyze->w_optionsize )    {
1653                         if( isRegType( p_node->w_typeid,
1654                                                                 OPTYPE_BASE_REG_GENERIC ))      {
1655                                 i_optionsize    = p_node->i_operandsize;
1656                         }
1657                 }
1658         }
1659
1660         if( 0 != i_destsize )   {
1661                 i_defaultsize   = i_destsize;
1662         }
1663
1664         if( 0 != i_srcsize )    {
1665                 if( 0 != i_defaultsize )        {
1666                         p_node  = p_assemble->p_srctree;
1667                         if( isBitFlag( p_node->w_typeid,
1668                                                 OPTYPE_BASE_DATA_IMMEDIATE_IMM ))       {
1669                                 if( i_defaultsize < i_srcsize )
1670                                         { return 0x01; }
1671                         }
1672                         else    {
1673                                 if( i_defaultsize != i_srcsize )
1674                                         { return 0x02; }
1675                         }
1676                 }
1677                 else    {
1678                         i_defaultsize   = i_srcsize;
1679                 }
1680         }
1681
1682         if( 0 != i_optionsize ) {
1683                 if( 0 != i_defaultsize )        {
1684                         p_node  = p_assemble->p_optiontree;
1685                         if( isBitFlag( p_node->w_typeid,
1686                                                 OPTYPE_BASE_DATA_IMMEDIATE_IMM ))       {
1687                                 if( i_defaultsize < i_optionsize )
1688                                         { return 0x01; }
1689                         }
1690                         else    {
1691                                 if( i_defaultsize != i_optionsize )
1692                                         { return 0x02; }
1693                         }
1694                 }
1695                 else    {
1696                         i_defaultsize   = i_optionsize;
1697                 }
1698         }
1699
1700         if( 0 == i_defaultsize )
1701                 { i_defaultsize = 4; }
1702
1703         p_analyze->i_operandsize        = i_defaultsize;
1704
1705         return 0x00;
1706 }
1707
1708
1709 int
1710         Drd64_Intel64_SetPrefixByte(
1711                 Drd64_Intel64_AnalyzePacket *p_analyze,
1712                 Drd64_Intel64_AssemblePacket *p_assemble )
1713 {
1714         /* Address Size Prefix */
1715         if( 4 == p_analyze->i_addresssize )     {
1716                 p_analyze->b_prefix[p_analyze->i_prefixes++]    = 0x67;
1717         }
1718
1719         /* Operand Size Prefix */
1720         if( 8 == p_analyze->i_operandsize )     {
1721                 p_analyze->rex.rex.w    = 0x01;
1722         }
1723         else if( 2 == p_analyze->i_operandsize )        {
1724                 p_analyze->b_prefix[p_analyze->i_prefixes++]    = 0x66;
1725         }
1726
1727         /* Rex Byte */
1728         if( 0x00 != p_analyze->rex.b_rex )      {
1729                 p_analyze->rex.rex.head = 0x04;
1730         }
1731
1732         /* Segment Prefix Byte */
1733         if( NULL != p_assemble->p_segment )     {
1734                 if( (unsigned int)p_assemble->p_segment->w_typeid
1735                                 == OPTYPE_REG_FS )
1736                         { p_analyze->b_prefix[p_analyze->i_prefixes++]  = 0x64; }
1737                 else if( (unsigned int)p_assemble->p_segment->w_typeid
1738                                 == OPTYPE_REG_GS )
1739                         { p_analyze->b_prefix[p_analyze->i_prefixes++]  = 0x65; }
1740                 else if( (unsigned int)p_assemble->p_segment->w_typeid
1741                                 == OPTYPE_REG_ES )
1742                         { p_analyze->b_prefix[p_analyze->i_prefixes++]  = 0x26; }
1743                 else if( (unsigned int)p_assemble->p_segment->w_typeid
1744                                 == OPTYPE_REG_CS )
1745                         { p_analyze->b_prefix[p_analyze->i_prefixes++]  = 0x2e; }
1746                 else if( (unsigned int)p_assemble->p_segment->w_typeid
1747                                 == OPTYPE_REG_SS )
1748                         { p_analyze->b_prefix[p_analyze->i_prefixes++]  = 0x36; }
1749                 else if( (unsigned int)p_assemble->p_segment->w_typeid
1750                                 == OPTYPE_REG_DS )
1751                         { p_analyze->b_prefix[p_analyze->i_prefixes++]  = 0x3e; }
1752         }
1753
1754         return 0x00;
1755 }
1756
1757
1758 int
1759         Drd64_Intel64_ConstructBinary(
1760                 Byte    *pb_dest,
1761                 Drd64_Intel64_AnalyzePacket     *p_analyze,
1762                 int             i_maxdest )
1763 {
1764         Byte    *pb_now;
1765         Drd64_Intel64_OperandNode       *p_disp;
1766         int             i_bytes;
1767         int             i_cnt;
1768
1769         i_bytes = 0;
1770         pb_now  = pb_dest;
1771
1772         /* Prefix */
1773         for( i_cnt = p_analyze->i_prefixes; i_cnt > 0; i_cnt-- )        {
1774                 *pb_now++       = p_analyze->b_prefix[i_cnt - 1];
1775                 i_bytes++;
1776         }
1777
1778         /* Rex */
1779         if( 0x00 != p_analyze->rex.b_rex )      {
1780                 *pb_now++       = p_analyze->rex.b_rex;
1781                 i_bytes++;
1782         }
1783
1784         /* OpeCode */
1785         for( i_cnt = 0; i_cnt < p_analyze->i_opcodes; i_cnt++ ) {
1786                 *pb_now++       = p_analyze->b_opcode[i_cnt];
1787                 i_bytes++;
1788         }
1789
1790         /* ModR/M */
1791         if( 0x00 != p_analyze->modrm.b_modrm )  {
1792                 *pb_now++       = p_analyze->modrm.b_modrm;
1793                 i_bytes++;
1794         }
1795
1796         /* SiB */
1797         if( 0x00 != p_analyze->sib.b_sib )      {
1798                 *pb_now++       = p_analyze->sib.b_sib;
1799                 i_bytes++;
1800         }
1801
1802         /* Displacement */
1803         if( 0 != p_analyze->v_disp.i_bytes )    {
1804
1805                 if( 1 == p_analyze->v_disp.i_bytes )    {
1806                         *pb_now++       = p_analyze->v_disp.val.val8;
1807                         i_bytes++;
1808                 }
1809                 else    {
1810                         if( 2 == p_analyze->v_disp.i_bytes )    {
1811                                 Drd64_Intel64_Common_ExtendValueBit(
1812                                         &(p_analyze->v_disp), 4 , 1);
1813                         }
1814                         *(pb_now + 0)
1815                                 = (((DWord)(p_analyze->v_disp.val.val32)) & 0x000000ff);
1816                         *(pb_now + 1)
1817                                 = (((DWord)(p_analyze->v_disp.val.val32)) & 0x0000ff00) >>  8;
1818                         *(pb_now + 2)
1819                                 = (((DWord)(p_analyze->v_disp.val.val32)) & 0x00ff0000) >> 16;
1820                         *(pb_now + 3)
1821                                 = (((DWord)(p_analyze->v_disp.val.val32)) & 0xff000000) >> 24;
1822                         pb_now  += 4;
1823                         i_bytes += 4;
1824                 }
1825         }
1826
1827         /* Immediate */
1828         if( 0 != p_analyze->v_imm.i_bytes )     {
1829
1830                 if( 1 == p_analyze->v_imm.i_bytes )     {
1831                         *pb_now++       = p_analyze->v_imm.val.val8;
1832                         i_bytes++;
1833                 }
1834                 else if( 2 == p_analyze->v_imm.i_bytes )        {
1835                         *(pb_now + 0)
1836                                 = (((DWord)(p_analyze->v_imm.val.val16)) & 0x00ff);
1837                         *(pb_now + 1)
1838                                 = (((DWord)(p_analyze->v_imm.val.val16)) & 0xff00) >>  8;
1839                         pb_now  += 2;
1840                         i_bytes += 2;
1841                 }
1842                 else if( 4 == p_analyze->v_imm.i_bytes )        {
1843                         *(pb_now + 0)
1844                                 = (((DWord)(p_analyze->v_imm.val.val32)) & 0x000000ff);
1845                         *(pb_now + 1)
1846                                 = (((DWord)(p_analyze->v_imm.val.val32)) & 0x0000ff00) >>  8;
1847                         *(pb_now + 2)
1848                                 = (((DWord)(p_analyze->v_imm.val.val32)) & 0x00ff0000) >> 16;
1849                         *(pb_now + 3)
1850                                 = (((DWord)(p_analyze->v_imm.val.val32)) & 0xff000000) >> 24;
1851                         pb_now  += 4;
1852                         i_bytes += 4;
1853                 }
1854                 else if( 8 == p_analyze->v_imm.i_bytes )        {
1855                         *(pb_now + 0)
1856                                 = (((QWord)(p_analyze->v_imm.val.val64))
1857                                                 & 0x00000000000000ff);
1858                         *(pb_now + 1)
1859                                 = (((QWord)(p_analyze->v_imm.val.val64))
1860                                                 & 0x000000000000ff00) >>  8;
1861                         *(pb_now + 2)
1862                                 = (((QWord)(p_analyze->v_imm.val.val64))
1863                                                 & 0x0000000000ff0000) >> 16;
1864                         *(pb_now + 3)
1865                                 = (((QWord)(p_analyze->v_imm.val.val64))
1866                                                 & 0x00000000ff000000) >> 24;
1867                         *(pb_now + 4)
1868                                 = (((QWord)(p_analyze->v_imm.val.val64))
1869                                                 & 0x000000ff00000000) >> 32;
1870                         *(pb_now + 5)
1871                                 = (((QWord)(p_analyze->v_imm.val.val64))
1872                                                 & 0x0000ff0000000000) >> 40;
1873                         *(pb_now + 6)
1874                                 = (((QWord)(p_analyze->v_imm.val.val64))
1875                                                 & 0x00ff000000000000) >> 48;
1876                         *(pb_now + 7)
1877                                 = (((QWord)(p_analyze->v_imm.val.val64))
1878                                                 & 0xff00000000000000) >> 56;
1879                         pb_now  += 8;
1880                         i_bytes += 8;
1881                 }
1882         }
1883
1884         return i_bytes;
1885 }
1886
1887
1888 LIBINTEL64ASM_FUNC      int
1889         Drd64_LibIntel64asm_AsmLine(
1890                 Byte    *pb_dest,
1891                 char    *p_src,
1892                 int             i_maxdest)
1893 {
1894         Drd64_Intel64_AssemblePacket    drd64_assemble;
1895         Drd64_Intel64_AnalyzePacket             drd64_analyze;
1896         int             i_bytes;
1897         int             i_err;
1898         char    *p_now;
1899         char    *p_temp;
1900
1901         p_now   = p_src;
1902         i_bytes = 0;
1903
1904         memset( &drd64_assemble, 0x00, sizeof(Drd64_Intel64_AssemblePacket) );
1905         memset( &drd64_analyze, 0x00, sizeof(Drd64_Intel64_AnalyzePacket) );
1906
1907         /* Phase 1 : Carve String to String Block */
1908         i_err   = Drd64_Intel64_CarveStringBlock( &drd64_assemble, p_src );
1909         if( 0x00 != i_err )             { return 0xff; }
1910
1911         Drd64_Intel64_Debug_Asm_PrintCarveString( &drd64_assemble, p_src );
1912
1913         /* Phase 2 : Check Operand & Construct Operand Tree */
1914         if( '\0' != drd64_assemble.str_destination[0] ) {
1915                 drd64_assemble.p_desttree       =
1916                         Drd64_Intel64_CheckOperand(
1917                                 drd64_assemble.str_destination, &drd64_assemble );
1918                 if( NULL == drd64_assemble.p_desttree ) { return 0xff; }
1919         }
1920         Drd64_Intel64_Debug_PrintOperandTree(
1921                                 drd64_assemble.p_desttree, "Destination" );
1922
1923         if( '\0' != drd64_assemble.str_source[0] )      {
1924                 drd64_assemble.p_srctree        =
1925                         Drd64_Intel64_CheckOperand(
1926                                 drd64_assemble.str_source, &drd64_assemble );
1927                 if( NULL == drd64_assemble.p_srctree )  { return 0xff; }
1928         }
1929         Drd64_Intel64_Debug_PrintOperandTree(
1930                         drd64_assemble.p_srctree, "Source" );
1931
1932         if( '\0' != drd64_assemble.str_option[0] )      {
1933                 drd64_assemble.p_optiontree     =
1934                         Drd64_Intel64_CheckOperand(
1935                                 drd64_assemble.str_option, &drd64_assemble );
1936                 if( NULL == drd64_assemble.p_optiontree )       { return 0xff; }
1937         }
1938         Drd64_Intel64_Debug_PrintOperandTree(
1939                         drd64_assemble.p_optiontree, "Option" );
1940
1941         /* Phase 3 : Search Intel64 Database */
1942         i_err   = Drd64_Intel64db_SearchInstruction(
1943                                         &drd64_analyze, &drd64_assemble );
1944         Drd64_Intel64_Debug_PrintAnalyzePacket( &drd64_analyze, "Search DB", 3 );
1945         if( 0x00 != i_err )             { return 0x00; }
1946
1947         /* Phase 4 : Calc Default Operand Size */
1948         i_err   = Drd64_Intel64_CalcDefaultAddressSize(
1949                                 &drd64_analyze, &drd64_assemble );
1950         if( 0x00 != i_err )             { return 0x01; }
1951
1952         i_err   = Drd64_Intel64_CalcDefaultOperandSize(
1953                                 &drd64_analyze, &drd64_assemble );
1954         if( 0x00 != i_err )             { return 0x01; }
1955
1956         /* Phase 4 : Construct */
1957         /* Phase 4-1 : construct ModR/M Encoding */
1958         Drd64_Intel64_ConstructModRM( &drd64_analyze );
1959
1960         /* Phase 4-2 : Construct ModR/M + SiB */
1961         Drd64_Intel64_SetAnalyzePacket( &drd64_analyze, &drd64_assemble );
1962         Drd64_Intel64_Debug_PrintAnalyzePacket( &drd64_analyze, "Set Analyze", 3 );
1963
1964         /* Phase 4-3 : Construct Prefix & Rex Byte */
1965         Drd64_Intel64_SetPrefixByte(&drd64_analyze, &drd64_assemble );
1966
1967         Drd64_Intel64_Debug_PrintAnalyzePacket( &drd64_analyze, "Final", 2);
1968         Drd64_Intel64_Debug_Asm_PrintCarveString( &drd64_assemble, p_src );
1969
1970         /* Phase 5 : Construct Binary */
1971         i_bytes = Drd64_Intel64_ConstructBinary(
1972                                                 pb_dest, &drd64_analyze, i_maxdest );
1973
1974         Drd64_Intel64_Debug_Asm_PrintAnswer( pb_dest, p_src, i_bytes );
1975
1976         Drd64_Intel64_ResetOperandNode_Memory();
1977
1978         return 0x00;
1979 }
1980
1981
1982
1983 /* EOF of drd64_intel64_asm.c ----------------------------------- */