jilc-patches
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Jilc-patches] CVS: jilc/src ChangeLog,1.6,1.7 jdasm.c,1.4,1.5 jdasm.h,1


From: Gopal.V <address@hidden>
Subject: [Jilc-patches] CVS: jilc/src ChangeLog,1.6,1.7 jdasm.c,1.4,1.5 jdasm.h,1.6,1.7 jopcodes.c,1.5,1.6 jopcodes.h,1.5,1.6 jparser.h,1.3,1.4 jparser.c,1.3,1.4
Date: Tue, 26 Feb 2002 17:31:25 -0500

Update of /cvsroot/jilc/jilc/src
In directory subversions:/tmp/cvs-serv1855

Modified Files:
        ChangeLog jdasm.c jdasm.h jopcodes.c jopcodes.h jparser.h 
        jparser.c 
Log Message:
lot of things , added support for all parameter types, added 
exception support , added try catch support, improved opcode table, 
label support fixed. Fixed almost everything I could find ..


Index: ChangeLog
===================================================================
RCS file: /cvsroot/jilc/jilc/src/ChangeLog,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -r1.6 -r1.7
*** ChangeLog   26 Feb 2002 05:08:19 -0000      1.6
--- ChangeLog   26 Feb 2002 22:31:23 -0000      1.7
***************
*** 2,5 ****
--- 2,25 ----
  
  
+ 2002-02-27     Gopal.V <address@hidden>
+       * jopcodes.h :
+       * jopcodes.c : Changed arg type for solving
+       signed/unsigned and size issues. Converted
+       old types into new format, corrected code 
+       shows size and sign of the parameter , rather
+       than count.
+       * jdasm.h : Added READ_UINT32/16 and fixed
+       READ_UINT32/16 once and for all ! (I hope)
+       Added array_type list for handling ARRAYTYPE.
+       * jdasm.c : Fixed label handling, signing of
+       output, fixe IINC param bug, added method's
+       throw exception support, added try catch 
+       support. Added support for INTERFACE, MARRAY
+       and ARRAYTYPE parameters.
+       * jparser.h :
+       * jparser.c : Added a status_flag to the 
+       JVMethodEntry to check for exception/code.
+       Put in exception attribute processing. 
+ 
  2002-02-26     Gaurav Vaish <address@hidden>
  

Index: jdasm.c
===================================================================
RCS file: /cvsroot/jilc/jilc/src/jdasm.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -C2 -r1.4 -r1.5
*** jdasm.c     25 Feb 2002 15:31:10 -0000      1.4
--- jdasm.c     26 Feb 2002 22:31:23 -0000      1.5
***************
*** 31,35 ****
  }
  
! void print_string_cp(JVCPEntry *cp_entry, int index)
  {
        switch(cp_entry[index].type)
--- 31,35 ----
  }
  
! void print_string_cp(JVCPEntry *cp_entry, unsigned int index)
  {
        switch(cp_entry[index].type)
***************
*** 80,83 ****
--- 80,84 ----
        jump_points=(UInt32*)calloc(codelen >> 5,sizeof(UInt32));
        //a bit for each byte in code
+ #ifndef __STABLE__
        while(start<codelen)
        {
***************
*** 90,122 ****
                                                start++; // default: already 
does this
                                                break;*/
!                               case CONSTANT:
!                               case I:
!                                               start+=2;
!                                               break;
!                               case FIELD:
!                               case METHOD:
!                               case CLASS:
!                               case BIGCONSTANT:
!                               case II:                                
!                                               start+=3;
!                                               break;
!                               case SWITCH:                                    
                
!                                    start++;
!                                    while( (start % 4) != 0)
!                                    {
                                                         start++;
!                                            }
!                                                
dest=insn_offset+READ_INT32(code,start);
!                                                if(dest<codelen) // default 
offset
!                                                       
jump_points[dest/32]|=(UInt32)(1L << (dest%32));
!                                                else fprintf(stderr,"illegal 
jump offset %ld\n",dest);
!                                            start += 4;
!                                                if(found.opcode == 
JAVA_LOOKUPSWITCH)
!                                                {
!                                               count = READ_INT32(code,start);
                                                    start += 4;
!                                                       for(j=0;j<count;j++)
                                                        {
!                                                               start+=4;//skip 
key
                                                                
dest=insn_offset+READ_INT32(code,start);
                                                                if(dest<codelen)
--- 91,153 ----
                                                start++; // default: already 
does this
                                                break;*/
!                               case I_S1:
!                               case I_U1:      
!                               case CONSTANT_U1:
!                               case ARRAYTYPE_U1:
!                                                       start++;
!                                           start += 1;
!                                           break;
!                               case I_U2:      
!                               case I_S2:      
!                               case II_U1_S1:
!                               case FIELD_U2:
!                               case METHOD_U2:
!                               case CLASS_U2:
!                               case CONSTANT_U2:
!                               case BIGCONSTANT_U2:
                                                         start++;
!                                            start += 2;
!                                            break;
!                               case LABEL_S2:                                  
                 
!                                                        start++;
!                                                        
dest=insn_offset+READ_INT16(code,start);
!                                                        if(dest<codelen)
!                                                               
jump_points[dest/32]|=(UInt32)(1L << \
!                                                                               
                (dest%32));
!                                                    else 
!                                                               
fprintf(stderr,"illegal jump offset %ld\n"\
!                                                                               
                ,dest);
!                                            start += 2;
!                                            break;
!                               case LABEL_S4:
!                                                       start++;
!                                                        
dest=insn_offset+READ_INT32(code,start);
!                                                        if(dest<codelen)
!                                                               
jump_points[dest/32]|=(UInt32)(1L << \
!                                                                               
                (dest%32));
!                                                    else 
!                                                               
fprintf(stderr,"illegal jump offset %ld\n"\
!                                                                               
                ,dest);
!                                                       start+=4;
!                                                       break;
!                               case LOOKUP_SWITCH:
!                                           start++;
!                                           while( (start % 4) != 0)
!                                           {
!                                                               start++;
!                                                   }
!                                                   dest = 
insn_offset+READ_INT32(code,start);
!                                                       if(dest<codelen) // 
default offset
!                                                               
jump_points[dest/32]|=(UInt32)(1L << \
!                                                                               
                (dest%32));
!                                                       else 
!                                                               
fprintf(stderr,"illegal jump offset %ld\n",\
!                                                                               
                dest);
                                                    start += 4;
!                                                   count = 
READ_INT32(code,start);
!                                                       start += 4;
!                                                       for(j = 0; j < count; 
j++)
                                                        {
!                                                       start += 4;//skip key
                                                                
dest=insn_offset+READ_INT32(code,start);
                                                                if(dest<codelen)
***************
*** 124,136 ****
                                                                                
                        (dest%32));
                                                                else 
fprintf(stderr,"illegal jump offset");
!                                                               start+=4;
                                                        }
!                                                }
!                                                else if (found.opcode == 
JAVA_TABLESWITCH)
!                                                {
                                                        low = 
READ_INT32(code,start);
                                                        start+= 4;
                                                        high = 
READ_INT32(code,start);
                                                        start+= 4;
                                                        for(j=low;j<=high;j++)
                                                        {
--- 155,184 ----
                                                                                
                        (dest%32));
                                                                else 
fprintf(stderr,"illegal jump offset");
!                                                       start += 4;
                                                        }
!                                                       break;                  
                         
!                               case TABLE_SWITCH: 
!                                           start++;
!                                           while( (start % 4) != 0)
!                                           {
!                                                               start++;
!                                                   }
!                                                       dest = 
insn_offset+READ_INT32(code,start);
!                                                       if(dest<codelen) // 
default offset
!                                                               
jump_points[dest/32]|=(UInt32)(1L << \
!                                                                               
                (dest%32));
!                                                       else 
!                                                               
fprintf(stderr,"illegal jump offset %ld\n",\
!                                                                               
                dest);
!                                                   start += 4;
                                                        low = 
READ_INT32(code,start);
                                                        start+= 4;
                                                        high = 
READ_INT32(code,start);
                                                        start+= 4;
+                                                       if(low>high)
+                                                       {
+                                                               
fprintf(stderr,"Error !\n");
+                                                               return NULL;
+                                                       }
                                                        for(j=low;j<=high;j++)
                                                        {
***************
*** 142,159 ****
                                                                start+=4;
                                                        }
!                                                 }
!                                               break;
!                               case LABEL:
!                                               start++;
!                                               
dest=insn_offset+READ_INT16(code,start);
!                                               if(dest<codelen)
!                                                       
jump_points[dest/32]|=(UInt32)(1L << (dest%32));
!                                               else fprintf(stderr,"illegal 
jump offset %ld\n",dest);
!                                               start+=2;
!                               default:
!                                               start++;
!                                               break;
!                       }
        }
        return jump_points;
  }
--- 190,207 ----
                                                                start+=4;
                                                        }
!                                                       break;
!                               case MARRAY_U2_U1:
!                                                       start++;
!                                                       start+=3;
!                                                       break;
!                               case INTERFACE_U2_U1_X1:
!                                                       start++;
!                                                       start+=4;//skip one 
byte xtra coz SUN says so
!                                                       break;
!                               default:   //this does the work of none and 
ignore  
!                                           start++;
!                               }
        }
+ #endif
        return jump_points;
  }
***************
*** 169,173 ****
        int   insn_offset = start;
        int   j;
!       Int16 tmp;//to solve glib's printf signing problem ! 
  
        int   i = search_jopcode_map(code[start]);
--- 217,225 ----
        int   insn_offset = start;
        int   j;
!       /* code to solve printf("%d") sign problem*/
!       UInt16 uint_16;
!       UInt32 uint_32;
!       Int16 int_16;
!       Int32 int_32;
  
        int   i = search_jopcode_map(code[start]);
***************
*** 183,270 ****
                switch(found.args)
                {
!                       case NONE:   PRINT_OP_NAME(found);
!                                    start++;
!                                    break;
!                       case I:      PRINT_OP_NAME(found);
!                                                start++;
!                                    printf(" %d ", code[start + 1]);
!                                    start += 1;
!                                    break;
!                       case II:     PRINT_OP_NAME(found);
!                                                start++;
!                                    printf(" %d %d", (code[start + 1]), 
(code[start + 2]));
!                                    start += 2;
!                                    break;
!                       case FIELD:
!                       case METHOD:
!                       case CLASS:
!                       case BIGCONSTANT:
                                     PRINT_OP_NAME(found);
                                                 start++;
!                                    print_string_cp(cp_entry, 
READ_INT16(code,start));
                                     start += 2;
                                     break;
!                       case CONSTANT:
                                     PRINT_OP_NAME(found);
                                                 start++;
!                                    print_string_cp(cp_entry, code[start + 1]);
                                     start += 1;
                                     break;
!                       case SWITCH: PRINT_OP_NAME(found);
!                                    start++;
!                                    while( (start % 4) != 0)
!                                    {
!                                                        start++;
!                                            }
!                                            default_offset = 
READ_INT32(code,start);
!                                            start += 4;
!                                                if(found.opcode == 
JAVA_LOOKUPSWITCH)
!                                                {
!                                                count = READ_INT32(code,start);
!                                                    start += 4;
!                                                    printf(" %ld 
key-values\n", count);
!                                                    for(j = 0; j < count; j++)
!                                                    {
!                                                    key = 
READ_INT32(code,start);
!                                                start += 4;
!                                                offset = 
READ_INT32(code,start); 
!                                                start += 4;
!                                                printf("\t\t%ld\t: j_%04d\n", 
key, insn_offset + \
!                                                                               
         offset);
!                                                    }
!                                                printf("\t\tdefault\t: 
j_%04d", insn_offset + \
                                                                                
         default_offset);
!                                                }
!                                                else if (found.opcode == 
JAVA_TABLESWITCH)
!                                                {
!                                                                low = 
READ_INT32(code,start);
!                                                                start+= 4;
!                                                                printf(" %d; 
low value\n",low);
!                                                                high = 
READ_INT32(code,start);
!                                                                start+= 4;
!                                                                if(low>high)
!                                                                {
!                                                                       
fprintf(stderr,"Error !\n");
!                                                                       return;
!                                                                }
!                                                                
for(j=low;j<=high;j++)
!                                                                {
!                                                               offset = 
READ_INT32(code,start); 
!                                                               start += 4;
!                                                               printf("\t\t 
j_%04d; offset for %d\n",\
!                                                                               
                        insn_offset + offset,j);
!                                                                }
!                                               printf("\t default:j_%04d", 
insn_offset + \
!                                                                               
                default_offset);
!                                                }
!                                            break;
!                       case LABEL:  PRINT_OP_NAME(found);
!                                                start++;
!                                                tmp= insn_offset + 
READ_INT16(code,start);
!                                                printf(" j_%04d",tmp);
!                                    start += 2;
!                                    break;
!                       default:     printf(": Unknown instruction %d", 
code[start]);
!                                    start++;
                }
                printf("\n");
--- 235,388 ----
                switch(found.args)
                {
!                       case NONE:   
!                                               PRINT_OP_NAME(found);
!                                   start++;
!                                   break;
!                       case I_U1:      
!                                               PRINT_OP_NAME(found);
!                                               start++;
!                                   printf(" %u ", (unsigned 
char)(code[start]));
!                                   start += 1;
!                                   break;
!                       case I_U2:      
!                                               PRINT_OP_NAME(found);
!                                               start++;
!                                               
uint_16=(UInt16)READ_UINT16(code,start);
!                                               printf(" %u ",uint_16);
!                                               start += 2;
!                                               break;
!                       case I_S1:      
!                                               PRINT_OP_NAME(found);
!                                               start++;
!                                               printf(" %d ",(signed 
char)(code[start]));
!                                               start += 1;
!                                               break;
!                       case I_S2:      
!                                               PRINT_OP_NAME(found);
!                                               start++;
!                                               
int_16=(Int16)READ_INT16(code,start);
!                                               printf(" %d ",int_16);
!                                               start += 2;
!                                               break;
!                       case II_U1_S1:
!                                               PRINT_OP_NAME(found);
!                                               start++;
!                                   printf(" %u %d", (unsigned 
char)(code[start]), \
!                                                                               
(signed char)(code[start + 1]));
!                                   start += 2;
!                                   break;
!                       case FIELD_U2:
!                       case METHOD_U2:
!                       case CLASS_U2:
!                       case CONSTANT_U2:
!                       case BIGCONSTANT_U2:
                                     PRINT_OP_NAME(found);
                                                 start++;
!                                    print_string_cp(cp_entry, 
READ_UINT16(code,start));
                                     start += 2;
                                     break;
!                       case CONSTANT_U1:
                                     PRINT_OP_NAME(found);
                                                 start++;
!                                    print_string_cp(cp_entry, code[start]);
                                     start += 1;
                                     break;
!                       case LOOKUP_SWITCH:
!                                               PRINT_OP_NAME(found);
!                                   start++;
!                                   while( (start % 4) != 0)
!                                   {
!                                                       start++;
!                                           }
!                                           default_offset = 
READ_INT32(code,start);
!                                           start += 4;
!                                           count = READ_INT32(code,start);
!                                               start += 4;
!                                               printf(" %ld key-values\n", 
count);
!                                               for(j = 0; j < count; j++)
!                                               {
!                                                       key = 
READ_INT32(code,start);
!                                               start += 4;
!                                               offset = 
READ_INT32(code,start); 
!                                               start += 4;
!                                               printf("\t\t%ld\t: j_%04d\n", 
key, insn_offset + \
!                                                                               
        offset);
!                                               }
!                                           printf("\t\tdefault\t: j_%04d", 
insn_offset + \
                                                                                
         default_offset);
!                                               break;                          
                 
!                       case TABLE_SWITCH: 
!                                               PRINT_OP_NAME(found);
!                                   start++;
!                                   while( (start % 4) != 0)
!                                   {
!                                                       start++;
!                                           }
!                                           default_offset = 
READ_INT32(code,start);
!                                           start += 4;
!                                               low = READ_INT32(code,start);
!                                               start+= 4;
!                                               printf(" %d; low value\n",low);
!                                               high = READ_INT32(code,start);
!                                               start+= 4;
!                                               if(low>high)
!                                               {
!                                                       fprintf(stderr,"Error 
!\n");
!                                                       return;
!                                               }
!                                               for(j=low;j<=high;j++)
!                                               {
!                                               offset = 
READ_INT32(code,start); 
!                                               start += 4;
!                                               printf("\t\t j_%04d; offset for 
%d\n",\
!                                                                               
                insn_offset + offset,j);
!                                               }
!                                           printf("\t default:j_%04d", 
insn_offset + \
!                                                                               
        default_offset);                                 
!                                               break;
!                       case LABEL_S2:
!                                               PRINT_OP_NAME(found);
!                                               start++;
!                                               int_16=insn_offset + 
READ_INT16(code,start);
!                                               printf(" j_%04d",int_16);
!                                   start += 2;
!                                   break;
!                       case LABEL_S4:
!                                               PRINT_OP_NAME(found);
!                                               start++;
!                                               int_32=insn_offset + 
(Int32)(READ_INT32(code,start));
!                                               printf(" j_%04d",int_32);
!                                               start+=4;
!                                               break;
!                       case MARRAY_U2_U1:
!                                               PRINT_OP_NAME(found);
!                                               start++;
!                                               
uint_16=(UInt16)(READ_UINT16(code,start));
!                                               
print_string_cp(cp_entry,uint_16);                                              
!                                               printf(" %u ",(unsigned 
char)code[start+2]);
!                                               start+=3;
!                                               break;
!                       case ARRAYTYPE_U1:
!                                               PRINT_OP_NAME(found);
!                                               start++;
!                                               if(code[start]<4 || 
code[start]>11)
!                                               {
!                                                       fprintf(stderr,"invalid 
array type => %d\n",\
!                                                                               
        code[start]);
!                                               }
!                                               else
!                                                               printf(" %s 
",array_types[code[start]]);
!                                               start+=1;
!                                               break;
!                       case INTERFACE_U2_U1_X1:
!                                               PRINT_OP_NAME(found);
!                                               start++;
!                                               
uint_16=(UInt16)(READ_UINT16(code,start));
!                                               
print_string_cp(cp_entry,uint_16);
!                                               printf(" %u ",(unsigned 
char)code[start+2]);
!                                               start+=4;//skip one byte coz 
SUN says so
!                                               break;
!                       default:    printf(": Unknown instruction %d", 
code[start]);
!                                   start++;
                }
                printf("\n");
***************
*** 272,292 ****
        *start_index = start;
  }
! 
  void print_method_code(JVMethodEntry *method, JVCPEntry *cp_entry)
  {
        int   i;
        int   start   = 0;
!       byte *code    = 
method->attr_entries[method->code_index].attributes.code.code;
!       int   codelen = 
method->attr_entries[method->code_index].attributes.code.code_count;
        UInt32 *jump_points;
  
-       printf(".limit stack %d\n", 
method->attr_entries[method->code_index].attributes.code.max_stack);
-       printf(".limit locals %d\n", 
method->attr_entries[method->code_index].attributes.code.max_locals);
- 
        if( (method->acc_flags & ACCESS_ABSTRACT) != 0 || codelen == 0)
        {
                return;
        }
        jump_points=get_jump_points(code,codelen);
        while(start < codelen)
        {
--- 390,441 ----
        *start_index = start;
  }
! void mark_try_catch_blocks(JVAttributeEntry *code,int codelen, UInt32 
*jump_points,JVCPEntry *cp_entry)
! {
!       int i;
!       JVExceptionHandler handle;
!       Int32 dest;
!       for(i=0;i<code->attributes.code.handler_count;i++)
!       {
!               handle=code->attributes.code.handlers[i];
!               printf(".catch ");
!               print_string_cp(cp_entry,handle.catch_type);
!               printf(" from j_%04d to j_%04d using j_%04d 
\n",handle.start_pc,\
!                                               
handle.end_pc,handle.handler_pc);
!               dest = handle.start_pc;
!               if(dest<codelen)
!                       jump_points[dest/32]|=(UInt32)(1L << (dest%32));
!               else fprintf(stderr,"illegal jump offset");
!               dest = handle.end_pc;
!               if(dest<codelen)
!                       jump_points[dest/32]|=(UInt32)(1L << (dest%32));
!               else fprintf(stderr,"illegal jump offset");
!               dest = handle.handler_pc;
!               if(dest<codelen)
!                       jump_points[dest/32]|=(UInt32)(1L << (dest%32));
!               else fprintf(stderr,"illegal jump offset");             
!       }
! }
  void print_method_code(JVMethodEntry *method, JVCPEntry *cp_entry)
  {
        int   i;
        int   start   = 0;
!       byte *code = 
method->attr_entries[method->code_index].attributes.code.code;
!       int codelen = 
method->attr_entries[method->code_index].attributes.code.code_count;
        UInt32 *jump_points;
  
        if( (method->acc_flags & ACCESS_ABSTRACT) != 0 || codelen == 0)
        {
                return;
        }
+       if((method->status_flags & METHOD_CODE)==0)
+       {
+               return;//no code attribute ?
+       }
+       printf(".limit stack %d\n", 
method->attr_entries[method->code_index].attributes.code.max_stack);
+       printf(".limit locals %d\n", 
method->attr_entries[method->code_index].attributes.code.max_locals);
+       print_method_throws(method,cp_entry);
        jump_points=get_jump_points(code,codelen);
+       
mark_try_catch_blocks(&(method->attr_entries[method->code_index]),codelen,\
+                                       jump_points,cp_entry);
        while(start < codelen)
        {
***************
*** 296,300 ****
        printf(": TODO-> wide opcode not supported\n");
  }
! 
  void print_methods(JVClass *klass, JVCPEntry *cp_entry)
  {
--- 445,464 ----
        printf(": TODO-> wide opcode not supported\n");
  }
! void print_method_throws(JVMethodEntry *method,JVCPEntry *cp_entry)
! {
!       int i;
!       int 
count=method->attr_entries[method->except_index].attributes.exception.except_count;
!       if((method->status_flags & METHOD_EXCEPTION) ==0)
!       {
!               return;
!               //no throws clause ? (you mean just like no santa clause ? ;-)
!       }
!       for(i=0;i<count;i++)
!       {
!                       printf("\t .throws ");
!                       
print_string_cp(cp_entry,method->attr_entries[method->except_index].attributes.exception.excepts[i].class_index);
!                       printf("\n");
!       }
! }
  void print_methods(JVClass *klass, JVCPEntry *cp_entry)
  {
***************
*** 342,346 ****
        {
                usage();
!               return;
        }
        while(argv[1][0] == '-' && argc > 1)
--- 506,510 ----
        {
                usage();
!               return ERROR;
        }
        while(argv[1][0] == '-' && argc > 1)

Index: jdasm.h
===================================================================
RCS file: /cvsroot/jilc/jilc/src/jdasm.h,v
retrieving revision 1.6
retrieving revision 1.7
diff -C2 -r1.6 -r1.7
*** jdasm.h     26 Feb 2002 05:05:06 -0000      1.6
--- jdasm.h     26 Feb 2002 22:31:23 -0000      1.7
***************
*** 21,29 ****
                                                      ((Int32)code[start + 3]) )
  */
! 
! #define READ_INT32(code,start) ( (Int32)((code[start]     << 0x18) | \
!                                         (code[start + 1] << 0x10) | \
!                                         (code[start + 2] << 0x08) | \
!                                         (code[start + 3])) )
  
  /*
--- 21,34 ----
                                                      ((Int32)code[start + 3]) )
  */
! //hoping these work ! ;-)
! #define READ_INT32(code,start) ( (Int32)((((Int32)code[start]    ) << 0x18) | 
\
!                                          (((Int32)code[start + 1] )<< 0x10) | 
\
!                                          (((Int32)code[start + 2] )<< 0x08) | 
\
!                                          (((Int32)code[start + 3] ) )) )
!               
! #define READ_UINT32(code,start) ((UInt32)((((UInt32)code[start] ) << 0x18) | \
!                                          (((UInt32)code[start + 1] )<< 0x10) 
| \
!                                          (((UInt32)code[start + 2] )<< 0x08) 
| \
!                                          (((UInt32)code[start + 3] ) )) )
  
  /*
***************
*** 32,45 ****
  */
  
! #define READ_INT16(code,start) ( (Int16) ((code[start]     << 0x08) | \
!                                           (code[start + 1])) )
  
  /**
   * Methods to help printing the deassmbled code.
   */
! 
  void print_interfaces(JVClass *klass, JVCPEntry *cp_entry);
  void print_fields(JVClass *klass, JVCPEntry *cp_entry);
! void print_string_cp(JVCPEntry *cp_entry, int i);
  void print_byte_code(byte *code, int *start_index, int code_len, UInt32 * 
jump_points, JVCPEntry *cp_entry);
  void print_method_code(JVMethodEntry *method, JVCPEntry *cp_entry);
--- 37,66 ----
  */
  
! #define READ_INT16(code,start) (Int16) ((((Int16)code[start]     << 0x08) | \
!                                           ((Int16)code[start + 1])) )
  
+ #define READ_UINT16(code,start) (UInt16)(((UInt16)code[start]     << 0x08) | \
+                                           ((UInt16)code[start + 1]) )
  /**
   * Methods to help printing the deassmbled code.
   */
! char *array_types[]=
! {
!       "JUNK 0",
!       "JUNK 1",
!       "JUNK 2",
!       "JUNK 3",
!       "boolean",//4
!       "char",//5
!       "float",//6
!       "double",//7
!       "byte",//8
!       "short",//9
!       "int",//10
!       "long"//11
! };
  void print_interfaces(JVClass *klass, JVCPEntry *cp_entry);
  void print_fields(JVClass *klass, JVCPEntry *cp_entry);
! void print_string_cp(JVCPEntry *cp_entry, unsigned int i);
  void print_byte_code(byte *code, int *start_index, int code_len, UInt32 * 
jump_points, JVCPEntry *cp_entry);
  void print_method_code(JVMethodEntry *method, JVCPEntry *cp_entry);
***************
*** 47,50 ****
--- 68,76 ----
  void print_class(JVClass *klass, JVCPEntry *cp_entry);
  
+ /* exception handling */
+ void print_method_throws(JVMethodEntry *method,JVCPEntry *cp_entry);
+ void mark_try_catch_blocks(JVAttributeEntry *code,int codelen, UInt32 
*jump_points,JVCPEntry *cp_entry);
+ /* label management */
+ UInt32 * get_jump_points(byte *code,int codelen);
  void usage(void);
  

Index: jopcodes.c
===================================================================
RCS file: /cvsroot/jilc/jilc/src/jopcodes.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -r1.5 -r1.6
*** jopcodes.c  25 Feb 2002 15:29:50 -0000      1.5
--- jopcodes.c  26 Feb 2002 22:31:23 -0000      1.6
***************
*** 18,30 ****
         {JAVA_AASTORE,"aastore",NONE},
         {JAVA_ACONST_NULL,"aconst_null",NONE},
!        {JAVA_ALOAD,"aload",I},
         {JAVA_ALOAD_0,"aload_0",NONE},
         {JAVA_ALOAD_1,"aload_1",NONE},
         {JAVA_ALOAD_2,"aload_2",NONE},
         {JAVA_ALOAD_3,"aload_3",NONE},
!        {JAVA_ANEWARRAY,"anewarray",CLASS},
         {JAVA_ARETURN,"areturn",NONE},
         {JAVA_ARRAYLENGTH,"arraylength",NONE},
!        {JAVA_ASTORE,"astore",I},
         {JAVA_ASTORE_0,"astore_0",NONE},
         {JAVA_ASTORE_1,"astore_1",NONE},
--- 18,30 ----
         {JAVA_AASTORE,"aastore",NONE},
         {JAVA_ACONST_NULL,"aconst_null",NONE},
!        {JAVA_ALOAD,"aload",I_U1},
         {JAVA_ALOAD_0,"aload_0",NONE},
         {JAVA_ALOAD_1,"aload_1",NONE},
         {JAVA_ALOAD_2,"aload_2",NONE},
         {JAVA_ALOAD_3,"aload_3",NONE},
!        {JAVA_ANEWARRAY,"anewarray",CLASS_U2},
         {JAVA_ARETURN,"areturn",NONE},
         {JAVA_ARRAYLENGTH,"arraylength",NONE},
!        {JAVA_ASTORE,"astore",I_U1},
         {JAVA_ASTORE_0,"astore_0",NONE},
         {JAVA_ASTORE_1,"astore_1",NONE},
***************
*** 34,42 ****
         {JAVA_BALOAD,"baload",NONE},
         {JAVA_BASTORE,"bastore",NONE},
!        {JAVA_BIPUSH,"bipush",I},
         {JAVA_BREAKPOINT,"breakpoint",NONE},
         {JAVA_CALOAD,"caload",NONE},
         {JAVA_CASTORE,"castore",NONE},
!        {JAVA_CHECKCAST,"checkcast",CLASS},
         {JAVA_D2F,"d2f",NONE},
         {JAVA_D2I,"d2i",NONE},
--- 34,42 ----
         {JAVA_BALOAD,"baload",NONE},
         {JAVA_BASTORE,"bastore",NONE},
!        {JAVA_BIPUSH,"bipush",I_S1},
         {JAVA_BREAKPOINT,"breakpoint",NONE},
         {JAVA_CALOAD,"caload",NONE},
         {JAVA_CASTORE,"castore",NONE},
!        {JAVA_CHECKCAST,"checkcast",CLASS_U2},
         {JAVA_D2F,"d2f",NONE},
         {JAVA_D2I,"d2i",NONE},
***************
*** 50,54 ****
         {JAVA_DCONST_1,"dconst_1",NONE},
         {JAVA_DDIV,"ddiv",NONE},
!        {JAVA_DLOAD,"dload",I},
         {JAVA_DLOAD_0,"dload_0",NONE},
         {JAVA_DLOAD_1,"dload_1",NONE},
--- 50,54 ----
         {JAVA_DCONST_1,"dconst_1",NONE},
         {JAVA_DDIV,"ddiv",NONE},
!        {JAVA_DLOAD,"dload",I_U1},
         {JAVA_DLOAD_0,"dload_0",NONE},
         {JAVA_DLOAD_1,"dload_1",NONE},
***************
*** 59,63 ****
         {JAVA_DREM,"drem",NONE},
         {JAVA_DRETURN,"dreturn",NONE},
!        {JAVA_DSTORE,"dstore",I},
         {JAVA_DSTORE_0,"dstore_0",NONE},
         {JAVA_DSTORE_1,"dstore_1",NONE},
--- 59,63 ----
         {JAVA_DREM,"drem",NONE},
         {JAVA_DRETURN,"dreturn",NONE},
!        {JAVA_DSTORE,"dstore",I_U1},
         {JAVA_DSTORE_0,"dstore_0",NONE},
         {JAVA_DSTORE_1,"dstore_1",NONE},
***************
*** 83,87 ****
         {JAVA_FCONST_2,"fconst_2",NONE},
         {JAVA_FDIV,"fdiv",NONE},
!        {JAVA_FLOAD,"fload",I},
         {JAVA_FLOAD_0,"fload_0",NONE},
         {JAVA_FLOAD_1,"fload_1",NONE},
--- 83,87 ----
         {JAVA_FCONST_2,"fconst_2",NONE},
         {JAVA_FDIV,"fdiv",NONE},
!        {JAVA_FLOAD,"fload",I_U1},
         {JAVA_FLOAD_0,"fload_0",NONE},
         {JAVA_FLOAD_1,"fload_1",NONE},
***************
*** 92,96 ****
         {JAVA_FREM,"frem",NONE},
         {JAVA_FRETURN,"freturn",NONE},
!        {JAVA_FSTORE,"fstore",I},
         {JAVA_FSTORE_0,"fstore_0",NONE},
         {JAVA_FSTORE_1,"fstore_1",NONE},
--- 92,96 ----
         {JAVA_FREM,"frem",NONE},
         {JAVA_FRETURN,"freturn",NONE},
!        {JAVA_FSTORE,"fstore",I_U1},
         {JAVA_FSTORE_0,"fstore_0",NONE},
         {JAVA_FSTORE_1,"fstore_1",NONE},
***************
*** 98,105 ****
         {JAVA_FSTORE_3,"fstore_3",NONE},
         {JAVA_FSUB,"fsub",NONE},
!        {JAVA_GETFIELD,"getfield",FIELD},
!        {JAVA_GETSTATIC,"getstatic",FIELD},
!        {JAVA_GOTO,"goto",LABEL},
!        {JAVA_GOTO_W,"goto_w",LABEL},
         {JAVA_I2D,"i2d",NONE},
         {JAVA_I2F,"i2f",NONE},
--- 98,105 ----
         {JAVA_FSTORE_3,"fstore_3",NONE},
         {JAVA_FSUB,"fsub",NONE},
!        {JAVA_GETFIELD,"getfield",FIELD_U2},
!        {JAVA_GETSTATIC,"getstatic",FIELD_U2},
!        {JAVA_GOTO,"goto",LABEL_S2},
!        {JAVA_GOTO_W,"goto_w",LABEL_S4},
         {JAVA_I2D,"i2d",NONE},
         {JAVA_I2F,"i2f",NONE},
***************
*** 117,138 ****
         {JAVA_ICONST_M1,"iconst_m1",NONE},
         {JAVA_IDIV,"idiv",NONE},
!        {JAVA_IF_ACMPEQ,"if_acmpeq",LABEL},
!        {JAVA_IF_ACMPNE,"if_acmpne",LABEL},
!        {JAVA_IF_ICMPEQ,"if_icmpeq",LABEL},
!        {JAVA_IF_ICMPGE,"if_icmpge",LABEL},
!        {JAVA_IF_ICMPGT,"if_icmpgt",LABEL},
!        {JAVA_IF_ICMPLE,"if_icmple",LABEL},
!        {JAVA_IF_ICMPLT,"if_icmplt",LABEL},
!        {JAVA_IF_ICMPNE,"if_icmpne",LABEL},
!        {JAVA_IFEQ,"ifeq",LABEL},
!        {JAVA_IFGE,"ifge",LABEL},
!        {JAVA_IFGT,"ifgt",LABEL},
!        {JAVA_IFLE,"ifle",LABEL},
!        {JAVA_IFLT,"iflt",LABEL},
!        {JAVA_IFNE,"ifne",LABEL},
!        {JAVA_IFNONNULL,"ifnonnull",LABEL},
!        {JAVA_IFNULL,"ifnull",LABEL},
!        {JAVA_IINC,"iinc",II},
!        {JAVA_ILOAD,"iload",I},
         {JAVA_ILOAD_0,"iload_0",NONE},
         {JAVA_ILOAD_1,"iload_1",NONE},
--- 117,138 ----
         {JAVA_ICONST_M1,"iconst_m1",NONE},
         {JAVA_IDIV,"idiv",NONE},
!        {JAVA_IF_ACMPEQ,"if_acmpeq",LABEL_S2},
!        {JAVA_IF_ACMPNE,"if_acmpne",LABEL_S2},
!        {JAVA_IF_ICMPEQ,"if_icmpeq",LABEL_S2},
!        {JAVA_IF_ICMPGE,"if_icmpge",LABEL_S2},
!        {JAVA_IF_ICMPGT,"if_icmpgt",LABEL_S2},
!        {JAVA_IF_ICMPLE,"if_icmple",LABEL_S2},
!        {JAVA_IF_ICMPLT,"if_icmplt",LABEL_S2},
!        {JAVA_IF_ICMPNE,"if_icmpne",LABEL_S2},
!        {JAVA_IFEQ,"ifeq",LABEL_S2},
!        {JAVA_IFGE,"ifge",LABEL_S2},
!        {JAVA_IFGT,"ifgt",LABEL_S2},
!        {JAVA_IFLE,"ifle",LABEL_S2},
!        {JAVA_IFLT,"iflt",LABEL_S2},
!        {JAVA_IFNE,"ifne",LABEL_S2},
!        {JAVA_IFNONNULL,"ifnonnull",LABEL_S2},
!        {JAVA_IFNULL,"ifnull",LABEL_S2},
!        {JAVA_IINC,"iinc",II_U1_S1},
!        {JAVA_ILOAD,"iload",I_U1},
         {JAVA_ILOAD_0,"iload_0",NONE},
         {JAVA_ILOAD_1,"iload_1",NONE},
***************
*** 141,153 ****
         {JAVA_IMUL,"imul",NONE},
         {JAVA_INEG,"ineg",NONE},
!        {JAVA_INSTANCEOF,"instanceof",CLASS},
         {JAVA_I2B,"i2b",NONE},
         {JAVA_I2C,"i2c",NONE},
         {JAVA_I2S,"i2s",NONE},
!        {JAVA_INVOKEINTERFACE,"invokeinterface",INTERFACE},
!        {JAVA_INVOKESPECIAL,"invokenonvirtual",METHOD},
!        {JAVA_INVOKESPECIAL,"invokespecial",METHOD},
!        {JAVA_INVOKESTATIC,"invokestatic",METHOD},
!        {JAVA_INVOKEVIRTUAL,"invokevirtual",METHOD},
         {JAVA_IOR,"ior",NONE},
         {JAVA_IREM,"irem",NONE},
--- 141,153 ----
         {JAVA_IMUL,"imul",NONE},
         {JAVA_INEG,"ineg",NONE},
!        {JAVA_INSTANCEOF,"instanceof",CLASS_U2},
         {JAVA_I2B,"i2b",NONE},
         {JAVA_I2C,"i2c",NONE},
         {JAVA_I2S,"i2s",NONE},
!        {JAVA_INVOKEINTERFACE,"invokeinterface",INTERFACE_U2_U1_X1},
!        {JAVA_INVOKESPECIAL,"invokenonvirtual",METHOD_U2},
!        {JAVA_INVOKESPECIAL,"invokespecial",METHOD_U2},
!        {JAVA_INVOKESTATIC,"invokestatic",METHOD_U2},
!        {JAVA_INVOKEVIRTUAL,"invokevirtual",METHOD_U2},
         {JAVA_IOR,"ior",NONE},
         {JAVA_IREM,"irem",NONE},
***************
*** 155,159 ****
         {JAVA_ISHL,"ishl",NONE},
         {JAVA_ISHR,"ishr",NONE},
!        {JAVA_ISTORE,"istore",I},
         {JAVA_ISTORE_0,"istore_0",NONE},
         {JAVA_ISTORE_1,"istore_1",NONE},
--- 155,159 ----
         {JAVA_ISHL,"ishl",NONE},
         {JAVA_ISHR,"ishr",NONE},
!        {JAVA_ISTORE,"istore",I_U1},
         {JAVA_ISTORE_0,"istore_0",NONE},
         {JAVA_ISTORE_1,"istore_1",NONE},
***************
*** 163,168 ****
         {JAVA_IUSHR,"iushr",NONE},
         {JAVA_IXOR,"ixor",NONE},
!        {JAVA_JSR,"jsr",LABEL},
!        {JAVA_JSR_W,"jsr_w",LABEL},
         {JAVA_L2D,"l2d",NONE},
         {JAVA_L2F,"l2f",NONE},
--- 163,168 ----
         {JAVA_IUSHR,"iushr",NONE},
         {JAVA_IXOR,"ixor",NONE},
!        {JAVA_JSR,"jsr",LABEL_S2},
!        {JAVA_JSR_W,"jsr_w",LABEL_S4},
         {JAVA_L2D,"l2d",NONE},
         {JAVA_L2F,"l2f",NONE},
***************
*** 175,183 ****
         {JAVA_LCONST_0,"lconst_0",NONE},
         {JAVA_LCONST_1,"lconst_1",NONE},
!        {JAVA_LDC,"ldc",CONSTANT},
!        {JAVA_LDC_W,"ldc_w",CONSTANT},
!        {JAVA_LDC2_W,"ldc2_w",BIGCONSTANT},
         {JAVA_LDIV,"ldiv",NONE},
!        {JAVA_LLOAD,"lload",I},
         {JAVA_LLOAD_0,"lload_0",NONE},
         {JAVA_LLOAD_1,"lload_1",NONE},
--- 175,183 ----
         {JAVA_LCONST_0,"lconst_0",NONE},
         {JAVA_LCONST_1,"lconst_1",NONE},
!        {JAVA_LDC,"ldc",CONSTANT_U1},
!        {JAVA_LDC_W,"ldc_w",CONSTANT_U2},
!        {JAVA_LDC2_W,"ldc2_w",BIGCONSTANT_U2},
         {JAVA_LDIV,"ldiv",NONE},
!        {JAVA_LLOAD,"lload",I_U1},
         {JAVA_LLOAD_0,"lload_0",NONE},
         {JAVA_LLOAD_1,"lload_1",NONE},
***************
*** 186,190 ****
         {JAVA_LMUL,"lmul",NONE},
         {JAVA_LNEG,"lneg",NONE},
!        {JAVA_LOOKUPSWITCH,"lookupswitch",SWITCH},
         {JAVA_LOR,"lor",NONE},
         {JAVA_LREM,"lrem",NONE},
--- 186,190 ----
         {JAVA_LMUL,"lmul",NONE},
         {JAVA_LNEG,"lneg",NONE},
!        {JAVA_LOOKUPSWITCH,"lookupswitch",LOOKUP_SWITCH},
         {JAVA_LOR,"lor",NONE},
         {JAVA_LREM,"lrem",NONE},
***************
*** 192,196 ****
         {JAVA_LSHL,"lshl",NONE},
         {JAVA_LSHR,"lshr",NONE},
!        {JAVA_LSTORE,"lstore",I},
         {JAVA_LSTORE_0,"lstore_0",NONE},
         {JAVA_LSTORE_1,"lstore_1",NONE},
--- 192,196 ----
         {JAVA_LSHL,"lshl",NONE},
         {JAVA_LSHR,"lshr",NONE},
!        {JAVA_LSTORE,"lstore",I_U1},
         {JAVA_LSTORE_0,"lstore_0",NONE},
         {JAVA_LSTORE_1,"lstore_1",NONE},
***************
*** 202,220 ****
         {JAVA_MONITORENTER,"monitorenter",NONE},
         {JAVA_MONITOREXIT,"monitorexit",NONE},
!        {JAVA_MULTIANEWARRAY,"multianewarray",MARRAY},
!        {JAVA_NEW,"new",CLASS},
!        {JAVA_NEWARRAY,"newarray",ARRAYTYPE},
         {JAVA_NOP,"nop",NONE},
         {JAVA_POP,"pop",NONE},
         {JAVA_POP2,"pop2",NONE},
!        {JAVA_PUTFIELD,"putfield",FIELD},
!        {JAVA_PUTSTATIC,"putstatic",FIELD},
!        {JAVA_RET,"ret",I},
         {JAVA_RETURN,"return",NONE},
         {JAVA_SALOAD,"saload",NONE},
         {JAVA_SASTORE,"sastore",NONE},
!        {JAVA_SIPUSH,"sipush",I},
         {JAVA_SWAP,"swap",NONE},
!        {JAVA_TABLESWITCH,"tableswitch",SWITCH},
         {JAVA_WIDE,"wide",IGNORE}
  };
--- 202,220 ----
         {JAVA_MONITORENTER,"monitorenter",NONE},
         {JAVA_MONITOREXIT,"monitorexit",NONE},
!        {JAVA_MULTIANEWARRAY,"multianewarray",MARRAY_U2_U1},
!        {JAVA_NEW,"new",CLASS_U2},
!        {JAVA_NEWARRAY,"newarray",ARRAYTYPE_U1},
         {JAVA_NOP,"nop",NONE},
         {JAVA_POP,"pop",NONE},
         {JAVA_POP2,"pop2",NONE},
!        {JAVA_PUTFIELD,"putfield",FIELD_U2},
!        {JAVA_PUTSTATIC,"putstatic",FIELD_U2},
!        {JAVA_RET,"ret",I_U1},
         {JAVA_RETURN,"return",NONE},
         {JAVA_SALOAD,"saload",NONE},
         {JAVA_SASTORE,"sastore",NONE},
!        {JAVA_SIPUSH,"sipush",I_S2},
         {JAVA_SWAP,"swap",NONE},
!        {JAVA_TABLESWITCH,"tableswitch",TABLE_SWITCH},
         {JAVA_WIDE,"wide",IGNORE}
  };

Index: jopcodes.h
===================================================================
RCS file: /cvsroot/jilc/jilc/src/jopcodes.h,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -r1.5 -r1.6
*** jopcodes.h  25 Feb 2002 15:29:09 -0000      1.5
--- jopcodes.h  26 Feb 2002 22:31:23 -0000      1.6
***************
*** 16,36 ****
  /* Count */
  
! #define NONE 0
! #define I    1
! #define II   2
  
  /* Construct */
  
! #define ARRAYTYPE    3
! #define BIGCONSTANT  4
! #define CONSTANT     5
! #define CLASS        6
! #define FIELD        7
! #define IGNORE       8
! #define INTERFACE    9
! #define LABEL       10
! #define METHOD      11
! #define MARRAY      12
! #define SWITCH      13
  /**
   * JOpcode defs
--- 16,42 ----
  /* Count */
  
! #define NONE          0
! #define I_U1          1
! #define I_U2          3
! #define I_S1          4
! #define I_S2          5
! #define II_U1_S1      6
  
  /* Construct */
  
! #define ARRAYTYPE_U1          7
! #define CONSTANT_U1           8
! #define CONSTANT_U2           9
! #define BIGCONSTANT_U2        10
! #define CLASS_U2              11
! #define FIELD_U2              12
! #define IGNORE                13
! #define INTERFACE_U2_U1_X1    14      
! #define LABEL_S2                      15
! #define LABEL_S4              16
! #define METHOD_U2                     17
! #define MARRAY_U2_U1                  18
! #define LOOKUP_SWITCH                 19
! #define TABLE_SWITCH                  20
  /**
   * JOpcode defs

Index: jparser.h
===================================================================
RCS file: /cvsroot/jilc/jilc/src/jparser.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -r1.3 -r1.4
*** jparser.h   22 Feb 2002 07:01:32 -0000      1.3
--- jparser.h   26 Feb 2002 22:31:23 -0000      1.4
***************
*** 63,66 ****
--- 63,75 ----
  
  /**
+  * Method Status (Flags)
+  */
+ 
+ #define METHOD_CODE                   0x0001
+ #define METHOD_EXCEPTION              0x0002
+ #define METHOD_CONSTANTVALUE  0x0004
+ #define METHOD_INNERCLASS             0x0008
+ 
+ /**
   * Java Constant Pool Entry structure
   */
***************
*** 200,203 ****
--- 209,213 ----
        UInt16            code_index;
        UInt16            except_index;
+       UInt16            status_flags;
        char             *full_flags;
        char             *full_name;
***************
*** 288,291 ****
  int process_source_attribute(JVAttributeEntry *attr_entry, JVCPEntry 
*cp_entry);
  int process_methodcode_attribute(JVAttributeEntry *code, JVCPEntry *cp_entry);
  
! #endif
\ No newline at end of file
--- 298,302 ----
  int process_source_attribute(JVAttributeEntry *attr_entry, JVCPEntry 
*cp_entry);
  int process_methodcode_attribute(JVAttributeEntry *code, JVCPEntry *cp_entry);
+ int process_exceptions_attribute(JVAttributeEntry *except,JVCPEntry *cp);
  
! #endif

Index: jparser.c
===================================================================
RCS file: /cvsroot/jilc/jilc/src/jparser.c,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -r1.3 -r1.4
*** jparser.c   21 Feb 2002 13:25:20 -0000      1.3
--- jparser.c   26 Feb 2002 22:31:23 -0000      1.4
***************
*** 429,432 ****
--- 429,439 ----
                        method->code_index = i;
                        
process_methodcode_attribute(&((method->attr_entries)[i]), cp_entry);
+                       method->status_flags = method->status_flags | 
METHOD_CODE;
+               }
+               else  if(strncmp("Exceptions", 
method->attr_entries[i].full_name,10) == 0)
+               {
+                       method->except_index = i;
+                       
process_exceptions_attribute(&((method->attr_entries)[i]),cp_entry);
+                       method->status_flags = method->status_flags | 
METHOD_EXCEPTION;
                }
        }
***************
*** 508,511 ****
--- 515,531 ----
        }
  
+       return OK;
+ }
+ int process_exceptions_attribute(JVAttributeEntry *except,JVCPEntry *cp)
+ {
+       int i;
+       
except->attributes.exception.except_count=buffer_read_uint16(except->buffer);
+       except->attributes.exception.excepts=\
+                       (JVException *) 
calloc(except->attributes.exception.except_count,\
+                                                                  
sizeof(JVException));
+       for(i=0;i < except->attributes.exception.except_count ; i++)
+       {
+               (except->attributes.exception.excepts[i]).class_index = 
buffer_read_uint16(except->buffer);
+       }
        return OK;
  }




reply via email to

[Prev in Thread] Current Thread [Next in Thread]