Subversion Repositories openrisc_me

# This testcase is part of GDB, the GNU debugger.

# Copyright 2000, 2002, 2003, 2004, 2005, 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 .

if [target_info exists gdb,noinferiorio] {

    verbose "Skipping fileio.exp because of no fileio capabilities."

    continue

}

if $tracelevel {

    strace $tracelevel

}

#

# test running programs

#

set prms_id 0

set bug_id 0

set testfile "sizeof"

set srcfile ${testfile}.c

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

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

     untested sizeof.exp

     return -1

}

if [get_compiler_info ${binfile}] {

    return -1;

}

gdb_exit

gdb_start

gdb_reinitialize_dir $srcdir/$subdir

gdb_load ${binfile}

#

# set it up at a breakpoint so we can play with the variable values

#

if ![runto_main] then {

    perror "couldn't run to breakpoint"

    continue

}

#

# Query GDB for the size of various types

#

proc get_valueof { fmt exp default } {

    global gdb_prompt

    set test "get valueof \"${exp}\""

    set val ${default}

    gdb_test_multiple "print${fmt} ${exp}" "$test" {

        -re "\\$\[0-9\]* = (\[-\]*\[0-9\]*).*$gdb_prompt $" {

            set val $expect_out(1,string)

            pass "$test ($val)"

        }

    }

    return ${val}

}

proc get_sizeof { type default } {

    return [get_valueof "/d" "sizeof (${type})" $default]

}

gdb_test "next"

set sizeof_char [get_sizeof "char" 1]

set sizeof_short [get_sizeof "short" 2]

set sizeof_int [get_sizeof "int" 4]

set sizeof_long [get_sizeof "long" 4]

set sizeof_long_long [get_sizeof "long long" 8]

set sizeof_data_ptr [get_sizeof "void *" 4]

set sizeof_func_ptr [get_sizeof "void (*)(void)" 4]

set sizeof_float [get_sizeof "float" 4]

set sizeof_double [get_sizeof "double" 8]

set sizeof_long_double [get_sizeof "long double" 8]

#

# Compare GDB's idea of types with the running program

#

proc check_sizeof { type size } {

    global gdb_prompt

    set pat [string_to_regexp "sizeof (${type}) == ${size}"]

    gdb_test "next" "${pat}\[\r\n\]+\[0-9\].*"  "check sizeof \"$type\""

}

check_sizeof "char" ${sizeof_char}

check_sizeof "short" ${sizeof_short}

check_sizeof "int" ${sizeof_int}

check_sizeof "long" ${sizeof_long}

check_sizeof "long long" ${sizeof_long_long}

check_sizeof "void *" ${sizeof_data_ptr}

check_sizeof "void (*)(void)" ${sizeof_func_ptr}

check_sizeof "float" ${sizeof_float}

check_sizeof "double" ${sizeof_double}

check_sizeof "long double" ${sizeof_long_double}

proc check_valueof { exp val } {

    global gdb_prompt

    set pat [string_to_regexp "valueof (${exp}) == ${val}"]

    gdb_test "next" "${pat}\[\r\n\]+\[0-9\].*" "check valueof \"$exp\""

}

# Check that GDB and the target agree over the sign of a character.

set signof_byte [get_valueof "/d" "'\\377'" -1]

set signof_char [get_valueof "/d" "(int) (char) -1" -1]

set signof_signed_char [get_valueof "/d" "(int) (signed char) -1" -1]

set signof_unsigned_char [get_valueof "/d" "(int) (unsigned char) -1" -1]

check_valueof "'\\377'" ${signof_byte}

check_valueof "(int) (char) -1" ${signof_char}

check_valueof "(int) (signed char) -1" ${signof_signed_char}

check_valueof "(int) (unsigned char) -1" ${signof_unsigned_char}

proc check_padding { fmt type val } {

    global gdb_prompt

    gdb_test "set padding_${type}.v = ${val}"

    gdb_test "print padding_${type}.p1" "= \"The quick brown \""

    gdb_test "print${fmt} padding_${type}.v" "= ${val}"

    gdb_test "print padding_${type}.p2" "\"The quick brown \".*"

}

# Check that GDB is managing to store a value in a struct field

# without corrupting the fields immediately adjacent to it.

check_padding "/d" "char" 1

check_padding "/d" "short" 2

check_padding "/d" "int" 4

check_padding "/d" "long" 4

check_padding "/d" "long_long" 8

# use multiples of two which can be represented exactly

check_padding "/f" "float" 1

check_padding "/f" "double" 2

check_padding "/f" "long_double" 4

#

# For reference, dump out the entire architecture

#

# The output is very long so use a while loop to consume it

send_gdb "maint print arch\n"

set ok 1

while { $ok } {

    gdb_expect {

        -re ".*dump" {

            #pass "maint print arch $ok"

            #set ok [expr $ok + 1]

        }

        -re "$gdb_prompt $" {

            pass "maint print arch"

            set ok 0

        }

        timeout {

            fail "maint print arch (timeout)"

            set ok 0

        }

    }

}