URL https://opencores.org/ocsvn/openmsp430/openmsp430/trunk

Subversion Repositories openmsp430

[/] [openmsp430/] [trunk/] [tools/] [openmsp430-gdbproxy/] [commands.tcl] - Blame information for rev 217

Details | Compare with Previous | View Log


#!/usr/bin/wish
#------------------------------------------------------------------------------
# Copyright (C) 2001 Authors
#
# This source file may be used and distributed without restriction provided
# that this copyright statement is not removed from the file and that any
# derivative work contains the original copyright notice and the associated
# disclaimer.
#
# This source file is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published
# by the Free Software Foundation; either version 2.1 of the License, or
# (at your option) any later version.
#
# This source is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
# License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this source; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
#
#------------------------------------------------------------------------------
#
# File Name: commands.tcl
#
# Author(s):
#             - Olivier Girard,    olgirard@gmail.com
#
#------------------------------------------------------------------------------
# $Rev: 217 $
# $LastChangedBy: olivier.girard $
# $LastChangedDate: 2016-08-01 23:04:04 +0200 (Mon, 01 Aug 2016) $
#------------------------------------------------------------------------------
 
global mem_breakpoint
global mem_mapping
global breakSelect
 
###############################################################################
#                                                                             #
#                              RSP COMMAND PARSER                             #
#                                                                             #
###############################################################################
 
proc rspParse {CpuNr sock rsp_cmd} {
 
    set rsp_answer ""
    set cmd_tail [string range $rsp_cmd 1 [string length $rsp_cmd]]
 
    switch -exact -- [string index $rsp_cmd 0] {
        "!"     {set rsp_answer "OK"}
        "?"     {set rsp_answer [rsp_stop_reply $CpuNr $sock "?"]}
        "A"     {}
        "b"     {}
        "c"     {set rsp_answer [rsp_c $CpuNr $sock $cmd_tail]}
        "C"     {set rsp_answer [rsp_c $CpuNr $sock $cmd_tail]}
        "D"     {}
        "F"     {}
        "g"     {set rsp_answer [rsp_g $CpuNr]}
        "G"     {set rsp_answer [rsp_G $CpuNr $cmd_tail]}
        "H"     {set rsp_answer ""}
        "i"     {}
        "I"     {}
        "k"     {set rsp_answer [rsp_k $CpuNr $cmd_tail]}
        "m"     {set rsp_answer [rsp_m $CpuNr $cmd_tail]}
        "M"     {set rsp_answer [rsp_M $CpuNr $cmd_tail]}
        "p"     {}
        "P"     {}
        "q"     {set rsp_answer [rsp_q $CpuNr $sock $cmd_tail]}
        "Q"     {}
        "R"     {}
        "s"     {set rsp_answer [rsp_s $CpuNr $sock $cmd_tail]}
        "S"     {set rsp_answer [rsp_s $CpuNr $sock $cmd_tail]}
        "t"     {}
        "T"     {}
        "v"     {}
        "X"     {}
        "z"     {set rsp_answer [rsp_z $CpuNr $sock $cmd_tail]}
        "Z"     {set rsp_answer [rsp_Z $CpuNr $sock $cmd_tail]}
        default {}
    }
 
 
    return $rsp_answer
}
 
 
###############################################################################
#                                                                             #
#                                   RSP COMMANDS                              #
#                                                                             #
###############################################################################
 
#-----------------------------------------------------------------------------#
# Read CPU registers                                                          #
#-----------------------------------------------------------------------------#
proc rsp_g {CpuNr} {
 
    global mspgcc_compat_mode
 
    # Read register value
    set reg_val [ReadRegAll $CpuNr]
 
    # Format answer
    set rsp_answer ""
    for {set i 0} {$i < [llength $reg_val]} {incr i} {
        regexp {0x(..)(..)} [lindex $reg_val $i] match msb lsb
        if {$mspgcc_compat_mode} {
            append rsp_answer "$lsb$msb"
        } else {
            append rsp_answer "$lsb${msb}0000"
        }
    }
 
    return $rsp_answer
}
 
#-----------------------------------------------------------------------------#
# Write CPU registers                                                         #
#-----------------------------------------------------------------------------#
proc rsp_G {CpuNr cmd} {
 
    global mspgcc_compat_mode
 
    # Format register value
    if {$mspgcc_compat_mode} {
        set num_reg [expr [string length $cmd]/4]
    } else {
        set num_reg [expr [string length $cmd]/8]
    }
    set reg_val ""
    for {set i 0} {$i < $num_reg} {incr i} {
        if {$mspgcc_compat_mode} {
            set lsb "[string index $cmd [expr $i*4+0]][string index $cmd [expr $i*4+1]]"
            set msb "[string index $cmd [expr $i*4+2]][string index $cmd [expr $i*4+3]]"
        } else {
            set lsb "[string index $cmd [expr $i*8+0]][string index $cmd [expr $i*8+1]]"
            set msb "[string index $cmd [expr $i*8+2]][string index $cmd [expr $i*8+3]]"
        }
        lappend reg_val "0x$msb$lsb"
    }
 
    # Write registers
    WriteRegAll $CpuNr $reg_val
 
    return "OK"
}
 
 
#-----------------------------------------------------------------------------#
# Kill request.                                                               #
#-----------------------------------------------------------------------------#
proc rsp_k {CpuNr cmd} {
 
    # Reset & Stop CPU
    ExecutePOR_Halt $CpuNr
 
    return "-1"
}
 
#-----------------------------------------------------------------------------#
# Write length bytes of memory.                                               #
#-----------------------------------------------------------------------------#
proc rsp_M {CpuNr cmd} {
 
    global mem_breakpoint
    global mem_mapping
    global breakSelect
 
    # Parse command
    regexp {(.*),(.*):(.*)} $cmd match addr length data
    set addr   [format %04x "0x$addr"]
    set length [format %d   "0x$length"]
 
    # Format data
    set mem_val ""
    for {set i 0} {$i<$length} {incr i} {
        lappend mem_val "0x[string range $data [expr $i*2] [expr $i*2+1]]"
    }
 
    # Write memory
    if {$length==2} {
        regexp {(..)(..)} $data match data_lo data_hi
        WriteMem       $CpuNr 0 "0x$addr" "0x${data_hi}${data_lo}"
    } else {
        WriteMemQuick8 $CpuNr   "0x$addr" $mem_val
    }
 
    # Eventually re-set the software breakpoints in case they have been overwritten
    if {$breakSelect==0} {
        set addr_start [format %d "0x$addr"]
        foreach {brk_addr brk_val} [array get mem_breakpoint] {
            regsub {,} $brk_addr { } brk_addr_lst
            if {[lindex $brk_addr_lst 0]==$mem_mapping($CpuNr)} {
                set brk_addr_dec    [format %d "0x[lindex $brk_addr_lst 1]"]
                set brk_addr_offset [expr $brk_addr_dec-$addr_start]
                if {(0<=$brk_addr_offset) && ($brk_addr_offset<=$length)} {
                    set mem_breakpoint($brk_addr) [lindex $mem_val $brk_addr_offset]
                    WriteMem $CpuNr 0 "0x[lindex $brk_addr 1]" 0x4343
                }
            }
        }
    }
 
    return "OK"
}
 
 
#-----------------------------------------------------------------------------#
# Read length bytes from memory.                                              #
#-----------------------------------------------------------------------------#
proc rsp_m {CpuNr cmd} {
 
    global mem_breakpoint
    global mem_mapping
    global breakSelect
 
    # Parse command
    regexp {(.*),(.*)} $cmd match addr length
    set addr   [format %04x "0x$addr"]
    set length [format %d   "0x$length"]
 
    # Read memory
    set data [ReadMemQuick8  $CpuNr "0x$addr" $length]
 
 
    # Eventually replace read data by the original software breakpoint value
    if {$breakSelect==0} {
        set addr_start [format %d "0x$addr"]
        foreach {brk_addr brk_val} [array get mem_breakpoint] {
            regsub {,} $brk_addr { } brk_addr_lst
            if {[lindex $brk_addr_lst 0]==$mem_mapping($CpuNr)} {
                set brk_addr_dec    [format %d "0x[lindex $brk_addr_lst 1]"]
                set brk_addr_offset [expr $brk_addr_dec-$addr_start]
                if {(0<=$brk_addr_offset) && ($brk_addr_offset<=$length)} {
                    set data [lreplace $data $brk_addr_offset $brk_addr_offset "0x$mem_breakpoint($brk_addr)"]
                }
            }
        }
    }
 
    # Format data
    regsub -all {0x} $data {} data
    regsub -all { }  $data {} data
 
    return $data
}
 
 
#-----------------------------------------------------------------------------#
# Insert breakpoint.                                                          #
#-----------------------------------------------------------------------------#
proc rsp_Z {CpuNr sock cmd} {
 
    global mem_breakpoint
    global mem_mapping
    global breakSelect
 
    # Parse command
    regexp {(.),(.*),(.*)} $cmd match type addr length
    set addr   [format %04x "0x$addr"]
 
    switch -exact -- $type {
        "0"     {# Soft Memory breakpoint
                 if {$breakSelect==0} {
                     if {![info exists mem_breakpoint($mem_mapping($CpuNr),$addr)]} {
                         set mem_breakpoint($mem_mapping($CpuNr),$addr) [ReadMem $CpuNr 0 "0x$addr"]
                         WriteMem $CpuNr 0 "0x$addr" 0x4343
                     }
                     return "OK"
 
                 # Hard Memory breakpoint
                 } else {
                     if {[SetHWBreak $CpuNr 1 [format "0x%04x" 0x$addr] 1 0]} {
                         #putsLog "CORE $CpuNr: --- INFO --- SET HARDWARE MEMORY BREAKPOINT. "
                         return "OK"
                     }
                     putsLog "CORE $CpuNr: --- ERROR --- NO MORE HARDWARE MEMORY BREAKPOINT AVAILABLE. "
                     return ""
                 }
                }
 
        "1"     {# Hardware breakpoint
                 if {[SetHWBreak $CpuNr 1 [format "0x%04x" 0x$addr] 1 0]} {
                     return "OK"
                 }
                 putsLog "CORE $CpuNr: --- ERROR --- NO MORE HARDWARE BREAKPOINT AVAILABLE. "
                 return ""
                }
 
        "2"     {# Write watchpoint
                 if {[SetHWBreak $CpuNr 0 [format "0x%04x" 0x$addr] 0 1]} {
                     return "OK"
                 }
                 putsLog "CORE $CpuNr: --- ERROR --- NO MORE WRITE WATCHPOINT AVAILABLE. "
                 return ""
                }
 
        "3"     {# Read watchpoint
                 if {[SetHWBreak $CpuNr 0 [format "0x%04x" 0x$addr] 1 0]} {
                     return "OK"
                 }
                 putsLog "CORE $CpuNr: --- ERROR --- NO MORE READ WATCHPOINT AVAILABLE. "
                 return ""
                }
 
        "4"     {# Access watchpoint
                 if {[SetHWBreak $CpuNr 0 [format "0x%04x" 0x$addr] 1 1]} {
                     return "OK"
                 }
                 putsLog "CORE $CpuNr: --- ERROR --- NO MORE ACCESS WATCHPOINT AVAILABLE. "
                 return ""
                }
 
        default {return ""}
    }
}
 
#-----------------------------------------------------------------------------#
# Remove breakpoint.                                                          #
#-----------------------------------------------------------------------------#
proc rsp_z {CpuNr sock cmd} {
 
    global mem_breakpoint
    global mem_mapping
    global breakSelect
 
    # Parse command
    regexp {(.),(.*),(.*)} $cmd match type addr length
    set addr   [format %04x "0x$addr"]
 
    switch -exact -- $type {
        "0"     {# Soft Memory breakpoint
                 if {$breakSelect==0} {
                     if {[info exists mem_breakpoint($mem_mapping($CpuNr),$addr)]} {
                         WriteMem $CpuNr 0 "0x$addr" $mem_breakpoint($mem_mapping($CpuNr),$addr)
                         unset mem_breakpoint($mem_mapping($CpuNr),$addr)
                     }
                     return "OK"
 
                 # Hard Memory breakpoint
                 } else {
                     if {[ClearHWBreak $CpuNr 1 [format "0x%04x" 0x$addr]]} {
                         #putsLog "CORE $CpuNr: --- INFO --- RELEASE HARDWARE MEMORY BREAKPOINT. "
                         return "OK"
                     }
                     putsLog "CORE $CpuNr: --- ERROR --- COULD NOT REMOVE HARDWARE MEMORY BREAKPOINT. "
                     return ""
                 }
                }
 
        "1"     {# Hardware breakpoint
                 if {[ClearHWBreak $CpuNr 1 [format "0x%04x" 0x$addr]]} {
                     return "OK"
                 }
                 return ""
                }
 
        "2"     {# Write watchpoint
                 if {[ClearHWBreak $CpuNr 0 [format "0x%04x" 0x$addr]]} {
                     return "OK"
                 }
                 return ""
                }
 
        "3"     {# Read watchpoint
                 if {[ClearHWBreak $CpuNr 0 [format "0x%04x" 0x$addr]]} {
                     return "OK"
                 }
                 return ""
                }
 
        "4"     {# Access watchpoint
                 if {[ClearHWBreak $CpuNr 0 [format "0x%04x" 0x$addr]]} {
                     return "OK"
                 }
                 return ""
                }
 
        default {return ""}
    }
}
 
#-----------------------------------------------------------------------------#
# Continue.                                                                   #
#-----------------------------------------------------------------------------#
proc rsp_c {CpuNr sock cmd} {
 
    # Set address if required
    if {$cmd!=""} {
        set cmd [format %04x "0x$cmd"]
        SetPC $CpuNr "0x$cmd"
    }
 
    # Clear status
    ClrStatus  $CpuNr
 
    # Continue
    ReleaseCPU $CpuNr
 
 
    return [rsp_stop_reply $CpuNr $sock "c"]
}
 
#-----------------------------------------------------------------------------#
# Step.                                                                       #
#-----------------------------------------------------------------------------#
proc rsp_s {CpuNr sock cmd} {
 
    # Set address if required
    if {$cmd!=""} {
        set cmd [format %04x "0x$cmd"]
        SetPC $CpuNr "0x$cmd"
    }
 
    # Clear status
    ClrStatus $CpuNr
 
    # Read current PC value
    set pc [ReadReg $CpuNr 0]
 
    # Incremental step
    StepCPU $CpuNr
 
    return [rsp_stop_reply $CpuNr $sock "s" $pc]
}
 
 
#-----------------------------------------------------------------------------#
# The `C', `c', `S', `s', `vCont', `vAttach', `vRun', `vStopped', and `?'     #
# packets can receive any of the below as a reply. Except for `?' and         #
# `vStopped', that reply is only returned when the target halts.              #
#-----------------------------------------------------------------------------#
proc rsp_stop_reply {CpuNr sock cmd {opt_val "0"}} {
 
    global mspgcc_compat_mode
 
    # Wait until halted
    while {![IsHalted $CpuNr]} {
 
        # Wait a few milliseconds to prevent the gui from freezing
        after 100 {set end 1}
        vwait end
 
        # Check if we are interrupted by GDB
        fconfigure $sock -blocking 0
        set break_char [read -nonewline $sock]
        fconfigure $sock -blocking 1
        binary scan $break_char H* break_char
        if {$break_char=="03"} {
            putsVerbose "--> BREAK"
            HaltCPU $CpuNr
        }
    }
 
    # Read some important registers
    set pc [ReadReg $CpuNr 0]
    regexp {0x(..)(..)} $pc match pc_hi pc_lo
    set r4 [ReadReg $CpuNr 4]
    regexp {0x(..)(..)} $r4 match r4_hi r4_lo
 
    # In case of a single step command, make sure that the PC
    # value changes. If not, return an error otherwise GDB will
    # end-up in an infinite loop.
    if {$cmd == "s"} {
        if {$opt_val == $pc} {
            return "E05"
        }
    }
 
    if {$mspgcc_compat_mode} {
        return "T0500:$pc_lo$pc_hi;04:$r4_lo$r4_hi;"               ;# 16bit word Response for older MSPGCC versions
    } else {
        return "T0500:$pc_lo${pc_hi}0000;04:$r4_lo${r4_hi}0000;"   ;# 32bit word Response starting with TI/RedHat GCC port
    }
}
 
 
#-----------------------------------------------------------------------------#
#                                                                             #
#-----------------------------------------------------------------------------#
proc rsp_q {CpuNr sock cmd} {
 
       switch -regexp -- $cmd {
 
        "C"       {set rsp_answer ""}
        "Offsets" {set rsp_answer "Text=0;Data=0;Bss=0"}
        "Rcmd,.+" {set rsp_answer [rsp_qRcmd $CpuNr $sock $cmd]}
        default   {set rsp_answer ""}
    }
    return $rsp_answer
}
 
#-----------------------------------------------------------------------------#
# qRcmd,command'                                                              #
#    command (hex encoded) is passed to the local interpreter for execution.  #
#    Invalid commands should be reported using the output string. Before the  #
#    final result packet, the target may also respond with a number of        #
#    intermediate `Ooutput' console output packets. Implementors should note  #
#    that providing access to a stubs's interpreter may have security         #
#    implications.                                                            #
#-----------------------------------------------------------------------------#
proc rsp_qRcmd {CpuNr sock cmd} {
 
    regsub {^Rcmd,} $cmd {} cmd
    set cmd [binary format H* $cmd];  # Convert hex to ascii
 
    switch -exact -- $cmd {
        "erase all" {;# Convert ascii to hex
                     binary scan "Erasing target program memory..." H* text1
                     binary scan " Erased OK\n"                     H* text2
                     ;# Execute erase command
                     sendRSPpacket $sock "O$text1"
                     EraseROM $CpuNr
                     sendRSPpacket $sock "O$text2"
                     set rsp_answer "OK"
                    }
        default     {set rsp_answer "OK"}
    }
 
    return $rsp_answer
 
}

Line No.	Rev	Author	Line
1	2	olivier.gi	`#!/usr/bin/wish`
2			`#------------------------------------------------------------------------------`
3			`# Copyright (C) 2001 Authors`
4			`#`
5			`# This source file may be used and distributed without restriction provided`
6			`# that this copyright statement is not removed from the file and that any`
7			`# derivative work contains the original copyright notice and the associated`
8			`# disclaimer.`
9			`#`
10			`# This source file is free software; you can redistribute it and/or modify`
11			`# it under the terms of the GNU Lesser General Public License as published`
12			`# by the Free Software Foundation; either version 2.1 of the License, or`
13			`# (at your option) any later version.`
14			`#`
15			`# This source is distributed in the hope that it will be useful, but WITHOUT`
16			`# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or`
17			`# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public`
18			`# License for more details.`
19			`#`
20			`# You should have received a copy of the GNU Lesser General Public License`
21			`# along with this source; if not, write to the Free Software Foundation,`
22			`# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA`
23			`#`
24			`#------------------------------------------------------------------------------`
25	217	olivier.gi	`#`
26	2	olivier.gi	`# File Name: commands.tcl`
27	217	olivier.gi	`#`
28	15	olivier.gi	`# Author(s):`
29			`# - Olivier Girard, olgirard@gmail.com`
30			`#`
31	2	olivier.gi	`#------------------------------------------------------------------------------`
32	15	olivier.gi	`# $Rev: 217 $`
33			`# $LastChangedBy: olivier.girard $`
34			`# $LastChangedDate: 2016-08-01 23:04:04 +0200 (Mon, 01 Aug 2016) $`
35			`#------------------------------------------------------------------------------`
36	2	olivier.gi
37			`global mem_breakpoint`
38	172	olivier.gi	`global mem_mapping`
39			`global breakSelect`
40	2	olivier.gi
41			`###############################################################################`
42			`# #`
43			`# RSP COMMAND PARSER #`
44			`# #`
45			`###############################################################################`
46
47	172	olivier.gi	`proc rspParse {CpuNr sock rsp_cmd} {`
48	2	olivier.gi
49			`set rsp_answer ""`
50			`set cmd_tail [string range $rsp_cmd 1 [string length $rsp_cmd]]`
51
52			`switch -exact -- [string index $rsp_cmd 0] {`
53	158	olivier.gi	`"!" {set rsp_answer "OK"}`
54	172	olivier.gi	`"?" {set rsp_answer [rsp_stop_reply $CpuNr $sock "?"]}`
55	158	olivier.gi	`"A" {}`
56			`"b" {}`
57	172	olivier.gi	`"c" {set rsp_answer [rsp_c $CpuNr $sock $cmd_tail]}`
58			`"C" {set rsp_answer [rsp_c $CpuNr $sock $cmd_tail]}`
59	158	olivier.gi	`"D" {}`
60			`"F" {}`
61	172	olivier.gi	`"g" {set rsp_answer [rsp_g $CpuNr]}`
62			`"G" {set rsp_answer [rsp_G $CpuNr $cmd_tail]}`
63	158	olivier.gi	`"H" {set rsp_answer ""}`
64			`"i" {}`
65			`"I" {}`
66	172	olivier.gi	`"k" {set rsp_answer [rsp_k $CpuNr $cmd_tail]}`
67			`"m" {set rsp_answer [rsp_m $CpuNr $cmd_tail]}`
68			`"M" {set rsp_answer [rsp_M $CpuNr $cmd_tail]}`
69	158	olivier.gi	`"p" {}`
70			`"P" {}`
71	172	olivier.gi	`"q" {set rsp_answer [rsp_q $CpuNr $sock $cmd_tail]}`
72	158	olivier.gi	`"Q" {}`
73			`"R" {}`
74	172	olivier.gi	`"s" {set rsp_answer [rsp_s $CpuNr $sock $cmd_tail]}`
75			`"S" {set rsp_answer [rsp_s $CpuNr $sock $cmd_tail]}`
76	158	olivier.gi	`"t" {}`
77			`"T" {}`
78			`"v" {}`
79			`"X" {}`
80	172	olivier.gi	`"z" {set rsp_answer [rsp_z $CpuNr $sock $cmd_tail]}`
81			`"Z" {set rsp_answer [rsp_Z $CpuNr $sock $cmd_tail]}`
82	158	olivier.gi	`default {}`
83	2	olivier.gi	`}`
84
85
86			`return $rsp_answer`
87			`}`
88
89
90			`###############################################################################`
91			`# #`
92			`# RSP COMMANDS #`
93			`# #`
94			`###############################################################################`
95
96			`#-----------------------------------------------------------------------------#`
97			`# Read CPU registers #`
98			`#-----------------------------------------------------------------------------#`
99	172	olivier.gi	`proc rsp_g {CpuNr} {`
100	217	olivier.gi
101			`global mspgcc_compat_mode`
102
103	2	olivier.gi	`# Read register value`
104	158	olivier.gi	`set reg_val [ReadRegAll $CpuNr]`
105	2	olivier.gi
106			`# Format answer`
107			`set rsp_answer ""`
108			`for {set i 0} {$i < [llength $reg_val]} {incr i} {`
109	158	olivier.gi	`regexp {0x(..)(..)} [lindex $reg_val $i] match msb lsb`
110	217	olivier.gi	`if {$mspgcc_compat_mode} {`
111			`append rsp_answer "$lsb$msb"`
112			`} else {`
113			`append rsp_answer "$lsb${msb}0000"`
114			`}`
115	2	olivier.gi	`}`
116
117			`return $rsp_answer`
118			`}`
119
120			`#-----------------------------------------------------------------------------#`
121			`# Write CPU registers #`
122			`#-----------------------------------------------------------------------------#`
123	172	olivier.gi	`proc rsp_G {CpuNr cmd} {`
124	217	olivier.gi
125			`global mspgcc_compat_mode`
126
127	2	olivier.gi	`# Format register value`
128	217	olivier.gi	`if {$mspgcc_compat_mode} {`
129			`set num_reg [expr [string length $cmd]/4]`
130			`} else {`
131			`set num_reg [expr [string length $cmd]/8]`
132			`}`
133	2	olivier.gi	`set reg_val ""`
134			`for {set i 0} {$i < $num_reg} {incr i} {`
135	217	olivier.gi	`if {$mspgcc_compat_mode} {`
136			`set lsb "[string index $cmd [expr $i4+0]][string index $cmd [expr $i4+1]]"`
137			`set msb "[string index $cmd [expr $i4+2]][string index $cmd [expr $i4+3]]"`
138			`} else {`
139			`set lsb "[string index $cmd [expr $i8+0]][string index $cmd [expr $i8+1]]"`
140			`set msb "[string index $cmd [expr $i8+2]][string index $cmd [expr $i8+3]]"`
141			`}`
142	158	olivier.gi	`lappend reg_val "0x$msb$lsb"`
143	2	olivier.gi	`}`
144
145			`# Write registers`
146	158	olivier.gi	`WriteRegAll $CpuNr $reg_val`
147	2	olivier.gi
148			`return "OK"`
149			`}`
150
151	217	olivier.gi
152	2	olivier.gi	`#-----------------------------------------------------------------------------#`
153			`# Kill request. #`
154			`#-----------------------------------------------------------------------------#`
155	172	olivier.gi	`proc rsp_k {CpuNr cmd} {`
156	217	olivier.gi
157	2	olivier.gi	`# Reset & Stop CPU`
158	158	olivier.gi	`ExecutePOR_Halt $CpuNr`
159	217	olivier.gi
160	2	olivier.gi	`return "-1"`
161			`}`
162
163			`#-----------------------------------------------------------------------------#`
164			`# Write length bytes of memory. #`
165			`#-----------------------------------------------------------------------------#`
166	172	olivier.gi	`proc rsp_M {CpuNr cmd} {`
167	217	olivier.gi
168	2	olivier.gi	`global mem_breakpoint`
169	172	olivier.gi	`global mem_mapping`
170			`global breakSelect`
171	217	olivier.gi
172	2	olivier.gi	`# Parse command`
173			`regexp {(.),(.):(.*)} $cmd match addr length data`
174			`set addr [format %04x "0x$addr"]`
175			`set length [format %d "0x$length"]`
176	217	olivier.gi
177	2	olivier.gi	`# Format data`
178			`set mem_val ""`
179			`for {set i 0} {$i<$length} {incr i} {`
180	158	olivier.gi	`lappend mem_val "0x[string range $data [expr $i2] [expr $i2+1]]"`
181	2	olivier.gi	`}`
182
183			`# Write memory`
184	119	olivier.gi	`if {$length==2} {`
185	158	olivier.gi	`regexp {(..)(..)} $data match data_lo data_hi`
186			`WriteMem $CpuNr 0 "0x$addr" "0x${data_hi}${data_lo}"`
187	119	olivier.gi	`} else {`
188	158	olivier.gi	`WriteMemQuick8 $CpuNr "0x$addr" $mem_val`
189	119	olivier.gi	`}`
190	2	olivier.gi
191			`# Eventually re-set the software breakpoints in case they have been overwritten`
192	172	olivier.gi	`if {$breakSelect==0} {`
193	217	olivier.gi	`set addr_start [format %d "0x$addr"]`
194			`foreach {brk_addr brk_val} [array get mem_breakpoint] {`
195			`regsub {,} $brk_addr { } brk_addr_lst`
196			`if {[lindex $brk_addr_lst 0]==$mem_mapping($CpuNr)} {`
197			`set brk_addr_dec [format %d "0x[lindex $brk_addr_lst 1]"]`
198			`set brk_addr_offset [expr $brk_addr_dec-$addr_start]`
199			`if {(0<=$brk_addr_offset) && ($brk_addr_offset<=$length)} {`
200			`set mem_breakpoint($brk_addr) [lindex $mem_val $brk_addr_offset]`
201			`WriteMem $CpuNr 0 "0x[lindex $brk_addr 1]" 0x4343`
202			`}`
203			`}`
204			`}`
205	2	olivier.gi	`}`
206
207			`return "OK"`
208			`}`
209
210
211			`#-----------------------------------------------------------------------------#`
212			`# Read length bytes from memory. #`
213			`#-----------------------------------------------------------------------------#`
214	172	olivier.gi	`proc rsp_m {CpuNr cmd} {`
215	217	olivier.gi
216	2	olivier.gi	`global mem_breakpoint`
217	172	olivier.gi	`global mem_mapping`
218			`global breakSelect`
219	2	olivier.gi
220			`# Parse command`
221			`regexp {(.),(.)} $cmd match addr length`
222			`set addr [format %04x "0x$addr"]`
223			`set length [format %d "0x$length"]`
224
225			`# Read memory`
226	158	olivier.gi	`set data [ReadMemQuick8 $CpuNr "0x$addr" $length]`
227	2	olivier.gi
228	217	olivier.gi
229	2	olivier.gi	`# Eventually replace read data by the original software breakpoint value`
230	172	olivier.gi	`if {$breakSelect==0} {`
231	217	olivier.gi	`set addr_start [format %d "0x$addr"]`
232			`foreach {brk_addr brk_val} [array get mem_breakpoint] {`
233			`regsub {,} $brk_addr { } brk_addr_lst`
234			`if {[lindex $brk_addr_lst 0]==$mem_mapping($CpuNr)} {`
235			`set brk_addr_dec [format %d "0x[lindex $brk_addr_lst 1]"]`
236			`set brk_addr_offset [expr $brk_addr_dec-$addr_start]`
237			`if {(0<=$brk_addr_offset) && ($brk_addr_offset<=$length)} {`
238			`set data [lreplace $data $brk_addr_offset $brk_addr_offset "0x$mem_breakpoint($brk_addr)"]`
239			`}`
240			`}`
241			`}`
242	2	olivier.gi	`}`
243
244			`# Format data`
245			`regsub -all {0x} $data {} data`
246			`regsub -all { } $data {} data`
247
248			`return $data`
249			`}`
250
251
252			`#-----------------------------------------------------------------------------#`
253			`# Insert breakpoint. #`
254			`#-----------------------------------------------------------------------------#`
255	172	olivier.gi	`proc rsp_Z {CpuNr sock cmd} {`
256	2	olivier.gi
257			`global mem_breakpoint`
258	172	olivier.gi	`global mem_mapping`
259			`global breakSelect`
260	2	olivier.gi
261			`# Parse command`
262			`regexp {(.),(.),(.)} $cmd match type addr length`
263			`set addr [format %04x "0x$addr"]`
264
265			`switch -exact -- $type {`
266	172	olivier.gi	`"0" {# Soft Memory breakpoint`
267			`if {$breakSelect==0} {`
268	217	olivier.gi	`if {![info exists mem_breakpoint($mem_mapping($CpuNr),$addr)]} {`
269			`set mem_breakpoint($mem_mapping($CpuNr),$addr) [ReadMem $CpuNr 0 "0x$addr"]`
270			`WriteMem $CpuNr 0 "0x$addr" 0x4343`
271			`}`
272			`return "OK"`
273	172	olivier.gi
274			`# Hard Memory breakpoint`
275			`} else {`
276			`if {[SetHWBreak $CpuNr 1 [format "0x%04x" 0x$addr] 1 0]} {`
277	217	olivier.gi	`#putsLog "CORE $CpuNr: --- INFO --- SET HARDWARE MEMORY BREAKPOINT. "`
278	172	olivier.gi	`return "OK"`
279			`}`
280	217	olivier.gi	`putsLog "CORE $CpuNr: --- ERROR --- NO MORE HARDWARE MEMORY BREAKPOINT AVAILABLE. "`
281	172	olivier.gi	`return ""`
282			`}`
283	2	olivier.gi	`}`
284
285	158	olivier.gi	`"1" {# Hardware breakpoint`
286			`if {[SetHWBreak $CpuNr 1 [format "0x%04x" 0x$addr] 1 0]} {`
287			`return "OK"`
288			`}`
289	217	olivier.gi	`putsLog "CORE $CpuNr: --- ERROR --- NO MORE HARDWARE BREAKPOINT AVAILABLE. "`
290	158	olivier.gi	`return ""`
291	2	olivier.gi	`}`
292
293	158	olivier.gi	`"2" {# Write watchpoint`
294			`if {[SetHWBreak $CpuNr 0 [format "0x%04x" 0x$addr] 0 1]} {`
295			`return "OK"`
296			`}`
297	217	olivier.gi	`putsLog "CORE $CpuNr: --- ERROR --- NO MORE WRITE WATCHPOINT AVAILABLE. "`
298	158	olivier.gi	`return ""`
299	2	olivier.gi	`}`
300
301	158	olivier.gi	`"3" {# Read watchpoint`
302			`if {[SetHWBreak $CpuNr 0 [format "0x%04x" 0x$addr] 1 0]} {`
303			`return "OK"`
304			`}`
305	217	olivier.gi	`putsLog "CORE $CpuNr: --- ERROR --- NO MORE READ WATCHPOINT AVAILABLE. "`
306	158	olivier.gi	`return ""`
307	2	olivier.gi	`}`
308
309	158	olivier.gi	`"4" {# Access watchpoint`
310			`if {[SetHWBreak $CpuNr 0 [format "0x%04x" 0x$addr] 1 1]} {`
311			`return "OK"`
312			`}`
313	217	olivier.gi	`putsLog "CORE $CpuNr: --- ERROR --- NO MORE ACCESS WATCHPOINT AVAILABLE. "`
314	158	olivier.gi	`return ""`
315	2	olivier.gi	`}`
316
317	158	olivier.gi	`default {return ""}`
318	2	olivier.gi	`}`
319			`}`
320
321			`#-----------------------------------------------------------------------------#`
322			`# Remove breakpoint. #`
323			`#-----------------------------------------------------------------------------#`
324	172	olivier.gi	`proc rsp_z {CpuNr sock cmd} {`
325	2	olivier.gi
326			`global mem_breakpoint`
327	172	olivier.gi	`global mem_mapping`
328			`global breakSelect`
329	2	olivier.gi
330			`# Parse command`
331			`regexp {(.),(.),(.)} $cmd match type addr length`
332			`set addr [format %04x "0x$addr"]`
333
334			`switch -exact -- $type {`
335	172	olivier.gi	`"0" {# Soft Memory breakpoint`
336			`if {$breakSelect==0} {`
337	217	olivier.gi	`if {[info exists mem_breakpoint($mem_mapping($CpuNr),$addr)]} {`
338			`WriteMem $CpuNr 0 "0x$addr" $mem_breakpoint($mem_mapping($CpuNr),$addr)`
339			`unset mem_breakpoint($mem_mapping($CpuNr),$addr)`
340			`}`
341	172	olivier.gi	`return "OK"`
342
343			`# Hard Memory breakpoint`
344			`} else {`
345			`if {[ClearHWBreak $CpuNr 1 [format "0x%04x" 0x$addr]]} {`
346	217	olivier.gi	`#putsLog "CORE $CpuNr: --- INFO --- RELEASE HARDWARE MEMORY BREAKPOINT. "`
347	172	olivier.gi	`return "OK"`
348			`}`
349	217	olivier.gi	`putsLog "CORE $CpuNr: --- ERROR --- COULD NOT REMOVE HARDWARE MEMORY BREAKPOINT. "`
350	172	olivier.gi	`return ""`
351			`}`
352	2	olivier.gi	`}`
353
354	158	olivier.gi	`"1" {# Hardware breakpoint`
355			`if {[ClearHWBreak $CpuNr 1 [format "0x%04x" 0x$addr]]} {`
356			`return "OK"`
357			`}`
358			`return ""`
359	2	olivier.gi	`}`
360
361	158	olivier.gi	`"2" {# Write watchpoint`
362			`if {[ClearHWBreak $CpuNr 0 [format "0x%04x" 0x$addr]]} {`
363			`return "OK"`
364			`}`
365			`return ""`
366	2	olivier.gi	`}`
367
368	158	olivier.gi	`"3" {# Read watchpoint`
369			`if {[ClearHWBreak $CpuNr 0 [format "0x%04x" 0x$addr]]} {`
370			`return "OK"`
371			`}`
372			`return ""`
373	2	olivier.gi	`}`
374
375	158	olivier.gi	`"4" {# Access watchpoint`
376			`if {[ClearHWBreak $CpuNr 0 [format "0x%04x" 0x$addr]]} {`
377			`return "OK"`
378			`}`
379			`return ""`
380	2	olivier.gi	`}`
381
382	158	olivier.gi	`default {return ""}`
383	2	olivier.gi	`}`
384			`}`
385
386			`#-----------------------------------------------------------------------------#`
387			`# Continue. #`
388			`#-----------------------------------------------------------------------------#`
389	172	olivier.gi	`proc rsp_c {CpuNr sock cmd} {`
390	217	olivier.gi
391	2	olivier.gi	`# Set address if required`
392			`if {$cmd!=""} {`
393	158	olivier.gi	`set cmd [format %04x "0x$cmd"]`
394			`SetPC $CpuNr "0x$cmd"`
395	2	olivier.gi	`}`
396
397			`# Clear status`
398	158	olivier.gi	`ClrStatus $CpuNr`
399	2	olivier.gi
400			`# Continue`
401	158	olivier.gi	`ReleaseCPU $CpuNr`
402	2	olivier.gi
403
404	172	olivier.gi	`return [rsp_stop_reply $CpuNr $sock "c"]`
405	2	olivier.gi	`}`
406
407			`#-----------------------------------------------------------------------------#`
408			`# Step. #`
409			`#-----------------------------------------------------------------------------#`
410	172	olivier.gi	`proc rsp_s {CpuNr sock cmd} {`
411	217	olivier.gi
412	2	olivier.gi	`# Set address if required`
413			`if {$cmd!=""} {`
414	158	olivier.gi	`set cmd [format %04x "0x$cmd"]`
415			`SetPC $CpuNr "0x$cmd"`
416	2	olivier.gi	`}`
417
418			`# Clear status`
419	158	olivier.gi	`ClrStatus $CpuNr`
420	2	olivier.gi
421	124	olivier.gi	`# Read current PC value`
422	158	olivier.gi	`set pc [ReadReg $CpuNr 0]`
423	124	olivier.gi
424	2	olivier.gi	`# Incremental step`
425	158	olivier.gi	`StepCPU $CpuNr`
426	2	olivier.gi
427	172	olivier.gi	`return [rsp_stop_reply $CpuNr $sock "s" $pc]`
428	2	olivier.gi	`}`
429
430
431			`#-----------------------------------------------------------------------------#`
432			# The `C', `c', `S', `s', `vCont', `vAttach', `vRun', `vStopped', and `?' #
433			# packets can receive any of the below as a reply. Except for `?' and #
434			# `vStopped', that reply is only returned when the target halts. #
435			`#-----------------------------------------------------------------------------#`
436	172	olivier.gi	`proc rsp_stop_reply {CpuNr sock cmd {opt_val "0"}} {`
437	2	olivier.gi
438	198	olivier.gi	`global mspgcc_compat_mode`
439
440	2	olivier.gi	`# Wait until halted`
441	158	olivier.gi	`while {![IsHalted $CpuNr]} {`
442	2	olivier.gi
443	158	olivier.gi	`# Wait a few milliseconds to prevent the gui from freezing`
444			`after 100 {set end 1}`
445			`vwait end`
446	2	olivier.gi
447	158	olivier.gi	`# Check if we are interrupted by GDB`
448			`fconfigure $sock -blocking 0`
449			`set break_char [read -nonewline $sock]`
450			`fconfigure $sock -blocking 1`
451			`binary scan $break_char H* break_char`
452			`if {$break_char=="03"} {`
453			`putsVerbose "--> BREAK"`
454			`HaltCPU $CpuNr`
455			`}`
456	2	olivier.gi	`}`
457
458			`# Read some important registers`
459	158	olivier.gi	`set pc [ReadReg $CpuNr 0]`
460	2	olivier.gi	`regexp {0x(..)(..)} $pc match pc_hi pc_lo`
461	158	olivier.gi	`set r4 [ReadReg $CpuNr 4]`
462	2	olivier.gi	`regexp {0x(..)(..)} $r4 match r4_hi r4_lo`
463
464	198	olivier.gi	`# In case of a single step command, make sure that the PC`
465			`# value changes. If not, return an error otherwise GDB will`
466			`# end-up in an infinite loop.`
467			`if {$cmd == "s"} {`
468	217	olivier.gi	`if {$opt_val == $pc} {`
469			`return "E05"`
470			`}`
471	198	olivier.gi	`}`
472
473			`if {$mspgcc_compat_mode} {`
474	217	olivier.gi	`return "T0500:$pc_lo$pc_hi;04:$r4_lo$r4_hi;" ;# 16bit word Response for older MSPGCC versions`
475	198	olivier.gi	`} else {`
476	217	olivier.gi	`return "T0500:$pc_lo${pc_hi}0000;04:$r4_lo${r4_hi}0000;" ;# 32bit word Response starting with TI/RedHat GCC port`
477	198	olivier.gi	`}`
478	2	olivier.gi	`}`
479
480
481			`#-----------------------------------------------------------------------------#`
482			`# #`
483			`#-----------------------------------------------------------------------------#`
484	172	olivier.gi	`proc rsp_q {CpuNr sock cmd} {`
485	217	olivier.gi
486	2	olivier.gi	`switch -regexp -- $cmd {`
487
488	158	olivier.gi	`"C" {set rsp_answer ""}`
489			`"Offsets" {set rsp_answer "Text=0;Data=0;Bss=0"}`
490	172	olivier.gi	`"Rcmd,.+" {set rsp_answer [rsp_qRcmd $CpuNr $sock $cmd]}`
491	158	olivier.gi	`default {set rsp_answer ""}`
492	2	olivier.gi	`}`
493			`return $rsp_answer`
494			`}`
495
496			`#-----------------------------------------------------------------------------#`
497			`# qRcmd,command' #`
498			`# command (hex encoded) is passed to the local interpreter for execution. #`
499			`# Invalid commands should be reported using the output string. Before the #`
500			`# final result packet, the target may also respond with a number of #`

Browse

Tools

Subversion Repositories openmsp430

[/] [openmsp430/] [trunk/] [tools/] [openmsp430-gdbproxy/] [commands.tcl] - Blame information for rev 217