Subversion Repositories openrisc

proc gdb_emc_readvar { varname } {
    global gdb_prompt;

    set result -1;
    send_gdb "print $varname\n"
    gdb_expect 5 {
        -re "\[$\].*= (\[0-9\]+).*$gdb_prompt $" {
            set result $expect_out(1,string);
        }
        -re "$gdb_prompt $" { }
        default { }
    }
    return $result;
}
    
proc gdb_emc_gettpnum { testname } {
    global gdb_prompt;

    if { $testname != "" } {
        gdb_test "trace $testname" "" ""
    }
    return [gdb_emc_readvar "\$tpnum"];
}

proc gdb_emc_setactions { testname actionname args } {
    global gdb_prompt;

    set state 0;
    set status "pass";
    send_gdb "actions $actionname\n";
    set expected_result "";
    gdb_expect 5 {
        -re "No tracepoint number .*$gdb_prompt $" {
            fail $testname
            return 1;
        }
        -re "Enter actions for tracepoint $actionname.*>" {
            if { [llength $args] > 0 } {
                set lastcommand "[lindex $args $state]";
                send_gdb "[lindex $args $state]\n";
                incr state;
                set expected_result [lindex $args $state];
                incr state;
            } else {
                send_gdb "end\n";
            }
            exp_continue;
        }
        -re "\(.*\[\r\n\]+)\[ \t]*> $" {
            if { $expected_result != "" } {
                # Remove echoed command and its associated newline.
                regsub "^\[^\r\n\]+\[\r\n\]+" "$expect_out(1,string)" "" out;
                # Strip off any newlines at the end of the string.
                regsub "\[\r\n\]+$" "$out" "" out;
                verbose "expected '$expected_result', got '$out', expect_out is '$expect_out(1,string)'";
                if ![regexp $expected_result $out] {
                    set status "fail";
                }
                set expected_result "";
            }
            if { $state < [llength $args] } {
                send_gdb "[lindex $args $state]\n";
                incr state;
                set expected_result [lindex $args $state];
                incr state;
            } else {
                send_gdb "end\n";
                set expected_result "";
            }
            exp_continue;
        }
        -re "\(.*\)$gdb_prompt $" {
            if { $expected_result != "" } {
                if ![regexp $expected_result $expect_out(1,string)] {
                    set status "fail";
                }
                set expected_result "";
            }
            if { [llength $args] < $state } {
                set status "fail";
            }
        }
        default {
            set status "fail";
        }
    }
    if { $testname != "" } {
        $status $testname;
    }
    if { $status == "pass" } then { 
        return 0;
    } else {
        return 1;
    }
}

#
# test collect command
#

proc gdb_emc_tracetest_collect { arg1 msgstring } {
    global decimal
    global gdb_prompt;

    set teststate 0
    gdb_expect 30 {
        -re "Enter actions for tracepoint $decimal.*> $" {
            send_gdb "collect $arg1\n"
            incr teststate;
            exp_continue
        }
        -re "> $" {
            if { $teststate == 1 } {
                send_gdb "end\n"
                incr teststate;
                exp_continue
            } else { 
                fail "$msgstring"
            }
        }
        -re ".*$gdb_prompt $" {
            if { $teststate == 2 } {
                pass "$msgstring";
            } else { 
                fail "$msgstring";
            }
        }
        default { 
            fail "$msgstring (default)";
        }
    }
    regsub -all "(\[($@*+)\])" "collect $arg1" "\[\\1\]" arg1_regexp;
    gdb_test "info tracepoints" ".*$arg1_regexp.*" "$msgstring info tracepoint"
}

proc gdb_delete_tracepoints { } {
    global gdb_prompt;

    send_gdb "delete tracepoints\n"
    gdb_expect 30 {
        -re "Delete all tracepoints.*y or n.*$" {
            send_gdb "y\n"
            exp_continue;
        }
        -re "$gdb_prompt $" { }
        timeout { fail "delete all tracepoints (timeout)" }
    }
}


# Send each command in the list CMDLIST to gdb. If we see the string
# "error" or "warning" from gdb, we assume an error has occured and
# return a non-zero result. All of the commands in CMDLIST are always
# sent, even if an error occurs.
# If TESTNAME is non-null, we call pass or fail with the string in TESTNAME
# depending on whether or not an error/warning has occurred.
#
proc gdb_do_cmdlist { cmdlist testname } {
    global gdb_prompt;

    set status 0;

    foreach x $cmdlist {
        send_gdb "$x\n";
        gdb_expect 60 {
            -re "\[Ee\]rror|\[Ww\]arning" {
                set status 1;
                exp_continue;
            }
            -re "$gdb_prompt $" { }
            -re "\[\r\n\]\[ \t\]*> *$" { }
        }
    }
    if { $testname != "" } {
        if { $status == 0 } {
            pass "$testname";
        } else {
            fail "$testname";
        }
    }
    return $status;
}

#
# Given the file FILENAME, we read it as a list of commands and generate
# a list suitable for use by gdb_do_cmdlist. Lines beginning with # are
# ignored; blank lines are interpreted as empty lines to be sent to gdb.
#
proc gdb_process_cmdfile { filename } {
    set id [open $filename "r"];
    if { $id < 0 } {
        return "";
    }
    set result {};
    while { [gets $id line] >= 0 } {
        if [regexp "^#" $line] {
            continue;
        }
        set result [concat $result [list "$line"]];
    }
    close $id;
    return $result;
}

# gdb_find_c_test_baseline
# returns -1 on failure (CALLER MUST CHECK RETURN!)
proc gdb_find_c_test_baseline { } {
    global gdb_prompt;

    set gdb_c_test_baseline -1;

    send_gdb "list gdb_c_test\n"
    gdb_expect {
        -re "void.*p5,.*void.*p6.*\[\r\n\](\[0-9\]+)\[\t \]+\{.*$gdb_prompt $" {
            set gdb_c_test_baseline $expect_out(1,string)
        }
        -re "$gdb_prompt $" { }
        default { }
    }
    return $gdb_c_test_baseline;
}