Subversion Repositories openrisc_me

# Copyright 1998, 2007, 2008 Free Software Foundation, Inc.

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 3 of the License, or

# (at your option) any later version.

#

# This program 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 General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see .

# Please email any bugs, comments, and/or additions to this file to:

# bug-gdb@prep.ai.mit.edu

if [istarget "m68k-*-elf"] then {

    pass "Test not supported on this target"

    return;

}

load_lib "trace-support.exp"

if $tracelevel then {

        strace $tracelevel

}

set prms_id 0

set bug_id 0

set testfile "limits"

set srcfile ${testfile}.c

set binfile $objdir/$subdir/$testfile

if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile \

        executable {debug nowarnings}] != "" } {

    untested limits.exp

    return -1

}

# Tests:

# 1) Meet and exceed artificial limit on number of tracepoints

# 2) Meet and exceed artificial limit on number of memranges

# 3) Meet and exceed artificial limit on bytes  of bytecode data

# [NOTE: number four is moved out into its own separate test module.]

# 4) Meet and exceed artificial limit on bytes  of trace buffer storage

#    (circular and non-circular modes).  However note that a more

#    thorough test of the circular mode can be made separately.

set cr "\[\r\n\]+"

proc gdb_tracepoint_limit_test { } {

    global gdb_prompt

    global cr

    # Make sure we're in a sane starting state.

    gdb_test "tstop" "" ""

    gdb_test "tfind none" "" ""

    gdb_delete_tracepoints

    # Set three tracepoints

    gdb_test "trace foo" \

            "Tracepoint \[0-9\]+ at .*" \

            "tracepoint limit test: set first tracepoint"

    gdb_test "trace bar" \

            "Tracepoint \[0-9\]+ at .*" \

            "tracepoint limit test: set second tracepoint"

    gdb_test "trace baz" \

            "Tracepoint \[0-9\]+ at .*" \

            "tracepoint limit test: set third tracepoint"

    # Set secret artificial tracepoint limit to four

    gdb_test "maint packet QTLimit:tp:4" \

            "received: .OK." \

            "tracepoint limit test: set limit to four"

    # Now sending three tracepoints should succeed.

    send_gdb "tstart\n"

    gdb_expect {

        -re "$cr$gdb_prompt" {

            pass "tracepoint limit test: send fewer than limit"

        }

        default {

            fail "tracepoint limit test: send fewer than limit"

        }

    }

    # Set secret artificial tracepoint limit to three

    gdb_test "maint packet QTLimit:tp:3" \

            "received: .OK." \

            "tracepoint limit test: set limit to three"

    # Now sending three tracepoints should still succeed.

    send_gdb "tstart\n"

    gdb_expect {

        -re "$cr$gdb_prompt" {

            pass "tracepoint limit test: send equal to limit"

        }

        default {

            fail "tracepoint limit test: send equal to limit"

        }

    }

    # Set secret artificial tracepoint limit to two

    gdb_test "maint packet QTLimit:tp:2" \

            "received: .OK." \

            "tracepoint limit test: set limit to two"

    # Now sending three tracepoints should fail.

    gdb_test "tstart" \

            ".*\[Ee\]rror.*" \

            "tracepoint limit test: send more than limit"

    # Clean up:

    gdb_test "tstop" "" ""

    gdb_test "maint packet QTLimit:tp:FFFFFFFF" "" ""

}

proc gdb_memrange_limit_test { } {

    global gdb_prompt

    global cr

    # Make sure we're in a sane starting state.

    gdb_test "tstop" "" ""

    gdb_test "tfind none" "" ""

    gdb_delete_tracepoints

    # Set three tracepoints, and make 'em collect memranges

    gdb_test "trace foo" \

            "Tracepoint \[0-9\]+ at .*" \

            "memrange limit test: set first tracepoint"

    gdb_trace_setactions "memrange limit test: set first actions" \

            "" \

            "collect \$arg" "^$"

    gdb_test "trace bar" \

            "Tracepoint \[0-9\]+ at .*" \

            "memrange limit test: set second tracepoint"

    gdb_trace_setactions "memrange limit test: set second actions" \

            "" \

            "collect \$arg" "^$"

    gdb_test "trace baz" \

            "Tracepoint \[0-9\]+ at .*" \

            "memrange limit test: set third tracepoint"

    gdb_trace_setactions "memrange limit test: set third actions" \

            "" \

            "collect \$arg" "^$"

    # Set secret artificial memrange limit to four

    gdb_test "maint packet QTLimit:memrange:4" \

            "received: .OK." \

            "memrange limit test: set limit to four"

    # Now sending three memranges should still succeed.

    send_gdb "tstart\n"

    gdb_expect {

        -re "$cr$gdb_prompt" {

            pass "memrange limit test: send fewer than limit"

        }

        default {

            fail "memrange limit test: send fewer than limit"

        }

    }

    # Set secret artificial memrange limit to three

    gdb_test "maint packet QTLimit:memrange:3" \

            "received: .OK." \

            "memrange limit test: set limit to three"

    # Now sending three memranges should still succeed.

    send_gdb "tstart\n"

    gdb_expect {

        -re "$cr$gdb_prompt" {

            pass "memrange limit test: send equal to limit"

        }

        default {

            fail "memrange limit test: send equal to limit"

        }

    }

    # Set secret artificial memrange limit to two

    gdb_test "maint packet QTLimit:memrange:2" \

            "received: .OK." \

            "memrange limit test: set limit to two"

    # Now sending three memranges should fail.

    gdb_test "tstart" \

            ".*\[Ee\]rror.*" \

            "memrange limit test: send more than limit"

    # Clean up:

    gdb_test "tstop" "" ""

    gdb_test "maint packet QTLimit:memrange:FFFFFFFF" "" ""

}

proc gdb_bytecode_limit_test { } {

    global gdb_prompt

    global cr

    # Make sure we're in a sane starting state.

    gdb_test "tstop" "" ""

    gdb_test "tfind none" "" ""

    gdb_delete_tracepoints

    # Set three tracepoints

    gdb_test "trace foo" \

            "Tracepoint \[0-9\]+ at .*" \

            "bytecode limit test: set first tracepoint"

    gdb_trace_setactions "bytecode limit test: set first actions" \

            "" \

            "collect x + n" "^$"

    gdb_test "trace bar" \

            "Tracepoint \[0-9\]+ at .*" \

            "bytecode limit test: set second tracepoint"

    gdb_trace_setactions "bytecode limit test: set second actions" \

            "" \

            "collect y + n" "^$"

    gdb_test "trace baz" \

            "Tracepoint \[0-9\]+ at .*" \

            "bytecode limit test: set third tracepoint"

    gdb_trace_setactions "bytecode limit test: set third actions" \

            "" \

            "collect z + n" "^$"

    # Set secret artificial bytecode limit to a large number

    gdb_test "maint packet QTLimit:bytecode:400" \

            "received: .OK." \

            "bytecode limit test: set limit to large"

    # Now sending three bytecodes should still succeed.

    send_gdb "tstart\n"

    gdb_expect {

        -re "$cr$gdb_prompt" {

            pass "bytecode limit test: send fewer than limit"

        }

        default {

            fail "bytecode limit test: send fewer than limit"

        }

    }

    # Set secret artificial bytecode limit to a small number

    gdb_test "maint packet QTLimit:bytecode:40" \

            "received: .OK." \

            "bytecode limit test: set limit to small"

    # Now sending three bytecodes should fail.

    gdb_test "tstart" \

            ".*\[Ee\]rror.*" \

            "bytecode limit test: send more than limit"

    # Clean up:

    gdb_test "tstop" "" ""

    gdb_test "maint packet QTLimit:bytecode:FFFFFFFF" "" ""

}

proc gdb_trace_limits_tests { } {

    global gdb_prompt

    # We generously give ourselves one "pass" if we successfully

    # detect that this test cannot be run on this target!

    if { ![gdb_target_supports_trace] } then {

        pass "Current target does not support trace"

        return 1;

    }

    if [gdb_test "maint packet QTLimit:tp:ffffffff" \

            "received: .OK." ""] then {

        pass "This test cannot be run on this target"

        return 1;

    }

    if [gdb_test "maint packet QTLimit:memrange:ffffffff" \

            "received: .OK." ""] then {

        pass "This test cannot be run on this target"

        return 1;

    }

    if [gdb_test "maint packet QTLimit:bytecode:ffffffff" \

            "received: .OK." ""] then {

        pass "This test cannot be run on this target"

        return;

    }

    gdb_tracepoint_limit_test

    gdb_memrange_limit_test

    gdb_bytecode_limit_test

}

# Start with a fresh gdb.

gdb_exit

gdb_start

gdb_reinitialize_dir $srcdir/$subdir

gdb_load $binfile

if [target_info exists gdb_stub] {

    gdb_step_for_stub;

}

# Body of test encased in a proc so we can return prematurely.

gdb_trace_limits_tests