Subversion Repositories openrisc

# Copyright 2008, 2009, 2010 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 .

# This tests the find command.

if $tracelevel then {

    strace $tracelevel

}

set testfile "find"

set srcfile ${testfile}.c

set binfile ${objdir}/${subdir}/${testfile}

if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug nowarnings}] != "" } {

    untested find.exp

    return -1

}

gdb_exit

gdb_start

gdb_reinitialize_dir $srcdir/$subdir

gdb_load ${binfile}

gdb_test "break $srcfile:stop_here" \

    "Breakpoint.*at.* file .*$srcfile, line.*" \

    "breakpoint function in file"

gdb_run_cmd

gdb_expect {

    -re "Breakpoint \[0-9\]+,.*stop_here.* at .*$srcfile:.*$gdb_prompt $" {

        pass "run until function breakpoint"

    }

    -re "$gdb_prompt $" {

        fail "run until function breakpoint"

    }

    timeout {

        fail "run until function breakpoint (timeout)"

    }

}

# We've now got the target program in a state where we can test "find".

set hex_number {0x[0-9a-fA-F][0-9a-fA-F]*}

set history_prefix {[$][0-9]* = }

set newline "\[\r\n\]*"

set pattern_not_found "${newline}Pattern not found\[.\]"

set one_pattern_found "${newline}1 pattern found\[.\]"

set two_patterns_found "${newline}2 patterns found\[.\]"

# Test string pattern.

gdb_test "set *(int32_t*) &int8_search_buf\[10\] = 0x61616161" "" ""

gdb_test "find &int8_search_buf\[0\], +sizeof(int8_search_buf), 'a', 'a', 'a'" \

    "${hex_number}.*${newline}${hex_number}.*${two_patterns_found}" \

    "find string pattern"

# Test not finding pattern because search range too small, with

# potential find at the edge of the range.

gdb_test "find &int8_search_buf\[0\], +10+3, \"aaaa\"" \

    "${pattern_not_found}" \

    "pattern not found at end of range"

# Increase the search range by 1 and we should find the pattern.

gdb_test "find &int8_search_buf\[0\], +10+3+1, 'a', 'a', 'a', 'a'" \

    "${hex_number}.*${one_pattern_found}" \

    "pattern found at end of range"

# Test max-count, $_ and $numfound.

gdb_test "find /1 &int8_search_buf\[0\], +sizeof(int8_search_buf), 'a', 'a', 'a'" \

    "${hex_number}.*${one_pattern_found}" \

    "max-count"

gdb_test "print \$_" \

    "${history_prefix}.*${hex_number}" \

    "\$_"

gdb_test "print \$numfound" \

    "${history_prefix}1" \

    "\$numfound"

# Test max-count with size-char.

# They can be specified in either order.

gdb_test "find /1b &int8_search_buf\[0\], +sizeof(int8_search_buf), 0x61, 0x61, 0x61" \

    "${hex_number}.*${one_pattern_found}" \

    "size,max-count, /1b"

gdb_test "find /b1 &int8_search_buf\[0\], +sizeof(int8_search_buf), 0x61, 0x61, 0x61" \

    "${hex_number}.*${one_pattern_found}" \

    "size,max-count, /b1"

gdb_test "find /b /1 &int8_search_buf\[0\], +sizeof(int8_search_buf), 0x61, 0x61, 0x61" \

    "${hex_number}.*${one_pattern_found}" \

    "size,max-count, /b/1"

gdb_test "find /1 /b &int8_search_buf\[0\], +sizeof(int8_search_buf), 0x61, 0x61, 0x61" \

    "${hex_number}.*${one_pattern_found}" \

    "size,max-count, /1/b"

# Test specifying end address.

gdb_test "find /b &int8_search_buf\[0\], &int8_search_buf\[0\]+sizeof(int8_search_buf), 0x61, 0x61, 0x61, 0x61" \

    "${hex_number}.*${one_pattern_found}" \

    "find byte pattern with end address"

# Test 16-bit pattern.

gdb_test "set int16_search_buf\[10\] = 0x1234" "" ""

gdb_test "find /h &int16_search_buf\[0\], +sizeof(int16_search_buf), 0x1234" \

    "${hex_number}.*${one_pattern_found}" \

    "find 16-bit pattern"

gdb_test "find &int16_search_buf\[0\], +sizeof(int16_search_buf), (int16_t) 0x1234" \

    "${hex_number}.*${one_pattern_found}" \

    "find 16-bit pattern"

# Test 32-bit pattern.

gdb_test "set int32_search_buf\[10\] = 0x12345678" "" ""

gdb_test "find &int32_search_buf\[0\], +sizeof(int32_search_buf), (int32_t) 0x12345678" \

    "${hex_number}.*${one_pattern_found}" \

    "find 32-bit pattern"

gdb_test "find /w &int32_search_buf\[0\], +sizeof(int32_search_buf), 0x12345678" \

    "${hex_number}.*${one_pattern_found}" \

    "find 32-bit pattern"

# Test 64-bit pattern.

gdb_test "set int64_search_buf\[10\] = 0xfedcba9876543210LL" "" ""

gdb_test "find &int64_search_buf\[0\], +sizeof(int64_search_buf), (int64_t) 0xfedcba9876543210LL" \

    "${hex_number}.*${one_pattern_found}" \

    "find 64-bit pattern"

gdb_test "find /g &int64_search_buf\[0\], +sizeof(int64_search_buf), 0xfedcba9876543210LL" \

    "${hex_number}.*${one_pattern_found}" \

    "find 64-bit pattern"

# Test mixed-sized patterns.

gdb_test "set *(int8_t*) &search_buf\[10\] = 0x62" "" ""

gdb_test "set *(int16_t*) &search_buf\[11\] = 0x6363" "" ""

gdb_test "set *(int32_t*) &search_buf\[13\] = 0x64646464" "" ""

gdb_test "find &search_buf\[0\], +100, (int8_t) 0x62, (int16_t) 0x6363, (int32_t) 0x64646464" \

    "${hex_number}${one_pattern_found}" \

    "find mixed-sized pattern"

# Test search spanning a large range, in the particular case of native

# targets, test the search spanning multiple chunks.

# Remote targets may implement the search differently.

set CHUNK_SIZE 16000 ;# see findcmd.c

gdb_test "set *(int32_t*) &search_buf\[0*${CHUNK_SIZE}+100\] = 0x12345678" "" ""

gdb_test "set *(int32_t*) &search_buf\[1*${CHUNK_SIZE}+100\] = 0x12345678" "" ""

gdb_test "find /w search_buf, +search_buf_size, 0x12345678" \

    "${hex_number}${newline}${hex_number}${two_patterns_found}" \

    "search spanning large range"

# For native targets, test a pattern straddling a chunk boundary.

if [isnative] {

    gdb_test "set *(int32_t*) &search_buf\[${CHUNK_SIZE}-1\] = 0xfdb97531" "" ""

    gdb_test "find /w search_buf, +search_buf_size, 0xfdb97531" \

    "${hex_number}${one_pattern_found}" \

    "find pattern straddling chunk boundary"

}