Author: martin
Date: 2005-04-10 23:20:33 -0400 (Sun, 10 Apr 2005)
New Revision: 42771

Modified:
   trunk/debugger/ChangeLog
   trunk/debugger/arch/Architecture_I386.cs
   trunk/debugger/arch/Architecture_PowerPC.cs
   trunk/debugger/arch/Architecture_X86_64.cs
   trunk/debugger/arch/Bfd.cs
   trunk/debugger/arch/DwarfReader.cs
   trunk/debugger/backends/mono/MonoSymbolFile.cs
   trunk/debugger/interfaces/IArchitecture.cs
Log:
2005-04-11  Martin Baulig  <[EMAIL PROTECTED]>

        * arch/DwarfReader.cs: Add support for x86_64.

        * arch/Bfd.cs (Bfd.GetTrampoline): Move arch-specific code into
        IArchitecture.

        * interface/IArchitecture.cs
        (IArchitecture.GetJumpTarget): New method.
        (IArchitecture.RegisterMap): New property.

        * backends/mono/MonoSymbolFile.cs (MonoVariable.register_map):
        Moved into IArchitecture.RegisterMap since it's arch-specific.  



Modified: trunk/debugger/ChangeLog
===================================================================
--- trunk/debugger/ChangeLog    2005-04-10 23:17:26 UTC (rev 42770)
+++ trunk/debugger/ChangeLog    2005-04-11 03:20:33 UTC (rev 42771)
@@ -1,3 +1,17 @@
+2005-04-11  Martin Baulig  <[EMAIL PROTECTED]>
+
+       * arch/DwarfReader.cs: Add support for x86_64.
+
+       * arch/Bfd.cs (Bfd.GetTrampoline): Move arch-specific code into
+       IArchitecture.
+
+       * interface/IArchitecture.cs
+       (IArchitecture.GetJumpTarget): New method.
+       (IArchitecture.RegisterMap): New property.
+
+       * backends/mono/MonoSymbolFile.cs (MonoVariable.register_map):
+       Moved into IArchitecture.RegisterMap since it's arch-specific.  
+
 2005-04-08  Chris Toshok  <[EMAIL PROTECTED]>
 
        * frontend/Command.cs (UpCommand, DownCommand): oops, fix these so

Modified: trunk/debugger/arch/Architecture_I386.cs
===================================================================
--- trunk/debugger/arch/Architecture_I386.cs    2005-04-10 23:17:26 UTC (rev 
42770)
+++ trunk/debugger/arch/Architecture_I386.cs    2005-04-11 03:20:33 UTC (rev 
42771)
@@ -129,6 +129,30 @@
                                return vtable_addr;
                }
 
+               public TargetAddress GetJumpTarget (ITargetMemoryAccess target, 
TargetAddress address,
+                                                   out int insn_size)
+               {
+                       ITargetMemoryReader reader = target.ReadMemory 
(address, 10);
+
+                       byte opcode = reader.ReadByte ();
+                       byte opcode2 = reader.ReadByte ();
+
+                       if ((opcode == 0xff) && (opcode2 == 0x25)) {
+                               insn_size = 2 + target.TargetAddressSize;
+                               return reader.ReadAddress ();
+                       } else if ((opcode == 0xff) && (opcode2 == 0xa3)) {
+                               int offset = reader.BinaryReader.ReadInt32 ();
+                               Registers regs = target.GetRegisters ();
+                               long ebx = regs [(int) I386Register.EBX].Value;
+
+                               insn_size = 6;
+                               return new TargetAddress (target.AddressDomain, 
ebx + offset);
+                       }
+
+                       insn_size = 0;
+                       return TargetAddress.Null;
+               }
+
                public TargetAddress GetTrampoline (ITargetMemoryAccess target,
                                                    TargetAddress location,
                                                    TargetAddress 
trampoline_address)
@@ -180,6 +204,12 @@
                        }
                }
 
+               public int[] RegisterMap {
+                       get {
+                               return register_map;
+                       }
+               }
+
                public int CountRegisters {
                        get {
                                return (int) I386Register.COUNT;
@@ -213,6 +243,13 @@
                                         (int) I386Register.ESP,
                                         (int) I386Register.EIP,
                                         (int) I386Register.EFLAGS };
+
+               // FIXME: Map mono/arch/x86/x86-codegen.h registers to
+               //        debugger/arch/IArchitecture_I386.cs registers.
+               int[] register_map = { (int) I386Register.EAX, (int) 
I386Register.ECX,
+                                      (int) I386Register.EDX, (int) 
I386Register.EBX,
+                                      (int) I386Register.ESP, (int) 
I386Register.EBP,
+                                      (int) I386Register.ESI, (int) 
I386Register.EDI };
                                
                string[] registers = { "ebx", "ecx", "edx", "esi", "edi", 
"ebp", "eax", "ds",
                                       "es", "fs", "gs", "eip", "cs", "eflags", 
"esp", "ss" };

Modified: trunk/debugger/arch/Architecture_PowerPC.cs
===================================================================
--- trunk/debugger/arch/Architecture_PowerPC.cs 2005-04-10 23:17:26 UTC (rev 
42770)
+++ trunk/debugger/arch/Architecture_PowerPC.cs 2005-04-11 03:20:33 UTC (rev 
42771)
@@ -69,6 +69,13 @@
                        return TargetAddress.Null;
                }
 
+               public TargetAddress GetJumpTarget (ITargetMemoryAccess target,
+                                                   TargetAddress address, out 
int insn_size)
+               {
+                       insn_size = 0;
+                       return TargetAddress.Null;
+               }
+
                public TargetAddress GetTrampoline (ITargetMemoryAccess target,
                                                    TargetAddress location,
                                                    TargetAddress 
trampoline_address)
@@ -119,6 +126,19 @@
                                   (int) PowerPCRegister.VRSAVE
                };
 
+               int[] register_map = { (int) PowerPCRegister.R0,
+                                      (int) PowerPCRegister.R1,
+                                      (int) PowerPCRegister.R1,
+                                      (int) PowerPCRegister.R2,
+                                      (int) PowerPCRegister.R3,
+                                      (int) PowerPCRegister.R4,
+                                      (int) PowerPCRegister.R5,
+                                      (int) PowerPCRegister.R6,
+                                      (int) PowerPCRegister.R7,
+                                      (int) PowerPCRegister.R8,
+                                      (int) PowerPCRegister.R9
+               };
+
                string[] registers = { "r0", "r1", "r2", "r3", "r4", "r5", 
"r6", "r7",
                                       "r8", "r9", "r10", "r11", "r12", "r13", 
"r14",
                                       "r15", "r16", "r17", "r18", "r19", 
"r20", "r21",
@@ -154,6 +174,12 @@
                        }
                }
 
+               public int[] RegisterMap {
+                       get {
+                               return register_map;
+                       }
+               }
+
                public int CountRegisters {
                        get {
                                return (int) PowerPCRegister.COUNT;

Modified: trunk/debugger/arch/Architecture_X86_64.cs
===================================================================
--- trunk/debugger/arch/Architecture_X86_64.cs  2005-04-10 23:17:26 UTC (rev 
42770)
+++ trunk/debugger/arch/Architecture_X86_64.cs  2005-04-11 03:20:33 UTC (rev 
42771)
@@ -44,11 +44,124 @@
        {
                public bool IsRetInstruction (ITargetMemoryAccess memory, 
TargetAddress address)
                {
-                       return false;
+                       return memory.ReadByte (address) == 0xc3;
                }
 
-               public TargetAddress GetCallTarget (ITargetMemoryAccess target, 
TargetAddress address, out int insn_size)
+               public TargetAddress GetCallTarget (ITargetMemoryAccess target, 
TargetAddress address,
+                                                   out int insn_size)
                {
+                       if (address.Address == 0xffffe002) {
+                               insn_size = 0;
+                               return TargetAddress.Null;
+                       }
+
+                       ITargetMemoryReader reader = target.ReadMemory 
(address, 6);
+
+                       byte opcode = reader.ReadByte ();
+
+                       if (opcode == 0xe8) {
+                               int call_target = reader.ReadInteger ();
+                               insn_size = 5;
+                               return address + reader.Offset + call_target;
+                       } else if (opcode != 0xff) {
+                               insn_size = 0;
+                               return TargetAddress.Null;
+                       }
+
+                       byte address_byte = reader.ReadByte ();
+                       byte register;
+                       int disp;
+                       bool dereference_addr;
+
+                       if (((address_byte & 0x38) == 0x10) && ((address_byte 
>> 6) == 1)) {
+                               register = (byte) (address_byte & 0x07);
+                               disp = reader.ReadByte ();
+                               insn_size = 3;
+                               dereference_addr = true;
+                       } else if (((address_byte & 0x38) == 0x10) && 
((address_byte >> 6) == 2)) {
+                               register = (byte) (address_byte & 0x07);
+                               disp = reader.ReadInteger ();
+                               insn_size = 6;
+                               dereference_addr = true;
+                       } else if (((address_byte & 0x38) == 0x10) && 
((address_byte >> 6) == 3)) {
+                               register = (byte) (address_byte & 0x07);
+                               disp = 0;
+                               insn_size = 2;
+                               dereference_addr = false;
+                       } else if (((address_byte & 0x38) == 0x10) && 
((address_byte >> 6) == 0)) {
+                               register = (byte) (address_byte & 0x07);
+                               disp = 0;
+                               insn_size = 2;
+                               dereference_addr = true;
+                       } else {
+                               insn_size = 0;
+                               return TargetAddress.Null;
+                       }
+
+                       X86_64_Register reg;
+                       switch (register) {
+                       case 0:
+                               reg = X86_64_Register.RAX;
+                               break;
+
+                       case 1:
+                               reg = X86_64_Register.RCX;
+                               break;
+
+                       case 2:
+                               reg = X86_64_Register.RDX;
+                               break;
+
+                       case 3:
+                               reg = X86_64_Register.RBX;
+                               break;
+
+                       case 6:
+                               reg = X86_64_Register.RSI;
+                               break;
+
+                       case 7:
+                               reg = X86_64_Register.RDI;
+                               break;
+
+                       default:
+                               insn_size = 0;
+                               return TargetAddress.Null;
+                       }
+
+                       Registers regs = target.GetRegisters ();
+                       Register addr = regs [(int) reg];
+
+                       TargetAddress vtable_addr = new TargetAddress 
(target.GlobalAddressDomain, addr);
+                       vtable_addr += disp;
+
+                       if (dereference_addr)
+                               return target.ReadGlobalAddress (vtable_addr);
+                       else
+                               return vtable_addr;
+               }
+
+               public TargetAddress GetJumpTarget (ITargetMemoryAccess target, 
TargetAddress address,
+                                                   out int insn_size)
+               {
+                       ITargetMemoryReader reader = target.ReadMemory 
(address, 10);
+
+                       byte opcode = reader.ReadByte ();
+                       byte opcode2 = reader.ReadByte ();
+
+                       if ((opcode == 0xff) && (opcode2 == 0x25)) {
+                               insn_size = 6;
+                               int offset = reader.BinaryReader.ReadInt32 ();
+                               return address + offset + 6;
+                       } else if ((opcode == 0xff) && (opcode2 == 0xa3)) {
+                               int offset = reader.BinaryReader.ReadInt32 ();
+                               Registers regs = target.GetRegisters ();
+                               long rbx = regs [(int) 
X86_64_Register.RBX].Value;
+
+                               insn_size = 6;
+                               return new TargetAddress (target.AddressDomain, 
rbx + offset);
+                       }
+
                        insn_size = 0;
                        return TargetAddress.Null;
                }
@@ -84,6 +197,12 @@
                        }
                }
 
+               public int[] RegisterMap {
+                       get {
+                               return register_map;
+                       }
+               }
+
                public int CountRegisters {
                        get {
                                return (int) X86_64_Register.COUNT;
@@ -128,6 +247,13 @@
                                         (int) X86_64_Register.EFLAGS,
                                         (int) X86_64_Register.RSP };
 
+               // FIXME: Map mono/arch/amd64/amd64-codegen.h registers to
+               //        debugger/arch/IArchitecture_X86_64.cs registers.
+               int[] register_map = { (int) X86_64_Register.RAX, (int) 
X86_64_Register.RCX,
+                                      (int) X86_64_Register.RDX, (int) 
X86_64_Register.RBX,
+                                      (int) X86_64_Register.RSP, (int) 
X86_64_Register.RBP,
+                                      (int) X86_64_Register.RSI, (int) 
X86_64_Register.RDI };
+
                string[] registers = { "r15", "r14", "r13", "r12", "rbp", 
"rbx", "r11", "r10",
                                       "r9", "r8", "rax", "rcx", "rdx", "rsi", 
"rdi", "orig_rax",
                                       "rip", "cs", "eflags", "rsp", "fs_base", 
"gs_base",
@@ -149,7 +275,7 @@
                        if (!register.Valid)
                                return "XXXXXXXX";
 
-                       int bits = 8;
+                       int bits = 16;
                        string saddr = register.Value.ToString ("x");
                        for (int i = saddr.Length; i < bits; i++)
                                saddr = "0" + saddr;
@@ -160,8 +286,9 @@
                {
                        Registers registers = frame.Registers;
                        return String.Format (
-                               "RAX={0}  RBX={1}  RCX={2}  RDX={3}  RSI={4}  
RDI={5}\n" +
-                               "RBP={6}  RSP={7}  RIP={8}  EFLAGS={9}\n",
+                               "RAX={0}  RBX={1}  RCX={2}  RDX={3}\n" +
+                               "RSI={4}  RDI={5}  RBP={6}  RSP={7}\n" +
+                               "RIP={8}  EFLAGS={9}\n",
                                format (registers [(int) X86_64_Register.RAX]),
                                format (registers [(int) X86_64_Register.RBX]),
                                format (registers [(int) X86_64_Register.RCX]),

Modified: trunk/debugger/arch/Bfd.cs
===================================================================
--- trunk/debugger/arch/Bfd.cs  2005-04-10 23:17:26 UTC (rev 42770)
+++ trunk/debugger/arch/Bfd.cs  2005-04-11 03:20:33 UTC (rev 42771)
@@ -1018,22 +1018,9 @@
                                return TargetAddress.Null;
                        }
 
-                       ITargetMemoryReader reader = memory.ReadMemory 
(address, 10);
-
-                       byte opcode = reader.ReadByte ();
-                       byte opcode2 = reader.ReadByte ();
-
-                       TargetAddress jmp_target;
-                       if ((opcode == 0xff) && (opcode2 == 0x25)) {
-                               jmp_target = reader.ReadAddress ();
-                       } else if ((opcode == 0xff) && (opcode2 == 0xa3)) {
-                               int offset = reader.BinaryReader.ReadInt32 ();
-                               Registers regs = memory.GetRegisters ();
-                               long ebx = regs [(int) I386Register.EBX].Value;
-
-                               jmp_target = new TargetAddress (
-                                       memory.AddressDomain, ebx + offset);
-                       } else {
+                       int insn_size;
+                       TargetAddress jmp_target = arch.GetJumpTarget (memory, 
address, out insn_size);
+                       if (jmp_target.IsNull) {
                                is_start = false;
                                return TargetAddress.Null;
                        }
@@ -1046,7 +1033,7 @@
                        }
 
                        is_start = true;
-                       return memory.ReadGlobalAddress (got_start + 8);
+                       return memory.ReadGlobalAddress (got_start + 2 * 
memory.TargetAddressSize);
                }
 
                internal override SimpleStackFrame UnwindStack 
(SimpleStackFrame frame,

Modified: trunk/debugger/arch/DwarfReader.cs
===================================================================
--- trunk/debugger/arch/DwarfReader.cs  2005-04-10 23:17:26 UTC (rev 42770)
+++ trunk/debugger/arch/DwarfReader.cs  2005-04-11 03:20:33 UTC (rev 42771)
@@ -98,6 +98,7 @@
                protected string filename;
                bool is64bit;
                byte address_size;
+               int frame_register;
 
                ObjectCache debug_info_reader;
                ObjectCache debug_abbrev_reader;
@@ -125,6 +126,14 @@
                        this.factory = factory;
                        this.target_info = bfd.TargetInfo;
 
+                       if (bfd.Target == "elf32-i386")
+                               frame_register = (int) I386Register.EBP;
+                       else if (bfd.Target == "elf64-x86-64")
+                               frame_register = (int) X86_64_Register.RBP;
+                       else
+                               throw new DwarfException (
+                                       bfd, "Unknown architecture: {0}", 
bfd.Target);
+
                        debug_info_reader = create_reader (".debug_info");
 
                        DwarfBinaryReader reader = DebugInfoReader;
@@ -181,7 +190,7 @@
 
                public static bool IsSupported (Bfd bfd)
                {
-                       if (bfd.Target == "elf32-i386")
+                       if ((bfd.Target == "elf32-i386") || (bfd.Target == 
"elf64-x86-64"))
                                return bfd.HasSection (".debug_info");
                        else
                                return false;
@@ -2381,20 +2390,25 @@
 
                protected class TargetVariable : IVariable
                {
+                       DwarfReader dwarf;
                        string name;
                        NativeType type;
                        TargetBinaryReader location;
                        int offset;
 
-                       public TargetVariable (string name, NativeType type, 
TargetBinaryReader location)
+                       public TargetVariable (DwarfReader dwarf, string name, 
NativeType type,
+                                              TargetBinaryReader location)
                        {
+                               this.dwarf = dwarf;
                                this.name = name;
                                this.type = type;
                                this.location = location;
                        }
 
-                       public TargetVariable (string name, NativeType type, 
int offset)
+                       public TargetVariable (DwarfReader dwarf, string name, 
NativeType type,
+                                              int offset)
                        {
+                               this.dwarf = dwarf;
                                this.name = name;
                                this.type = type;
                                this.offset = offset;
@@ -2444,7 +2458,7 @@
                                        off = offset;
                                }
 
-                               return new MonoVariableLocation (frame, true, 
(int) I386Register.EBP,
+                               return new MonoVariableLocation (frame, true, 
dwarf.frame_register,
                                                                 off, 
type.IsByRef, 0);
                        }
 
@@ -3114,10 +3128,12 @@
                                if (!use_constant) {
                                        TargetBinaryReader locreader = new 
TargetBinaryReader (
                                                       location_block, 
target_info);
-                                       variable = new TargetVariable (Name, 
type, locreader);
+                                       variable = new TargetVariable (
+                                               dwarf, Name, type, locreader);
                                }
                                else {
-                                       variable = new TargetVariable (Name, 
type, (int)location_constant);
+                                       variable = new TargetVariable (
+                                               dwarf, Name, type, 
(int)location_constant);
                                }
                                return true;
                        }

Modified: trunk/debugger/backends/mono/MonoSymbolFile.cs
===================================================================
--- trunk/debugger/backends/mono/MonoSymbolFile.cs      2005-04-10 23:17:26 UTC 
(rev 42770)
+++ trunk/debugger/backends/mono/MonoSymbolFile.cs      2005-04-11 03:20:33 UTC 
(rev 42771)
@@ -31,14 +31,7 @@
                        get { return 20; }
                }
 
-               // FIXME: Map mono/arch/x86/x86-codegen.h registers to
-               //        debugger/arch/IArchitectureI386.cs registers.
-               int[] register_map = { (int)I386Register.EAX, 
(int)I386Register.ECX,
-                                      (int)I386Register.EDX, 
(int)I386Register.EBX,
-                                      (int)I386Register.ESP, 
(int)I386Register.EBP,
-                                      (int)I386Register.ESI, 
(int)I386Register.EDI };
-
-               public VariableInfo (TargetBinaryReader reader)
+               public VariableInfo (IArchitecture arch, TargetBinaryReader 
reader)
                {
                        Index = reader.ReadLeb128 ();
                        Offset = reader.ReadSLeb128 ();
@@ -49,9 +42,13 @@
                        Mode = (AddressMode) (Index & AddressModeFlags);
                        Index = (int) ((long) Index & ~AddressModeFlags);
 
+                       Console.WriteLine ("VARIABLE INFO: {0} {1} {2}", Mode, 
Index, arch);
+
                        if (Mode == AddressMode.Register)
-                               Index = register_map [Index];
+                               Index = arch.RegisterMap [Index];
 
+                       Console.WriteLine ("VARIABLE INFO #1: {0}", Index);
+
                        HasLivenessInfo = (BeginLiveness != 0) && (EndLiveness 
!= 0);
                }
 
@@ -124,7 +121,8 @@
                                return TargetAddress.Null;
                }
 
-               public MethodAddress (C.MethodEntry entry, TargetBinaryReader 
reader, AddressDomain domain)
+               public MethodAddress (C.MethodEntry entry, TargetBinaryReader 
reader,
+                                     AddressDomain domain, IArchitecture arch)
                {
                        reader.Position = 16;
                        StartAddress = ReadAddress (reader, domain);
@@ -169,17 +167,17 @@
 
                        HasThis = reader.ReadByte () != 0;
                        if (HasThis)
-                               ThisVariableInfo = new VariableInfo (reader);
+                               ThisVariableInfo = new VariableInfo (arch, 
reader);
 
                        int num_params = reader.ReadLeb128 ();
                        ParamVariableInfo = new VariableInfo [num_params];
                        for (int i = 0; i < num_params; i++)
-                               ParamVariableInfo [i] = new VariableInfo 
(reader);
+                               ParamVariableInfo [i] = new VariableInfo (arch, 
reader);
 
                        int num_locals = reader.ReadLeb128 ();
                        LocalVariableInfo = new VariableInfo [num_locals];
                        for (int i = 0; i < num_locals; i++)
-                               LocalVariableInfo [i] = new VariableInfo 
(reader);
+                               LocalVariableInfo [i] = new VariableInfo (arch, 
reader);
                }
 
                public override string ToString ()
@@ -200,7 +198,7 @@
                internal readonly C.MonoSymbolFile File;
                internal readonly ThreadManager ThreadManager;
                internal readonly AddressDomain GlobalAddressDomain;
-               internal readonly ITargetInfo TargetInfo;
+               internal readonly ITargetMemoryInfo TargetInfo;
                internal readonly MonoLanguageBackend MonoLanguage;
                protected readonly DebuggerBackend backend;
                readonly MonoSymbolTable symtab;
@@ -218,7 +216,7 @@
                Hashtable method_index_hash;
 
                internal MonoSymbolFile (MonoLanguageBackend language, 
DebuggerBackend backend,
-                                        ITargetInfo target_info, 
ITargetMemoryAccess memory,
+                                        ITargetMemoryInfo target_info, 
ITargetMemoryAccess memory,
                                         TargetAddress address)
                {
                        this.MonoLanguage = language;
@@ -296,6 +294,10 @@
                        get { return this; }
                }
 
+               internal IArchitecture Architecture {
+                       get { return TargetInfo.Architecture; }
+               }
+
                public override bool SymbolsLoaded {
                        get { return LoadSymbols; }
                }
@@ -600,7 +602,8 @@
 
                                is_loaded = true;
 
-                               address = new MethodAddress (method, 
dynamic_reader, domain);
+                               address = new MethodAddress (
+                                       method, dynamic_reader, domain, 
file.Architecture);
 
                                SetAddresses (address.StartAddress, 
address.EndAddress);
                                SetMethodBounds (address.MethodStartAddress, 
address.MethodEndAddress);

Modified: trunk/debugger/interfaces/IArchitecture.cs
===================================================================
--- trunk/debugger/interfaces/IArchitecture.cs  2005-04-10 23:17:26 UTC (rev 
42770)
+++ trunk/debugger/interfaces/IArchitecture.cs  2005-04-11 03:20:33 UTC (rev 
42771)
@@ -30,6 +30,10 @@
                        get;
                }
 
+               int[] RegisterMap {
+                       get;
+               }
+
                int CountRegisters {
                        get;
                }
@@ -55,6 +59,9 @@
                TargetAddress GetCallTarget (ITargetMemoryAccess target, 
TargetAddress address,
                                             out int insn_size);
 
+               TargetAddress GetJumpTarget (ITargetMemoryAccess target, 
TargetAddress address,
+                                            out int insn_size);
+
                // <summary>
                //   Check whether the instruction at target address @address 
is a trampoline method.
                //   If it's a trampoline, return the address of the 
corresponding method's

_______________________________________________
Mono-patches maillist  -  [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches

Reply via email to