OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

Compare Revisions

  • This comparison shows the changes necessary to convert path
    /openrisc/trunk/or1ksim/testsuite
    from Rev 97 to Rev 98
    Reverse comparison

Rev 97 → Rev 98

/libsim.tests/jtag-select-module.exp
0,0 → 1,414
# jtag-select-module.exp. Tests of the library JTAG module selection
 
# Copyright (C) 2010 Embecosm Limited
 
# Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
# This file is part of OpenRISC 1000 Architectural Simulator.
 
# 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 <http:#www.gnu.org/licenses/>. */
 
# -----------------------------------------------------------------------------
# This code is commented throughout for use with Doxygen.
# -----------------------------------------------------------------------------
 
 
# These tests check all the module selection behavior. Behavior consequential
# on subsequent commands (WRITE_COMMAND, READ_COMMAND, GO_COMMAND_READ,
# GO_COMMAND_WRITE, READ_CONTROL and READ_CONTROL) appears in the test file
# for that command.
 
# NOTE. All these tests return timing information, but we ignore it, since in
# general it will not be repeatable.
 
# Just check if we can reset
run_libsim "JTAG SELECT_MODULE reset" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET"
 
# Check instruction selection. Just a partial test. Comprehensive testing of
# this is in jtag-basic.exp
run_libsim "JTAG SELECT_MODULE EXTEST instr" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x00" \
"Warning: JTAG EXTEST shifted" \
" shifted out: 0x00" \
" time taken: " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "0"
 
run_libsim "JTAG SELECT_MODULE invalid instr" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x0c" \
"ERROR: Unknown JTAG instruction 0x3 shifted" \
" shifted out: 0x0c" \
" time taken: " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "3"
 
run_libsim "JTAG SELECT_MODULE DEBUG instr" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8"
 
# Comprehensive test of selecting all possible modules. Only Wishbone (0),
# CPU0 (1) and CPU1 (2) should work silently (although CPU1 will prompt
# warnings if subsequent GO commands are used). All other values will fail by
# setting the status field on response.
 
# Wishbone module select (0)
run_libsim "JTAG SELECT_MODULE SELECT_MODULE WB (0)" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "0"
 
# CPU0 module select (1)
run_libsim "JTAG SELECT_MODULE SELECT_MODULE CPU0 (1)" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "1"
 
# CPU1 module select (2)
run_libsim "JTAG SELECT_MODULE SELECT_MODULE CPU1 (2)" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001993c98e69" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "2"
 
# All remaining modules should fail
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 3" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000424d9ea79" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "3"
 
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 4" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000102585a565" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "4"
 
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 5" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000d9295c175" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "5"
 
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 6" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001efe0d976d" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "6"
 
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 7" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x000000000003491df37d" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "7"
 
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 8" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x000000000014fea3b0e3" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "8"
 
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 9" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000949b3d4f3" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "9"
 
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 10" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001a252b82eb" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "a"
 
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 11" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x000000000007923be6fb" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "b"
 
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 12" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000139367a9e7" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "c"
 
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 13" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000e2477cdf7" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "d"
 
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 14" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001d48ef9bef" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "e"
 
run_libsim "JTAG SELECT_MODULE SELECT_MODULE 15" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x000000000000ffffffff" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "f"
/libsim.tests/Makefile.in
140,6 → 140,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
POW_LIB = @POW_LIB@
211,14 → 212,21
top_srcdir = @top_srcdir@
 
# Just distribute this stuff
EXTRA_DIST = default.cfg \
int-edge.cfg \
int-edge.exp \
int-level.cfg \
int-level.exp \
jtag-basic.exp \
jtag-full.exp \
lib-iftest.exp \
EXTRA_DIST = default.cfg \
int-edge.cfg \
int-edge.exp \
int-level.cfg \
int-level.exp \
jtag-basic.exp \
jtag-go-command-read.exp \
jtag-go-command-write.exp \
jtag-read-command.exp \
jtag-read-control.exp \
jtag-select-module.exp \
jtag-write-control.exp \
jtag-write-command.exp \
lib-iftest.exp \
upcalls.exp \
upcalls.cfg
 
all: all-am
/libsim.tests/default.cfg
51,6 → 51,22
delayw = 4
end
 
/* High memory for testing */
section memory
/*random_seed = 12345
type = random*/
pattern = 0x00
type = unknown /* Fastest */
name = "RAM"
ce = 2
mc = 0
baseaddr = 0xffe00000
size = 0x00200000
delayr = 2
delayw = 4
end
 
section immu
enabled = 1
nsets = 64
83,10 → 99,12
blocksize = 16
end
 
/* Set the CPU to take vectors at 0xf0000000 */
section cpu
ver = 0x12
rev = 0x0001
/* upr = */
sr = 0xc001
superscalar = 0
hazards = 0
dependstats = 0
113,8 → 131,24
exe_log_fn = "executed.log"
end
 
/* Memory instead of MC. Stops write errors when the startup code tries to
access a non-existent MC */
section memory
/*random_seed = 12345
type = random*/
pattern = 0x00
type = unknown /* Fastest */
name = "MC shadow"
baseaddr = 0x93000000
size = 0x00000080
delayr = 2
delayw = 4
end
 
/* Disabled */
section mc
enabled = 1
enabled = 0
baseaddr = 0x93000000
POC = 0x00000008 /* Power on configuration register */
index = 0
/libsim.tests/jtag-write-command.exp
0,0 → 1,1672
# jtag-command.exp. Tests of the library JTAG WRITE_COMMAND
 
# Copyright (C) 2010 Embecosm Limited
 
# Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
# This file is part of OpenRISC 1000 Architectural Simulator.
 
# 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 <http:#www.gnu.org/licenses/>. */
 
# -----------------------------------------------------------------------------
# This code is commented throughout for use with Doxygen.
# -----------------------------------------------------------------------------
 
 
# These are the tests of the high level JTAG WRITE_COMMAND interface.
 
# NOTE. All these tests return timing information, but we ignore it, since in
# general it will not be repeatable.
 
# Test of WRITE_COMMAND for each module (including none). This should raise an
# error for any module other than WB and CPU0. There are different errors for
# CPU1 (which can be selected, but for which WRITE_COMMAND is invalid) and all
# other modules.
 
# WRITE_COMMAND with no module selection
run_libsim "JTAG WRITE_COMMAND no module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken: " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "4"
 
# WRITE_COMMAND for Wishbone
run_libsim "JTAG WRITE_COMMAND module WB" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "4"
 
# WRITE_COMMAND for CPU0
run_libsim "JTAG WRITE_COMMAND module CPU0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "1" "WRITE_COMMAND" "2" "100000" "4"
 
# WRITE_COMMAND for CPU1
run_libsim "JTAG WRITE_COMMAND module CPU1" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001993c98e69" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
"ERROR: JTAG WRITE_COMMAND for CPU1 not supported." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "2" "WRITE_COMMAND" "2" "100000" "4"
 
# WRITE_COMMAND for invalid module
run_libsim "JTAG WRITE_COMMAND invalid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000424d9ea79" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
"ERROR: JTAG WRITE_COMMAND with no module selected." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "3" "WRITE_COMMAND" "2" "100000" "4"
 
# WRITE_COMMAND for valid followed by invalid module
run_libsim "JTAG WRITE_COMMAND valid then invalid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001993c98e69" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000424d9ea79" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
"ERROR: JTAG WRITE_COMMAND with no module selected." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "2" "SELECT_MODULE" "3" "WRITE_COMMAND" "2" \
"100000" "4"
 
# WRITE_COMMAND for invalid followed by valid module
run_libsim "JTAG WRITE_COMMAND invalid then valid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000424d9ea79" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "3" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" \
"100000" "4"
 
# Tests of WRITE_COMMAND access types for WishBone. Check the different access
# types are accepted/rejected as expected (0, 1, 2, 4, 5 and 6 are OK).
 
# WRITE_COMMAND to write bytes for WishBone (access type 0)
run_libsim "JTAG WRITE_COMMAND WB write bytes" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000107557c0580000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "4"
 
# WRITE_COMMAND to write half words for WishBone (access type 1)
run_libsim "JTAG WRITE_COMMAND WB write half words" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001778a9e180000000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100000" "4"
 
# WRITE_COMMAND to write words for WishBone (access type 2)
run_libsim "JTAG WRITE_COMMAND WB write words" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "4"
 
# WRITE_COMMAND to write access type 3 for WishBone. This should fail with an
# error.
run_libsim "JTAG WRITE_COMMAND WB write access type 3" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000009f6e431380000000100188" \
"ERROR: JTAG WRITE_COMMAND unknown access type 3." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "3" "100000" "4"
 
# WRITE_COMMAND to read bytes for WishBone (access type 4). All the read
# accesses use the init version of the loop, so consistent values are set.
run_libsim "JTAG WRITE_COMMAND WB read bytes" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000982f0f3d80000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "4"
 
# WRITE_COMMAND to read half words for WishBone (access type 5)
run_libsim "JTAG WRITE_COMMAND WB read half words" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018802dad980000000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "4"
 
# WRITE_COMMAND to read words for WishBone (access type 6)
run_libsim "JTAG WRITE_COMMAND WB read words" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001039e5cf800000001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "4"
 
# WRITE_COMMAND to read access type 7 for WishBone. This should fail with an
# error.
run_libsim "JTAG WRITE_COMMAND WB read access type 7" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000010014302b800000001001c8" \
"ERROR: JTAG WRITE_COMMAND unknown access type 7." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "7" "100000" "4"
 
# Tests of WRITE_COMMAND addresses for WishBone. Check different addresses are
# all accepted. For all of these we use the simple loop and a byte write. Test
# the boundaries (address 0 and address 0xffffffff).
 
# WRITE_COMMAND for WishBone to address 0
run_libsim "JTAG WRITE_COMMAND WB write address 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000517c6ee600000000000008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "0" "1"
 
# WRITE_COMMAND for WishBone to address ffffffff
run_libsim "JTAG WRITE_COMMAND WB write address 0xffffffff" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000cd06d25e0001fffffffe08" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "ffffffff" "1"
 
# Tests of WRITE_COMMAND lengths for WishBone. Check the different lengths are
# accepted. For all of these we use the simple loop and write. There is no
# point testing sizes outside the range, since these fail in the test rather
# than the progrma under test. We use byte reads from the initialized loop
 
# Test of WRITE_COMMAND for WishBone 1 byte.
run_libsim "JTAG WRITE_COMMAND WB read length 1" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001aee68a5c00000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "1"
 
# Test of WRITE_COMMAND for WishBone 0x10000 bytes. We only match the first
# few bytes of the shifted strings and data.
run_libsim "JTAG WRITE_COMMAND WB read length 0x10000" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000d2aaafa3fffe0000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "10000"
 
# Tests of WRITE_COMMAND with different alignments. Byte access should be
# aligned on any boundary. Half-word on half-word boundaries and word on word
# boundaries. In each case we use 4 byte transfers.
 
# Write bytes, aligned on byte 0
run_libsim "JTAG WRITE_COMMAND WB write bytes, byte 0 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000107557c0580000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "4"
 
# Write bytes, aligned on byte 1
run_libsim "JTAG WRITE_COMMAND WB write bytes, byte 1 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000c53f4b0580010000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100001" "4"
 
# Write bytes, aligned on byte 2
run_libsim "JTAG WRITE_COMMAND WB write bytes, byte 2 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001e660678580008000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100002" "4"
 
# Write bytes, aligned on byte 3
run_libsim "JTAG WRITE_COMMAND WB write bytes, byte 3 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000240a508580018000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100003" "4"
 
# Write half words, aligned on byte 0
run_libsim "JTAG WRITE_COMMAND WB write half words, byte 0 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001778a9e180000000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100000" "4"
 
# Write half words, aligned on byte 1
run_libsim "JTAG WRITE_COMMAND WB write half words, byte 1 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001d5129ee180010000100108" \
"ERROR: JTAG WishBone 16-bit access must be 2-byte aligned." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100001" "4"
 
# Write half words, aligned on byte 2
run_libsim "JTAG WRITE_COMMAND WB write half words, byte 2 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000f64db26180008000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100002" "4"
 
# Write half words, aligned on byte 3
run_libsim "JTAG WRITE_COMMAND WB write half words, byte 3 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000013427856180018000100108" \
"ERROR: JTAG WishBone 16-bit access must be 2-byte aligned." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100003" "4"
 
# Write words, aligned on byte 0
run_libsim "JTAG WRITE_COMMAND WB write words, byte 0 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "4"
 
# Write words, aligned on byte 1
run_libsim "JTAG WRITE_COMMAND WB write words, byte 1 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000004d29a1f780010000100088" \
"ERROR: JTAG WishBone 32-bit access must be 4-byte aligned." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100001" "4"
 
# Write words, aligned on byte 2
run_libsim "JTAG WRITE_COMMAND WB write words, byte 2 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000016e768d7780008000100088" \
"ERROR: JTAG WishBone 32-bit access must be 4-byte aligned." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100002" "4"
 
# Write words, aligned on byte 3
run_libsim "JTAG WRITE_COMMAND WB write words, byte 3 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000ac1cba7780018000100088" \
"ERROR: JTAG WishBone 32-bit access must be 4-byte aligned." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100003" "4"
 
# Read bytes, aligned on byte 0
run_libsim "JTAG WRITE_COMMAND WB read bytes, byte 0 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000982f0f3d80000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "4"
 
# Read bytes, aligned on byte 1
run_libsim "JTAG WRITE_COMMAND WB read bytes, byte 1 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000015a45383d80010000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100001" "4"
 
# Read bytes, aligned on byte 2
run_libsim "JTAG WRITE_COMMAND WB read bytes, byte 2 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000791a14bd80008000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100002" "4"
 
# Read bytes, aligned on byte 3
run_libsim "JTAG WRITE_COMMAND WB read bytes, byte 3 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001bb7023bd80018000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100003" "4"
 
# Read half words, aligned on byte 0
run_libsim "JTAG WRITE_COMMAND WB read half words, byte 0 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018802dad980000000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "4"
 
# Read half words, aligned on byte 1
run_libsim "JTAG WRITE_COMMAND WB read half words, byte 1 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000004a68edd980010000100148" \
"ERROR: JTAG WishBone 16-bit access must be 2-byte aligned." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100001" "4"
 
# Read half words, aligned on byte 2
run_libsim "JTAG WRITE_COMMAND WB read half words, byte 2 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000016937c15980008000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100002" "4"
 
# Read half words, aligned on byte 3
run_libsim "JTAG WRITE_COMMAND WB read half words, byte 3 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000ab5df65980018000100148" \
"ERROR: JTAG WishBone 16-bit access must be 2-byte aligned." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100003" "4"
 
# Read words, aligned on byte 0
run_libsim "JTAG WRITE_COMMAND WB read words, byte 0 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001039e5cf800000001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "4"
 
# Read words, aligned on byte 1
run_libsim "JTAG WRITE_COMMAND WB read words, byte 1 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001d253d2cf800100001000c8" \
"ERROR: JTAG WishBone 32-bit access must be 4-byte aligned." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100001" "4"
 
# Read words, aligned on byte 2
run_libsim "JTAG WRITE_COMMAND WB read words, byte 2 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000f10cfe4f800080001000c8" \
"ERROR: JTAG WishBone 32-bit access must be 4-byte aligned." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100002" "4"
 
# Read words, aligned on byte 3
run_libsim "JTAG WRITE_COMMAND WB read words, byte 3 aligned" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000013366c94f800180001000c8" \
"ERROR: JTAG WishBone 32-bit access must be 4-byte aligned." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100003" "4"
 
# Tests of WRITE_COMMAND for CPU0. Check the different access types are
# accepted/rejected as expected (2 and 6 are OK).
 
# WRITE_COMMAND to write bytes for CPU0 (access type 0). This should fail
# with an error message.
run_libsim "JTAG WRITE_COMMAND CPU0 write bytes" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000011b285d1780010028000008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "0" "2801" "4"
 
# WRITE_COMMAND to write half words for CPU0 (access type 1). This should fail
# with an error message.
run_libsim "JTAG WRITE_COMMAND CPU0 write half words" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000000b0588f380010028000108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "1" "2801" "4"
 
# WRITE_COMMAND to write words for CPU0 (access type 2).
run_libsim "JTAG WRITE_COMMAND CPU0 write words" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001933eb7e580010028000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "2" "2801" "4"
 
# WRITE_COMMAND to write access type 3. This should fail with an error
# message.
run_libsim "JTAG WRITE_COMMAND CPU0 write access type 3" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000008313620180010028000188" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "3" "2801" "4"
 
# WRITE_COMMAND to read bytes for CPU0 (access type 4). This should fail
# with an error message.
run_libsim "JTAG WRITE_COMMAND CPU0 read bytes" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000084522e2f80010028000048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "4" "2801" "4"
 
# WRITE_COMMAND to read half words for CPU0 (access type 5). This should fail
# with an error message.
run_libsim "JTAG WRITE_COMMAND CPU0 read half words" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001947ffbcb80010028000148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "5" "2801" "4"
 
# WRITE_COMMAND to read words for CPU0 (access type 6)
run_libsim "JTAG WRITE_COMMAND CPU0 read words" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000000c44c4dd800100280000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "6" "2801" "4"
 
# WRITE_COMMAND to read access type 7. This should fail with an error message.
run_libsim "JTAG WRITE_COMMAND CPU0 read access type 7" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000011c691139800100280001c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "7" "2801" "4"
 
# Tests of WRITE_COMMAND addresses for CPU0. Addresses up to 0xffff are
# OK. Check different addresses are all accepted. For all of these we use the
# simple loop and a word write. Test the boundaries (addresses 0, 0xffff and
# 0x10000). Over-size addresses should be truncated with a warning. Remember
# these are SPR addresses, which are effectively word addresses.
 
# WRITE_COMMAND for CPU0 to address 0
run_libsim "JTAG WRITE_COMMAND CPU0 write address 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001efa3017580000000000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "2" "0" "4"
 
# WRITE_COMMAND for CPU0 to address 0xffff
run_libsim "JTAG WRITE_COMMAND CPU0 write address 0xffff" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000012e99654d8001fffe000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "2" "ffff" "4"
 
# WRITE_COMMAND for CPU0 to address 0x10000. Should be trucated witha
# warning.
run_libsim "JTAG WRITE_COMMAND CPU0 write address 0x10000" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000008c6e605180000001000088" \
"Warning: truncated JTAG SPR address 0x00010000." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "2" "10000" "4"
 
# Tests of WRITE_COMMAND lengths for CPU0. Check only length 4 is
# accepted. For all of these we use the simple loop and write. There is no
# point in testing values outside the permitted range, since these are
# rejected in the test code, rather than the target code. Test sizes 3, 4, 5
# and 0x10000 bytes.
 
# Test of WRITE_COMMAND for CPU0 3 bytes. This should fail with an error
# message.
run_libsim "JTAG WRITE_COMMAND CPU0 read length 3" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001d735c29c800100280000c8" \
"ERROR: JTAG SPR access 0x3 bytes not supported." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "6" "2801" "3"
 
# Test of WRITE_COMMAND for CPU0 4 bytes.
run_libsim "JTAG WRITE_COMMAND CPU0 read length 4" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000000c44c4dd800100280000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "6" "2801" "4"
 
# Test of WRITE_COMMAND for CPU0 5 bytes. This should fail with an error
# message.
run_libsim "JTAG WRITE_COMMAND CPU0 read length 5" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000014c51002c400100280000c8" \
"ERROR: JTAG SPR access 0x5 bytes not supported." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "6" "2801" "5"
 
# Test of WRITE_COMMAND for CPU0 0x10000 bytes. This should fail with an error
# message.
run_libsim "JTAG WRITE_COMMAND CPU0 read length 0x10000" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000046c16443ffff00280000c8" \
"ERROR: JTAG SPR access 0x10000 bytes not supported." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "6" "2801" "10000"
/libsim.tests/jtag-write-control.exp
0,0 → 1,426
# jtag-write-control.exp. Tests of the library JTAG WRITE_CONTROL command
 
# Copyright (C) 2010 Embecosm Limited
 
# Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
# This file is part of OpenRISC 1000 Architectural Simulator.
 
# 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 <http:#www.gnu.org/licenses/>. */
 
# -----------------------------------------------------------------------------
# This code is commented throughout for use with Doxygen.
# -----------------------------------------------------------------------------
 
 
# These tests check all the behavior associated with the JTAG WRITE_CONTROL
# command.
 
# NOTE. All these tests return timing information, but we ignore it, since in
# general it will not be repeatable.
 
# Tests of the WRITE_CONTROL for writing from different modules. This should
# work fine for CPU0, but provoke a warning for Wishbone and CPU1 and a
# different warning for all other modules. Test no module, Wishbone, CPU0,
# CPU1 and module 6.
 
# WRITE_CONTROL with no module selected.
run_libsim "JTAG WRITE_CONTROL no module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000096dc049200000000000004" \
"ERROR: JTAG WRITE_CONTROL with no module selected." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "WRITE_CONTROL" "0" "0"
 
# WRITE_CONTROL with only WishBone module selected.
run_libsim "JTAG WRITE_CONTROL WB module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000096dc049200000000000004" \
"ERROR: JTAG WRITE_CONTROL of WishBone not supported." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_CONTROL" "0" "0"
 
# WRITE_CONTROL with only invalid module selected.
run_libsim "JTAG WRITE_CONTROL invalid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001993c98e69" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000096dc049200000000000004" \
"ERROR: JTAG WRITE_CONTROL of CPU1 not supported." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "2" "WRITE_CONTROL" "0" "0"
 
# WRITE_CONTROL with invalid module selected after valid module
run_libsim "JTAG WRITE_CONTROL invalid after valid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x000000000003491df37d" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000096dc049200000000000004" \
"ERROR: JTAG WRITE_CONTROL with no module selected." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "SELECT_MODULE" "7" "WRITE_CONTROL" "0" "0"
 
# WRITE_CONTROL with valid module selected after invalid module
run_libsim "JTAG WRITE_CONTROL valid after invalid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x000000000003491df37d" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
" shifting in: 0x000000000096dc049200000000000004" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "7" "SELECT_MODULE" "1" "WRITE_CONTROL" "0" "0"
 
# Verify that writing works correctly from the valid module, CPU0.
 
# WRITE_CONTROL for CPU0.
run_libsim "JTAG WRITE_CONTROL CPU0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000096dc049200000000000004" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_CONTROL" "0" "0"
 
# Test of setting and clearing the stall bit for CPU0. We can only do this via
# multiple WRITE_COMMANDs. After stalling we should complete execution on a
# breakpoint and after clearing complete OK.
 
# Set the stall bit.
run_libsim "JTAG WRITE_CONTROL CPU0 set stall" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000109a677aa00000000000044" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed with breakpoint." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_CONTROL" "0" "1"
 
# Clear the stall bit.
run_libsim "JTAG WRITE_CONTROL CPU0 clear stall" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000096dc049200000000000004" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_CONTROL" "0" "0"
 
# Set, then clear the stall bit.
run_libsim "JTAG WRITE_CONTROL CPU0 set then clear stall" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000109a677aa00000000000044" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed with breakpoint." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000096dc049200000000000004" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "1" "WRITE_CONTROL" "0" "1" "WRITE_CONTROL" "0" "0"
 
# Clear, then set the stall bit.
run_libsim "JTAG WRITE_CONTROL CPU0 clear then set stall" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000096dc049200000000000004" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000109a677aa00000000000044" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed with breakpoint." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "1" "WRITE_CONTROL" "0" "0" "WRITE_CONTROL" "0" "1"
 
# Test the reset bit. We can see this works, becaause the PIC puts out a
# message on reset.
 
# Set the reset bit.
run_libsim "JTAG WRITE_CONTROL CPU0 reset" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000059613d0e00000000000024" \
"Resetting PIC." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_CONTROL" "1" "0"
 
# Verify that reset overrides any simultaneous stall
run_libsim "JTAG WRITE_CONTROL CPU0 stall and reset" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x0000000001c61b4e3600000000000064" \
"Resetting PIC." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_CONTROL" "1" "1"
 
# Verify that reset clears any previous stall
run_libsim "JTAG WRITE_CONTROL CPU0 stall then reset" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000109a677aa00000000000044" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed with breakpoint." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000059613d0e00000000000024" \
"Resetting PIC." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_CONTROL" "0" "1" "WRITE_CONTROL" "1" "0"
/libsim.tests/jtag-go-command-write.exp
0,0 → 1,2232
# jtag-go-command-write.exp. Tests of the library JTAG GO_COMMAND for writing
 
# Copyright (C) 2010 Embecosm Limited
 
# Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
# This file is part of OpenRISC 1000 Architectural Simulator.
 
# 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 <http:#www.gnu.org/licenses/>. */
 
# -----------------------------------------------------------------------------
# This code is commented throughout for use with Doxygen.
# -----------------------------------------------------------------------------
 
 
# These tests check all the behavior associated with the JTAG GO_COMMAND when
# writing.
 
# NOTE. All these tests return timing information, but we ignore it, since in
# general it will not be repeatable.
 
# Tests of the GO_COMMAND for writing to different modules. This should work
# fine for Wishbone and CPU0. Other modules will have been weeded out by the
# prior WRITE_COMMAND. We specify 4 bytes to read each time.
 
# We use the loop-report OpenRISC program here, since we must be sure that
# values written make it to the target As SPR's we use MACLO (0x2801) and
# MACHI (0x2802). As Wishbone we use address 0x100000 - 0x12ffff. Changes to
# values in the first 16 bytes following 0x100000, 0x110000 and 0x120000 are
# reported.
 
# When testing GO_COMMAND (write) after invalid module selection, we cannot
# guarantee a CRC mismatch (or at least I can't do the maths to prove that no
# register of all zeros can have a valid CRC field for the possible GO_COMMAND
# register lengths, although it is highly likely), so we just look for the
# error message.
 
# GO_COMMAND writing with no module selection (address 0x100000).
run_libsim "JTAG SELECT_MODULE GO_COMMAND (write) no module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
"ERROR: JTAG WRITE_COMMAND with no module selected." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
"ERROR: JTAG GO_COMMAND with no prior WRITE_COMMAND." \
" shifted out: 0x0000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"WRITE_COMMAND" "2" "100000" "4" "GO_COMMAND_WRITE" "deadbeef"
 
# GO_COMMAND writing with only invalid module selected.
run_libsim "JTAG GO_COMMAND (write) invalid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001993c98e69" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001933eb7e580010028000088" \
"ERROR: JTAG WRITE_COMMAND for CPU1 not supported." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
"ERROR: JTAG GO_COMMAND with no prior WRITE_COMMAND." \
" shifted out: 0x0000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "2" "WRITE_COMMAND" "2" "2801" "4" \
"GO_COMMAND_WRITE" "deadbeef"
 
# GO_COMMAND writing with invalid module selected after valid module
run_libsim "JTAG GO_COMMAND (write) invalid after valid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001efe0d976d" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001933eb7e580010028000088" \
"ERROR: JTAG WRITE_COMMAND with no module selected." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
"ERROR: JTAG GO_COMMAND with no prior WRITE_COMMAND." \
" shifted out: 0x0000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "SELECT_MODULE" "6" "WRITE_COMMAND" "2" \
"2801" "4" "GO_COMMAND_WRITE" "deadbeef"
 
# GO_COMMAND writing with valid module selected after invalid module
run_libsim "JTAG GO_COMMAND (write) valid after invalid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001efe0d976d" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
" shifted out: 0x0164841bc6000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "6" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" \
"100000" "4" "GO_COMMAND_WRITE" "deadbeef"
 
# Verify that writing works correctly from both valid modules, WishBone and
# CPU0.
 
# GO_COMMAND writing for Wishbone (address 0x100000).
run_libsim "JTAG SELECT_MODULE GO_COMMAND (write) WB" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
" shifted out: 0x0164841bc6000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "4" \
"GO_COMMAND_WRITE" "deadbeef"
 
# GO_COMMAND writing for CPU0 (address 0x2801, MACLO).
run_libsim "JTAG SELECT_MODULE GO_COMMAND (write) CPU0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001933eb7e580010028000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
" shifted out: 0x0164841bc6000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "1" "WRITE_COMMAND" "2" "2801" "4" \
"GO_COMMAND_WRITE" "deadbeef"
 
# Tests of GO_COMMAND_WRITE with different access alignments, boundaries and
# lengths for WishBone. For this we use the loop-report program, which reports
# any changes in values at 0x100000-0x10000f, 0x110000-0x11000f and
# 0x120000-0x12000f or the SPRs MACLO (0x2801) and MACHI (0x2800), all of
# which are initialized to zero.
 
# First check that a single aligned unit can be written for each access type
# at its allowed alignments.
 
# GO_COMMAND writing one byte for Wishbone aligned at byte 0.
run_libsim "JTAG GO_COMMAND (write) WB 1 byte, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000319cf96400000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000006d6fa6e6f60" \
" shifted out: 0x0164841bc6000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100000 = 0xde" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "1" \
"GO_COMMAND_WRITE" "de"
 
# GO_COMMAND writing one byte for Wishbone aligned at byte 1.
run_libsim "JTAG GO_COMMAND (write) WB 1 byte, aligned byte 1" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001f3f6ce6400010000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000006d6fa6e6f60" \
" shifted out: 0x0164841bc6000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100001 = 0xde" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100001" "1" \
"GO_COMMAND_WRITE" "de"
 
# GO_COMMAND writing one byte for Wishbone aligned at byte 2.
run_libsim "JTAG GO_COMMAND (write) WB 1 byte, aligned byte 2" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000d0a9e2e400008000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000006d6fa6e6f60" \
" shifted out: 0x0164841bc6000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100002 = 0xde" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100002" "1" \
"GO_COMMAND_WRITE" "de"
 
# GO_COMMAND writing one byte for Wishbone aligned at byte 3.
run_libsim "JTAG GO_COMMAND (write) WB 1 byte, aligned byte 3" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000112c3d5e400018000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000006d6fa6e6f60" \
" shifted out: 0x0164841bc6000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100003 = 0xde" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100003" "1" \
"GO_COMMAND_WRITE" "de"
 
# GO_COMMAND writing one half word for Wishbone aligned at byte 0.
run_libsim "JTAG GO_COMMAND (write) WB 1 half word, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000fac02ac100000000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000000e463a0ad6af60" \
" shifted out: 0x0164841bc600000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100000 = 0xde" \
"New byte at 0x00100001 = 0xad" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100000" "2" \
"GO_COMMAND_WRITE" "dead"
 
# GO_COMMAND writing one half word for Wishbone aligned at byte 2.
run_libsim "JTAG GO_COMMAND (write) WB 1 half word, aligned byte 2" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001bf5314100008000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000000e463a0ad6af60" \
" shifted out: 0x0164841bc600000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100002 = 0xde" \
"New byte at 0x00100003 = 0xad" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100002" "2" \
"GO_COMMAND_WRITE" "dead"
 
# GO_COMMAND writing one word for Wishbone aligned at byte 0.
run_libsim "JTAG GO_COMMAND (write) WB 1 word, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
" shifted out: 0x0164841bc6000000000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100000 = 0xde" \
"New byte at 0x00100001 = 0xad" \
"New byte at 0x00100002 = 0xbe" \
"New byte at 0x00100003 = 0xef" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "4" \
"GO_COMMAND_WRITE" "deadbeef"
 
# Verify that longer writes work OK, at different boundaries. For byte access
# write 9 bytes, for half-word access write 10 bytes and for word access write
# 12 bytes.
 
# GO_COMMAND writing 9 bytes for Wishbone aligned at byte 0.
run_libsim "JTAG GO_COMMAND (write) WB 9 bytes, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000000af2d9ac20000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000005b486612bafabafea7eefb6af60" \
" shifted out: 0x0164841bc60000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100000 = 0xde" \
"New byte at 0x00100001 = 0xad" \
"New byte at 0x00100002 = 0xbe" \
"New byte at 0x00100003 = 0xef" \
"New byte at 0x00100004 = 0xca" \
"New byte at 0x00100005 = 0xfe" \
"New byte at 0x00100006 = 0xba" \
"New byte at 0x00100007 = 0xbe" \
"New byte at 0x00100008 = 0xba" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "9" \
"GO_COMMAND_WRITE" "deadbeefcafebabeba"
 
# GO_COMMAND writing 9 bytes for Wishbone aligned at byte 1.
run_libsim "JTAG GO_COMMAND (write) WB 9 bytes, aligned byte 1" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001c898eeac20010000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000005b486612bafabafea7eefb6af60" \
" shifted out: 0x0164841bc60000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100001 = 0xde" \
"New byte at 0x00100002 = 0xad" \
"New byte at 0x00100003 = 0xbe" \
"New byte at 0x00100004 = 0xef" \
"New byte at 0x00100005 = 0xca" \
"New byte at 0x00100006 = 0xfe" \
"New byte at 0x00100007 = 0xba" \
"New byte at 0x00100008 = 0xbe" \
"New byte at 0x00100009 = 0xba" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100001" "9" \
"GO_COMMAND_WRITE" "deadbeefcafebabeba"
 
# GO_COMMAND writing 9 bytes for Wishbone aligned at byte 2.
run_libsim "JTAG GO_COMMAND (write) WB 9 bytes, aligned byte 2" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000ebc7c22c20008000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000005b486612bafabafea7eefb6af60" \
" shifted out: 0x0164841bc60000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100002 = 0xde" \
"New byte at 0x00100003 = 0xad" \
"New byte at 0x00100004 = 0xbe" \
"New byte at 0x00100005 = 0xef" \
"New byte at 0x00100006 = 0xca" \
"New byte at 0x00100007 = 0xfe" \
"New byte at 0x00100008 = 0xba" \
"New byte at 0x00100009 = 0xbe" \
"New byte at 0x0010000a = 0xba" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100002" "9" \
"GO_COMMAND_WRITE" "deadbeefcafebabeba"
 
# GO_COMMAND writing 9 bytes for Wishbone aligned at byte 3.
run_libsim "JTAG GO_COMMAND (write) WB 9 bytes, aligned byte 3" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000129adf52c20018000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000005b486612bafabafea7eefb6af60" \
" shifted out: 0x0164841bc60000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100003 = 0xde" \
"New byte at 0x00100004 = 0xad" \
"New byte at 0x00100005 = 0xbe" \
"New byte at 0x00100006 = 0xef" \
"New byte at 0x00100007 = 0xca" \
"New byte at 0x00100008 = 0xfe" \
"New byte at 0x00100009 = 0xba" \
"New byte at 0x0010000a = 0xbe" \
"New byte at 0x0010000b = 0xba" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100003" "9" \
"GO_COMMAND_WRITE" "deadbeefcafebabeba"
 
# GO_COMMAND writing 5 half words for Wishbone aligned at byte 0.
run_libsim "JTAG GO_COMMAND (write) WB 5 half words, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000c1ae0a0920000000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x0000000000185f4b7296abafabafea7eefb6af60" \
" shifted out: 0x0164841bc6000000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100000 = 0xde" \
"New byte at 0x00100001 = 0xad" \
"New byte at 0x00100002 = 0xbe" \
"New byte at 0x00100003 = 0xef" \
"New byte at 0x00100004 = 0xca" \
"New byte at 0x00100005 = 0xfe" \
"New byte at 0x00100006 = 0xba" \
"New byte at 0x00100007 = 0xbe" \
"New byte at 0x00100008 = 0xba" \
"New byte at 0x00100009 = 0xad" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100000" "a" \
"GO_COMMAND_WRITE" "deadbeefcafebabebaad"
 
# GO_COMMAND writing 5 half words for Wishbone aligned at byte 2.
run_libsim "JTAG GO_COMMAND (write) WB 5 half words, aligned byte 2" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000209b118920008000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x0000000000185f4b7296abafabafea7eefb6af60" \
" shifted out: 0x0164841bc6000000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100002 = 0xde" \
"New byte at 0x00100003 = 0xad" \
"New byte at 0x00100004 = 0xbe" \
"New byte at 0x00100005 = 0xef" \
"New byte at 0x00100006 = 0xca" \
"New byte at 0x00100007 = 0xfe" \
"New byte at 0x00100008 = 0xba" \
"New byte at 0x00100009 = 0xbe" \
"New byte at 0x0010000a = 0xba" \
"New byte at 0x0010000b = 0xad" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100002" "a" \
"GO_COMMAND_WRITE" "deadbeefcafebabebaad"
 
# GO_COMMAND writing 3 words for Wishbone aligned at byte 0.
run_libsim "JTAG GO_COMMAND (write) WB 3 words, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001b42db63fa0000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000014adb55b7601f6abafabafea7eefb6af60" \
" shifted out: 0x0164841bc60000000000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"New byte at 0x00100000 = 0xde" \
"New byte at 0x00100001 = 0xad" \
"New byte at 0x00100002 = 0xbe" \
"New byte at 0x00100003 = 0xef" \
"New byte at 0x00100004 = 0xca" \
"New byte at 0x00100005 = 0xfe" \
"New byte at 0x00100006 = 0xba" \
"New byte at 0x00100007 = 0xbe" \
"New byte at 0x00100008 = 0xba" \
"New byte at 0x00100009 = 0xad" \
"New byte at 0x0010000a = 0xf0" \
"New byte at 0x0010000b = 0x0d" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "c" \
"GO_COMMAND_WRITE" "deadbeefcafebabebaadf00d"
 
# Test of access for CPU0. Much simpler, since access type, alignment and
# length are more prescribed. Make use of loop-report, which monitors MACLO
# (0x2801) and MACHI (0x2802). These are 32 bit values and presented in target
# endianess (which is big-endian for the OpenRISC, so the MS byte is as the
# highest address.
 
# GO_COMMAND writing 1 word for CPU0 aligned at byte 0.
run_libsim "JTAG GO_COMMAND (write) CPU0 1 word, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001933eb7e580010028000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
" shifted out: 0x0164841bc6000000000000000000" \
" status: 0x0" \
" time taken:" \
"New MACLO 0xefbeadde" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "2" "2801" "4" \
"GO_COMMAND_WRITE" "deadbeef"
 
# Check address advances after GO (1 per word for CPU, 4 per word for
# WB). Test WB with writing and reading all sizes and lengths 1 through
# 0x10000. Test CPU0 with writing and reading words with a range of lengths,
# all of which should return length 4.
 
# - for WB byte access try lengths 1, 2, 3, 4, 5, 8 and 9
# - for WB half word access try lengths 2, 4, 6, 8 and 10
# - for WB full word access try lengths 4, 8 and 12
# - for SPR try length 4
 
# Advance address after writing 1 byte for WishBone (access type 0)
run_libsim "JTAG GO_COMMAND (write) WB write 1 byte address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000319cf96400000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000006d6fa6e6f60" \
" shifted out: 0x0164841bc6000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0e460cbc200001000010000000000000" \
" access_type: 0x0" \
" address: 0x100001" \
" length: 0x1" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "1" \
"GO_COMMAND_WRITE" "de" "READ_COMMAND"
 
# Advance address after writing 2 bytes for WishBone (access type 0)
run_libsim "JTAG GO_COMMAND (write) WB write 2 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001eaedff2500000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000000e463a0ad6af60" \
" shifted out: 0x0164841bc600000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0ebe2296e10000800010000000000000" \
" access_type: 0x0" \
" address: 0x100002" \
" length: 0x2" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "2" \
"GO_COMMAND_WRITE" "dead" "READ_COMMAND"
 
# Advance address after writing 3 bytes for WishBone (access type 0)
run_libsim "JTAG GO_COMMAND (write) WB write 3 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000dc247a4480000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001599d9120fb6af60" \
" shifted out: 0x0164841bc60000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0e4a8124808001800010000000000000" \
" access_type: 0x0" \
" address: 0x100003" \
" length: 0x3" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "3" \
"GO_COMMAND_WRITE" "deadbe" "READ_COMMAND"
 
# Advance address after writing 4 bytes for WishBone (access type 0)
run_libsim "JTAG GO_COMMAND (write) WB write 4 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000107557c0580000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
" shifted out: 0x0164841bc6000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0ec23583818000400010000000000000" \
" access_type: 0x0" \
" address: 0x100004" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "4" \
"GO_COMMAND_WRITE" "deadbeef" "READ_COMMAND"
 
# Advance address after writing 5 bytes for WishBone (access type 0)
run_libsim "JTAG GO_COMMAND (write) WB write 5 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000004740b8f440000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000009ac236c4a7eefb6af60" \
" shifted out: 0x0164841bc600000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x13f75a14604001400010000000000000" \
" access_type: 0x0" \
" address: 0x100005" \
" length: 0x5" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "5" \
"GO_COMMAND_WRITE" "deadbeefca" "READ_COMMAND"
 
# Advance address after writing 8 bytes for WishBone (access type 0)
run_libsim "JTAG GO_COMMAND (write) WB write 8 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000171893d95c0000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000014db90944fabafea7eefb6af60" \
" shifted out: 0x0164841bc600000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x134b2e6d21c000200010000000000000" \
" access_type: 0x0" \
" address: 0x100008" \
" length: 0x8" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "8" \
"GO_COMMAND_WRITE" "deadbeefcafebabe" "READ_COMMAND"
 
# Advance address after writing 9 bytes for WishBone (access type 0)
run_libsim "JTAG GO_COMMAND (write) WB write 9 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000000af2d9ac20000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000005b486612bafabafea7eefb6af60" \
" shifted out: 0x0164841bc60000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x009ea7e8002001200010000000000000" \
" access_type: 0x0" \
" address: 0x100009" \
" length: 0x9" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "9" \
"GO_COMMAND_WRITE" "deadbeefcafebabeba" "READ_COMMAND"
 
# Advance address after writing 1 half word (2 bytes) for WishBone (access
# type 1)
run_libsim "JTAG GO_COMMAND (write) WB write 1 half word address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000fac02ac100000000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000000e463a0ad6af60" \
" shifted out: 0x0164841bc600000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x08c3cb5a010000800010010000000000" \
" access_type: 0x1" \
" address: 0x100002" \
" length: 0x2" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100000" "2" \
"GO_COMMAND_WRITE" "dead" "READ_COMMAND"
 
# Advance address after writing 2 half words (4 bytes) for WishBone (access
# type 1)
run_libsim "JTAG GO_COMMAND (write) WB write 2 half words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001778a9e180000000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
" shifted out: 0x0164841bc6000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x08bfdc4f618000400010010000000000" \
" access_type: 0x1" \
" address: 0x100004" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100000" "4" \
"GO_COMMAND_WRITE" "deadbeef" "READ_COMMAND"
 
# Advance address after writing 3 half words (6 bytes) for WishBone (access
# type 1)
run_libsim "JTAG GO_COMMAND (write) WB write 3 half words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000008c1c6b5140000000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000000c6961b84fea7eefb6af60" \
" shifted out: 0x0164841bc60000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x15729df2414000c00010010000000000" \
" access_type: 0x1" \
" address: 0x100006" \
" length: 0x6" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100000" "6" \
"GO_COMMAND_WRITE" "deadbeefcafe" "READ_COMMAND"
 
# Advance address after writing 4 half words (8 bytes) for WishBone (access
# type 1)
run_libsim "JTAG GO_COMMAND (write) WB write 4 half words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000061a4e871c0000000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000014db90944fabafea7eefb6af60" \
" shifted out: 0x0164841bc600000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1536c7a1c1c000200010010000000000" \
" access_type: 0x1" \
" address: 0x100008" \
" length: 0x8" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100000" "8" \
"GO_COMMAND_WRITE" "deadbeefcafebabe" "READ_COMMAND"
 
# Advance address after writing 5 half words (10 bytes) for WishBone (access
# type 1)
run_libsim "JTAG GO_COMMAND (write) WB write 5 half words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000c1ae0a0920000000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x0000000000185f4b7296abafabafea7eefb6af60" \
" shifted out: 0x0164841bc6000000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x061b600e212000a00010010000000000" \
" access_type: 0x1" \
" address: 0x10000a" \
" length: 0xa" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100000" "a" \
"GO_COMMAND_WRITE" "deadbeefcafebabebaad" "READ_COMMAND"
 
# Advance address after writing 1 word (4 bytes) for WishBone (access type 2)
run_libsim "JTAG GO_COMMAND (write) WB write 1 word address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
" shifted out: 0x0164841bc6000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x104bd101e18000400010008000000000" \
" access_type: 0x2" \
" address: 0x100004" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "4" \
"GO_COMMAND_WRITE" "deadbeef" "READ_COMMAND"
 
# Advance address after writing 2 words (8 bytes) for WishBone (access type 2)
run_libsim "JTAG GO_COMMAND (write) WB write 2 words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001f99fd767c0000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000014db90944fabafea7eefb6af60" \
" shifted out: 0x0164841bc600000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0dc2caef41c000200010008000000000" \
" access_type: 0x2" \
" address: 0x100008" \
" length: 0x8" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "8" \
"GO_COMMAND_WRITE" "deadbeefcafebabe" "READ_COMMAND"
 
# Advance address after writing 3 words (12 bytes) for WishBone (access type
# 2)
run_libsim "JTAG GO_COMMAND (write) WB write 3 words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001b42db63fa0000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000014adb55b7601f6abafabafea7eefb6af60" \
" shifted out: 0x0164841bc60000000000000000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1e937a55c1a000600010008000000000" \
" access_type: 0x2" \
" address: 0x10000c" \
" length: 0xc" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "c" \
"GO_COMMAND_WRITE" "deadbeefcafebabebaadf00d" "READ_COMMAND"
 
# Advance address after writing 1 word for CPU0 (access type 2). The address
# should advance by 1 (word, since SPRs are word addressed).
run_libsim "JTAG GO_COMMAND (write) CPU0 write 1 word address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001933eb7e580010028000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
" shifted out: 0x0164841bc6000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0f059be9218000802800008000000000" \
" access_type: 0x2" \
" address: 0x2802" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "2" "2801" "4" \
"GO_COMMAND_WRITE" "deadbeef" "READ_COMMAND"
 
# Tests of overrun and underrun. For Wishbone check both on different access
# sizes.
 
# GO_COMMAND_WRITE for WishBone underrun for byte access
run_libsim "JTAG GO_COMMAND (write) WB byte access underrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000171893d95c0000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000000c1a78bb0bafea7eefb6af60" \
" shifted out: 0x015fea3b0e200000000000000000000000" \
" status: 0x8" \
" time taken:" \
"New byte at 0x00100000 = 0xde" \
"New byte at 0x00100001 = 0xad" \
"New byte at 0x00100002 = 0xbe" \
"New byte at 0x00100003 = 0xef" \
"New byte at 0x00100004 = 0xca" \
"New byte at 0x00100005 = 0xfe" \
"New byte at 0x00100006 = 0xba" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "8" \
"GO_COMMAND_WRITE" "deadbeefcafeba"
 
# GO_COMMAND_WRITE for WishBone overrun for byte access
run_libsim "JTAG GO_COMMAND (write) WB byte access overrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000171893d95c0000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000005b486612bafabafea7eefb6af60" \
" shifted out: 0x015fea3b0e2000000000000000000000000000" \
" status: 0x8" \
" time taken:" \
"New byte at 0x00100000 = 0xde" \
"New byte at 0x00100001 = 0xad" \
"New byte at 0x00100002 = 0xbe" \
"New byte at 0x00100003 = 0xef" \
"New byte at 0x00100004 = 0xca" \
"New byte at 0x00100005 = 0xfe" \
"New byte at 0x00100006 = 0xba" \
"New byte at 0x00100007 = 0xbe" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "8" \
"GO_COMMAND_WRITE" "deadbeefcafebabeba"
 
# GO_COMMAND_WRITE for WishBone underrun for half word access
run_libsim "JTAG GO_COMMAND (write) WB half word access underrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000061a4e871c0000000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000000c1a78bb0bafea7eefb6af60" \
" shifted out: 0x015fea3b0e200000000000000000000000" \
" status: 0x8" \
" time taken:" \
"New byte at 0x00100000 = 0xde" \
"New byte at 0x00100001 = 0xad" \
"New byte at 0x00100002 = 0xbe" \
"New byte at 0x00100003 = 0xef" \
"New byte at 0x00100004 = 0xca" \
"New byte at 0x00100005 = 0xfe" \
"New byte at 0x00100006 = 0xba" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100000" "8" \
"GO_COMMAND_WRITE" "deadbeefcafeba"
 
# GO_COMMAND_WRITE for WishBone overrun for half word access
run_libsim "JTAG GO_COMMAND (write) WB half word access overrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000061a4e871c0000000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000005b486612bafabafea7eefb6af60" \
" shifted out: 0x015fea3b0e2000000000000000000000000000" \
" status: 0x8" \
" time taken:" \
"New byte at 0x00100000 = 0xde" \
"New byte at 0x00100001 = 0xad" \
"New byte at 0x00100002 = 0xbe" \
"New byte at 0x00100003 = 0xef" \
"New byte at 0x00100004 = 0xca" \
"New byte at 0x00100005 = 0xfe" \
"New byte at 0x00100006 = 0xba" \
"New byte at 0x00100007 = 0xbe" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100000" "8" \
"GO_COMMAND_WRITE" "deadbeefcafebabeba"
 
# GO_COMMAND_WRITE for WishBone underrun for word access
run_libsim "JTAG GO_COMMAND (write) WB word access underrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001f99fd767c0000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000000c1a78bb0bafea7eefb6af60" \
" shifted out: 0x015fea3b0e200000000000000000000000" \
" status: 0x8" \
" time taken:" \
"New byte at 0x00100000 = 0xde" \
"New byte at 0x00100001 = 0xad" \
"New byte at 0x00100002 = 0xbe" \
"New byte at 0x00100003 = 0xef" \
"New byte at 0x00100004 = 0xca" \
"New byte at 0x00100005 = 0xfe" \
"New byte at 0x00100006 = 0xba" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "8" \
"GO_COMMAND_WRITE" "deadbeefcafeba"
 
# GO_COMMAND_WRITE for WishBone overrun for word access
run_libsim "JTAG GO_COMMAND (write) WB word access overrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001f99fd767c0000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000005b486612bafabafea7eefb6af60" \
" shifted out: 0x015fea3b0e2000000000000000000000000000" \
" status: 0x8" \
" time taken:" \
"New byte at 0x00100000 = 0xde" \
"New byte at 0x00100001 = 0xad" \
"New byte at 0x00100002 = 0xbe" \
"New byte at 0x00100003 = 0xef" \
"New byte at 0x00100004 = 0xca" \
"New byte at 0x00100005 = 0xfe" \
"New byte at 0x00100006 = 0xba" \
"New byte at 0x00100007 = 0xbe" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "8" \
"GO_COMMAND_WRITE" "deadbeefcafebabeba"
 
# CPU0 underrun and overrun tests should remember that this is a 32-bit access
# with a big-endian organization.
 
# GO_COMMAND_WRITE for CPU0 underrun for word access
run_libsim "JTAG GO_COMMAND (write) CPU0 word access underrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001933eb7e580010028000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001599d9120fb6af60" \
" shifted out: 0x015fea3b0e2000000000000000" \
" status: 0x8" \
" time taken:" \
"New MACLO 0x00beadde" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "2" "2801" "4" \
"GO_COMMAND_WRITE" "deadbe"
 
# GO_COMMAND_WRITE for CPU0 overrun for word access
run_libsim "JTAG GO_COMMAND (write) CPU0 word access overrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001933eb7e580010028000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000009ac236c4a7eefb6af60" \
" shifted out: 0x015fea3b0e20000000000000000000" \
" status: 0x8" \
" time taken:" \
"New MACLO 0xefbeadde" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "2" "2801" "4" \
"GO_COMMAND_WRITE" "deadbeefca"
 
# Test access to invalid areas. We can only do this for Wishbone, since all
# SPRs are validly accessible (non-writeable ones just return undefined
# results).
 
# Test each access type with one unit and test blocks spanning start and end
# of writeable blocks.
 
# GO_COMMAND_WRITE for 1 byte write to invalid memory.
run_libsim "JTAG GO_COMMAND (write) WB 1 byte invalid write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001ba7d236600000000080008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000006d6fa6e6f60" \
" shifted out: 0x0112585a56400000000000" \
" status: 0x4" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "200000" "1" \
"GO_COMMAND_WRITE" "de"
 
# GO_COMMAND_WRITE for 2 byte write ending in invalid memory.
run_libsim "JTAG GO_COMMAND (write) WB 2 byte ending invalid write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001bbbf3ba70001fffff00008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000000e463a0ad6af60" \
" shifted out: 0x0112585a5640000000000000" \
" status: 0x4" \
" time taken:" \
"New byte at 0x001fffff = 0xde" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "1fffff" "2" \
"GO_COMMAND_WRITE" "dead"
 
# GO_COMMAND_WRITE for 2 byte write starting in invalid memory.
run_libsim "JTAG GO_COMMAND (write) WB 2 byte starting invalid write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000fd76999f0001fffff7fe08" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000000e463a0ad6af60" \
" shifted out: 0x0112585a5640000000000000" \
" status: 0x4" \
" time taken:" \
"New byte at 0xffe00000 = 0xad" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "ffdfffff" "2" \
"GO_COMMAND_WRITE" "dead"
 
# GO_COMMAND_WRITE for 1 half word write to invalid memory.
run_libsim "JTAG GO_COMMAND (write) WB 1 half word invalid write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000017121f0c300000000080108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000000e463a0ad6af60" \
" shifted out: 0x0112585a5640000000000000" \
" status: 0x4" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "200000" "2" \
"GO_COMMAND_WRITE" "dead"
 
# GO_COMMAND_WRITE for 2 half word write ending in invalid memory.
run_libsim "JTAG GO_COMMAND (write) WB 2 half word ending invalid write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000184405a638000fffff00108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
" shifted out: 0x0112585a56400000000000000000" \
" status: 0x4" \
" time taken:" \
"New byte at 0x001ffffe = 0xde" \
"New byte at 0x001fffff = 0xad" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "1ffffe" "4" \
"GO_COMMAND_WRITE" "deadbeef"
 
# GO_COMMAND_WRITE for 2 half word write starting in invalid memory.
run_libsim "JTAG GO_COMMAND (write) WB 2 half word starting invalid write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000c289f85b8000fffff7ff08" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
" shifted out: 0x0112585a56400000000000000000" \
" status: 0x4" \
" time taken:" \
"New byte at 0xffe00000 = 0xbe" \
"New byte at 0xffe00001 = 0xef" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "ffdffffe" "4" \
"GO_COMMAND_WRITE" "deadbeef"
 
# GO_COMMAND_WRITE for 1 word write to invalid memory.
run_libsim "JTAG GO_COMMAND (write) WB 1 word invalid write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000004a24cf580000000080088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x00000000001a6f47467eefb6af60" \
" shifted out: 0x0112585a56400000000000000000" \
" status: 0x4" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "200000" "4" \
"GO_COMMAND_WRITE" "deadbeef"
 
# GO_COMMAND_WRITE for 2 word write ending in invalid memory.
run_libsim "JTAG GO_COMMAND (write) WB 2 word ending invalid write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000008b923f65c0007ffff00088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000014db90944fabafea7eefb6af60" \
" shifted out: 0x0112585a5640000000000000000000000000" \
" status: 0x4" \
" time taken:" \
"New byte at 0x001ffffc = 0xde" \
"New byte at 0x001ffffd = 0xad" \
"New byte at 0x001ffffe = 0xbe" \
"New byte at 0x001fffff = 0xef" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "1ffffc" "8" \
"GO_COMMAND_WRITE" "deadbeefcafebabe"
 
# GO_COMMAND_WRITE for 2 word write starting in invalid memory.
run_libsim "JTAG GO_COMMAND (write) WB 2 word starting invalid write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001cd5b9d5dc0007ffff7fe88" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_WRITE." \
" shifting in: 0x000000000014db90944fabafea7eefb6af60" \
" shifted out: 0x0112585a5640000000000000000000000000" \
" status: 0x4" \
" time taken:" \
"New byte at 0xffe00000 = 0xca" \
"New byte at 0xffe00001 = 0xfe" \
"New byte at 0xffe00002 = 0xba" \
"New byte at 0xffe00003 = 0xbe" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-report" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "ffdffffc" "8" \
"GO_COMMAND_WRITE" "deadbeefcafebabe"
/libsim.tests/jtag-basic.exp
49,7 → 49,7
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "00"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "0"
 
run_libsim "lib-jtag IR 0001" \
[list "Initalization succeeded." \
63,7 → 63,7
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "08"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "8"
 
run_libsim "lib-jtag IR 0010" \
[list "Initalization succeeded." \
77,7 → 77,7
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "04"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "4"
 
run_libsim "lib-jtag instr reg 0011" \
[list "Initalization succeeded." \
86,12 → 86,12
"Execution step completed OK." \
"Shifting instruction register." \
" shifting in: 0c" \
"Warning: Unknown JTAG instruction 0x3 shifted" \
"ERROR: Unknown JTAG instruction 0x3 shifted" \
" shifted out: 0c" \
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "0c"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "c"
 
run_libsim "lib-jtag instr reg 0100" \
[list "Initalization succeeded." \
100,12 → 100,12
"Execution step completed OK." \
"Shifting instruction register." \
" shifting in: 02" \
"Warning: Unknown JTAG instruction 0x4 shifted" \
"ERROR: Unknown JTAG instruction 0x4 shifted" \
" shifted out: 02" \
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "02"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "2"
 
run_libsim "lib-jtag instr reg 0101" \
[list "Initalization succeeded." \
114,12 → 114,12
"Execution step completed OK." \
"Shifting instruction register." \
" shifting in: 0a" \
"Warning: Unknown JTAG instruction 0x5 shifted" \
"ERROR: Unknown JTAG instruction 0x5 shifted" \
" shifted out: 0a" \
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "0a"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "a"
 
run_libsim "lib-jtag instr reg 0110" \
[list "Initalization succeeded." \
128,12 → 128,12
"Execution step completed OK." \
"Shifting instruction register." \
" shifting in: 06" \
"Warning: Unknown JTAG instruction 0x6 shifted" \
"ERROR: Unknown JTAG instruction 0x6 shifted" \
" shifted out: 06" \
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "06"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "6"
 
run_libsim "lib-jtag instr reg 0111" \
[list "Initalization succeeded." \
142,12 → 142,12
"Execution step completed OK." \
"Shifting instruction register." \
" shifting in: 0e" \
"Warning: Unknown JTAG instruction 0x7 shifted" \
"ERROR: Unknown JTAG instruction 0x7 shifted" \
" shifted out: 0e" \
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "0e"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "e"
 
run_libsim "lib-jtag instr reg 1000" \
[list "Initalization succeeded." \
160,7 → 160,7
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "01"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "1"
 
run_libsim "lib-jtag IR 1001" \
[list "Initalization succeeded." \
174,7 → 174,7
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "09"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "9"
 
run_libsim "lib-jtag instr reg 1010" \
[list "Initalization succeeded." \
183,12 → 183,12
"Execution step completed OK." \
"Shifting instruction register." \
" shifting in: 05" \
"Warning: Unknown JTAG instruction 0xa shifted" \
"ERROR: Unknown JTAG instruction 0xa shifted" \
" shifted out: 05" \
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "05"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "5"
 
run_libsim "lib-jtag instr reg 1011" \
[list "Initalization succeeded." \
197,12 → 197,12
"Execution step completed OK." \
"Shifting instruction register." \
" shifting in: 0d" \
"Warning: Unknown JTAG instruction 0xb shifted" \
"ERROR: Unknown JTAG instruction 0xb shifted" \
" shifted out: 0d" \
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "0d"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "d"
 
run_libsim "lib-jtag instr reg 1100" \
[list "Initalization succeeded." \
211,12 → 211,12
"Execution step completed OK." \
"Shifting instruction register." \
" shifting in: 03" \
"Warning: Unknown JTAG instruction 0xc shifted" \
"ERROR: Unknown JTAG instruction 0xc shifted" \
" shifted out: 03" \
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "03"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "3"
 
run_libsim "lib-jtag instr reg 1101" \
[list "Initalization succeeded." \
225,12 → 225,12
"Execution step completed OK." \
"Shifting instruction register." \
" shifting in: 0b" \
"Warning: Unknown JTAG instruction 0xd shifted" \
"ERROR: Unknown JTAG instruction 0xd shifted" \
" shifted out: 0b" \
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "0b"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "b"
 
run_libsim "lib-jtag instr reg 1110" \
[list "Initalization succeeded." \
239,12 → 239,12
"Execution step completed OK." \
"Shifting instruction register." \
" shifting in: 07" \
"Warning: Unknown JTAG instruction 0xe shifted" \
"ERROR: Unknown JTAG instruction 0xe shifted" \
" shifted out: 07" \
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "07"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "7"
 
run_libsim "lib-jtag IR 1111" \
[list "Initalization succeeded." \
258,4 → 258,4
" time taken " \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "0f"
"lib-jtag/lib-jtag" "" "loop/loop" "R" "I" "4" "f"
/libsim.tests/jtag-read-command.exp
0,0 → 1,804
# jtag-read-command.exp. Tests of the library JTAG READ_COMMAND functions.
 
# Copyright (C) 2010 Embecosm Limited
 
# Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
# This file is part of OpenRISC 1000 Architectural Simulator.
 
# 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 <http:#www.gnu.org/licenses/>. */
 
# -----------------------------------------------------------------------------
# This code is commented throughout for use with Doxygen.
# -----------------------------------------------------------------------------
 
 
# These are the tests of the high level JTAG interface.
 
# NOTE. All these tests return timing information, but we ignore it, since in
# general it will not be repeatable.
 
# Tests of READ_COMMAND returning the correct data back. Use Wishbone as
# module, since it has the widest range of fields for WRITE_COMMAND. We don't
# do any actual reading or writing, so the simple loop program is
# sufficient.
 
# Test of READ_COMMAND when no WRITE_COMMAND has been issued.
run_libsim "JTAG READ_COMMAND no prior write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
"ERROR: JTAG READ_COMMAND finds no data" \
" shifted out: 0x0c526410200000000000000000000000" \
" access_type: 0x0" \
" address: 0x0" \
" length: 0x1" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "READ_COMMAND"
 
# READ_COMMAND when invalid WRITE_COMMAND has been issued.
run_libsim "JTAG READ_COMMAND no valid prior write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000009f6e431380000000100188" \
"ERROR: JTAG WRITE_COMMAND unknown access type 3." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
"ERROR: JTAG READ_COMMAND finds no data." \
" shifted out: 0x0c526410200000000000000000000000" \
" access_type: 0x0" \
" address: 0x0" \
" length: 0x1" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "3" "100000" "4" \
"READ_COMMAND"
 
# READ_COMMAND when invalid WRITE_COMMAND has been issued after a previously
# valid WRITE_COMMAND.
run_libsim "JTAG READ_COMMAND invalid after valid prior write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000009f6e431380000000100188" \
"ERROR: JTAG WRITE_COMMAND unknown access type 3." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
"ERROR: JTAG READ_COMMAND finds no data." \
" shifted out: 0x0c526410200000000000000000000000" \
" access_type: 0x0" \
" address: 0x0" \
" length: 0x1" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "4" \
"WRITE_COMMAND" "3" "100000" "4" "READ_COMMAND"
 
# READ_COMMAND when valid WRITE_COMMAND has been issued after a previously
# invalid WRITE_COMMAND.
run_libsim "JTAG READ_COMMAND valid after invalid prior write" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000009f6e431380000000100188" \
"ERROR: JTAG WRITE_COMMAND unknown access type 3." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x103b4b8c218000000010008000000000" \
" access_type: 0x2" \
" address: 0x100000" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "3" "100000" "4" \
"WRITE_COMMAND" "2" "100000" "4" "READ_COMMAND"
 
# Tests of READ_COMMAND with WRITE_COMMANDS to different modules. Should work
# for WB and CPU0. Rejection of other modules should happen earlier, so not
# tested here.
 
# READ_COMMAND for Wishbone
run_libsim "JTAG SELECT_MODULE READ_COMMAND WB" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x103b4b8c218000000010008000000000" \
" access_type: 0x2" \
" address: 0x100000" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "4" "READ_COMMAND"
 
# READ_COMMAND for CPU0
run_libsim "JTAG SELECT_MODULE READ_COMMAND CPU0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001933eb7e580010028000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0e26c4c5a18001002800008000000000" \
" access_type: 0x2" \
" address: 0x2801" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" "8" \
"SELECT_MODULE" "1" "WRITE_COMMAND" "2" "2801" "4" "READ_COMMAND"
 
# Tests of READ_COMMAND access types correctly being returned. Errors should
# be prevented earlier in the WRITE_COMMAND, so we only check behavior that
# would follow a valid WRITE_COMMAND.
 
# READ_COMMAND to write bytes for WishBone (access type 0)
run_libsim "JTAG READ_COMMAND WB write bytes" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000107557c0580000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0eb2af0e418000000010000000000000" \
" access_type: 0x0" \
" address: 0x100000" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "4" \
"READ_COMMAND"
 
# READ_COMMAND to write half words for WishBone (access type 1)
run_libsim "JTAG READ_COMMAND WB write half words" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001778a9e180000000100108" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x08cf46c2a18000000010010000000000" \
" access_type: 0x1" \
" address: 0x100000" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "1" "100000" "4" \
"READ_COMMAND"
 
# READ_COMMAND to write words for WishBone (access type 2)
run_libsim "JTAG READ_COMMAND WB write words" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018f4396f780000000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x103b4b8c218000000010008000000000" \
" access_type: 0x2" \
" address: 0x100000" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "4" \
"READ_COMMAND"
 
# READ_COMMAND to read bytes for WishBone (access type 4)
run_libsim "JTAG READ_COMMAND WB read bytes" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000982f0f3d80000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1c414d2b618000000010004000000000" \
" access_type: 0x4" \
" address: 0x100000" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "4" \
"READ_COMMAND"
 
# READ_COMMAND to read half words for WishBone (access type 5)
run_libsim "JTAG READ_COMMAND WB read half words" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018802dad980000000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1a3ca4e7818000000010014000000000" \
" access_type: 0x5" \
" address: 0x100000" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "4" \
"READ_COMMAND"
 
# READ_COMMAND to read words for WishBone (access type 6)
run_libsim "JTAG READ_COMMAND WB read words" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001039e5cf800000001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x02c8a9a901800000001000c000000000" \
" access_type: 0x6" \
" address: 0x100000" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "4" \
"READ_COMMAND"
 
# Check address ranges. For Wishbone check 0x0 and 0xffffffff. For CPU0 check
# 0x12801 also still works, even though it is an invalid address for a SPR (it
# should be truncated with a warning).
 
# READ_COMMAND to write to address 0 for WishBone
run_libsim "JTAG READ_COMMAND WB write address 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001efa3017580000000000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x13ed4917218000000000008000000000" \
" access_type: 0x2" \
" address: 0x0" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "0" "4" \
"READ_COMMAND"
 
# READ_COMMAND to write to address 0xffffffff for WishBone
run_libsim "JTAG READ_COMMAND WB write address 0xffffffff" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000cd06d25e0001fffffffe08" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1fa286fa800001fffffffe0000000000" \
" access_type: 0x0" \
" address: 0xffffffff" \
" length: 0x1" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "ffffffff" "1" \
"READ_COMMAND"
 
# READ_COMMAND to write to address 0 for CPU0.
run_libsim "JTAG READ_COMMAND CPU0 write address 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001efa3017580000000000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x13ed4917218000000000008000000000" \
" access_type: 0x2" \
" address: 0x0" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "2" "0" "4" \
"READ_COMMAND"
 
# READ_COMMAND to write to address 0xffff for CPU0.
run_libsim "JTAG READ_COMMAND CPU0 write address 0xffff" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000012e99654d8001fffe000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0040eb25018001fffe00008000000000" \
" access_type: 0x2" \
" address: 0xffff" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "2" "ffff" "4" \
"READ_COMMAND"
 
# READ_COMMAND to write to address 0x12801 for CPU0. Even though out of range,
# this should work, since it will be truncated.
run_libsim "JTAG READ_COMMAND CPU0 write address 0x12801" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000f0f3d6c180010029000088" \
"Warning: truncated JTAG SPR address 0x00012801." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0e26c4c5a18001002800008000000000" \
" access_type: 0x2" \
" address: 0x2801" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "2" "12801" "4" \
"READ_COMMAND"
 
# Check lengths. For Wishbone check 0x1 and 0x10000. For CPU0 check 0x4, which
# is the only valid length (tests of failure will have been done as part of
# the WRITE_COMMAND tests elsewhere).
 
# READ_COMMAND to write byte length 1 byte for WishBone
run_libsim "JTAG READ_COMMAND WB write length 1 byte" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000319cf96400000000100008" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0f84668b200000000010000000000000" \
" access_type: 0x0" \
" address: 0x100000" \
" length: 0x1" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "0" "100000" "1" \
"READ_COMMAND"
 
# READ_COMMAND to write words length 0x10000 bytes for WishBone
run_libsim "JTAG READ_COMMAND WB write length 0x10000 bytes" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001c5c63669fffe0000100088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x07c6706f21fffe000010008000000000" \
" access_type: 0x2" \
" address: 0x100000" \
" length: 0x10000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "2" "100000" "10000" \
"READ_COMMAND"
 
# READ_COMMAND to write words length 4 bytes for CPU0
run_libsim "JTAG READ_COMMAND CPU0 write length 4 bytes" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001933eb7e580010028000088" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0e26c4c5a18001002800008000000000" \
" access_type: 0x2" \
" address: 0x2801" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "2" "2801" "4" \
"READ_COMMAND"
/libsim.tests/jtag-read-control.exp
0,0 → 1,294
# jtag-read-control.exp. Tests of the library JTAG READ_CONTROL command
 
# Copyright (C) 2010 Embecosm Limited
 
# Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
# This file is part of OpenRISC 1000 Architectural Simulator.
 
# 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 <http:#www.gnu.org/licenses/>. */
 
# -----------------------------------------------------------------------------
# This code is commented throughout for use with Doxygen.
# -----------------------------------------------------------------------------
 
 
# These tests check all the behavior associated with the JTAG READ_CONTROL
# command.
 
# NOTE. All these tests return timing information, but we ignore it, since in
# general it will not be repeatable.
 
# Tests of the READ_CONTROL for reading from different modules. This should
# work fine for CPU0, but provoke a warning for Wishbone and CPU1 and a
# different warning for all other modules. Test no module, Wishbone, CPU0,
# CPU1 and module 6.
 
# READ_CONTROL with no module selected.
run_libsim "JTAG READ_CONTROL no module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_CONTROL." \
" shifting in: 0x000000000000000000000005ffa8ec38" \
"ERROR: JTAG READ_CONTROL with no module selected." \
" shifted out: 0x0c526410200000000000000000000000" \
" reset: disabled" \
" stall: unstalled" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "READ_CONTROL"
 
# READ_CONTROL with only WishBone module selected.
run_libsim "JTAG READ_CONTROL WB module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_CONTROL." \
" shifting in: 0x000000000000000000000005ffa8ec38" \
"ERROR: JTAG READ_CONTROL of WishBone not supported." \
" shifted out: 0x0c526410200000000000000000000000" \
" reset: disabled" \
" stall: unstalled" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "READ_CONTROL"
 
# READ_CONTROL with only invalid module selected.
run_libsim "JTAG READ_CONTROL invalid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001993c98e69" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_CONTROL." \
" shifting in: 0x000000000000000000000005ffa8ec38" \
"ERROR: JTAG READ_CONTROL of CPU1 not supported." \
" shifted out: 0x0c526410200000000000000000000000" \
" reset: disabled" \
" stall: unstalled" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "2" "READ_CONTROL"
 
# READ_CONTROL with invalid module selected after valid module
run_libsim "JTAG READ_CONTROL invalid after valid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001efe0d976d" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_CONTROL." \
" shifting in: 0x000000000000000000000005ffa8ec38" \
"ERROR: JTAG READ_CONTROL with no module selected." \
" shifted out: 0x0c526410200000000000000000000000" \
" reset: disabled" \
" stall: unstalled" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "SELECT_MODULE" "6" "READ_CONTROL"
 
# READ_CONTROL with valid module selected after invalid module
run_libsim "JTAG READ_CONTROL valid after invalid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001efe0d976d" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_CONTROL." \
" shifting in: 0x000000000000000000000005ffa8ec38" \
" shifted out: 0x0c526410200000000000000000000000" \
" reset: disabled" \
" stall: unstalled" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "6" "SELECT_MODULE" "1" "READ_CONTROL"
 
# Verify that reading works correctly from the valid module, CPU0.
 
# READ_CONTROL for CPU0.
run_libsim "JTAG READ_CONTROL CPU0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_CONTROL." \
" shifting in: 0x000000000000000000000005ffa8ec38" \
" shifted out: 0x0c526410200000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "READ_CONTROL"
 
# The only flag that we can sensible read back is the stall flag. In practice
# the reset flag is only set during the reset sequence, during which we may
# not get back any data. All we can test (simply) is that if we set the stall
# flag it reads back correctly. We leave it to the test of WRITE_CONTROL to
# determine that the stall actually happens!
 
# Write the stall bit for CPU and read it back.
run_libsim "JTAG READ_CONTROL CPU0 read stall bit set" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000109a677aa00000000000044" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed with breakpoint." \
"Processing READ_CONTROL." \
" shifting in: 0x000000000000000000000005ffa8ec38" \
" shifted out: 0x1ea18635000000000000004000000000" \
" reset: disabled" \
" stall: stalled" \
" status: 0x0" \
" time taken:" \
"Execution step completed with breakpoint." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_CONTROL" "0" "1" "READ_CONTROL"
 
# Clear the stall bit for CPU and read it back.
run_libsim "JTAG READ_CONTROL CPU0 read stall bit clear" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_CONTROL." \
" shifting in: 0x000000000096dc049200000000000004" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_CONTROL." \
" shifting in: 0x000000000000000000000005ffa8ec38" \
" shifted out: 0x0c526410200000000000000000000000" \
" reset: disabled" \
" stall: unstalled" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_CONTROL" "0" "0" "READ_CONTROL"
/libsim.tests/jtag-go-command-read.exp
0,0 → 1,2433
# jtag-go-command-read.exp. Tests of the library JTAG GO_COMMAND for reading
 
# Copyright (C) 2010 Embecosm Limited
 
# Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
# This file is part of OpenRISC 1000 Architectural Simulator.
 
# 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 <http:#www.gnu.org/licenses/>. */
 
# -----------------------------------------------------------------------------
# This code is commented throughout for use with Doxygen.
# -----------------------------------------------------------------------------
 
 
# These tests check all the behavior associated with the JTAG GO_COMMAND when
# reading.
 
# NOTE. All these tests return timing information, but we ignore it, since in
# general it will not be repeatable.
 
# Tests of the GO_COMMAND for reading from different modules. This should work
# fine for Wishbone and CPU0. Other modules will have been weeded out by the
# prior WRITE_COMMAND. We specify 4 bytes to read each time.
 
# We use the loop-init OpenRISC program here, since we must be sure that
# defined values are placed in the various read targets. As SPR's we use MACLO
# (0x2801) and MACHI (0x2802), which are initialized to 0xdeadbeef and
# 0xcafebabe respectively (but remember Or1ksim is by default BIG_ENDIAN when
# reading the results). As Wishbone we use address 0x100000, which is
# initialized to 0x10111213.
 
# When testing GO_COMMAND (read) after invalid module selection, we cannot
# guarantee a CRC mismatch (or at least I can't do the maths to prove that no
# register of all zeros can have a valid CRC field for the possible GO_COMMAND
# register lengths, although it is highly likely), so we just look for the
# error message.
 
# GO_COMMAND reading with no module selection (address 0x100000).
run_libsim "JTAG GO_COMMAND (read) no module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001039e5cf800000001000c8" \
"ERROR: JTAG WRITE_COMMAND with no module selected." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
"ERROR: JTAG GO_COMMAND with no prior WRITE_COMMAND." \
" shifted out: 0x0000000000000000000000000000" \
" data: 00000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "WRITE_COMMAND" "6" "100000" "4" "GO_COMMAND_READ" "4"
 
# GO_COMMAND reading with only invalid module selected.
run_libsim "JTAG GO_COMMAND (read) invalid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001993c98e69" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000000c44c4dd800100280000c8" \
"ERROR: JTAG WRITE_COMMAND for CPU1 not supported." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
"ERROR: JTAG GO_COMMAND with no prior WRITE_COMMAND." \
" shifted out: 0x0000000000000000000000000000" \
" data: 00000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "2" "WRITE_COMMAND" "6" "2801" "4" \
"GO_COMMAND_READ" "4"
 
# GO_COMMAND reading with invalid module selected after valid module
run_libsim "JTAG GO_COMMAND (read) invalid after valid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001efe0d976d" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000000c44c4dd800100280000c8" \
"ERROR: JTAG WRITE_COMMAND with no module selected." \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
"ERROR: JTAG GO_COMMAND with no prior WRITE_COMMAND." \
" shifted out: 0x0000000000000000000000000000" \
" data: 00000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "SELECT_MODULE" "6" "WRITE_COMMAND" "6" \
"2801" "4" "GO_COMMAND_READ" "4"
 
# GO_COMMAND reading with valid module selected after invalid module
run_libsim "JTAG GO_COMMAND (read) valid after invalid module" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000001efe0d976d" \
" shifted out: 0x01893c98e68000000000" \
" status: 0x2" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001039e5cf800000001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
" shifted out: 0x019de5beae190911010000000000" \
" data: 10111213" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "6" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" \
"100000" "4" "GO_COMMAND_READ" "4"
 
# Verify that reading works correctly from both valid modules, WishBone and
# CPU0.
 
# GO_COMMAND reading for Wishbone (address 0x100000).
run_libsim "JTAG SELECT_MODULE GO_COMMAND (read) WB" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken: " \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001039e5cf800000001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
" shifted out: 0x019de5beae190911010000000000" \
" data: 10111213" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "4" \
"GO_COMMAND_READ" "4"
 
# GO_COMMAND reading for CPU0 (address 0x2081, MACLO).
run_libsim "JTAG SELECT_MODULE GO_COMMAND (read) CPU0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000000c44c4dd800100280000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
" shifted out: 0x00b8e2228e0f76afbee000000000" \
" data: efbeadde" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "6" "2801" "4" \
"GO_COMMAND_READ" "4"
 
# Tests of GO_COMMAND_READ with different access alignments, boundaries and
# lengths for WishBone. For this we use the loop-init program, which has
# values initialized at 0x100000-0x10000f (values 0x10 through 0x1f
# respectively), 0x110000-0x11000f (values 0x20 through 0x2f respectively) and
# 0x120000-0x12000f (values 0x30 through 0x3f respectively).
 
# First check that a single aligned unit can be read for each access type at
# its allowed alignments.
 
# GO_COMMAND reading one byte for Wishbone aligned at byte 0.
run_libsim "JTAG GO_COMMAND (read) WB 1 byte, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001aee68a5c00000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000169330ba20" \
" shifted out: 0x000464d308010000000000" \
" data: 10" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "1" \
"GO_COMMAND_READ" "1"
 
# GO_COMMAND reading one byte for Wishbone aligned at byte 1.
run_libsim "JTAG GO_COMMAND (read) WB 1 byte, aligned byte 1" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000006c8cbd5c00010000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000169330ba20" \
" shifted out: 0x0019d3c36c110000000000" \
" data: 11" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100001" "1" \
"GO_COMMAND_READ" "1"
 
# GO_COMMAND reading one byte for Wishbone aligned at byte 2.
run_libsim "JTAG GO_COMMAND (read) WB 1 byte, aligned byte 2" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000014fd391dc00008000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000169330ba20" \
" shifted out: 0x000abf5b3a090000000000" \
" data: 12" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100002" "1" \
"GO_COMMAND_READ" "1"
 
# GO_COMMAND reading one byte for Wishbone aligned at byte 3.
run_libsim "JTAG GO_COMMAND (read) WB 1 byte, aligned byte 3" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000008db9a6dc00018000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000169330ba20" \
" shifted out: 0x0017084b5e190000000000" \
" data: 13" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100003" "1" \
"GO_COMMAND_READ" "1"
 
# GO_COMMAND reading one half word for Wishbone aligned at byte 0.
run_libsim "JTAG GO_COMMAND (read) WB 1 half word, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000165ba59f900000000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000169330ba20" \
" shifted out: 0x01bf1eca5211010000000000" \
" data: 1011" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "2" \
"GO_COMMAND_READ" "2"
 
# GO_COMMAND reading one half word for Wishbone aligned at byte 2.
run_libsim "JTAG GO_COMMAND (read) WB 1 half word, aligned byte 2" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001848f427900008000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000169330ba20" \
" shifted out: 0x01791cc86819090000000000" \
" data: 1213" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100002" "2" \
"GO_COMMAND_READ" "2"
 
# GO_COMMAND reading one word for Wishbone aligned at byte 0.
run_libsim "JTAG GO_COMMAND (read) WB 1 word, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001039e5cf800000001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
" shifted out: 0x019de5beae190911010000000000" \
" data: 10111213" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "4" \
"GO_COMMAND_READ" "4"
 
# Verify that longer reads work OK, at different boundaries. For byte access
# read 9 bytes, for half-word access read 10 bytes and for word access read 12
# bytes.
 
# GO_COMMAND reading 9 bytes for Wishbone aligned at byte 0.
run_libsim "JTAG GO_COMMAND (read) WB 9 bytes, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000019588aa9420000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000000000000000169330ba20" \
" shifted out: 0x00efe148fc031d0d1505190911010000000000" \
" data: 101112131415161718" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "9" \
"GO_COMMAND_READ" "9"
 
# GO_COMMAND reading 9 bytes for Wishbone aligned at byte 1.
run_libsim "JTAG GO_COMMAND (read) WB 9 bytes, aligned byte 1" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000057e29d9420010000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000000000000000169330ba20" \
" shifted out: 0x00df281a0413031d0d15051909110000000000" \
" data: 111213141516171819" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100001" "9" \
"GO_COMMAND_READ" "9"
 
# GO_COMMAND reading 9 bytes for Wishbone aligned at byte 2.
run_libsim "JTAG GO_COMMAND (read) WB 9 bytes, aligned byte 2" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000174bdb11420008000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000000000000000169330ba20" \
" shifted out: 0x0058bcb0c60b13031d0d150519090000000000" \
" data: 12131415161718191a" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100002" "9" \
"GO_COMMAND_READ" "9"
 
# GO_COMMAND reading 9 bytes for Wishbone aligned at byte 3.
run_libsim "JTAG GO_COMMAND (read) WB 9 bytes, aligned byte 3" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000b6d7861420018000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000000000000000169330ba20" \
" shifted out: 0x00049f56881b0b13031d0d1505190000000000" \
" data: 131415161718191a1b" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100003" "9" \
"GO_COMMAND_READ" "9"
 
# GO_COMMAND reading 5 half words for Wishbone aligned at byte 0.
run_libsim "JTAG GO_COMMAND (read) WB 5 half words, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000015ed4793120000000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000000000000000169330ba20" \
" shifted out: 0x01eb2b18e013031d0d1505190911010000000000" \
" data: 10111213141516171819" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "a" \
"GO_COMMAND_READ" "a"
 
# GO_COMMAND reading 5 half words for Wishbone aligned at byte 2.
run_libsim "JTAG GO_COMMAND (read) WB 5 half words, aligned byte 2" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001bfe162b120008000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000000000000000169330ba20" \
" shifted out: 0x01234b14981b0b13031d0d150519090000000000" \
" data: 12131415161718191a1b" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100002" "a" \
"GO_COMMAND_READ" "a"
 
# GO_COMMAND reading 3 words for Wishbone aligned at byte 0.
run_libsim "JTAG GO_COMMAND (read) WB 3 words, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000002b57c507a00000001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000000000000000000000169330ba20" \
" shifted out: 0x00248290b61b0b13031d0d1505190911010000000000" \
" data: 101112131415161718191a1b" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "c" \
"GO_COMMAND_READ" "c"
 
# Test of access for CPU0. Much simpler, since access type, alignment and
# length are more prescribed. Make use of loop-init, which initializes MACLO
# (0x2801) and MACHI (0x2802) to 0xdeadbeef and 0xcafebabe respectively. These
# are 32 bit values and presented in target endianess (which is big-endian for
# the OpenRISC, so the MS byte is as the highest address.
 
# GO_COMMAND reading 1 word for CPU0 aligned at byte 0.
run_libsim "JTAG GO_COMMAND (read) CPU0 1 word, aligned byte 0" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000000c44c4dd800100280000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
" shifted out: 0x00b8e2228e0f76afbee000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "6" "2801" "4" \
"GO_COMMAND_READ" "4"
 
# Check address advances after GO_COMMAND read (1 per word for CPU, 4 per word
# for WB). Test WB with reading all sizes and lengths 1 through 0x10000. Test
# CPU0 with reading one word. Uses the initialized looping program for
# reproducible results.
 
# - for WB byte access try lengths 1, 2, 3, 4, 5, 8, 9, 0xffff and 0x10000
# - for WB half word access try lengths 2, 4, 6, 8, 10, 0xfffe and 0x10000
# - for WB full word access try lengths 4, 8, 12, 0xfffc and 0x10000
# - for CPU0 try length 4
 
# READ_COMMAND to advance address after reading 1 byte for WishBone (access
# type 4)
run_libsim "JTAG GO_COMMAND (read) WB read 1 byte address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001aee68a5c00000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000169330ba20" \
" shifted out: 0x000464d308010000000000" \
" data: 10" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1cb5ee99000001000010004000000000" \
" access_type: 0x4" \
" address: 0x100001" \
" length: 0x1" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "1" \
"GO_COMMAND_READ" "1" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 2 bytes for WishBone (access
# type 4)
run_libsim "JTAG GO_COMMAND (read) WB read 2 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000075978c1d00000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000169330ba20" \
" shifted out: 0x01bf1eca5211010000000000" \
" data: 1011" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1c4dc0b3c10000800010004000000000" \
" access_type: 0x4" \
" address: 0x100002" \
" length: 0x2" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "2" \
"GO_COMMAND_READ" "2" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 3 bytes for WishBone (access
# type 4)
run_libsim "JTAG GO_COMMAND (read) WB read 3 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001435e097c80000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000169330ba20" \
" shifted out: 0x00fd0696b60911010000000000" \
" data: 101112" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1cb96301a08001800010004000000000" \
" access_type: 0x4" \
" address: 0x100003" \
" length: 0x3" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "3" \
"GO_COMMAND_READ" "3" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 4 bytes for WishBone (access
# type 4)
run_libsim "JTAG GO_COMMAND (read) WB read 4 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000982f0f3d80000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
" shifted out: 0x019de5beae190911010000000000" \
" data: 10111213" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1c31d7a6a18000400010004000000000" \
" access_type: 0x4" \
" address: 0x100004" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "4" \
"GO_COMMAND_READ" "4" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 5 bytes for WishBone (access
# type 4)
run_libsim "JTAG GO_COMMAND (read) WB read 5 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001d83acbcc40000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000169330ba20" \
" shifted out: 0x0040999fde05190911010000000000" \
" data: 1011121314" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0104b831404001400010004000000000" \
" access_type: 0x4" \
" address: 0x100005" \
" length: 0x5" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "5" \
"GO_COMMAND_READ" "5" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 8 bytes for WishBone (access
# type 4)
run_libsim "JTAG GO_COMMAND (read) WB read 8 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000eef34eadc0000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000000000169330ba20" \
" shifted out: 0x003458d6401d0d1505190911010000000000" \
" data: 1011121314151617" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x01b8cc4801c000200010004000000000" \
" access_type: 0x4" \
" address: 0x100008" \
" length: 0x8" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "8" \
"GO_COMMAND_READ" "8" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 9 bytes for WishBone (access
# type 4)
run_libsim "JTAG GO_COMMAND (read) WB read 9 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000019588aa9420000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000000000000000169330ba20" \
" shifted out: 0x00efe148fc031d0d1505190911010000000000" \
" data: 101112131415161718" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x126d45cd202001200010004000000000" \
" access_type: 0x4" \
" address: 0x100009" \
" length: 0x9" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "9" \
"GO_COMMAND_READ" "9" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 0xffff bytes for WishBone
# (access type 4). Only partially match the data read back.
run_libsim "JTAG GO_COMMAND (read) WB read 0xffff bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000109dba9e2fffe0000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000000000000000000000000000000" \
" shifted out: 0x00a0a530360000000000000000000000000000000000000" \
" data: 101112131415161718191a1b1c1d1e1f00000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x19caa5fc00fffffffe10004000000000" \
" access_type: 0x4" \
" address: 0x10ffff" \
" length: 0xffff" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "ffff" \
"GO_COMMAND_READ" "ffff" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 0x10000 bytes for WishBone
# (access type 4). Only partially match the data read back.
run_libsim "JTAG GO_COMMAND (read) WB read 0x10000 bytes address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000d2aaafa3fffe0000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000000000000000000000000000000" \
" shifted out: 0x01146b36e80000000000000000000000000000000000000" \
" data: 101112131415161718191a1b1c1d1e1f00000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0db27fb041fffe000110004000000000" \
" access_type: 0x4" \
" address: 0x110000" \
" length: 0x10000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "10000" \
"GO_COMMAND_READ" "10000" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 1 half word (2 bytes) for
# WishBone (access type 5)
run_libsim "JTAG GO_COMMAND (read) WB read 1 half word address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000165ba59f900000000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000169330ba20" \
" shifted out: 0x01bf1eca5211010000000000" \
" data: 1011" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1a30297f210000800010014000000000" \
" access_type: 0x5" \
" address: 0x100002" \
" length: 0x2" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "2" \
"GO_COMMAND_READ" "2" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 2 half words (4 bytes) for
# WishBone (access type 5)
run_libsim "JTAG GO_COMMAND (read) WB read 2 half words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000018802dad980000000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
" shifted out: 0x019de5beae190911010000000000" \
" data: 10111213" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1a4c3e6a418000400010014000000000" \
" access_type: 0x5" \
" address: 0x100004" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "4" \
"GO_COMMAND_READ" "4" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 3 half words (6 bytes) for
# WishBone (access type 5)
run_libsim "JTAG GO_COMMAND (read) WB read 3 half words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000011366186940000000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000000000169330ba20" \
" shifted out: 0x01d78784e61505190911010000000000" \
" data: 101112131415" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x07817fd7614000c00010014000000000" \
" access_type: 0x5" \
" address: 0x100006" \
" length: 0x6" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "6" \
"GO_COMMAND_READ" "6" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 4 half words (8 bytes) for
# WishBone (access type 5)
run_libsim "JTAG GO_COMMAND (read) WB read 4 half words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001fede9b49c0000000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000000000169330ba20" \
" shifted out: 0x003458d6401d0d1505190911010000000000" \
" data: 1011121314151617" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x07c52584e1c000200010014000000000" \
" access_type: 0x5" \
" address: 0x100008" \
" length: 0x8" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "8" \
"GO_COMMAND_READ" "8" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 5 half words (10 bytes) for
# WishBone (access type 5)
run_libsim "JTAG GO_COMMAND (read) WB read 5 half words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000015ed4793120000000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000000000000000169330ba20" \
" shifted out: 0x01eb2b18e013031d0d1505190911010000000000" \
" data: 10111213141516171819" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x14e8822b012000a00010014000000000" \
" access_type: 0x5" \
" address: 0x10000a" \
" length: 0xa" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "a" \
"GO_COMMAND_READ" "a" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 0x7fff half words (0xfffe
# bytes) for WishBone (access type 5)
run_libsim "JTAG GO_COMMAND (read) WB read 0x7fff half words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000012f3ff9677ffe0000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000000000000000000000000000000" \
" shifted out: 0x00afd24ee00000000000000000000000000000000000000" \
" data: 101112131415161718191a1b1c1d1e1f00000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1f43ef82817ffefffe10014000000000" \
" access_type: 0x5" \
" address: 0x10fffe" \
" length: 0xfffe" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "fffe" \
"GO_COMMAND_READ" "fffe" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 0x8000 half words (0x10000
# bytes) for WishBone (access type 5)
run_libsim "JTAG GO_COMMAND (read) WB read 0x8000 half words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001c2877a47fffe0000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000000000000000000000000000000" \
" shifted out: 0x01146b36e80000000000000000000000000000000000000" \
" data: 101112131415161718191a1b1c1d1e1f00000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0bcf967ca1fffe000110014000000000" \
" access_type: 0x5" \
" address: 0x110000" \
" length: 0x10000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "10000" \
"GO_COMMAND_READ" "10000" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 1 word (4 bytes) for WishBone
# (access type 6)
run_libsim "JTAG GO_COMMAND (read) WB read 1 word address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001039e5cf800000001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
" shifted out: 0x019de5beae190911010000000000" \
" data: 10111213" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x02b83324c1800040001000c000000000" \
" access_type: 0x6" \
" address: 0x100004" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "4" \
"GO_COMMAND_READ" "4" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 2 words (8 bytes) for WishBone
# (access type 6)
run_libsim "JTAG GO_COMMAND (read) WB read 2 words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000066e5a45fc00000001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000000000169330ba20" \
" shifted out: 0x003458d6401d0d1505190911010000000000" \
" data: 1011121314151617" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1f3128ca61c00020001000c000000000" \
" access_type: 0x6" \
" address: 0x100008" \
" length: 0x8" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "8" \
"GO_COMMAND_READ" "8" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 3 words (12 bytes) for WishBone
# (access type 6)
run_libsim "JTAG GO_COMMAND (read) WB read 3 words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000002b57c507a00000001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000000000000000000000169330ba20" \
" shifted out: 0x00248290b61b0b13031d0d1505190911010000000000" \
" data: 101112131415161718191a1b" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x0c609870e1a00060001000c000000000" \
" access_type: 0x6" \
" address: 0x10000c" \
" length: 0xc" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "c" \
"GO_COMMAND_READ" "c" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 0x3fff words (0xfffc bytes)
# for WishBone (access type 6)
run_libsim "JTAG GO_COMMAND (read) WB read 0x3fff words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000002c6004c1bffe00001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000000000000000000000000000000" \
" shifted out: 0x00588773a80000000000000000000000000000000000000" \
" data: 101112131415161718191a1b1c1d1e1f00000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1a7aa37121bffe7ffe1000c000000000" \
" access_type: 0x6" \
" address: 0x10fffc" \
" length: 0xfffc" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "fffc" \
"GO_COMMAND_READ" "fffc" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 0x4000 words (0x10000 bytes)
# for WishBone (access type 6)
run_libsim "JTAG GO_COMMAND (read) WB read 0x400 words address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000005abc4551fffe00001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000000000000000000000000000000" \
" shifted out: 0x01146b36e80000000000000000000000000000000000000" \
" data: 101112131415161718191a1b1c1d1e1f00000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x133b9b3221fffe00011000c000000000" \
" access_type: 0x6" \
" address: 0x110000" \
" length: 0x10000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "10000" \
"GO_COMMAND_READ" "10000" "READ_COMMAND"
 
# READ_COMMAND to advance address after reading 1 word for CPU0
# (access type 2). The address should advance by 1 (word, since SPRs are word
# addressed).
run_libsim "JTAG GO_COMMAND (read) CPU0 read 1 word address advance" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000000c44c4dd800100280000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
" shifted out: 0x00b8e2228e0f76afbee000000000" \
" data: efbeadde" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing READ_COMMAND." \
" shifting in: 0x00000000000000000000000b2420de30" \
" shifted out: 0x1df679cc01800080280000c000000000" \
" access_type: 0x6" \
" address: 0x2802" \
" length: 0x4" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "6" "2801" "4" \
"GO_COMMAND_READ" "4" "READ_COMMAND"
 
# Tests of overrun and underrun. For Wishbone check both on different access
# sizes.
 
# GO_COMMAND_READ for WishBone underrun for byte access
run_libsim "JTAG GO_COMMAND (read) WB byte access underrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000eef34eadc0000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000000000169330ba20" \
" shifted out: 0x000d619cbc2d1505190911010000000000" \
" data: 10111213141516" \
" status: 0x8" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "8" \
"GO_COMMAND_READ" "7"
 
# GO_COMMAND_READ for WishBone overrun for byte access
run_libsim "JTAG GO_COMMAND (read) WB byte access overrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000eef34eadc0000000100048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000000000000000169330ba20" \
" shifted out: 0x004d86398e201d0d1505190911010000000000" \
" data: 101112131415161700" \
" status: 0x8" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "100000" "8" \
"GO_COMMAND_READ" "9"
 
# GO_COMMAND_READ for WishBone underrun for half word access
run_libsim "JTAG GO_COMMAND (read) WB half word access underrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001fede9b49c0000000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000000000169330ba20" \
" shifted out: 0x000d619cbc2d1505190911010000000000" \
" data: 10111213141516" \
" status: 0x8" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "8" \
"GO_COMMAND_READ" "7"
 
# GO_COMMAND_READ for WishBone overrun for half word access
run_libsim "JTAG GO_COMMAND (read) WB half word access overrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001fede9b49c0000000100148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000000000000000169330ba20" \
" shifted out: 0x004d86398e201d0d1505190911010000000000" \
" data: 101112131415161700" \
" status: 0x8" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "100000" "8" \
"GO_COMMAND_READ" "9"
 
# GO_COMMAND_READ for WishBone underrun for word access
run_libsim "JTAG GO_COMMAND (read) WB word access underrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000066e5a45fc00000001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000000000169330ba20" \
" shifted out: 0x000d619cbc2d1505190911010000000000" \
" data: 10111213141516" \
" status: 0x8" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "8" \
"GO_COMMAND_READ" "7"
 
# GO_COMMAND_READ for WishBone overrun for word access
run_libsim "JTAG GO_COMMAND (read) WB word access overrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000066e5a45fc00000001000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000000000000000169330ba20" \
" shifted out: 0x004d86398e201d0d1505190911010000000000" \
" data: 101112131415161700" \
" status: 0x8" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "100000" "8" \
"GO_COMMAND_READ" "9"
 
# CPU0 underrun and overrun tests should remember that this is a 32-bit access
# with a big-endian organization.
 
# GO_COMMAND_READ for CPU0 underrun for word access
run_libsim "JTAG GO_COMMAND (read) CPU0 word access underrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000000c44c4dd800100280000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x0000000000000000169330ba20" \
" shifted out: 0x00295bc0a836afbee000000000" \
" data: efbead" \
" status: 0x8" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "6" "2801" "4" \
"GO_COMMAND_READ" "3"
 
# GO_COMMAND_READ for CPU0 overrun for word access
run_libsim "JTAG GO_COMMAND (read) CPU0 word access overrun" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x00000000000aff51d871" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000000c44c4dd800100280000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000169330ba20" \
" shifted out: 0x01eaa76a8c200f76afbee000000000" \
" data: efbeadde00" \
" status: 0x8" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "1" "WRITE_COMMAND" "6" "2801" "4" \
"GO_COMMAND_READ" "5"
 
# Test access to invalid areas. We can only do this for Wishbone, since all
# SPRs are validly accessible (non-readable ones just return undefined
# results). For the default CFG we have the following memory areas.
# 0x00000000 - 0x001fffff RAM (read/write)
# 0xf0000000 - 0xf01fffff Flash (read only)
# 0xffe00000 - 0xffffffff RAM (read/write)
 
# For convenience the top 8 bytes of the each block of RAM (0x001ffff8 -
# 0x001fffff) and (0xfffffff8 - 0xffffffff) and the bottom 8 bytes of the
# second block of RAM (0xffe00000 - 0xffe00007) are initialized to
# 0xdeadbeefcafebabe.
 
# Test each access type with one unit and test blocks spanning start and end
# of readable blocks.
 
# GO_COMMAND_READ for 1 byte read from invalid memory.
run_libsim "JTAG GO_COMMAND (read) WB 1 byte invalid read" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000002507505e00000000080048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000169330ba20" \
" shifted out: 0x0005bfa20e400000000000" \
" data: 00" \
" status: 0x4" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "200000" "1" \
"GO_COMMAND_READ" "1"
 
# GO_COMMAND_READ for 2 byte read ending in invalid memory.
run_libsim "JTAG GO_COMMAND (read) WB 2 byte ending invalid read" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000024c5489f0001fffff00048" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000169330ba20" \
" shifted out: 0x01e489dbde400fa000000000" \
" data: be00" \
" status: 0x4" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "1fffff" "2" \
"GO_COMMAND_READ" "2"
 
# GO_COMMAND_READ for 2 byte read starting in invalid memory.
run_libsim "JTAG GO_COMMAND (read) WB 2 byte starting invalid read" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000001620ceaa70001fffff7fe48" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000169330ba20" \
" shifted out: 0x00945aea064f600000000000" \
" data: 00de" \
" status: 0x4" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "4" "ffdfffff" "2" \
"GO_COMMAND_READ" "2"
 
# GO_COMMAND_READ for 1 half word read from invalid memory.
run_libsim "JTAG GO_COMMAND (read) WB 1 half word invalid read" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x0000000000ee5b83fb00000000080148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000169330ba20" \
" shifted out: 0x0061189c3040000000000000" \
" data: 0000" \
" status: 0x4" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "200000" "2" \
"GO_COMMAND_READ" "2"
 
# GO_COMMAND_READ for 2 half word read ending in invalid memory.
run_libsim "JTAG GO_COMMAND (read) WB 2 half word ending invalid read" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000001b3a295b8000fffff00148" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
" shifted out: 0x011ad9043a40000faba000000000" \
" data: babe0000" \
" status: 0x4" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "1ffffe" "4" \
"GO_COMMAND_READ" "4"
 
# GO_COMMAND_READ for 2 half word read starting in invalid memory.
run_libsim "JTAG GO_COMMAND (read) WB 2 half word starting invalid read" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000015df38b638000fffff7ff48" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
" shifted out: 0x016e549cc256af60000000000000" \
" data: 0000dead" \
" status: 0x4" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "5" "ffdffffe" "4" \
"GO_COMMAND_READ" "4"
 
# GO_COMMAND_READ for 1 word read from invalid memory.
run_libsim "JTAG GO_COMMAND (read) WB 1 word invalid read" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000019bd83fcd800000000800c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x000000000000000000169330ba20" \
" shifted out: 0x0020b944d4400000000000000000" \
" data: 00000000" \
" status: 0x4" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "200000" "4" \
"GO_COMMAND_READ" "4"
 
# GO_COMMAND_READ for 2 word read ending in invalid memory.
run_libsim "JTAG GO_COMMAND (read) WB 2 word ending invalid read" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x000000000114e84c5dc0007ffff000c8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000000000169330ba20" \
" shifted out: 0x00f0f84a44400000000fabafea6000000000" \
" data: cafebabe00000000" \
" status: 0x4" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "1ffffc" "8" \
"GO_COMMAND_READ" "8"
 
# GO_COMMAND_READ for 2 word read starting in invalid memory.
run_libsim "JTAG GO_COMMAND (read) WB 2 word starting invalid read" \
[list "Initalization succeeded." \
"Execution step completed OK." \
"Resetting JTAG." \
"Execution step completed OK." \
"Shifting instruction." \
" shifting in: 0x01" \
" shifted out: 0x01" \
" time taken:" \
"Execution step completed OK." \
"Selecting module." \
" shifting in: 0x0000000000174841bc61" \
" shifted out: 0x0164841bc60000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing WRITE_COMMAND." \
" shifting in: 0x00000000005221ee65c0007ffff7fec8" \
" shifted out: 0x164841bc600000000000000000000000" \
" status: 0x0" \
" time taken:" \
"Execution step completed OK." \
"Processing GO_COMMAND_READ." \
" shifting in: 0x00000000000000000000000000169330ba20" \
" shifted out: 0x0090e309ce5eefb6af600000000000000000" \
" data: 00000000deadbeef" \
" status: 0x4" \
" time taken:" \
"Execution step completed OK." \
"Test completed successfully."] \
"lib-jtag/lib-jtag-full" "" "loop/loop-init" "RESET" "INSTRUCTION" \
"8" "SELECT_MODULE" "0" "WRITE_COMMAND" "6" "ffdffffc" "8" \
"GO_COMMAND_READ" "8"
 
/libsim.tests/Makefile.am
28,12 → 28,19
 
 
# Just distribute this stuff
EXTRA_DIST = default.cfg \
int-edge.cfg \
int-edge.exp \
int-level.cfg \
int-level.exp \
jtag-basic.exp \
jtag-full.exp \
lib-iftest.exp \
EXTRA_DIST = default.cfg \
int-edge.cfg \
int-edge.exp \
int-level.cfg \
int-level.exp \
jtag-basic.exp \
jtag-go-command-read.exp \
jtag-go-command-write.exp \
jtag-read-command.exp \
jtag-read-control.exp \
jtag-select-module.exp \
jtag-write-control.exp \
jtag-write-command.exp \
lib-iftest.exp \
upcalls.exp \
upcalls.cfg
/test-code-or1k/eth/Makefile.in
149,6 → 149,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/configure
1,20 → 1,24
#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.63 for or1ksim-testsuite 0.4.0rc1.
# Generated by GNU Autoconf 2.65 for or1ksim-testsuite 0.4.0rc1.
#
# Report bugs to <openrisc@opencores.org>.
#
#
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
# 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
# Inc.
#
#
# This configure script is free software; the Free Software Foundation
# gives unlimited permission to copy, distribute and modify it.
## --------------------- ##
## M4sh Initialization. ##
## --------------------- ##
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##
 
# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
22,23 → 26,15
alias -g '${1+"$@"}'='"$@"'
setopt NO_GLOB_SUBST
else
case `(set -o) 2>/dev/null` in
*posix*) set -o posix ;;
case `(set -o) 2>/dev/null` in #(
*posix*) :
set -o posix ;; #(
*) :
;;
esac
 
fi
 
 
 
 
# PATH needs CR
# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits
 
as_nl='
'
export as_nl
46,7 → 42,13
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
if (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
&& (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
as_echo='print -r --'
as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
as_echo='printf %s\n'
as_echo_n='printf %s'
else
57,7 → 59,7
as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
as_echo_n_body='eval
arg=$1;
case $arg in
case $arg in #(
*"$as_nl"*)
expr "X$arg" : "X\\(.*\\)$as_nl";
arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
80,14 → 82,7
}
fi
 
# Support unset when possible.
if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
as_unset=unset
else
as_unset=false
fi
 
 
# IFS
# We need space, tab and new line, in precisely that order. Quoting is
# there to prevent editors from complaining about space-tab.
96,7 → 91,7
IFS=" "" $as_nl"
 
# Find who we are. Look in the path if we contain no directory separator.
case $0 in
case $0 in #((
*[\\/]* ) as_myself=$0 ;;
*) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
103,8 → 98,8
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
done
test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
done
IFS=$as_save_IFS
 
;;
116,12 → 111,16
fi
if test ! -f "$as_myself"; then
$as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
{ (exit 1); exit 1; }
exit 1
fi
 
# Work around bugs in pre-3.0 UWIN ksh.
for as_var in ENV MAIL MAILPATH
do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there. '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
&& ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
133,330 → 132,300
LANGUAGE=C
export LANGUAGE
 
# Required to use basename.
if expr a : '\(a\)' >/dev/null 2>&1 &&
test "X`expr 00001 : '.*\(...\)'`" = X001; then
as_expr=expr
else
as_expr=false
fi
 
if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
as_basename=basename
else
as_basename=false
fi
 
 
# Name of the executable.
as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
X"$0" : 'X\(//\)$' \| \
X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
sed '/^.*\/\([^/][^/]*\)\/*$/{
s//\1/
q
}
/^X\/\(\/\/\)$/{
s//\1/
q
}
/^X\/\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
 
# CDPATH.
$as_unset CDPATH
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 
 
if test "x$CONFIG_SHELL" = x; then
if (eval ":") 2>/dev/null; then
as_have_required=yes
as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
# is contrary to our usage. Disable this feature.
alias -g '\${1+\"\$@\"}'='\"\$@\"'
setopt NO_GLOB_SUBST
else
as_have_required=no
case \`(set -o) 2>/dev/null\` in #(
*posix*) :
set -o posix ;; #(
*) :
;;
esac
fi
"
as_required="as_fn_return () { (exit \$1); }
as_fn_success () { as_fn_return 0; }
as_fn_failure () { as_fn_return 1; }
as_fn_ret_success () { return 0; }
as_fn_ret_failure () { return 1; }
 
if test $as_have_required = yes && (eval ":
(as_func_return () {
(exit \$1)
}
as_func_success () {
as_func_return 0
}
as_func_failure () {
as_func_return 1
}
as_func_ret_success () {
return 0
}
as_func_ret_failure () {
return 1
}
 
exitcode=0
if as_func_success; then
:
else
exitcode=1
echo as_func_success failed.
fi
as_fn_success || { exitcode=1; echo as_fn_success failed.; }
as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
 
if as_func_failure; then
exitcode=1
echo as_func_failure succeeded.
fi
 
if as_func_ret_success; then
:
else
exitcode=1
echo as_func_ret_success failed.
exitcode=1; echo positional parameters were not saved.
fi
 
if as_func_ret_failure; then
exitcode=1
echo as_func_ret_failure succeeded.
fi
 
if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
:
test x\$exitcode = x0 || exit 1"
as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
test \$(( 1 + 1 )) = 2 || exit 1"
if (eval "$as_required") 2>/dev/null; then :
as_have_required=yes
else
exitcode=1
echo positional parameters were not saved.
as_have_required=no
fi
if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
 
test \$exitcode = 0) || { (exit 1); exit 1; }
 
(
as_lineno_1=\$LINENO
as_lineno_2=\$LINENO
test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }
") 2> /dev/null; then
:
else
as_candidate_shells=
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
as_found=false
for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
case $as_dir in
as_found=:
case $as_dir in #(
/*)
for as_base in sh bash ksh sh5; do
as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
# Try only shells that exist, to save several forks.
as_shell=$as_dir/$as_base
if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
{ $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
CONFIG_SHELL=$as_shell as_have_required=yes
if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
break 2
fi
fi
done;;
esac
as_found=false
done
$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
{ $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
CONFIG_SHELL=$SHELL as_have_required=yes
fi; }
IFS=$as_save_IFS
 
 
for as_shell in $as_candidate_shells $SHELL; do
# Try only shells that exist, to save several forks.
if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
{ ("$as_shell") 2> /dev/null <<\_ASEOF
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
# is contrary to our usage. Disable this feature.
alias -g '${1+"$@"}'='"$@"'
setopt NO_GLOB_SUBST
else
case `(set -o) 2>/dev/null` in
*posix*) set -o posix ;;
esac
 
if test "x$CONFIG_SHELL" != x; then :
# We cannot yet assume a decent shell, so we have to provide a
# neutralization value for shells without unset; and this also
# works around shells that cannot unset nonexistent variables.
BASH_ENV=/dev/null
ENV=/dev/null
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
export CONFIG_SHELL
exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
fi
 
 
:
_ASEOF
}; then
CONFIG_SHELL=$as_shell
as_have_required=yes
if { "$as_shell" 2> /dev/null <<\_ASEOF
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
# is contrary to our usage. Disable this feature.
alias -g '${1+"$@"}'='"$@"'
setopt NO_GLOB_SUBST
else
case `(set -o) 2>/dev/null` in
*posix*) set -o posix ;;
esac
 
if test x$as_have_required = xno; then :
$as_echo "$0: This script requires a shell more modern than all"
$as_echo "$0: the shells that I found on your system."
if test x${ZSH_VERSION+set} = xset ; then
$as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
$as_echo "$0: be upgraded to zsh 4.3.4 or later."
else
$as_echo "$0: Please tell bug-autoconf@gnu.org and
$0: openrisc@opencores.org about your system, including any
$0: error possibly output before this message. Then install
$0: a modern shell, or manually run the script under such a
$0: shell if you do have one."
fi
exit 1
fi
 
 
:
(as_func_return () {
(exit $1)
}
as_func_success () {
as_func_return 0
}
as_func_failure () {
as_func_return 1
}
as_func_ret_success () {
return 0
}
as_func_ret_failure () {
return 1
}
 
exitcode=0
if as_func_success; then
:
else
exitcode=1
echo as_func_success failed.
fi
 
if as_func_failure; then
exitcode=1
echo as_func_failure succeeded.
fi
SHELL=${CONFIG_SHELL-/bin/sh}
export SHELL
# Unset more variables known to interfere with behavior of common tools.
CLICOLOR_FORCE= GREP_OPTIONS=
unset CLICOLOR_FORCE GREP_OPTIONS
 
if as_func_ret_success; then
:
else
exitcode=1
echo as_func_ret_success failed.
fi
## --------------------- ##
## M4sh Shell Functions. ##
## --------------------- ##
# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
{ eval $1=; unset $1;}
}
as_unset=as_fn_unset
 
if as_func_ret_failure; then
exitcode=1
echo as_func_ret_failure succeeded.
fi
# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
return $1
} # as_fn_set_status
 
if ( set x; as_func_ret_success y && test x = "$1" ); then
:
else
exitcode=1
echo positional parameters were not saved.
fi
# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
set +e
as_fn_set_status $1
exit $1
} # as_fn_exit
 
test $exitcode = 0) || { (exit 1); exit 1; }
# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{
 
(
as_lineno_1=$LINENO
as_lineno_2=$LINENO
test "x$as_lineno_1" != "x$as_lineno_2" &&
test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }
case $as_dir in #(
-*) as_dir=./$as_dir;;
esac
test -d "$as_dir" || eval $as_mkdir_p || {
as_dirs=
while :; do
case $as_dir in #(
*\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
*) as_qdir=$as_dir;;
esac
as_dirs="'$as_qdir' $as_dirs"
as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
X"$as_dir" : 'X\(//\)[^/]' \| \
X"$as_dir" : 'X\(//\)$' \| \
X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
}
/^X\(\/\/\)[^/].*/{
s//\1/
q
}
/^X\(\/\/\)$/{
s//\1/
q
}
/^X\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
test -d "$as_dir" && break
done
test -z "$as_dirs" || eval "mkdir $as_dirs"
} || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir"
 
_ASEOF
}; then
break
fi
 
fi
} # as_fn_mkdir_p
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
eval 'as_fn_append ()
{
eval $1+=\$2
}'
else
as_fn_append ()
{
eval $1=\$$1\$2
}
fi # as_fn_append
 
done
# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
eval 'as_fn_arith ()
{
as_val=$(( $* ))
}'
else
as_fn_arith ()
{
as_val=`expr "$@" || test $? -eq 1`
}
fi # as_fn_arith
 
if test "x$CONFIG_SHELL" != x; then
for as_var in BASH_ENV ENV
do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
done
export CONFIG_SHELL
exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
fi
 
# as_fn_error ERROR [LINENO LOG_FD]
# ---------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with status $?, using 1 if that was 0.
as_fn_error ()
{
as_status=$?; test $as_status -eq 0 && as_status=1
if test "$3"; then
as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
$as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3
fi
$as_echo "$as_me: error: $1" >&2
as_fn_exit $as_status
} # as_fn_error
 
if test $as_have_required = no; then
echo This script requires a shell more modern than all the
echo shells that I found on your system. Please install a
echo modern shell, or manually run the script under such a
echo shell if you do have one.
{ (exit 1); exit 1; }
fi
 
 
fi
 
fi
 
 
 
(eval "as_func_return () {
(exit \$1)
}
as_func_success () {
as_func_return 0
}
as_func_failure () {
as_func_return 1
}
as_func_ret_success () {
return 0
}
as_func_ret_failure () {
return 1
}
 
exitcode=0
if as_func_success; then
:
if expr a : '\(a\)' >/dev/null 2>&1 &&
test "X`expr 00001 : '.*\(...\)'`" = X001; then
as_expr=expr
else
exitcode=1
echo as_func_success failed.
as_expr=false
fi
 
if as_func_failure; then
exitcode=1
echo as_func_failure succeeded.
fi
 
if as_func_ret_success; then
:
if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
as_basename=basename
else
exitcode=1
echo as_func_ret_success failed.
as_basename=false
fi
 
if as_func_ret_failure; then
exitcode=1
echo as_func_ret_failure succeeded.
fi
 
if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
:
if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
as_dirname=dirname
else
exitcode=1
echo positional parameters were not saved.
as_dirname=false
fi
 
test \$exitcode = 0") || {
echo No shell found that supports shell functions.
echo Please tell bug-autoconf@gnu.org about your system,
echo including any error possibly output before this message.
echo This can help us improve future autoconf versions.
echo Configuration will now proceed without shell functions.
}
as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
X"$0" : 'X\(//\)$' \| \
X"$0" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X/"$0" |
sed '/^.*\/\([^/][^/]*\)\/*$/{
s//\1/
q
}
/^X\/\(\/\/\)$/{
s//\1/
q
}
/^X\/\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
 
# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits
 
 
as_lineno_1=$LINENO
as_lineno_2=$LINENO
test "x$as_lineno_1" != "x$as_lineno_2" &&
test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
 
# Create $as_me.lineno as a copy of $as_myself, but with $LINENO
# uniformly replaced by the line number. The first 'sed' inserts a
# line-number line after each line using $LINENO; the second 'sed'
# does the real work. The second script uses 'N' to pair each
# line-number line with the line containing $LINENO, and appends
# trailing '-' during substitution so that $LINENO is not a special
# case at line end.
# (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
# scripts with optimization help from Paolo Bonzini. Blame Lee
# E. McMahon (1931-1989) for sed's syntax. :-)
as_lineno_1=$LINENO as_lineno_1a=$LINENO
as_lineno_2=$LINENO as_lineno_2a=$LINENO
eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
# Blame Lee E. McMahon (1931-1989) for sed's syntax. :-)
sed -n '
p
/[$]LINENO/=
473,8 → 442,7
s/-\n.*//
' >$as_me.lineno &&
chmod +x "$as_me.lineno" ||
{ $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
{ (exit 1); exit 1; }; }
{ $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
 
# Don't try to exec as it changes $[0], causing all sort of problems
# (the dirname of $[0] is not the place where we might find the
484,29 → 452,18
exit
}
 
 
if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
as_dirname=dirname
else
as_dirname=false
fi
 
ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in
case `echo -n x` in #(((((
-n*)
case `echo 'x\c'` in
case `echo 'xy\c'` in
*c*) ECHO_T=' ';; # ECHO_T is single tab character.
*) ECHO_C='\c';;
xy) ECHO_C='\c';;
*) echo `echo ksh88 bug on AIX 6.1` > /dev/null
ECHO_T=' ';;
esac;;
*)
ECHO_N='-n';;
esac
if expr a : '\(a\)' >/dev/null 2>&1 &&
test "X`expr 00001 : '.*\(...\)'`" = X001; then
as_expr=expr
else
as_expr=false
fi
 
rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
536,7 → 493,7
rmdir conf$$.dir 2>/dev/null
 
if mkdir -p . 2>/dev/null; then
as_mkdir_p=:
as_mkdir_p='mkdir -p "$as_dir"'
else
test -d ./-p && rmdir ./-p
as_mkdir_p=false
555,10 → 512,10
if test -d "$1"; then
test -d "$1/.";
else
case $1 in
case $1 in #(
-*)set "./$1";;
esac;
case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
???[sx]*):;;*)false;;esac;fi
'\'' sh
'
573,7 → 530,6
 
 
 
 
# Check that we are running under the correct shell.
SHELL=${CONFIG_SHELL-/bin/sh}
 
722,7 → 678,8
 
 
 
exec 7<&0 </dev/null 6>&1
test -n "$DJDIR" || exec 7<&0 </dev/null
exec 6>&1
 
# Name of the host.
# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
740,7 → 697,6
subdirs=
MFLAGS=
MAKEFLAGS=
SHELL=${CONFIG_SHELL-/bin/sh}
 
# Identity of this package.
PACKAGE_NAME='or1ksim-testsuite'
748,6 → 704,7
PACKAGE_VERSION='0.4.0rc1'
PACKAGE_STRING='or1ksim-testsuite 0.4.0rc1'
PACKAGE_BUGREPORT='openrisc@opencores.org'
PACKAGE_URL=''
 
# Factoring default headers for most tests.
ac_includes_default="\
894,6 → 851,7
program_transform_name
prefix
exec_prefix
PACKAGE_URL
PACKAGE_BUGREPORT
PACKAGE_STRING
PACKAGE_VERSION
1033,8 → 991,7
ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
# Reject names that are not valid shell variable names.
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
{ $as_echo "$as_me: error: invalid feature name: $ac_useropt" >&2
{ (exit 1); exit 1; }; }
as_fn_error "invalid feature name: $ac_useropt"
ac_useropt_orig=$ac_useropt
ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
1060,8 → 1017,7
ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
# Reject names that are not valid shell variable names.
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
{ $as_echo "$as_me: error: invalid feature name: $ac_useropt" >&2
{ (exit 1); exit 1; }; }
as_fn_error "invalid feature name: $ac_useropt"
ac_useropt_orig=$ac_useropt
ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
1265,8 → 1221,7
ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
# Reject names that are not valid shell variable names.
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
{ $as_echo "$as_me: error: invalid package name: $ac_useropt" >&2
{ (exit 1); exit 1; }; }
as_fn_error "invalid package name: $ac_useropt"
ac_useropt_orig=$ac_useropt
ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
1282,8 → 1237,7
ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
# Reject names that are not valid shell variable names.
expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
{ $as_echo "$as_me: error: invalid package name: $ac_useropt" >&2
{ (exit 1); exit 1; }; }
as_fn_error "invalid package name: $ac_useropt"
ac_useropt_orig=$ac_useropt
ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
case $ac_user_opts in
1313,17 → 1267,17
| --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
x_libraries=$ac_optarg ;;
 
-*) { $as_echo "$as_me: error: unrecognized option: $ac_option
Try \`$0 --help' for more information." >&2
{ (exit 1); exit 1; }; }
-*) as_fn_error "unrecognized option: \`$ac_option'
Try \`$0 --help' for more information."
;;
 
*=*)
ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
# Reject names that are not valid shell variable names.
expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
{ $as_echo "$as_me: error: invalid variable name: $ac_envvar" >&2
{ (exit 1); exit 1; }; }
case $ac_envvar in #(
'' | [0-9]* | *[!_$as_cr_alnum]* )
as_fn_error "invalid variable name: \`$ac_envvar'" ;;
esac
eval $ac_envvar=\$ac_optarg
export $ac_envvar ;;
 
1340,15 → 1294,13
 
if test -n "$ac_prev"; then
ac_option=--`echo $ac_prev | sed 's/_/-/g'`
{ $as_echo "$as_me: error: missing argument to $ac_option" >&2
{ (exit 1); exit 1; }; }
as_fn_error "missing argument to $ac_option"
fi
 
if test -n "$ac_unrecognized_opts"; then
case $enable_option_checking in
no) ;;
fatal) { $as_echo "$as_me: error: unrecognized options: $ac_unrecognized_opts" >&2
{ (exit 1); exit 1; }; } ;;
fatal) as_fn_error "unrecognized options: $ac_unrecognized_opts" ;;
*) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
esac
fi
1371,8 → 1323,7
[\\/$]* | ?:[\\/]* ) continue;;
NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
esac
{ $as_echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
{ (exit 1); exit 1; }; }
as_fn_error "expected an absolute directory name for --$ac_var: $ac_val"
done
 
# There might be people who depend on the old broken behavior: `$host'
1402,11 → 1353,9
ac_pwd=`pwd` && test -n "$ac_pwd" &&
ac_ls_di=`ls -di .` &&
ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
{ $as_echo "$as_me: error: working directory cannot be determined" >&2
{ (exit 1); exit 1; }; }
as_fn_error "working directory cannot be determined"
test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
{ $as_echo "$as_me: error: pwd does not report name of working directory" >&2
{ (exit 1); exit 1; }; }
as_fn_error "pwd does not report name of working directory"
 
 
# Find the source files, if location was not specified.
1445,13 → 1394,11
fi
if test ! -r "$srcdir/$ac_unique_file"; then
test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
{ $as_echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
{ (exit 1); exit 1; }; }
as_fn_error "cannot find sources ($ac_unique_file) in $srcdir"
fi
ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
ac_abs_confdir=`(
cd "$srcdir" && test -r "./$ac_unique_file" || { $as_echo "$as_me: error: $ac_msg" >&2
{ (exit 1); exit 1; }; }
cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error "$ac_msg"
pwd)`
# When building in place, set srcdir=.
if test "$ac_abs_confdir" = "$ac_pwd"; then
1581,7 → 1528,7
LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a
nonstandard directory <lib dir>
LIBS libraries to pass to the linker, e.g. -l<library>
CPPFLAGS C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
you have headers in a nonstandard directory <include dir>
CPP C preprocessor
CCAS assembler compiler command (defaults to CC)
1654,21 → 1601,432
if $ac_init_version; then
cat <<\_ACEOF
or1ksim-testsuite configure 0.4.0rc1
generated by GNU Autoconf 2.63
generated by GNU Autoconf 2.65
 
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
Copyright (C) 2009 Free Software Foundation, Inc.
This configure script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it.
_ACEOF
exit
fi
 
## ------------------------ ##
## Autoconf initialization. ##
## ------------------------ ##
 
# ac_fn_c_try_compile LINENO
# --------------------------
# Try to compile conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_compile ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
rm -f conftest.$ac_objext
if { { ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_compile") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
grep -v '^ *+' conftest.err >conftest.er1
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then :
ac_retval=0
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_retval=1
fi
eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
as_fn_set_status $ac_retval
 
} # ac_fn_c_try_compile
 
# ac_fn_c_try_link LINENO
# -----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_link ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
rm -f conftest.$ac_objext conftest$ac_exeext
if { { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_link") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
grep -v '^ *+' conftest.err >conftest.er1
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then :
ac_retval=0
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_retval=1
fi
# Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
# created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
# interfere with the next link command; also delete a directory that is
# left behind by Apple's compiler. We do this before executing the actions.
rm -rf conftest.dSYM conftest_ipa8_conftest.oo
eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
as_fn_set_status $ac_retval
 
} # ac_fn_c_try_link
 
# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists and can be compiled using the include files in
# INCLUDES, setting the cache variable VAR accordingly.
ac_fn_c_check_header_compile ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$4
#include <$2>
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
eval "$3=yes"
else
eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
eval ac_res=\$$3
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
 
} # ac_fn_c_check_header_compile
 
# ac_fn_c_try_cpp LINENO
# ----------------------
# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_cpp ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
if { { ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
grep -v '^ *+' conftest.err >conftest.er1
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } >/dev/null && {
test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
test ! -s conftest.err
}; then :
ac_retval=0
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_retval=1
fi
eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
as_fn_set_status $ac_retval
 
} # ac_fn_c_try_cpp
 
# ac_fn_c_try_run LINENO
# ----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
# that executables *can* be run.
ac_fn_c_try_run ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
if { { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_link") 2>&5
ac_status=$?
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
{ { case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; }; then :
ac_retval=0
else
$as_echo "$as_me: program exited with status $ac_status" >&5
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_retval=$ac_status
fi
rm -rf conftest.dSYM conftest_ipa8_conftest.oo
eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
as_fn_set_status $ac_retval
 
} # ac_fn_c_try_run
 
# ac_fn_c_check_func LINENO FUNC VAR
# ----------------------------------
# Tests whether FUNC exists, setting the cache variable VAR accordingly
ac_fn_c_check_func ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
$as_echo_n "(cached) " >&6
else
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
For example, HP-UX 11i <limits.h> declares gettimeofday. */
#define $2 innocuous_$2
 
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $2 (); below.
Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
<limits.h> exists even on freestanding compilers. */
 
#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif
 
#undef $2
 
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
#ifdef __cplusplus
extern "C"
#endif
char $2 ();
/* The GNU C library defines this for functions which it implements
to always fail with ENOSYS. Some functions are actually named
something starting with __ and the normal name is an alias. */
#if defined __stub_$2 || defined __stub___$2
choke me
#endif
 
int
main ()
{
return $2 ();
;
return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
eval "$3=yes"
else
eval "$3=no"
fi
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
fi
eval ac_res=\$$3
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
 
} # ac_fn_c_check_func
 
# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists, giving a warning if it cannot be compiled using
# the include files in INCLUDES and setting the cache variable VAR
# accordingly.
ac_fn_c_check_header_mongrel ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
$as_echo_n "(cached) " >&6
fi
eval ac_res=\$$3
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
else
# Is the header compilable?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
$as_echo_n "checking $2 usability... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$4
#include <$2>
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
ac_header_compiler=yes
else
ac_header_compiler=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
$as_echo "$ac_header_compiler" >&6; }
 
# Is the header present?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
$as_echo_n "checking $2 presence... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <$2>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
ac_header_preproc=yes
else
ac_header_preproc=no
fi
rm -f conftest.err conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
$as_echo "$ac_header_preproc" >&6; }
 
# So? What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
yes:no: )
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
;;
no:yes:* )
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5
$as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5
$as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;}
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
( cat <<\_ASBOX
## ------------------------------------- ##
## Report this to openrisc@opencores.org ##
## ------------------------------------- ##
_ASBOX
) | sed "s/^/$as_me: WARNING: /" >&2
;;
esac
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
$as_echo_n "(cached) " >&6
else
eval "$3=\$ac_header_compiler"
fi
eval ac_res=\$$3
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
fi
eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
 
} # ac_fn_c_check_header_mongrel
 
# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
# -------------------------------------------
# Tests whether TYPE exists after having included INCLUDES, setting cache
# variable VAR accordingly.
ac_fn_c_check_type ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
$as_echo_n "(cached) " >&6
else
eval "$3=no"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$4
int
main ()
{
if (sizeof ($2))
return 0;
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
$4
int
main ()
{
if (sizeof (($2)))
return 0;
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
 
else
eval "$3=yes"
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
eval ac_res=\$$3
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
 
} # ac_fn_c_check_type
cat >config.log <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
 
It was created by or1ksim-testsuite $as_me 0.4.0rc1, which was
generated by GNU Autoconf 2.63. Invocation command line was
generated by GNU Autoconf 2.65. Invocation command line was
 
$ $0 $@
 
1704,8 → 2062,8
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
$as_echo "PATH: $as_dir"
done
$as_echo "PATH: $as_dir"
done
IFS=$as_save_IFS
 
} >&5
1742,9 → 2100,9
ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
esac
case $ac_pass in
1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2)
ac_configure_args1="$ac_configure_args1 '$ac_arg'"
as_fn_append ac_configure_args1 " '$ac_arg'"
if test $ac_must_keep_next = true; then
ac_must_keep_next=false # Got value, back to normal.
else
1760,13 → 2118,13
-* ) ac_must_keep_next=true ;;
esac
fi
ac_configure_args="$ac_configure_args '$ac_arg'"
as_fn_append ac_configure_args " '$ac_arg'"
;;
esac
done
done
$as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
$as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
{ ac_configure_args0=; unset ac_configure_args0;}
{ ac_configure_args1=; unset ac_configure_args1;}
 
# When interrupted or exit'd, cleanup temporary files, and complete
# config.log. We remove comments because anyway the quotes in there
1791,13 → 2149,13
case $ac_val in #(
*${as_nl}*)
case $ac_var in #(
*_cv_*) { $as_echo "$as_me:$LINENO: WARNING: cache variable $ac_var contains a newline" >&5
*_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
esac
case $ac_var in #(
_ | IFS | as_nl) ;; #(
BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
*) $as_unset $ac_var ;;
*) { eval $ac_var=; unset $ac_var;} ;;
esac ;;
esac
done
1869,7 → 2227,7
exit $exit_status
' 0
for ac_signal in 1 2 13 15; do
trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
done
ac_signal=0
 
1876,6 → 2234,8
# confdefs.h avoids OS command line length limits that DEFS can exceed.
rm -f -r conftest* confdefs.h
 
$as_echo "/* confdefs.h */" > confdefs.h
 
# Predefined preprocessor variables.
 
cat >>confdefs.h <<_ACEOF
1882,27 → 2242,27
#define PACKAGE_NAME "$PACKAGE_NAME"
_ACEOF
 
 
cat >>confdefs.h <<_ACEOF
#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
_ACEOF
 
 
cat >>confdefs.h <<_ACEOF
#define PACKAGE_VERSION "$PACKAGE_VERSION"
_ACEOF
 
 
cat >>confdefs.h <<_ACEOF
#define PACKAGE_STRING "$PACKAGE_STRING"
_ACEOF
 
 
cat >>confdefs.h <<_ACEOF
#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
_ACEOF
 
cat >>confdefs.h <<_ACEOF
#define PACKAGE_URL "$PACKAGE_URL"
_ACEOF
 
 
# Let the site file select an alternate cache file if it wants to.
# Prefer an explicitly selected file to automatically selected ones.
ac_site_file1=NONE
1919,8 → 2279,8
for ac_site_file in "$ac_site_file1" "$ac_site_file2"
do
test "x$ac_site_file" = xNONE && continue
if test -r "$ac_site_file"; then
{ $as_echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
$as_echo "$as_me: loading site script $ac_site_file" >&6;}
sed 's/^/| /' "$ac_site_file" >&5
. "$ac_site_file"
1928,10 → 2288,10
done
 
if test -r "$cache_file"; then
# Some versions of bash will fail to source /dev/null (special
# files actually), so we avoid doing that.
if test -f "$cache_file"; then
{ $as_echo "$as_me:$LINENO: loading cache $cache_file" >&5
# Some versions of bash will fail to source /dev/null (special files
# actually), so we avoid doing that. DJGPP emulates it as a regular file.
if test /dev/null != "$cache_file" && test -f "$cache_file"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
$as_echo "$as_me: loading cache $cache_file" >&6;}
case $cache_file in
[\\/]* | ?:[\\/]* ) . "$cache_file";;
1939,7 → 2299,7
esac
fi
else
{ $as_echo "$as_me:$LINENO: creating cache $cache_file" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
$as_echo "$as_me: creating cache $cache_file" >&6;}
>$cache_file
fi
1954,11 → 2314,11
eval ac_new_val=\$ac_env_${ac_var}_value
case $ac_old_set,$ac_new_set in
set,)
{ $as_echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
ac_cache_corrupted=: ;;
,set)
{ $as_echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
ac_cache_corrupted=: ;;
,);;
1968,17 → 2328,17
ac_old_val_w=`echo x $ac_old_val`
ac_new_val_w=`echo x $ac_new_val`
if test "$ac_old_val_w" != "$ac_new_val_w"; then
{ $as_echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
ac_cache_corrupted=:
else
{ $as_echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
eval $ac_var=\$ac_old_val
fi
{ $as_echo "$as_me:$LINENO: former value: \`$ac_old_val'" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5
$as_echo "$as_me: former value: \`$ac_old_val'" >&2;}
{ $as_echo "$as_me:$LINENO: current value: \`$ac_new_val'" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5
$as_echo "$as_me: current value: \`$ac_new_val'" >&2;}
fi;;
esac
1990,44 → 2350,21
esac
case " $ac_configure_args " in
*" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.
*) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
*) as_fn_append ac_configure_args " '$ac_arg'" ;;
esac
fi
done
if $ac_cache_corrupted; then
{ $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
{ $as_echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
{ { $as_echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
$as_echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
fi
## -------------------- ##
## Main body of script. ##
## -------------------- ##
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2039,7 → 2376,7
 
case `pwd` in
*\ * | *\ *)
{ $as_echo "$as_me:$LINENO: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
esac
 
2064,24 → 2401,16
 
ac_aux_dir=
for ac_dir in "$srcdir" "$srcdir/.." "$srcdir/../.."; do
if test -f "$ac_dir/install-sh"; then
ac_aux_dir=$ac_dir
ac_install_sh="$ac_aux_dir/install-sh -c"
break
elif test -f "$ac_dir/install.sh"; then
ac_aux_dir=$ac_dir
ac_install_sh="$ac_aux_dir/install.sh -c"
break
elif test -f "$ac_dir/shtool"; then
ac_aux_dir=$ac_dir
ac_install_sh="$ac_aux_dir/shtool install -c"
break
fi
for ac_t in install-sh install.sh shtool; do
if test -f "$ac_dir/$ac_t"; then
ac_aux_dir=$ac_dir
ac_install_sh="$ac_aux_dir/$ac_t -c"
break 2
fi
done
done
if test -z "$ac_aux_dir"; then
{ { $as_echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" >&5
$as_echo "$as_me: error: cannot find install-sh or install.sh in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "cannot find install-sh, install.sh, or shtool in \"$srcdir\" \"$srcdir/..\" \"$srcdir/../..\"" "$LINENO" 5
fi
 
# These three variables are undocumented and unsupported,
2095,13 → 2424,11
 
# Make sure we can run config.sub.
$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
{ { $as_echo "$as_me:$LINENO: error: cannot run $SHELL $ac_aux_dir/config.sub" >&5
$as_echo "$as_me: error: cannot run $SHELL $ac_aux_dir/config.sub" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
 
{ $as_echo "$as_me:$LINENO: checking build system type" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
$as_echo_n "checking build system type... " >&6; }
if test "${ac_cv_build+set}" = set; then
if test "${ac_cv_build+set}" = set; then :
$as_echo_n "(cached) " >&6
else
ac_build_alias=$build_alias
2108,22 → 2435,16
test "x$ac_build_alias" = x &&
ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
test "x$ac_build_alias" = x &&
{ { $as_echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
$as_echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "cannot guess build type; you must specify one" "$LINENO" 5
ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
{ { $as_echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&5
$as_echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
 
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_build" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
$as_echo "$ac_cv_build" >&6; }
case $ac_cv_build in
*-*-*) ;;
*) { { $as_echo "$as_me:$LINENO: error: invalid value of canonical build" >&5
$as_echo "$as_me: error: invalid value of canonical build" >&2;}
{ (exit 1); exit 1; }; };;
*) as_fn_error "invalid value of canonical build" "$LINENO" 5;;
esac
build=$ac_cv_build
ac_save_IFS=$IFS; IFS='-'
2139,9 → 2460,9
case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
 
 
{ $as_echo "$as_me:$LINENO: checking host system type" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
$as_echo_n "checking host system type... " >&6; }
if test "${ac_cv_host+set}" = set; then
if test "${ac_cv_host+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test "x$host_alias" = x; then
2148,19 → 2469,15
ac_cv_host=$ac_cv_build
else
ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
{ { $as_echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&5
$as_echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
fi
 
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_host" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
$as_echo "$ac_cv_host" >&6; }
case $ac_cv_host in
*-*-*) ;;
*) { { $as_echo "$as_me:$LINENO: error: invalid value of canonical host" >&5
$as_echo "$as_me: error: invalid value of canonical host" >&2;}
{ (exit 1); exit 1; }; };;
*) as_fn_error "invalid value of canonical host" "$LINENO" 5;;
esac
host=$ac_cv_host
ac_save_IFS=$IFS; IFS='-'
2184,9 → 2501,9
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
set dummy ${ac_tool_prefix}gcc; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_CC+set}" = set; then
if test "${ac_cv_prog_CC+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
2197,14 → 2514,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_CC="${ac_tool_prefix}gcc"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
2211,10 → 2528,10
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:$LINENO: result: $CC" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
2224,9 → 2541,9
ac_ct_CC=$CC
# Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_CC"; then
2237,14 → 2554,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_CC="gcc"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
2251,10 → 2568,10
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
2263,7 → 2580,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
2277,9 → 2594,9
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
set dummy ${ac_tool_prefix}cc; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_CC+set}" = set; then
if test "${ac_cv_prog_CC+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
2290,14 → 2607,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_CC="${ac_tool_prefix}cc"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
2304,10 → 2621,10
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:$LINENO: result: $CC" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
2317,9 → 2634,9
if test -z "$CC"; then
# Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_CC+set}" = set; then
if test "${ac_cv_prog_CC+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
2331,7 → 2648,7
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
ac_prog_rejected=yes
2338,11 → 2655,11
continue
fi
ac_cv_prog_CC="cc"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
if test $ac_prog_rejected = yes; then
2361,10 → 2678,10
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:$LINENO: result: $CC" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
2376,9 → 2693,9
do
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_CC+set}" = set; then
if test "${ac_cv_prog_CC+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
2389,14 → 2706,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
2403,10 → 2720,10
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:$LINENO: result: $CC" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
2420,9 → 2737,9
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_CC"; then
2433,14 → 2750,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_CC="$ac_prog"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
2447,10 → 2764,10
fi
ac_ct_CC=$ac_cv_prog_ac_ct_CC
if test -n "$ac_ct_CC"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
$as_echo "$ac_ct_CC" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
2463,7 → 2780,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
2474,57 → 2791,37
fi
 
 
test -z "$CC" && { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
{ { $as_echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
See \`config.log' for more details." >&5
$as_echo "$as_me: error: no acceptable C compiler found in \$PATH
See \`config.log' for more details." >&2;}
{ (exit 1); exit 1; }; }; }
as_fn_error "no acceptable C compiler found in \$PATH
See \`config.log' for more details." "$LINENO" 5; }
 
# Provide some information about the compiler.
$as_echo "$as_me:$LINENO: checking for C compiler version" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
set X $ac_compile
ac_compiler=$2
{ (ac_try="$ac_compiler --version >&5"
for ac_option in --version -v -V -qversion; do
{ { ac_try="$ac_compiler $ac_option >&5"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compiler --version >&5") 2>&5
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_compiler $ac_option >&5") 2>conftest.err
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }
{ (ac_try="$ac_compiler -v >&5"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compiler -v >&5") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }
{ (ac_try="$ac_compiler -V >&5"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compiler -V >&5") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }
if test -s conftest.err; then
sed '10a\
... rest of stderr output deleted ...
10q' conftest.err >conftest.er1
cat conftest.er1 >&5
fi
rm -f conftest.er1 conftest.err
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
done
 
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
int
2540,8 → 2837,8
# Try to create an executable without -o first, disregard a.out.
# It will help us diagnose broken compilers, and finding out an intuition
# of exeext.
{ $as_echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
$as_echo_n "checking for C compiler default output file name... " >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
$as_echo_n "checking whether the C compiler works... " >&6; }
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
 
# The possible output files:
2557,17 → 2854,17
done
rm -f $ac_rmfiles
 
if { (ac_try="$ac_link_default"
if { { ac_try="$ac_link_default"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_link_default") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then :
# Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
# in a Makefile. We should not override ac_cv_exeext if it was cached,
2584,7 → 2881,7
# certainly right.
break;;
*.* )
if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
then :; else
ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
fi
2603,84 → 2900,42
else
ac_file=''
fi
 
{ $as_echo "$as_me:$LINENO: result: $ac_file" >&5
$as_echo "$ac_file" >&6; }
if test -z "$ac_file"; then
$as_echo "$as_me: failed program was:" >&5
if test -z "$ac_file"; then :
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
{ { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
{ { $as_echo "$as_me:$LINENO: error: C compiler cannot create executables
See \`config.log' for more details." >&5
$as_echo "$as_me: error: C compiler cannot create executables
See \`config.log' for more details." >&2;}
{ (exit 77); exit 77; }; }; }
{ as_fn_set_status 77
as_fn_error "C compiler cannot create executables
See \`config.log' for more details." "$LINENO" 5; }; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
fi
 
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
$as_echo_n "checking for C compiler default output file name... " >&6; }
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
$as_echo "$ac_file" >&6; }
ac_exeext=$ac_cv_exeext
 
# Check that the compiler produces executables we can run. If not, either
# the compiler is broken, or we cross compile.
{ $as_echo "$as_me:$LINENO: checking whether the C compiler works" >&5
$as_echo_n "checking whether the C compiler works... " >&6; }
# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
# If not cross compiling, check that we can run a simple program.
if test "$cross_compiling" != yes; then
if { ac_try='./$ac_file'
{ (case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_try") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; }; then
cross_compiling=no
else
if test "$cross_compiling" = maybe; then
cross_compiling=yes
else
{ { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
{ { $as_echo "$as_me:$LINENO: error: cannot run C compiled programs.
If you meant to cross compile, use \`--host'.
See \`config.log' for more details." >&5
$as_echo "$as_me: error: cannot run C compiled programs.
If you meant to cross compile, use \`--host'.
See \`config.log' for more details." >&2;}
{ (exit 1); exit 1; }; }; }
fi
fi
fi
{ $as_echo "$as_me:$LINENO: result: yes" >&5
$as_echo "yes" >&6; }
 
rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
ac_clean_files=$ac_clean_files_save
# Check that the compiler produces executables we can run. If not, either
# the compiler is broken, or we cross compile.
{ $as_echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
$as_echo_n "checking whether we are cross compiling... " >&6; }
{ $as_echo "$as_me:$LINENO: result: $cross_compiling" >&5
$as_echo "$cross_compiling" >&6; }
 
{ $as_echo "$as_me:$LINENO: checking for suffix of executables" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
$as_echo_n "checking for suffix of executables... " >&6; }
if { (ac_try="$ac_link"
if { { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_link") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then :
# If both `conftest.exe' and `conftest' are `present' (well, observable)
# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will
# work properly (i.e., refer to `conftest.exe'), while it won't with
2695,32 → 2950,83
esac
done
else
{ { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
{ { $as_echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
See \`config.log' for more details." >&5
$as_echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
See \`config.log' for more details." >&2;}
{ (exit 1); exit 1; }; }; }
as_fn_error "cannot compute suffix of executables: cannot compile and link
See \`config.log' for more details." "$LINENO" 5; }
fi
 
rm -f conftest$ac_cv_exeext
{ $as_echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
rm -f conftest conftest$ac_cv_exeext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
$as_echo "$ac_cv_exeext" >&6; }
 
rm -f conftest.$ac_ext
EXEEXT=$ac_cv_exeext
ac_exeext=$EXEEXT
{ $as_echo "$as_me:$LINENO: checking for suffix of object files" >&5
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <stdio.h>
int
main ()
{
FILE *f = fopen ("conftest.out", "w");
return ferror (f) || fclose (f) != 0;
 
;
return 0;
}
_ACEOF
ac_clean_files="$ac_clean_files conftest.out"
# Check that the compiler produces executables we can run. If not, either
# the compiler is broken, or we cross compile.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
$as_echo_n "checking whether we are cross compiling... " >&6; }
if test "$cross_compiling" != yes; then
{ { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_link") 2>&5
ac_status=$?
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
if { ac_try='./conftest$ac_cv_exeext'
{ { case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; }; then
cross_compiling=no
else
if test "$cross_compiling" = maybe; then
cross_compiling=yes
else
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
as_fn_error "cannot run C compiled programs.
If you meant to cross compile, use \`--host'.
See \`config.log' for more details." "$LINENO" 5; }
fi
fi
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
$as_echo "$cross_compiling" >&6; }
 
rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
ac_clean_files=$ac_clean_files_save
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
$as_echo_n "checking for suffix of object files... " >&6; }
if test "${ac_cv_objext+set}" = set; then
if test "${ac_cv_objext+set}" = set; then :
$as_echo_n "(cached) " >&6
else
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
int
2732,17 → 3038,17
}
_ACEOF
rm -f conftest.o conftest.obj
if { (ac_try="$ac_compile"
if { { ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_compile") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then :
for ac_file in conftest.o conftest.obj conftest.*; do
test -f "$ac_file" || continue;
case $ac_file in
2755,31 → 3061,23
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
{ { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
{ { $as_echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
See \`config.log' for more details." >&5
$as_echo "$as_me: error: cannot compute suffix of object files: cannot compile
See \`config.log' for more details." >&2;}
{ (exit 1); exit 1; }; }; }
as_fn_error "cannot compute suffix of object files: cannot compile
See \`config.log' for more details." "$LINENO" 5; }
fi
 
rm -f conftest.$ac_cv_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
$as_echo "$ac_cv_objext" >&6; }
OBJEXT=$ac_cv_objext
ac_objext=$OBJEXT
{ $as_echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
if test "${ac_cv_c_compiler_gnu+set}" = set; then
if test "${ac_cv_c_compiler_gnu+set}" = set; then :
$as_echo_n "(cached) " >&6
else
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
int
2793,37 → 3091,16
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
if ac_fn_c_try_compile "$LINENO"; then :
ac_compiler_gnu=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_compiler_gnu=no
ac_compiler_gnu=no
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_cv_c_compiler_gnu=$ac_compiler_gnu
 
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
$as_echo "$ac_cv_c_compiler_gnu" >&6; }
if test $ac_compiler_gnu = yes; then
GCC=yes
2832,9 → 3109,9
fi
ac_test_CFLAGS=${CFLAGS+set}
ac_save_CFLAGS=$CFLAGS
{ $as_echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
$as_echo_n "checking whether $CC accepts -g... " >&6; }
if test "${ac_cv_prog_cc_g+set}" = set; then
if test "${ac_cv_prog_cc_g+set}" = set; then :
$as_echo_n "(cached) " >&6
else
ac_save_c_werror_flag=$ac_c_werror_flag
2841,11 → 3118,7
ac_c_werror_flag=yes
ac_cv_prog_cc_g=no
CFLAGS="-g"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
int
2856,35 → 3129,11
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_prog_cc_g=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
CFLAGS=""
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
CFLAGS=""
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
int
2895,36 → 3144,12
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
:
if ac_fn_c_try_compile "$LINENO"; then :
 
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_c_werror_flag=$ac_save_c_werror_flag
ac_c_werror_flag=$ac_save_c_werror_flag
CFLAGS="-g"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
int
2935,42 → 3160,17
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_prog_cc_g=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
 
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_c_werror_flag=$ac_save_c_werror_flag
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
$as_echo "$ac_cv_prog_cc_g" >&6; }
if test "$ac_test_CFLAGS" = set; then
CFLAGS=$ac_save_CFLAGS
2987,18 → 3187,14
CFLAGS=
fi
fi
{ $as_echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
if test "${ac_cv_prog_cc_c89+set}" = set; then
if test "${ac_cv_prog_cc_c89+set}" = set; then :
$as_echo_n "(cached) " >&6
else
ac_cv_prog_cc_c89=no
ac_save_CC=$CC
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <stdarg.h>
#include <stdio.h>
3055,32 → 3251,9
-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
do
CC="$ac_save_CC $ac_arg"
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_prog_cc_c89=$ac_arg
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
 
fi
 
rm -f core conftest.err conftest.$ac_objext
test "x$ac_cv_prog_cc_c89" != "xno" && break
done
3091,17 → 3264,19
# AC_CACHE_VAL
case "x$ac_cv_prog_cc_c89" in
x)
{ $as_echo "$as_me:$LINENO: result: none needed" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
$as_echo "none needed" >&6; } ;;
xno)
{ $as_echo "$as_me:$LINENO: result: unsupported" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
$as_echo "unsupported" >&6; } ;;
*)
CC="$CC $ac_cv_prog_cc_c89"
{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
esac
if test "x$ac_cv_prog_cc_c89" != xno; then :
 
fi
 
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
3109,9 → 3284,9
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
{ $as_echo "$as_me:$LINENO: checking for a sed that does not truncate output" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
$as_echo_n "checking for a sed that does not truncate output... " >&6; }
if test "${ac_cv_path_SED+set}" = set; then
if test "${ac_cv_path_SED+set}" = set; then :
$as_echo_n "(cached) " >&6
else
ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
3119,7 → 3294,7
ac_script="$ac_script$as_nl$ac_script"
done
echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
$as_unset ac_script || ac_script=
{ ac_script=; unset ac_script;}
if test -z "$SED"; then
ac_path_SED_found=false
# Loop through the user's path and test for each of PROGNAME-LIST
3128,7 → 3303,7
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_prog in sed gsed; do
for ac_prog in sed gsed; do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
{ test -f "$ac_path_SED" && $as_test_x "$ac_path_SED"; } || continue
3148,7 → 3323,7
$as_echo '' >> "conftest.nl"
"$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
ac_count=`expr $ac_count + 1`
as_fn_arith $ac_count + 1 && ac_count=$as_val
if test $ac_count -gt ${ac_path_SED_max-0}; then
# Best one so far, save it but keep looking for a better one
ac_cv_path_SED="$ac_path_SED"
3163,12 → 3338,10
$ac_path_SED_found && break 3
done
done
done
done
IFS=$as_save_IFS
if test -z "$ac_cv_path_SED"; then
{ { $as_echo "$as_me:$LINENO: error: no acceptable sed could be found in \$PATH" >&5
$as_echo "$as_me: error: no acceptable sed could be found in \$PATH" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "no acceptable sed could be found in \$PATH" "$LINENO" 5
fi
else
ac_cv_path_SED=$SED
3175,7 → 3348,7
fi
 
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_path_SED" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
$as_echo "$ac_cv_path_SED" >&6; }
SED="$ac_cv_path_SED"
rm -f conftest.sed
3193,9 → 3366,9
 
 
 
{ $as_echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
if test "${ac_cv_path_GREP+set}" = set; then
if test "${ac_cv_path_GREP+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -z "$GREP"; then
3206,7 → 3379,7
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_prog in grep ggrep; do
for ac_prog in grep ggrep; do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
{ test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
3226,7 → 3399,7
$as_echo 'GREP' >> "conftest.nl"
"$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
ac_count=`expr $ac_count + 1`
as_fn_arith $ac_count + 1 && ac_count=$as_val
if test $ac_count -gt ${ac_path_GREP_max-0}; then
# Best one so far, save it but keep looking for a better one
ac_cv_path_GREP="$ac_path_GREP"
3241,12 → 3414,10
$ac_path_GREP_found && break 3
done
done
done
done
IFS=$as_save_IFS
if test -z "$ac_cv_path_GREP"; then
{ { $as_echo "$as_me:$LINENO: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
$as_echo "$as_me: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
fi
else
ac_cv_path_GREP=$GREP
3253,14 → 3424,14
fi
 
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
$as_echo "$ac_cv_path_GREP" >&6; }
GREP="$ac_cv_path_GREP"
 
 
{ $as_echo "$as_me:$LINENO: checking for egrep" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
$as_echo_n "checking for egrep... " >&6; }
if test "${ac_cv_path_EGREP+set}" = set; then
if test "${ac_cv_path_EGREP+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
3274,7 → 3445,7
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_prog in egrep; do
for ac_prog in egrep; do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
{ test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
3294,7 → 3465,7
$as_echo 'EGREP' >> "conftest.nl"
"$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
ac_count=`expr $ac_count + 1`
as_fn_arith $ac_count + 1 && ac_count=$as_val
if test $ac_count -gt ${ac_path_EGREP_max-0}; then
# Best one so far, save it but keep looking for a better one
ac_cv_path_EGREP="$ac_path_EGREP"
3309,12 → 3480,10
$ac_path_EGREP_found && break 3
done
done
done
done
IFS=$as_save_IFS
if test -z "$ac_cv_path_EGREP"; then
{ { $as_echo "$as_me:$LINENO: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
$as_echo "$as_me: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
fi
else
ac_cv_path_EGREP=$EGREP
3322,14 → 3491,14
 
fi
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
$as_echo "$ac_cv_path_EGREP" >&6; }
EGREP="$ac_cv_path_EGREP"
 
 
{ $as_echo "$as_me:$LINENO: checking for fgrep" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
$as_echo_n "checking for fgrep... " >&6; }
if test "${ac_cv_path_FGREP+set}" = set; then
if test "${ac_cv_path_FGREP+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
3343,7 → 3512,7
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_prog in fgrep; do
for ac_prog in fgrep; do
for ac_exec_ext in '' $ac_executable_extensions; do
ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
{ test -f "$ac_path_FGREP" && $as_test_x "$ac_path_FGREP"; } || continue
3363,7 → 3532,7
$as_echo 'FGREP' >> "conftest.nl"
"$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
ac_count=`expr $ac_count + 1`
as_fn_arith $ac_count + 1 && ac_count=$as_val
if test $ac_count -gt ${ac_path_FGREP_max-0}; then
# Best one so far, save it but keep looking for a better one
ac_cv_path_FGREP="$ac_path_FGREP"
3378,12 → 3547,10
$ac_path_FGREP_found && break 3
done
done
done
done
IFS=$as_save_IFS
if test -z "$ac_cv_path_FGREP"; then
{ { $as_echo "$as_me:$LINENO: error: no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
$as_echo "$as_me: error: no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
fi
else
ac_cv_path_FGREP=$FGREP
3391,7 → 3558,7
 
fi
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_path_FGREP" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
$as_echo "$ac_cv_path_FGREP" >&6; }
FGREP="$ac_cv_path_FGREP"
 
3417,7 → 3584,7
 
 
# Check whether --with-gnu-ld was given.
if test "${with_gnu_ld+set}" = set; then
if test "${with_gnu_ld+set}" = set; then :
withval=$with_gnu_ld; test "$withval" = no || with_gnu_ld=yes
else
with_gnu_ld=no
3426,7 → 3593,7
ac_prog=ld
if test "$GCC" = yes; then
# Check if gcc -print-prog-name=ld gives a path.
{ $as_echo "$as_me:$LINENO: checking for ld used by $CC" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
$as_echo_n "checking for ld used by $CC... " >&6; }
case $host in
*-*-mingw*)
3456,13 → 3623,13
;;
esac
elif test "$with_gnu_ld" = yes; then
{ $as_echo "$as_me:$LINENO: checking for GNU ld" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
$as_echo_n "checking for GNU ld... " >&6; }
else
{ $as_echo "$as_me:$LINENO: checking for non-GNU ld" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
$as_echo_n "checking for non-GNU ld... " >&6; }
fi
if test "${lt_cv_path_LD+set}" = set; then
if test "${lt_cv_path_LD+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -z "$LD"; then
3493,18 → 3660,16
 
LD="$lt_cv_path_LD"
if test -n "$LD"; then
{ $as_echo "$as_me:$LINENO: result: $LD" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
$as_echo "$LD" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
test -z "$LD" && { { $as_echo "$as_me:$LINENO: error: no acceptable ld found in \$PATH" >&5
$as_echo "$as_me: error: no acceptable ld found in \$PATH" >&2;}
{ (exit 1); exit 1; }; }
{ $as_echo "$as_me:$LINENO: checking if the linker ($LD) is GNU ld" >&5
test -z "$LD" && as_fn_error "no acceptable ld found in \$PATH" "$LINENO" 5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; }
if test "${lt_cv_prog_gnu_ld+set}" = set; then
if test "${lt_cv_prog_gnu_ld+set}" = set; then :
$as_echo_n "(cached) " >&6
else
# I'd rather use --version here, but apparently some GNU lds only accept -v.
3517,7 → 3682,7
;;
esac
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
$as_echo "$lt_cv_prog_gnu_ld" >&6; }
with_gnu_ld=$lt_cv_prog_gnu_ld
 
3529,9 → 3694,9
 
 
 
{ $as_echo "$as_me:$LINENO: checking for BSD- or MS-compatible name lister (nm)" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
$as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
if test "${lt_cv_path_NM+set}" = set; then
if test "${lt_cv_path_NM+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$NM"; then
3578,7 → 3743,7
: ${lt_cv_path_NM=no}
fi
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_path_NM" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
$as_echo "$lt_cv_path_NM" >&6; }
if test "$lt_cv_path_NM" != "no"; then
NM="$lt_cv_path_NM"
3589,9 → 3754,9
do
# Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_DUMPBIN+set}" = set; then
if test "${ac_cv_prog_DUMPBIN+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$DUMPBIN"; then
3602,14 → 3767,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
3616,10 → 3781,10
fi
DUMPBIN=$ac_cv_prog_DUMPBIN
if test -n "$DUMPBIN"; then
{ $as_echo "$as_me:$LINENO: result: $DUMPBIN" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
$as_echo "$DUMPBIN" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
3633,9 → 3798,9
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_DUMPBIN+set}" = set; then
if test "${ac_cv_prog_ac_ct_DUMPBIN+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_DUMPBIN"; then
3646,14 → 3811,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
3660,10 → 3825,10
fi
ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
if test -n "$ac_ct_DUMPBIN"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_DUMPBIN" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
$as_echo "$ac_ct_DUMPBIN" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
3676,7 → 3841,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
3696,20 → 3861,20
 
 
 
{ $as_echo "$as_me:$LINENO: checking the name lister ($NM) interface" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
$as_echo_n "checking the name lister ($NM) interface... " >&6; }
if test "${lt_cv_nm_interface+set}" = set; then
if test "${lt_cv_nm_interface+set}" = set; then :
$as_echo_n "(cached) " >&6
else
lt_cv_nm_interface="BSD nm"
echo "int some_variable = 0;" > conftest.$ac_ext
(eval echo "\"\$as_me:3706: $ac_compile\"" >&5)
(eval echo "\"\$as_me:3871: $ac_compile\"" >&5)
(eval "$ac_compile" 2>conftest.err)
cat conftest.err >&5
(eval echo "\"\$as_me:3709: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
(eval echo "\"\$as_me:3874: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
(eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
cat conftest.err >&5
(eval echo "\"\$as_me:3712: output\"" >&5)
(eval echo "\"\$as_me:3877: output\"" >&5)
cat conftest.out >&5
if $GREP 'External.*some_variable' conftest.out > /dev/null; then
lt_cv_nm_interface="MS dumpbin"
3716,24 → 3881,24
fi
rm -f conftest*
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_nm_interface" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
$as_echo "$lt_cv_nm_interface" >&6; }
 
{ $as_echo "$as_me:$LINENO: checking whether ln -s works" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
$as_echo_n "checking whether ln -s works... " >&6; }
LN_S=$as_ln_s
if test "$LN_S" = "ln -s"; then
{ $as_echo "$as_me:$LINENO: result: yes" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no, using $LN_S" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
$as_echo "no, using $LN_S" >&6; }
fi
 
# find the maximum length of command line arguments
{ $as_echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
$as_echo_n "checking the maximum length of command line arguments... " >&6; }
if test "${lt_cv_sys_max_cmd_len+set}" = set; then
if test "${lt_cv_sys_max_cmd_len+set}" = set; then :
$as_echo_n "(cached) " >&6
else
i=0
3851,10 → 4016,10
fi
 
if test -n $lt_cv_sys_max_cmd_len ; then
{ $as_echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
$as_echo "$lt_cv_sys_max_cmd_len" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: none" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
$as_echo "none" >&6; }
fi
max_cmd_len=$lt_cv_sys_max_cmd_len
3868,7 → 4033,7
: ${MV="mv -f"}
: ${RM="rm -f"}
 
{ $as_echo "$as_me:$LINENO: checking whether the shell understands some XSI constructs" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands some XSI constructs" >&5
$as_echo_n "checking whether the shell understands some XSI constructs... " >&6; }
# Try some XSI features
xsi_shell=no
3878,17 → 4043,17
&& eval 'test $(( 1 + 1 )) -eq 2 \
&& test "${#_lt_dummy}" -eq 5' ) >/dev/null 2>&1 \
&& xsi_shell=yes
{ $as_echo "$as_me:$LINENO: result: $xsi_shell" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $xsi_shell" >&5
$as_echo "$xsi_shell" >&6; }
 
 
{ $as_echo "$as_me:$LINENO: checking whether the shell understands \"+=\"" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the shell understands \"+=\"" >&5
$as_echo_n "checking whether the shell understands \"+=\"... " >&6; }
lt_shell_append=no
( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \
>/dev/null 2>&1 \
&& lt_shell_append=yes
{ $as_echo "$as_me:$LINENO: result: $lt_shell_append" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_shell_append" >&5
$as_echo "$lt_shell_append" >&6; }
 
 
3923,14 → 4088,14
 
 
 
{ $as_echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
$as_echo_n "checking for $LD option to reload object files... " >&6; }
if test "${lt_cv_ld_reload_flag+set}" = set; then
if test "${lt_cv_ld_reload_flag+set}" = set; then :
$as_echo_n "(cached) " >&6
else
lt_cv_ld_reload_flag='-r'
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
$as_echo "$lt_cv_ld_reload_flag" >&6; }
reload_flag=$lt_cv_ld_reload_flag
case $reload_flag in
3959,9 → 4124,9
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
set dummy ${ac_tool_prefix}objdump; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_OBJDUMP+set}" = set; then
if test "${ac_cv_prog_OBJDUMP+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$OBJDUMP"; then
3972,14 → 4137,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
3986,10 → 4151,10
fi
OBJDUMP=$ac_cv_prog_OBJDUMP
if test -n "$OBJDUMP"; then
{ $as_echo "$as_me:$LINENO: result: $OBJDUMP" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
$as_echo "$OBJDUMP" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
3999,9 → 4164,9
ac_ct_OBJDUMP=$OBJDUMP
# Extract the first word of "objdump", so it can be a program name with args.
set dummy objdump; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_OBJDUMP+set}" = set; then
if test "${ac_cv_prog_ac_ct_OBJDUMP+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_OBJDUMP"; then
4012,14 → 4177,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_OBJDUMP="objdump"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
4026,10 → 4191,10
fi
ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
if test -n "$ac_ct_OBJDUMP"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_OBJDUMP" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
$as_echo "$ac_ct_OBJDUMP" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
4038,7 → 4203,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
4058,9 → 4223,9
 
 
 
{ $as_echo "$as_me:$LINENO: checking how to recognize dependent libraries" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
$as_echo_n "checking how to recognize dependent libraries... " >&6; }
if test "${lt_cv_deplibs_check_method+set}" = set; then
if test "${lt_cv_deplibs_check_method+set}" = set; then :
$as_echo_n "(cached) " >&6
else
lt_cv_file_magic_cmd='$MAGIC_CMD'
4254,7 → 4419,7
esac
 
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5
$as_echo "$lt_cv_deplibs_check_method" >&6; }
file_magic_cmd=$lt_cv_file_magic_cmd
deplibs_check_method=$lt_cv_deplibs_check_method
4274,9 → 4439,9
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
set dummy ${ac_tool_prefix}ar; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_AR+set}" = set; then
if test "${ac_cv_prog_AR+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$AR"; then
4287,14 → 4452,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_AR="${ac_tool_prefix}ar"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
4301,10 → 4466,10
fi
AR=$ac_cv_prog_AR
if test -n "$AR"; then
{ $as_echo "$as_me:$LINENO: result: $AR" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
$as_echo "$AR" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
4314,9 → 4479,9
ac_ct_AR=$AR
# Extract the first word of "ar", so it can be a program name with args.
set dummy ar; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
if test "${ac_cv_prog_ac_ct_AR+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_AR"; then
4327,14 → 4492,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_AR="ar"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
4341,10 → 4506,10
fi
ac_ct_AR=$ac_cv_prog_ac_ct_AR
if test -n "$ac_ct_AR"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
$as_echo "$ac_ct_AR" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
4353,7 → 4518,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
4379,9 → 4544,9
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
set dummy ${ac_tool_prefix}strip; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_STRIP+set}" = set; then
if test "${ac_cv_prog_STRIP+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$STRIP"; then
4392,14 → 4557,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_STRIP="${ac_tool_prefix}strip"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
4406,10 → 4571,10
fi
STRIP=$ac_cv_prog_STRIP
if test -n "$STRIP"; then
{ $as_echo "$as_me:$LINENO: result: $STRIP" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
$as_echo "$STRIP" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
4419,9 → 4584,9
ac_ct_STRIP=$STRIP
# Extract the first word of "strip", so it can be a program name with args.
set dummy strip; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_STRIP"; then
4432,14 → 4597,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_STRIP="strip"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
4446,10 → 4611,10
fi
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
if test -n "$ac_ct_STRIP"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
$as_echo "$ac_ct_STRIP" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
4458,7 → 4623,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
4478,9 → 4643,9
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_RANLIB+set}" = set; then
if test "${ac_cv_prog_RANLIB+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$RANLIB"; then
4491,14 → 4656,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
4505,10 → 4670,10
fi
RANLIB=$ac_cv_prog_RANLIB
if test -n "$RANLIB"; then
{ $as_echo "$as_me:$LINENO: result: $RANLIB" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
$as_echo "$RANLIB" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
4518,9 → 4683,9
ac_ct_RANLIB=$RANLIB
# Extract the first word of "ranlib", so it can be a program name with args.
set dummy ranlib; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_RANLIB"; then
4531,14 → 4696,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_RANLIB="ranlib"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
4545,10 → 4710,10
fi
ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
if test -n "$ac_ct_RANLIB"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
$as_echo "$ac_ct_RANLIB" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
4557,7 → 4722,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
4635,9 → 4800,9
 
 
# Check for command to grab the raw symbol name followed by C symbol from nm.
{ $as_echo "$as_me:$LINENO: checking command to parse $NM output from $compiler object" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5
$as_echo_n "checking command to parse $NM output from $compiler object... " >&6; }
if test "${lt_cv_sys_global_symbol_pipe+set}" = set; then
if test "${lt_cv_sys_global_symbol_pipe+set}" = set; then :
$as_echo_n "(cached) " >&6
else
 
4753,18 → 4918,18
int main(){nm_test_var='a';nm_test_func();return(0);}
_LT_EOF
 
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
# Now try to grab the symbols.
nlist=conftest.nm
if { (eval echo "$as_me:$LINENO: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\"") >&5
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\""; } >&5
(eval $NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && test -s "$nlist"; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && test -s "$nlist"; then
# Try sorting and uniquifying the output.
if sort "$nlist" | uniq > "$nlist"T; then
mv -f "$nlist"T "$nlist"
4817,11 → 4982,11
lt_save_CFLAGS="$CFLAGS"
LIBS="conftstm.$ac_objext"
CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
(eval $ac_link) 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && test -s conftest${ac_exeext}; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && test -s conftest${ac_exeext}; then
pipe_works=yes
fi
LIBS="$lt_save_LIBS"
4855,10 → 5020,10
lt_cv_sys_global_symbol_to_cdecl=
fi
if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
{ $as_echo "$as_me:$LINENO: result: failed" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
$as_echo "failed" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: ok" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
$as_echo "ok" >&6; }
fi
 
4885,7 → 5050,7
 
 
# Check whether --enable-libtool-lock was given.
if test "${enable_libtool_lock+set}" = set; then
if test "${enable_libtool_lock+set}" = set; then :
enableval=$enable_libtool_lock;
fi
 
4897,11 → 5062,11
ia64-*-hpux*)
# Find out which ABI we are using.
echo 'int i;' > conftest.$ac_ext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
case `/usr/bin/file conftest.$ac_objext` in
*ELF-32*)
HPUX_IA64_MODE="32"
4915,12 → 5080,12
;;
*-*-irix6*)
# Find out which ABI we are using.
echo '#line 4918 "configure"' > conftest.$ac_ext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
echo '#line 5083 "configure"' > conftest.$ac_ext
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
if test "$lt_cv_prog_gnu_ld" = yes; then
case `/usr/bin/file conftest.$ac_objext` in
*32-bit*)
4954,11 → 5119,11
s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
# Find out which ABI we are using.
echo 'int i;' > conftest.$ac_ext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
case `/usr/bin/file conftest.o` in
*32-bit*)
case $host in
5007,9 → 5172,9
# On SCO OpenServer 5, we need -belf to get full-featured binaries.
SAVE_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -belf"
{ $as_echo "$as_me:$LINENO: checking whether the C compiler needs -belf" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
$as_echo_n "checking whether the C compiler needs -belf... " >&6; }
if test "${lt_cv_cc_needs_belf+set}" = set; then
if test "${lt_cv_cc_needs_belf+set}" = set; then :
$as_echo_n "(cached) " >&6
else
ac_ext=c
5018,11 → 5183,7
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
int
5033,38 → 5194,13
return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
if ac_fn_c_try_link "$LINENO"; then :
lt_cv_cc_needs_belf=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
lt_cv_cc_needs_belf=no
lt_cv_cc_needs_belf=no
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5072,7 → 5208,7
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_cc_needs_belf" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
$as_echo "$lt_cv_cc_needs_belf" >&6; }
if test x"$lt_cv_cc_needs_belf" != x"yes"; then
# this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
5082,11 → 5218,11
sparc*-*solaris*)
# Find out which ABI we are using.
echo 'int i;' > conftest.$ac_ext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
case `/usr/bin/file conftest.o` in
*64-bit*)
case $lt_cv_prog_gnu_ld in
5112,9 → 5248,9
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args.
set dummy ${ac_tool_prefix}dsymutil; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_DSYMUTIL+set}" = set; then
if test "${ac_cv_prog_DSYMUTIL+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$DSYMUTIL"; then
5125,14 → 5261,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
5139,10 → 5275,10
fi
DSYMUTIL=$ac_cv_prog_DSYMUTIL
if test -n "$DSYMUTIL"; then
{ $as_echo "$as_me:$LINENO: result: $DSYMUTIL" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
$as_echo "$DSYMUTIL" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
5152,9 → 5288,9
ac_ct_DSYMUTIL=$DSYMUTIL
# Extract the first word of "dsymutil", so it can be a program name with args.
set dummy dsymutil; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_DSYMUTIL+set}" = set; then
if test "${ac_cv_prog_ac_ct_DSYMUTIL+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_DSYMUTIL"; then
5165,14 → 5301,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_DSYMUTIL="dsymutil"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
5179,10 → 5315,10
fi
ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
if test -n "$ac_ct_DSYMUTIL"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_DSYMUTIL" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5
$as_echo "$ac_ct_DSYMUTIL" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
5191,7 → 5327,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
5204,9 → 5340,9
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args.
set dummy ${ac_tool_prefix}nmedit; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_NMEDIT+set}" = set; then
if test "${ac_cv_prog_NMEDIT+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$NMEDIT"; then
5217,14 → 5353,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
5231,10 → 5367,10
fi
NMEDIT=$ac_cv_prog_NMEDIT
if test -n "$NMEDIT"; then
{ $as_echo "$as_me:$LINENO: result: $NMEDIT" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5
$as_echo "$NMEDIT" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
5244,9 → 5380,9
ac_ct_NMEDIT=$NMEDIT
# Extract the first word of "nmedit", so it can be a program name with args.
set dummy nmedit; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_NMEDIT+set}" = set; then
if test "${ac_cv_prog_ac_ct_NMEDIT+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_NMEDIT"; then
5257,14 → 5393,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_NMEDIT="nmedit"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
5271,10 → 5407,10
fi
ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
if test -n "$ac_ct_NMEDIT"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_NMEDIT" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5
$as_echo "$ac_ct_NMEDIT" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
5283,7 → 5419,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
5296,9 → 5432,9
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args.
set dummy ${ac_tool_prefix}lipo; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_LIPO+set}" = set; then
if test "${ac_cv_prog_LIPO+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$LIPO"; then
5309,14 → 5445,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_LIPO="${ac_tool_prefix}lipo"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
5323,10 → 5459,10
fi
LIPO=$ac_cv_prog_LIPO
if test -n "$LIPO"; then
{ $as_echo "$as_me:$LINENO: result: $LIPO" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
$as_echo "$LIPO" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
5336,9 → 5472,9
ac_ct_LIPO=$LIPO
# Extract the first word of "lipo", so it can be a program name with args.
set dummy lipo; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_LIPO+set}" = set; then
if test "${ac_cv_prog_ac_ct_LIPO+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_LIPO"; then
5349,14 → 5485,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_LIPO="lipo"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
5363,10 → 5499,10
fi
ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO
if test -n "$ac_ct_LIPO"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_LIPO" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5
$as_echo "$ac_ct_LIPO" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
5375,7 → 5511,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
5388,9 → 5524,9
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args.
set dummy ${ac_tool_prefix}otool; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_OTOOL+set}" = set; then
if test "${ac_cv_prog_OTOOL+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$OTOOL"; then
5401,14 → 5537,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_OTOOL="${ac_tool_prefix}otool"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
5415,10 → 5551,10
fi
OTOOL=$ac_cv_prog_OTOOL
if test -n "$OTOOL"; then
{ $as_echo "$as_me:$LINENO: result: $OTOOL" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
$as_echo "$OTOOL" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
5428,9 → 5564,9
ac_ct_OTOOL=$OTOOL
# Extract the first word of "otool", so it can be a program name with args.
set dummy otool; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_OTOOL+set}" = set; then
if test "${ac_cv_prog_ac_ct_OTOOL+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_OTOOL"; then
5441,14 → 5577,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_OTOOL="otool"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
5455,10 → 5591,10
fi
ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL
if test -n "$ac_ct_OTOOL"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_OTOOL" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5
$as_echo "$ac_ct_OTOOL" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
5467,7 → 5603,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
5480,9 → 5616,9
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args.
set dummy ${ac_tool_prefix}otool64; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_OTOOL64+set}" = set; then
if test "${ac_cv_prog_OTOOL64+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$OTOOL64"; then
5493,14 → 5629,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
5507,10 → 5643,10
fi
OTOOL64=$ac_cv_prog_OTOOL64
if test -n "$OTOOL64"; then
{ $as_echo "$as_me:$LINENO: result: $OTOOL64" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5
$as_echo "$OTOOL64" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
5520,9 → 5656,9
ac_ct_OTOOL64=$OTOOL64
# Extract the first word of "otool64", so it can be a program name with args.
set dummy otool64; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_OTOOL64+set}" = set; then
if test "${ac_cv_prog_ac_ct_OTOOL64+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_OTOOL64"; then
5533,14 → 5669,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_OTOOL64="otool64"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
5547,10 → 5683,10
fi
ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64
if test -n "$ac_ct_OTOOL64"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_OTOOL64" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5
$as_echo "$ac_ct_OTOOL64" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
5559,7 → 5695,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
5595,9 → 5731,9
 
 
 
{ $as_echo "$as_me:$LINENO: checking for -single_module linker flag" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5
$as_echo_n "checking for -single_module linker flag... " >&6; }
if test "${lt_cv_apple_cc_single_mod+set}" = set; then
if test "${lt_cv_apple_cc_single_mod+set}" = set; then :
$as_echo_n "(cached) " >&6
else
lt_cv_apple_cc_single_mod=no
5622,11 → 5758,11
rm -f conftest.*
fi
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_apple_cc_single_mod" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5
$as_echo "$lt_cv_apple_cc_single_mod" >&6; }
{ $as_echo "$as_me:$LINENO: checking for -exported_symbols_list linker flag" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5
$as_echo_n "checking for -exported_symbols_list linker flag... " >&6; }
if test "${lt_cv_ld_exported_symbols_list+set}" = set; then
if test "${lt_cv_ld_exported_symbols_list+set}" = set; then :
$as_echo_n "(cached) " >&6
else
lt_cv_ld_exported_symbols_list=no
5633,11 → 5769,7
save_LDFLAGS=$LDFLAGS
echo "_main" > conftest.sym
LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
int
5648,42 → 5780,17
return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
if ac_fn_c_try_link "$LINENO"; then :
lt_cv_ld_exported_symbols_list=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
lt_cv_ld_exported_symbols_list=no
lt_cv_ld_exported_symbols_list=no
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
LDFLAGS="$save_LDFLAGS"
 
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_ld_exported_symbols_list" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
$as_echo "$lt_cv_ld_exported_symbols_list" >&6; }
case $host_os in
rhapsody* | darwin1.[012])
5725,7 → 5832,7
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
{ $as_echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
$as_echo_n "checking how to run the C preprocessor... " >&6; }
# On Suns, sometimes $CPP names a directory.
if test -n "$CPP" && test -d "$CPP"; then
5732,7 → 5839,7
CPP=
fi
if test -z "$CPP"; then
if test "${ac_cv_prog_CPP+set}" = set; then
if test "${ac_cv_prog_CPP+set}" = set; then :
$as_echo_n "(cached) " >&6
else
# Double quotes because CPP needs to be expanded
5747,11 → 5854,7
# <limits.h> exists even on freestanding compilers.
# On the NeXT, cc -E runs the code through the compiler's parser,
# not just through cpp. "Syntax error" is here to catch this case.
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#ifdef __STDC__
# include <limits.h>
5760,78 → 5863,34
#endif
Syntax error
_ACEOF
if { (ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } >/dev/null && {
test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
test ! -s conftest.err
}; then
:
if ac_fn_c_try_cpp "$LINENO"; then :
 
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
# Broken: fails on valid input.
continue
fi
 
rm -f conftest.err conftest.$ac_ext
 
# OK, works on sane cases. Now check whether nonexistent headers
# can be detected and how.
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <ac_nonexistent.h>
_ACEOF
if { (ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } >/dev/null && {
test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
test ! -s conftest.err
}; then
if ac_fn_c_try_cpp "$LINENO"; then :
# Broken: success on invalid input.
continue
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
# Passes both tests.
ac_preproc_ok=:
break
fi
 
rm -f conftest.err conftest.$ac_ext
 
done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.err conftest.$ac_ext
if $ac_preproc_ok; then
if $ac_preproc_ok; then :
break
fi
 
5843,7 → 5902,7
else
ac_cv_prog_CPP=$CPP
fi
{ $as_echo "$as_me:$LINENO: result: $CPP" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
$as_echo "$CPP" >&6; }
ac_preproc_ok=false
for ac_c_preproc_warn_flag in '' yes
5854,11 → 5913,7
# <limits.h> exists even on freestanding compilers.
# On the NeXT, cc -E runs the code through the compiler's parser,
# not just through cpp. "Syntax error" is here to catch this case.
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#ifdef __STDC__
# include <limits.h>
5867,87 → 5922,40
#endif
Syntax error
_ACEOF
if { (ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } >/dev/null && {
test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
test ! -s conftest.err
}; then
:
if ac_fn_c_try_cpp "$LINENO"; then :
 
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
# Broken: fails on valid input.
continue
fi
 
rm -f conftest.err conftest.$ac_ext
 
# OK, works on sane cases. Now check whether nonexistent headers
# can be detected and how.
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <ac_nonexistent.h>
_ACEOF
if { (ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } >/dev/null && {
test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
test ! -s conftest.err
}; then
if ac_fn_c_try_cpp "$LINENO"; then :
# Broken: success on invalid input.
continue
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
# Passes both tests.
ac_preproc_ok=:
break
fi
 
rm -f conftest.err conftest.$ac_ext
 
done
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
rm -f conftest.err conftest.$ac_ext
if $ac_preproc_ok; then
:
if $ac_preproc_ok; then :
 
else
{ { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
{ { $as_echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
See \`config.log' for more details." >&5
$as_echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
See \`config.log' for more details." >&2;}
{ (exit 1); exit 1; }; }; }
as_fn_error "C preprocessor \"$CPP\" fails sanity check
See \`config.log' for more details." "$LINENO" 5; }
fi
 
ac_ext=c
5957,16 → 5965,12
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
 
{ $as_echo "$as_me:$LINENO: checking for ANSI C header files" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
$as_echo_n "checking for ANSI C header files... " >&6; }
if test "${ac_cv_header_stdc+set}" = set; then
if test "${ac_cv_header_stdc+set}" = set; then :
$as_echo_n "(cached) " >&6
else
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <stdlib.h>
#include <stdarg.h>
5981,48 → 5985,23
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_header_stdc=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_header_stdc=no
ac_cv_header_stdc=no
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
if test $ac_cv_header_stdc = yes; then
# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <string.h>
 
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
$EGREP "memchr" >/dev/null 2>&1; then
:
$EGREP "memchr" >/dev/null 2>&1; then :
 
else
ac_cv_header_stdc=no
fi
6032,18 → 6011,14
 
if test $ac_cv_header_stdc = yes; then
# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <stdlib.h>
 
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
$EGREP "free" >/dev/null 2>&1; then
:
$EGREP "free" >/dev/null 2>&1; then :
 
else
ac_cv_header_stdc=no
fi
6053,14 → 6028,10
 
if test $ac_cv_header_stdc = yes; then
# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
if test "$cross_compiling" = yes; then
if test "$cross_compiling" = yes; then :
:
else
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <ctype.h>
#include <stdlib.h>
6087,118 → 6058,34
return 0;
}
_ACEOF
rm -f conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
{ (case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_try") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; }; then
:
if ac_fn_c_try_run "$LINENO"; then :
 
else
$as_echo "$as_me: program exited with status $ac_status" >&5
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
( exit $ac_status )
ac_cv_header_stdc=no
ac_cv_header_stdc=no
fi
rm -rf conftest.dSYM
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
 
 
fi
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
$as_echo "$ac_cv_header_stdc" >&6; }
if test $ac_cv_header_stdc = yes; then
 
cat >>confdefs.h <<\_ACEOF
#define STDC_HEADERS 1
_ACEOF
$as_echo "#define STDC_HEADERS 1" >>confdefs.h
 
fi
 
# On IRIX 5.3, sys/types and inttypes.h are conflicting.
 
 
 
 
 
 
 
 
 
for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
inttypes.h stdint.h unistd.h
do
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
$as_echo_n "checking for $ac_header... " >&6; }
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
$as_echo_n "(cached) " >&6
else
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
$ac_includes_default
 
#include <$ac_header>
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
eval "$as_ac_Header=yes"
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
eval "$as_ac_Header=no"
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
ac_res=`eval 'as_val=${'$as_ac_Header'}
$as_echo "$as_val"'`
{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
as_val=`eval 'as_val=${'$as_ac_Header'}
$as_echo "$as_val"'`
if test "x$as_val" = x""yes; then
do :
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
"
eval as_val=\$$as_ac_Header
if test "x$as_val" = x""yes; then :
cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
_ACEOF
6208,62 → 6095,13
done
 
 
 
for ac_header in dlfcn.h
do
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
$as_echo_n "checking for $ac_header... " >&6; }
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
$as_echo_n "(cached) " >&6
else
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
$ac_includes_default
 
#include <$ac_header>
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
eval "$as_ac_Header=yes"
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
eval "$as_ac_Header=no"
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
ac_res=`eval 'as_val=${'$as_ac_Header'}
$as_echo "$as_val"'`
{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
as_val=`eval 'as_val=${'$as_ac_Header'}
$as_echo "$as_val"'`
if test "x$as_val" = x""yes; then
do :
ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default
"
if test "x$ac_cv_header_dlfcn_h" = x""yes; then :
cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
#define HAVE_DLFCN_H 1
_ACEOF
 
fi
6283,7 → 6121,7
 
 
# Check whether --enable-shared was given.
if test "${enable_shared+set}" = set; then
if test "${enable_shared+set}" = set; then :
enableval=$enable_shared; p=${PACKAGE-default}
case $enableval in
yes) enable_shared=yes ;;
6314,7 → 6152,7
 
 
# Check whether --enable-static was given.
if test "${enable_static+set}" = set; then
if test "${enable_static+set}" = set; then :
enableval=$enable_static; p=${PACKAGE-default}
case $enableval in
yes) enable_static=yes ;;
6346,7 → 6184,7
 
 
# Check whether --with-pic was given.
if test "${with_pic+set}" = set; then
if test "${with_pic+set}" = set; then :
withval=$with_pic; pic_mode="$withval"
else
pic_mode=default
6362,7 → 6200,7
 
 
# Check whether --enable-fast-install was given.
if test "${enable_fast_install+set}" = set; then
if test "${enable_fast_install+set}" = set; then :
enableval=$enable_fast_install; p=${PACKAGE-default}
case $enableval in
yes) enable_fast_install=yes ;;
6443,9 → 6281,9
setopt NO_GLOB_SUBST
fi
 
{ $as_echo "$as_me:$LINENO: checking for objdir" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5
$as_echo_n "checking for objdir... " >&6; }
if test "${lt_cv_objdir+set}" = set; then
if test "${lt_cv_objdir+set}" = set; then :
$as_echo_n "(cached) " >&6
else
rm -f .libs 2>/dev/null
6458,7 → 6296,7
fi
rmdir .libs 2>/dev/null
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_objdir" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5
$as_echo "$lt_cv_objdir" >&6; }
objdir=$lt_cv_objdir
 
6551,9 → 6389,9
case $deplibs_check_method in
file_magic*)
if test "$file_magic_cmd" = '$MAGIC_CMD'; then
{ $as_echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5
$as_echo_n "checking for ${ac_tool_prefix}file... " >&6; }
if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
if test "${lt_cv_path_MAGIC_CMD+set}" = set; then :
$as_echo_n "(cached) " >&6
else
case $MAGIC_CMD in
6604,10 → 6442,10
 
MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
if test -n "$MAGIC_CMD"; then
{ $as_echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
$as_echo "$MAGIC_CMD" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
6617,9 → 6455,9
 
if test -z "$lt_cv_path_MAGIC_CMD"; then
if test -n "$ac_tool_prefix"; then
{ $as_echo "$as_me:$LINENO: checking for file" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5
$as_echo_n "checking for file... " >&6; }
if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
if test "${lt_cv_path_MAGIC_CMD+set}" = set; then :
$as_echo_n "(cached) " >&6
else
case $MAGIC_CMD in
6670,10 → 6508,10
 
MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
if test -n "$MAGIC_CMD"; then
{ $as_echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
$as_echo "$MAGIC_CMD" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
6754,9 → 6592,9
if test "$GCC" = yes; then
lt_prog_compiler_no_builtin_flag=' -fno-builtin'
 
{ $as_echo "$as_me:$LINENO: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; }
if test "${lt_cv_prog_compiler_rtti_exceptions+set}" = set; then
if test "${lt_cv_prog_compiler_rtti_exceptions+set}" = set; then :
$as_echo_n "(cached) " >&6
else
lt_cv_prog_compiler_rtti_exceptions=no
6772,11 → 6610,11
-e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
-e 's:$: $lt_compiler_flag:'`
(eval echo "\"\$as_me:6775: $lt_compile\"" >&5)
(eval echo "\"\$as_me:6613: $lt_compile\"" >&5)
(eval "$lt_compile" 2>conftest.err)
ac_status=$?
cat conftest.err >&5
echo "$as_me:6779: \$? = $ac_status" >&5
echo "$as_me:6617: \$? = $ac_status" >&5
if (exit $ac_status) && test -s "$ac_outfile"; then
# The compiler can only warn and ignore the option if not recognized
# So say no if there are warnings other than the usual output.
6789,7 → 6627,7
$RM conftest*
 
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; }
 
if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then
6809,7 → 6647,7
lt_prog_compiler_pic=
lt_prog_compiler_static=
 
{ $as_echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
$as_echo_n "checking for $compiler option to produce PIC... " >&6; }
 
if test "$GCC" = yes; then
7081,7 → 6919,7
lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
;;
esac
{ $as_echo "$as_me:$LINENO: result: $lt_prog_compiler_pic" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_prog_compiler_pic" >&5
$as_echo "$lt_prog_compiler_pic" >&6; }
 
 
7093,9 → 6931,9
# Check to make sure the PIC flag actually works.
#
if test -n "$lt_prog_compiler_pic"; then
{ $as_echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; }
if test "${lt_cv_prog_compiler_pic_works+set}" = set; then
if test "${lt_cv_prog_compiler_pic_works+set}" = set; then :
$as_echo_n "(cached) " >&6
else
lt_cv_prog_compiler_pic_works=no
7111,11 → 6949,11
-e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
-e 's:$: $lt_compiler_flag:'`
(eval echo "\"\$as_me:7114: $lt_compile\"" >&5)
(eval echo "\"\$as_me:6952: $lt_compile\"" >&5)
(eval "$lt_compile" 2>conftest.err)
ac_status=$?
cat conftest.err >&5
echo "$as_me:7118: \$? = $ac_status" >&5
echo "$as_me:6956: \$? = $ac_status" >&5
if (exit $ac_status) && test -s "$ac_outfile"; then
# The compiler can only warn and ignore the option if not recognized
# So say no if there are warnings other than the usual output.
7128,7 → 6966,7
$RM conftest*
 
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_pic_works" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
$as_echo "$lt_cv_prog_compiler_pic_works" >&6; }
 
if test x"$lt_cv_prog_compiler_pic_works" = xyes; then
7152,9 → 6990,9
# Check to make sure the static flag actually works.
#
wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
{ $as_echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
if test "${lt_cv_prog_compiler_static_works+set}" = set; then
if test "${lt_cv_prog_compiler_static_works+set}" = set; then :
$as_echo_n "(cached) " >&6
else
lt_cv_prog_compiler_static_works=no
7180,7 → 7018,7
LDFLAGS="$save_LDFLAGS"
 
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_static_works" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
$as_echo "$lt_cv_prog_compiler_static_works" >&6; }
 
if test x"$lt_cv_prog_compiler_static_works" = xyes; then
7195,9 → 7033,9
 
 
 
{ $as_echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
if test "${lt_cv_prog_compiler_c_o+set}" = set; then
if test "${lt_cv_prog_compiler_c_o+set}" = set; then :
$as_echo_n "(cached) " >&6
else
lt_cv_prog_compiler_c_o=no
7216,11 → 7054,11
-e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
-e 's:$: $lt_compiler_flag:'`
(eval echo "\"\$as_me:7219: $lt_compile\"" >&5)
(eval echo "\"\$as_me:7057: $lt_compile\"" >&5)
(eval "$lt_compile" 2>out/conftest.err)
ac_status=$?
cat out/conftest.err >&5
echo "$as_me:7223: \$? = $ac_status" >&5
echo "$as_me:7061: \$? = $ac_status" >&5
if (exit $ac_status) && test -s out/conftest2.$ac_objext
then
# The compiler can only warn and ignore the option if not recognized
7242,7 → 7080,7
$RM conftest*
 
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
$as_echo "$lt_cv_prog_compiler_c_o" >&6; }
 
 
7250,9 → 7088,9
 
 
 
{ $as_echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
if test "${lt_cv_prog_compiler_c_o+set}" = set; then
if test "${lt_cv_prog_compiler_c_o+set}" = set; then :
$as_echo_n "(cached) " >&6
else
lt_cv_prog_compiler_c_o=no
7271,11 → 7109,11
-e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
-e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
-e 's:$: $lt_compiler_flag:'`
(eval echo "\"\$as_me:7274: $lt_compile\"" >&5)
(eval echo "\"\$as_me:7112: $lt_compile\"" >&5)
(eval "$lt_compile" 2>out/conftest.err)
ac_status=$?
cat out/conftest.err >&5
echo "$as_me:7278: \$? = $ac_status" >&5
echo "$as_me:7116: \$? = $ac_status" >&5
if (exit $ac_status) && test -s out/conftest2.$ac_objext
then
# The compiler can only warn and ignore the option if not recognized
7297,7 → 7135,7
$RM conftest*
 
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
$as_echo "$lt_cv_prog_compiler_c_o" >&6; }
 
 
7306,7 → 7144,7
hard_links="nottested"
if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then
# do not overwrite the value of need_locks provided by the user
{ $as_echo "$as_me:$LINENO: checking if we can lock with hard links" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
$as_echo_n "checking if we can lock with hard links... " >&6; }
hard_links=yes
$RM conftest*
7314,10 → 7152,10
touch conftest.a
ln conftest.a conftest.b 2>&5 || hard_links=no
ln conftest.a conftest.b 2>/dev/null && hard_links=no
{ $as_echo "$as_me:$LINENO: result: $hard_links" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
$as_echo "$hard_links" >&6; }
if test "$hard_links" = no; then
{ $as_echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
$as_echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
need_locks=warn
fi
7330,7 → 7168,7
 
 
 
{ $as_echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
 
runpath_var=
7776,11 → 7614,7
allow_undefined_flag='-berok'
# Determine the default libpath from the value encoded in an
# empty executable.
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
int
7791,27 → 7625,7
return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
if ac_fn_c_try_link "$LINENO"; then :
 
lt_aix_libpath_sed='
/Import File Strings/,/^$/ {
7825,16 → 7639,9
if test -z "$aix_libpath"; then
aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
fi
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
 
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
 
hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
7847,11 → 7654,7
else
# Determine the default libpath from the value encoded in an
# empty executable.
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
int
7862,27 → 7665,7
return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
if ac_fn_c_try_link "$LINENO"; then :
 
lt_aix_libpath_sed='
/Import File Strings/,/^$/ {
7896,16 → 7679,9
if test -z "$aix_libpath"; then
aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
fi
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
 
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
 
hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
8117,42 → 7893,16
# implicitly export all symbols.
save_LDFLAGS="$LDFLAGS"
LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"
cat >conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int foo(void) {}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
if ac_fn_c_try_link "$LINENO"; then :
archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
 
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
 
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
LDFLAGS="$save_LDFLAGS"
else
archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
8408,7 → 8158,7
fi
fi
 
{ $as_echo "$as_me:$LINENO: result: $ld_shlibs" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5
$as_echo "$ld_shlibs" >&6; }
test "$ld_shlibs" = no && can_build_shared=no
 
8445,16 → 8195,16
# Test whether the compiler implicitly links with -lc since on some
# systems, -lgcc has to come before -lc. If gcc already passes -lc
# to ld, don't add -lc before -lgcc.
{ $as_echo "$as_me:$LINENO: checking whether -lc should be explicitly linked in" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; }
$RM conftest*
echo "$lt_simple_compile_test_code" > conftest.$ac_ext
 
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
(eval $ac_compile) 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } 2>conftest.err; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } 2>conftest.err; then
soname=conftest
lib=conftest
libobjs=conftest.$ac_objext
8468,11 → 8218,11
libname=conftest
lt_save_allow_undefined_flag=$allow_undefined_flag
allow_undefined_flag=
if { (eval echo "$as_me:$LINENO: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\"") >&5
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
(eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }
then
archive_cmds_need_lc=no
else
8483,7 → 8233,7
cat conftest.err 1>&5
fi
$RM conftest*
{ $as_echo "$as_me:$LINENO: result: $archive_cmds_need_lc" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $archive_cmds_need_lc" >&5
$as_echo "$archive_cmds_need_lc" >&6; }
;;
esac
8647,7 → 8397,7
 
 
 
{ $as_echo "$as_me:$LINENO: checking dynamic linker characteristics" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
$as_echo_n "checking dynamic linker characteristics... " >&6; }
 
if test "$GCC" = yes; then
9069,11 → 8819,7
save_libdir=$libdir
eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \
LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\""
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
int
9084,41 → 8830,13
return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then
if ac_fn_c_try_link "$LINENO"; then :
if ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then :
shlibpath_overrides_runpath=yes
fi
 
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
 
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
LDFLAGS=$save_LDFLAGS
libdir=$save_libdir
 
9342,7 → 9060,7
dynamic_linker=no
;;
esac
{ $as_echo "$as_me:$LINENO: result: $dynamic_linker" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
$as_echo "$dynamic_linker" >&6; }
test "$dynamic_linker" = no && can_build_shared=no
 
9444,7 → 9162,7
 
 
 
{ $as_echo "$as_me:$LINENO: checking how to hardcode library paths into programs" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
$as_echo_n "checking how to hardcode library paths into programs... " >&6; }
hardcode_action=
if test -n "$hardcode_libdir_flag_spec" ||
9469,7 → 9187,7
# directories.
hardcode_action=unsupported
fi
{ $as_echo "$as_me:$LINENO: result: $hardcode_action" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5
$as_echo "$hardcode_action" >&6; }
 
if test "$hardcode_action" = relink ||
9514,18 → 9232,14
 
darwin*)
# if libdl is installed we need to link against it
{ $as_echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
$as_echo_n "checking for dlopen in -ldl... " >&6; }
if test "${ac_cv_lib_dl_dlopen+set}" = set; then
if test "${ac_cv_lib_dl_dlopen+set}" = set; then :
$as_echo_n "(cached) " >&6
else
ac_check_lib_save_LIBS=$LIBS
LIBS="-ldl $LIBS"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
/* Override any GCC internal prototype to avoid an error.
9543,43 → 9257,18
return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
if ac_fn_c_try_link "$LINENO"; then :
ac_cv_lib_dl_dlopen=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_lib_dl_dlopen=no
ac_cv_lib_dl_dlopen=no
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
if test "x$ac_cv_lib_dl_dlopen" = x""yes; then
if test "x$ac_cv_lib_dl_dlopen" = x""yes; then :
lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
else
 
9592,106 → 9281,18
;;
 
*)
{ $as_echo "$as_me:$LINENO: checking for shl_load" >&5
$as_echo_n "checking for shl_load... " >&6; }
if test "${ac_cv_func_shl_load+set}" = set; then
$as_echo_n "(cached) " >&6
else
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
/* Define shl_load to an innocuous variant, in case <limits.h> declares shl_load.
For example, HP-UX 11i <limits.h> declares gettimeofday. */
#define shl_load innocuous_shl_load
 
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char shl_load (); below.
Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
<limits.h> exists even on freestanding compilers. */
 
#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif
 
#undef shl_load
 
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
#ifdef __cplusplus
extern "C"
#endif
char shl_load ();
/* The GNU C library defines this for functions which it implements
to always fail with ENOSYS. Some functions are actually named
something starting with __ and the normal name is an alias. */
#if defined __stub_shl_load || defined __stub___shl_load
choke me
#endif
 
int
main ()
{
return shl_load ();
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
ac_cv_func_shl_load=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_func_shl_load=no
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_func_shl_load" >&5
$as_echo "$ac_cv_func_shl_load" >&6; }
if test "x$ac_cv_func_shl_load" = x""yes; then
ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load"
if test "x$ac_cv_func_shl_load" = x""yes; then :
lt_cv_dlopen="shl_load"
else
{ $as_echo "$as_me:$LINENO: checking for shl_load in -ldld" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
$as_echo_n "checking for shl_load in -ldld... " >&6; }
if test "${ac_cv_lib_dld_shl_load+set}" = set; then
if test "${ac_cv_lib_dld_shl_load+set}" = set; then :
$as_echo_n "(cached) " >&6
else
ac_check_lib_save_LIBS=$LIBS
LIBS="-ldld $LIBS"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
/* Override any GCC internal prototype to avoid an error.
9709,145 → 9310,32
return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
if ac_fn_c_try_link "$LINENO"; then :
ac_cv_lib_dld_shl_load=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_lib_dld_shl_load=no
ac_cv_lib_dld_shl_load=no
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_dld_shl_load" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
$as_echo "$ac_cv_lib_dld_shl_load" >&6; }
if test "x$ac_cv_lib_dld_shl_load" = x""yes; then
if test "x$ac_cv_lib_dld_shl_load" = x""yes; then :
lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-ldld"
else
{ $as_echo "$as_me:$LINENO: checking for dlopen" >&5
$as_echo_n "checking for dlopen... " >&6; }
if test "${ac_cv_func_dlopen+set}" = set; then
$as_echo_n "(cached) " >&6
else
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
/* Define dlopen to an innocuous variant, in case <limits.h> declares dlopen.
For example, HP-UX 11i <limits.h> declares gettimeofday. */
#define dlopen innocuous_dlopen
 
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char dlopen (); below.
Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
<limits.h> exists even on freestanding compilers. */
 
#ifdef __STDC__
# include <limits.h>
#else
# include <assert.h>
#endif
 
#undef dlopen
 
/* Override any GCC internal prototype to avoid an error.
Use char because int might match the return type of a GCC
builtin and then its argument prototype would still apply. */
#ifdef __cplusplus
extern "C"
#endif
char dlopen ();
/* The GNU C library defines this for functions which it implements
to always fail with ENOSYS. Some functions are actually named
something starting with __ and the normal name is an alias. */
#if defined __stub_dlopen || defined __stub___dlopen
choke me
#endif
 
int
main ()
{
return dlopen ();
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
ac_cv_func_dlopen=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_func_dlopen=no
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_func_dlopen" >&5
$as_echo "$ac_cv_func_dlopen" >&6; }
if test "x$ac_cv_func_dlopen" = x""yes; then
ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen"
if test "x$ac_cv_func_dlopen" = x""yes; then :
lt_cv_dlopen="dlopen"
else
{ $as_echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
$as_echo_n "checking for dlopen in -ldl... " >&6; }
if test "${ac_cv_lib_dl_dlopen+set}" = set; then
if test "${ac_cv_lib_dl_dlopen+set}" = set; then :
$as_echo_n "(cached) " >&6
else
ac_check_lib_save_LIBS=$LIBS
LIBS="-ldl $LIBS"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
/* Override any GCC internal prototype to avoid an error.
9865,57 → 9353,28
return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
if ac_fn_c_try_link "$LINENO"; then :
ac_cv_lib_dl_dlopen=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_lib_dl_dlopen=no
ac_cv_lib_dl_dlopen=no
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
if test "x$ac_cv_lib_dl_dlopen" = x""yes; then
if test "x$ac_cv_lib_dl_dlopen" = x""yes; then :
lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
else
{ $as_echo "$as_me:$LINENO: checking for dlopen in -lsvld" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
$as_echo_n "checking for dlopen in -lsvld... " >&6; }
if test "${ac_cv_lib_svld_dlopen+set}" = set; then
if test "${ac_cv_lib_svld_dlopen+set}" = set; then :
$as_echo_n "(cached) " >&6
else
ac_check_lib_save_LIBS=$LIBS
LIBS="-lsvld $LIBS"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
/* Override any GCC internal prototype to avoid an error.
9933,57 → 9392,28
return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
if ac_fn_c_try_link "$LINENO"; then :
ac_cv_lib_svld_dlopen=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_lib_svld_dlopen=no
ac_cv_lib_svld_dlopen=no
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_svld_dlopen" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5
$as_echo "$ac_cv_lib_svld_dlopen" >&6; }
if test "x$ac_cv_lib_svld_dlopen" = x""yes; then
if test "x$ac_cv_lib_svld_dlopen" = x""yes; then :
lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"
else
{ $as_echo "$as_me:$LINENO: checking for dld_link in -ldld" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
$as_echo_n "checking for dld_link in -ldld... " >&6; }
if test "${ac_cv_lib_dld_dld_link+set}" = set; then
if test "${ac_cv_lib_dld_dld_link+set}" = set; then :
$as_echo_n "(cached) " >&6
else
ac_check_lib_save_LIBS=$LIBS
LIBS="-ldld $LIBS"
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
/* Override any GCC internal prototype to avoid an error.
10001,43 → 9431,18
return 0;
}
_ACEOF
rm -f conftest.$ac_objext conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
$as_test_x conftest$ac_exeext
}; then
if ac_fn_c_try_link "$LINENO"; then :
ac_cv_lib_dld_dld_link=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_lib_dld_dld_link=no
ac_cv_lib_dld_dld_link=no
fi
 
rm -rf conftest.dSYM
rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
conftest$ac_exeext conftest.$ac_ext
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_lib_dld_dld_link" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5
$as_echo "$ac_cv_lib_dld_dld_link" >&6; }
if test "x$ac_cv_lib_dld_dld_link" = x""yes; then
if test "x$ac_cv_lib_dld_dld_link" = x""yes; then :
lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-ldld"
fi
 
10076,9 → 9481,9
save_LIBS="$LIBS"
LIBS="$lt_cv_dlopen_libs $LIBS"
 
{ $as_echo "$as_me:$LINENO: checking whether a program can dlopen itself" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5
$as_echo_n "checking whether a program can dlopen itself... " >&6; }
if test "${lt_cv_dlopen_self+set}" = set; then
if test "${lt_cv_dlopen_self+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test "$cross_compiling" = yes; then :
10087,7 → 9492,7
lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
lt_status=$lt_dlunknown
cat > conftest.$ac_ext <<_LT_EOF
#line 10090 "configure"
#line 9495 "configure"
#include "confdefs.h"
 
#if HAVE_DLFCN_H
10146,11 → 9551,11
return status;
}
_LT_EOF
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
(eval $ac_link) 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && test -s conftest${ac_exeext} 2>/dev/null; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then
(./conftest; exit; ) >&5 2>/dev/null
lt_status=$?
case x$lt_status in
10167,14 → 9572,14
 
 
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_dlopen_self" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5
$as_echo "$lt_cv_dlopen_self" >&6; }
 
if test "x$lt_cv_dlopen_self" = xyes; then
wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
{ $as_echo "$as_me:$LINENO: checking whether a statically linked program can dlopen itself" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5
$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; }
if test "${lt_cv_dlopen_self_static+set}" = set; then
if test "${lt_cv_dlopen_self_static+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test "$cross_compiling" = yes; then :
10183,7 → 9588,7
lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
lt_status=$lt_dlunknown
cat > conftest.$ac_ext <<_LT_EOF
#line 10186 "configure"
#line 9591 "configure"
#include "confdefs.h"
 
#if HAVE_DLFCN_H
10242,11 → 9647,11
return status;
}
_LT_EOF
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
(eval $ac_link) 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && test -s conftest${ac_exeext} 2>/dev/null; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && test -s conftest${ac_exeext} 2>/dev/null; then
(./conftest; exit; ) >&5 2>/dev/null
lt_status=$?
case x$lt_status in
10263,7 → 9668,7
 
 
fi
{ $as_echo "$as_me:$LINENO: result: $lt_cv_dlopen_self_static" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5
$as_echo "$lt_cv_dlopen_self_static" >&6; }
fi
 
10302,12 → 9707,12
 
striplib=
old_striplib=
{ $as_echo "$as_me:$LINENO: checking whether stripping libraries is possible" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5
$as_echo_n "checking whether stripping libraries is possible... " >&6; }
if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
test -z "$striplib" && striplib="$STRIP --strip-unneeded"
{ $as_echo "$as_me:$LINENO: result: yes" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
# FIXME - insert some real tests, host_os isn't really good enough
10316,15 → 9721,15
if test -n "$STRIP" ; then
striplib="$STRIP -x"
old_striplib="$STRIP -S"
{ $as_echo "$as_me:$LINENO: result: yes" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
;;
*)
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
;;
esac
10342,12 → 9747,12
 
 
# Report which library types will actually be built
{ $as_echo "$as_me:$LINENO: checking if libtool supports shared libraries" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5
$as_echo_n "checking if libtool supports shared libraries... " >&6; }
{ $as_echo "$as_me:$LINENO: result: $can_build_shared" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5
$as_echo "$can_build_shared" >&6; }
 
{ $as_echo "$as_me:$LINENO: checking whether to build shared libraries" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5
$as_echo_n "checking whether to build shared libraries... " >&6; }
test "$can_build_shared" = "no" && enable_shared=no
 
10368,14 → 9773,14
fi
;;
esac
{ $as_echo "$as_me:$LINENO: result: $enable_shared" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5
$as_echo "$enable_shared" >&6; }
 
{ $as_echo "$as_me:$LINENO: checking whether to build static libraries" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5
$as_echo_n "checking whether to build static libraries... " >&6; }
# Make sure either enable_shared or enable_static is yes.
test "$enable_shared" = yes || enable_static=yes
{ $as_echo "$as_me:$LINENO: result: $enable_static" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5
$as_echo "$enable_static" >&6; }
 
 
10426,10 → 9831,10
# OS/2's system install, which has a completely different semantic
# ./install, which can be erroneously created by make from ./install.sh.
# Reject install programs that cannot install multiple files.
{ $as_echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
$as_echo_n "checking for a BSD-compatible install... " >&6; }
if test -z "$INSTALL"; then
if test "${ac_cv_path_install+set}" = set; then
if test "${ac_cv_path_install+set}" = set; then :
$as_echo_n "(cached) " >&6
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10437,11 → 9842,11
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
# Account for people who put trailing slashes in PATH elements.
case $as_dir/ in
./ | .// | /cC/* | \
# Account for people who put trailing slashes in PATH elements.
case $as_dir/ in #((
./ | .// | /[cC]/* | \
/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
/usr/ucb/* ) ;;
*)
# OSF1 and SCO ODT 3.0 have their own names for install.
10478,7 → 9883,7
;;
esac
 
done
done
IFS=$as_save_IFS
 
rm -rf conftest.one conftest.two conftest.dir
10494,7 → 9899,7
INSTALL=$ac_install_sh
fi
fi
{ $as_echo "$as_me:$LINENO: result: $INSTALL" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
$as_echo "$INSTALL" >&6; }
 
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
10505,7 → 9910,7
 
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 
{ $as_echo "$as_me:$LINENO: checking whether build environment is sane" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
$as_echo_n "checking whether build environment is sane... " >&6; }
# Just in case
sleep 1
10516,15 → 9921,11
'
case `pwd` in
*[\\\"\#\$\&\'\`$am_lf]*)
{ { $as_echo "$as_me:$LINENO: error: unsafe absolute working directory name" >&5
$as_echo "$as_me: error: unsafe absolute working directory name" >&2;}
{ (exit 1); exit 1; }; };;
as_fn_error "unsafe absolute working directory name" "$LINENO" 5;;
esac
case $srcdir in
*[\\\"\#\$\&\'\`$am_lf\ \ ]*)
{ { $as_echo "$as_me:$LINENO: error: unsafe srcdir value: \`$srcdir'" >&5
$as_echo "$as_me: error: unsafe srcdir value: \`$srcdir'" >&2;}
{ (exit 1); exit 1; }; };;
as_fn_error "unsafe srcdir value: \`$srcdir'" "$LINENO" 5;;
esac
 
# Do `set' in a subshell so we don't clobber the current shell's
10546,11 → 9947,8
# if, for instance, CONFIG_SHELL is bash and it inherits a
# broken ls alias from the environment. This has actually
# happened. Such a system could not be considered "sane".
{ { $as_echo "$as_me:$LINENO: error: ls -t appears to fail. Make sure there is not a broken
alias in your environment" >&5
$as_echo "$as_me: error: ls -t appears to fail. Make sure there is not a broken
alias in your environment" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "ls -t appears to fail. Make sure there is not a broken
alias in your environment" "$LINENO" 5
fi
 
test "$2" = conftest.file
10559,13 → 9957,10
# Ok.
:
else
{ { $as_echo "$as_me:$LINENO: error: newly created file is older than distributed files!
Check your system clock" >&5
$as_echo "$as_me: error: newly created file is older than distributed files!
Check your system clock" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "newly created file is older than distributed files!
Check your system clock" "$LINENO" 5
fi
{ $as_echo "$as_me:$LINENO: result: yes" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
test "$program_prefix" != NONE &&
program_transform_name="s&^&$program_prefix&;$program_transform_name"
10593,7 → 9988,7
am_missing_run="$MISSING --run "
else
am_missing_run=
{ $as_echo "$as_me:$LINENO: WARNING: \`missing' script is too old or missing" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \`missing' script is too old or missing" >&5
$as_echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}
fi
 
10614,9 → 10009,9
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
set dummy ${ac_tool_prefix}strip; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_STRIP+set}" = set; then
if test "${ac_cv_prog_STRIP+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$STRIP"; then
10627,14 → 10022,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_STRIP="${ac_tool_prefix}strip"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
10641,10 → 10036,10
fi
STRIP=$ac_cv_prog_STRIP
if test -n "$STRIP"; then
{ $as_echo "$as_me:$LINENO: result: $STRIP" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
$as_echo "$STRIP" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
10654,9 → 10049,9
ac_ct_STRIP=$STRIP
# Extract the first word of "strip", so it can be a program name with args.
set dummy strip; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then
if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$ac_ct_STRIP"; then
10667,14 → 10062,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_ac_ct_STRIP="strip"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
10681,10 → 10076,10
fi
ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
if test -n "$ac_ct_STRIP"; then
{ $as_echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
$as_echo "$ac_ct_STRIP" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
10693,7 → 10088,7
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
10706,10 → 10101,10
fi
INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
 
{ $as_echo "$as_me:$LINENO: checking for a thread-safe mkdir -p" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
if test -z "$MKDIR_P"; then
if test "${ac_cv_path_mkdir+set}" = set; then
if test "${ac_cv_path_mkdir+set}" = set; then :
$as_echo_n "(cached) " >&6
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10717,7 → 10112,7
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_prog in mkdir gmkdir; do
for ac_prog in mkdir gmkdir; do
for ac_exec_ext in '' $ac_executable_extensions; do
{ test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; } || continue
case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
10729,11 → 10124,12
esac
done
done
done
done
IFS=$as_save_IFS
 
fi
 
test -d ./--version && rmdir ./--version
if test "${ac_cv_path_mkdir+set}" = set; then
MKDIR_P="$ac_cv_path_mkdir -p"
else
10741,11 → 10137,10
# value for MKDIR_P within a source directory, because that will
# break other packages using the cache if that directory is
# removed, or if the value is a relative name.
test -d ./--version && rmdir ./--version
MKDIR_P="$ac_install_sh -d"
fi
fi
{ $as_echo "$as_me:$LINENO: result: $MKDIR_P" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
$as_echo "$MKDIR_P" >&6; }
 
mkdir_p="$MKDIR_P"
10758,9 → 10153,9
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_AWK+set}" = set; then
if test "${ac_cv_prog_AWK+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$AWK"; then
10771,14 → 10166,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_AWK="$ac_prog"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
10785,10 → 10180,10
fi
AWK=$ac_cv_prog_AWK
if test -n "$AWK"; then
{ $as_echo "$as_me:$LINENO: result: $AWK" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
$as_echo "$AWK" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
10796,11 → 10191,11
test -n "$AWK" && break
done
 
{ $as_echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
set x ${MAKE-make}
ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then
if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then :
$as_echo_n "(cached) " >&6
else
cat >conftest.make <<\_ACEOF
10818,11 → 10213,11
rm -f conftest.make
fi
if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
{ $as_echo "$as_me:$LINENO: result: yes" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
SET_MAKE=
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
SET_MAKE="MAKE=${MAKE-make}"
fi
10848,7 → 10243,7
.PHONY: am__doit
END
# If we don't find an include directive, just comment out the code.
{ $as_echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
$as_echo_n "checking for style of include used by $am_make... " >&6; }
am__include="#"
am__quote=
10876,12 → 10271,12
fi
 
 
{ $as_echo "$as_me:$LINENO: result: $_am_result" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
$as_echo "$_am_result" >&6; }
rm -f confinc confmf
 
# Check whether --enable-dependency-tracking was given.
if test "${enable_dependency_tracking+set}" = set; then
if test "${enable_dependency_tracking+set}" = set; then :
enableval=$enable_dependency_tracking;
fi
 
10904,9 → 10299,7
am__isrc=' -I$(srcdir)'
# test to see if srcdir already configured
if test -f $srcdir/config.status; then
{ { $as_echo "$as_me:$LINENO: error: source directory already configured; run \"make distclean\" there first" >&5
$as_echo "$as_me: error: source directory already configured; run \"make distclean\" there first" >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
fi
fi
 
10963,9 → 10356,9
 
depcc="$CC" am_compiler_list=
 
{ $as_echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
$as_echo_n "checking dependency style of $depcc... " >&6; }
if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then
if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
11073,7 → 10466,7
fi
 
fi
{ $as_echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
 
11098,7 → 10491,7
# check for --enable-all-tests argument, in which case we attempt to build all
# tests, even those that do not compile properly.
# Check whether --enable-all-tests was given.
if test "${enable_all_tests+set}" = set; then
if test "${enable_all_tests+set}" = set; then :
enableval=$enable_all_tests; all_tests=true all_tests=false
fi
 
11122,9 → 10515,9
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_CC+set}" = set; then
if test "${ac_cv_prog_CC+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$CC"; then
11135,14 → 10528,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_CC="$ac_prog"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
11149,10 → 10542,10
fi
CC=$ac_cv_prog_CC
if test -n "$CC"; then
{ $as_echo "$as_me:$LINENO: result: $CC" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
$as_echo "$CC" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
11164,9 → 10557,9
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_RANLIB+set}" = set; then
if test "${ac_cv_prog_RANLIB+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$RANLIB"; then
11177,14 → 10570,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_RANLIB="$ac_prog"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
11191,10 → 10584,10
fi
RANLIB=$ac_cv_prog_RANLIB
if test -n "$RANLIB"; then
{ $as_echo "$as_me:$LINENO: result: $RANLIB" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
$as_echo "$RANLIB" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
11206,9 → 10599,9
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_LD+set}" = set; then
if test "${ac_cv_prog_LD+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$LD"; then
11219,14 → 10612,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_LD="$ac_prog"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
11233,10 → 10626,10
fi
LD=$ac_cv_prog_LD
if test -n "$LD"; then
{ $as_echo "$as_me:$LINENO: result: $LD" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
$as_echo "$LD" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
11248,9 → 10641,9
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if test "${ac_cv_prog_SIM+set}" = set; then
if test "${ac_cv_prog_SIM+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -n "$SIM"; then
11261,14 → 10654,14
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_prog_SIM="$ac_prog"
$as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
done
IFS=$as_save_IFS
 
fi
11275,10 → 10668,10
fi
SIM=$ac_cv_prog_SIM
if test -n "$SIM"; then
{ $as_echo "$as_me:$LINENO: result: $SIM" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $SIM" >&5
$as_echo "$SIM" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
 
11291,16 → 10684,12
 
 
 
{ $as_echo "$as_me:$LINENO: checking for ANSI C header files" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
$as_echo_n "checking for ANSI C header files... " >&6; }
if test "${ac_cv_header_stdc+set}" = set; then
if test "${ac_cv_header_stdc+set}" = set; then :
$as_echo_n "(cached) " >&6
else
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <stdlib.h>
#include <stdarg.h>
11315,48 → 10704,23
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
if ac_fn_c_try_compile "$LINENO"; then :
ac_cv_header_stdc=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_header_stdc=no
ac_cv_header_stdc=no
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
 
if test $ac_cv_header_stdc = yes; then
# SunOS 4.x string.h does not declare mem*, contrary to ANSI.
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <string.h>
 
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
$EGREP "memchr" >/dev/null 2>&1; then
:
$EGREP "memchr" >/dev/null 2>&1; then :
 
else
ac_cv_header_stdc=no
fi
11366,18 → 10730,14
 
if test $ac_cv_header_stdc = yes; then
# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <stdlib.h>
 
_ACEOF
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
$EGREP "free" >/dev/null 2>&1; then
:
$EGREP "free" >/dev/null 2>&1; then :
 
else
ac_cv_header_stdc=no
fi
11387,14 → 10747,10
 
if test $ac_cv_header_stdc = yes; then
# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
if test "$cross_compiling" = yes; then
if test "$cross_compiling" = yes; then :
:
else
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
#include <ctype.h>
#include <stdlib.h>
11421,51 → 10777,22
return 0;
}
_ACEOF
rm -f conftest$ac_exeext
if { (ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_link") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && { ac_try='./conftest$ac_exeext'
{ (case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_try") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; }; then
:
if ac_fn_c_try_run "$LINENO"; then :
 
else
$as_echo "$as_me: program exited with status $ac_status" >&5
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
( exit $ac_status )
ac_cv_header_stdc=no
ac_cv_header_stdc=no
fi
rm -rf conftest.dSYM
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
conftest.$ac_objext conftest.beam conftest.$ac_ext
fi
 
 
fi
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
$as_echo "$ac_cv_header_stdc" >&6; }
if test $ac_cv_header_stdc = yes; then
 
cat >>confdefs.h <<\_ACEOF
#define STDC_HEADERS 1
_ACEOF
$as_echo "#define STDC_HEADERS 1" >>confdefs.h
 
fi
 
11481,9 → 10808,9
 
depcc="$CCAS" am_compiler_list=
 
{ $as_echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
$as_echo_n "checking dependency style of $depcc... " >&6; }
if test "${am_cv_CCAS_dependencies_compiler_type+set}" = set; then
if test "${am_cv_CCAS_dependencies_compiler_type+set}" = set; then :
$as_echo_n "(cached) " >&6
else
if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
11589,7 → 10916,7
fi
 
fi
{ $as_echo "$as_me:$LINENO: result: $am_cv_CCAS_dependencies_compiler_type" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CCAS_dependencies_compiler_type" >&5
$as_echo "$am_cv_CCAS_dependencies_compiler_type" >&6; }
CCASDEPMODE=depmode=$am_cv_CCAS_dependencies_compiler_type
 
11605,22 → 10932,18
 
 
if test "x$CC" != xcc; then
{ $as_echo "$as_me:$LINENO: checking whether $CC and cc understand -c and -o together" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC and cc understand -c and -o together" >&5
$as_echo_n "checking whether $CC and cc understand -c and -o together... " >&6; }
else
{ $as_echo "$as_me:$LINENO: checking whether cc understands -c and -o together" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether cc understands -c and -o together" >&5
$as_echo_n "checking whether cc understands -c and -o together... " >&6; }
fi
set dummy $CC; ac_cc=`$as_echo "$2" |
sed 's/[^a-zA-Z0-9_]/_/g;s/^[0-9]/_/'`
if { as_var=ac_cv_prog_cc_${ac_cc}_c_o; eval "test \"\${$as_var+set}\" = set"; }; then
if { as_var=ac_cv_prog_cc_${ac_cc}_c_o; eval "test \"\${$as_var+set}\" = set"; }; then :
$as_echo_n "(cached) " >&6
else
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
 
int
11636,63 → 10959,63
# existing .o file with -o, though they will create one.
ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
rm -f conftest2.*
if { (case "(($ac_try" in
if { { case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
test -f conftest2.$ac_objext && { (case "(($ac_try" in
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } &&
test -f conftest2.$ac_objext && { { case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); };
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; };
then
eval ac_cv_prog_cc_${ac_cc}_c_o=yes
if test "x$CC" != xcc; then
# Test first that cc exists at all.
if { ac_try='cc -c conftest.$ac_ext >&5'
{ (case "(($ac_try" in
{ { case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); }; }; then
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; }; then
ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&5'
rm -f conftest2.*
if { (case "(($ac_try" in
if { { case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
test -f conftest2.$ac_objext && { (case "(($ac_try" in
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } &&
test -f conftest2.$ac_objext && { { case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_try") 2>&5
ac_status=$?
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); };
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; };
then
# cc works too.
:
11709,15 → 11032,13
 
fi
if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
{ $as_echo "$as_me:$LINENO: result: yes" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
{ $as_echo "$as_me:$LINENO: result: no" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
 
cat >>confdefs.h <<\_ACEOF
#define NO_MINUS_C_MINUS_O 1
_ACEOF
$as_echo "#define NO_MINUS_C_MINUS_O 1" >>confdefs.h
 
fi
 
11736,109 → 11057,17
fi
 
 
# Find a good install program. We prefer a C program (faster),
# so one script is as good as another. But avoid the broken or
# incompatible versions:
# SysV /etc/install, /usr/sbin/install
# SunOS /usr/etc/install
# IRIX /sbin/install
# AIX /bin/install
# AmigaOS /C/install, which installs bootblocks on floppy discs
# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
# AFS /usr/afsws/bin/install, which mishandles nonexistent args
# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
# OS/2's system install, which has a completely different semantic
# ./install, which can be erroneously created by make from ./install.sh.
# Reject install programs that cannot install multiple files.
{ $as_echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
$as_echo_n "checking for a BSD-compatible install... " >&6; }
if test -z "$INSTALL"; then
if test "${ac_cv_path_install+set}" = set; then
$as_echo_n "(cached) " >&6
else
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
# Account for people who put trailing slashes in PATH elements.
case $as_dir/ in
./ | .// | /cC/* | \
/etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
/usr/ucb/* ) ;;
*)
# OSF1 and SCO ODT 3.0 have their own names for install.
# Don't use installbsd from OSF since it installs stuff as root
# by default.
for ac_prog in ginstall scoinst install; do
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
if test $ac_prog = install &&
grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
# AIX install. It has an incompatible calling convention.
:
elif test $ac_prog = install &&
grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
# program-specific install script used by HP pwplus--don't use.
:
else
rm -rf conftest.one conftest.two conftest.dir
echo one > conftest.one
echo two > conftest.two
mkdir conftest.dir
if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
test -s conftest.one && test -s conftest.two &&
test -s conftest.dir/conftest.one &&
test -s conftest.dir/conftest.two
then
ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
break 3
fi
fi
fi
done
done
;;
esac
 
done
IFS=$as_save_IFS
 
rm -rf conftest.one conftest.two conftest.dir
 
fi
if test "${ac_cv_path_install+set}" = set; then
INSTALL=$ac_cv_path_install
else
# As a last resort, use the slow shell script. Don't cache a
# value for INSTALL within a source directory, because that will
# break other packages using the cache if that directory is
# removed, or if the value is a relative name.
INSTALL=$ac_install_sh
fi
fi
{ $as_echo "$as_me:$LINENO: result: $INSTALL" >&5
$as_echo "$INSTALL" >&6; }
 
# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
# It thinks the first close brace ends the variable substitution.
test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 
test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
 
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 
 
# Specify our baseline CFLAGS
CPPFLAGS="-I\${top_srcdir}/support -I\${top_srcdir}/mc-common"
CFLAGS="-Wall -Werror -g -nostdlib -mhard-div -mhard-mul"
 
# Flag to specify whether we want optimization when checking
{ $as_echo "$as_me:$LINENO: checking whether to enable optimizations when checking" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable optimizations when checking" >&5
$as_echo_n "checking whether to enable optimizations when checking... " >&6; }
# Check whether --enable-opt was given.
if test "${enable_opt+set}" = set; then
if test "${enable_opt+set}" = set; then :
enableval=$enable_opt;
case "$enableval" in
yes)
11851,7 → 11080,7
 
fi
 
{ $as_echo "$as_me:$LINENO: result: ${enable_check_opt-default}" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${enable_check_opt-default}" >&5
$as_echo "${enable_check_opt-default}" >&6; }
 
 
11859,9 → 11088,7
 
# This is GNU compliant source and uses GNU libraries
 
cat >>confdefs.h <<\_ACEOF
#define _GNU_SOURCE 1
_ACEOF
$as_echo "#define _GNU_SOURCE 1" >>confdefs.h
 
 
# Check for functions doesn't work, since we can't execute code. Define some
11869,161 → 11096,19
# headers from the main code body (for the memory controller tests
# principally) to work.
 
cat >>confdefs.h <<\_ACEOF
#define HAVE_STRNDUP /**/
_ACEOF
$as_echo "#define HAVE_STRNDUP /**/" >>confdefs.h
 
 
cat >>confdefs.h <<\_ACEOF
#define HAVE_ISBLANK /**/
_ACEOF
$as_echo "#define HAVE_ISBLANK /**/" >>confdefs.h
 
 
# Check for headers
 
 
for ac_header in sys/types.h inttypes.h
do
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
$as_echo_n "checking for $ac_header... " >&6; }
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
$as_echo_n "(cached) " >&6
fi
ac_res=`eval 'as_val=${'$as_ac_Header'}
$as_echo "$as_val"'`
{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
else
# Is the header compilable?
{ $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
$as_echo_n "checking $ac_header usability... " >&6; }
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
$ac_includes_default
#include <$ac_header>
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
ac_header_compiler=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_header_compiler=no
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
{ $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
$as_echo "$ac_header_compiler" >&6; }
 
# Is the header present?
{ $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
$as_echo_n "checking $ac_header presence... " >&6; }
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <$ac_header>
_ACEOF
if { (ac_try="$ac_cpp conftest.$ac_ext"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } >/dev/null && {
test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
test ! -s conftest.err
}; then
ac_header_preproc=yes
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_header_preproc=no
fi
 
rm -f conftest.err conftest.$ac_ext
{ $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
$as_echo "$ac_header_preproc" >&6; }
 
# So? What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
yes:no: )
{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
$as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
ac_header_preproc=yes
;;
no:yes:* )
{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
$as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
$as_echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
$as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5
$as_echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}
{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
$as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
{ $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
$as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
( cat <<\_ASBOX
## ------------------------------------- ##
## Report this to openrisc@opencores.org ##
## ------------------------------------- ##
_ASBOX
) | sed "s/^/$as_me: WARNING: /" >&2
;;
esac
{ $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
$as_echo_n "checking for $ac_header... " >&6; }
if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
$as_echo_n "(cached) " >&6
else
eval "$as_ac_Header=\$ac_header_preproc"
fi
ac_res=`eval 'as_val=${'$as_ac_Header'}
$as_echo "$as_val"'`
{ $as_echo "$as_me:$LINENO: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
 
fi
as_val=`eval 'as_val=${'$as_ac_Header'}
$as_echo "$as_val"'`
if test "x$as_val" = x""yes; then
do :
as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
eval as_val=\$$as_ac_Header
if test "x$as_val" = x""yes; then :
cat >>confdefs.h <<_ACEOF
#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
_ACEOF
12034,104 → 11119,10
 
 
# check for types and sizes
{ $as_echo "$as_me:$LINENO: checking for uint8_t" >&5
$as_echo_n "checking for uint8_t... " >&6; }
if test "${ac_cv_type_uint8_t+set}" = set; then
$as_echo_n "(cached) " >&6
else
ac_cv_type_uint8_t=no
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <inttypes.h>
ac_fn_c_check_type "$LINENO" "uint8_t" "ac_cv_type_uint8_t" "#include <inttypes.h>
"
if test "x$ac_cv_type_uint8_t" = x""yes; then :
 
int
main ()
{
if (sizeof (uint8_t))
return 0;
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <inttypes.h>
 
int
main ()
{
if (sizeof ((uint8_t)))
return 0;
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
:
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_type_uint8_t=yes
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
 
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_type_uint8_t" >&5
$as_echo "$ac_cv_type_uint8_t" >&6; }
if test "x$ac_cv_type_uint8_t" = x""yes; then
 
cat >>confdefs.h <<_ACEOF
#define HAVE_UINT8_T 1
_ACEOF
12138,104 → 11129,10
 
 
fi
{ $as_echo "$as_me:$LINENO: checking for uint16_t" >&5
$as_echo_n "checking for uint16_t... " >&6; }
if test "${ac_cv_type_uint16_t+set}" = set; then
$as_echo_n "(cached) " >&6
else
ac_cv_type_uint16_t=no
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <inttypes.h>
ac_fn_c_check_type "$LINENO" "uint16_t" "ac_cv_type_uint16_t" "#include <inttypes.h>
"
if test "x$ac_cv_type_uint16_t" = x""yes; then :
 
int
main ()
{
if (sizeof (uint16_t))
return 0;
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <inttypes.h>
 
int
main ()
{
if (sizeof ((uint16_t)))
return 0;
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
:
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_type_uint16_t=yes
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
 
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_type_uint16_t" >&5
$as_echo "$ac_cv_type_uint16_t" >&6; }
if test "x$ac_cv_type_uint16_t" = x""yes; then
 
cat >>confdefs.h <<_ACEOF
#define HAVE_UINT16_T 1
_ACEOF
12242,104 → 11139,10
 
 
fi
{ $as_echo "$as_me:$LINENO: checking for uint32_t" >&5
$as_echo_n "checking for uint32_t... " >&6; }
if test "${ac_cv_type_uint32_t+set}" = set; then
$as_echo_n "(cached) " >&6
else
ac_cv_type_uint32_t=no
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <inttypes.h>
ac_fn_c_check_type "$LINENO" "uint32_t" "ac_cv_type_uint32_t" "#include <inttypes.h>
"
if test "x$ac_cv_type_uint32_t" = x""yes; then :
 
int
main ()
{
if (sizeof (uint32_t))
return 0;
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <inttypes.h>
 
int
main ()
{
if (sizeof ((uint32_t)))
return 0;
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
:
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_type_uint32_t=yes
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
 
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_type_uint32_t" >&5
$as_echo "$ac_cv_type_uint32_t" >&6; }
if test "x$ac_cv_type_uint32_t" = x""yes; then
 
cat >>confdefs.h <<_ACEOF
#define HAVE_UINT32_T 1
_ACEOF
12347,104 → 11150,10
 
fi
 
{ $as_echo "$as_me:$LINENO: checking for int8_t" >&5
$as_echo_n "checking for int8_t... " >&6; }
if test "${ac_cv_type_int8_t+set}" = set; then
$as_echo_n "(cached) " >&6
else
ac_cv_type_int8_t=no
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <inttypes.h>
ac_fn_c_check_type "$LINENO" "int8_t" "ac_cv_type_int8_t" "#include <inttypes.h>
"
if test "x$ac_cv_type_int8_t" = x""yes; then :
 
int
main ()
{
if (sizeof (int8_t))
return 0;
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <inttypes.h>
 
int
main ()
{
if (sizeof ((int8_t)))
return 0;
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
:
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_type_int8_t=yes
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
 
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_type_int8_t" >&5
$as_echo "$ac_cv_type_int8_t" >&6; }
if test "x$ac_cv_type_int8_t" = x""yes; then
 
cat >>confdefs.h <<_ACEOF
#define HAVE_INT8_T 1
_ACEOF
12451,104 → 11160,10
 
 
fi
{ $as_echo "$as_me:$LINENO: checking for int16_t" >&5
$as_echo_n "checking for int16_t... " >&6; }
if test "${ac_cv_type_int16_t+set}" = set; then
$as_echo_n "(cached) " >&6
else
ac_cv_type_int16_t=no
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <inttypes.h>
ac_fn_c_check_type "$LINENO" "int16_t" "ac_cv_type_int16_t" "#include <inttypes.h>
"
if test "x$ac_cv_type_int16_t" = x""yes; then :
 
int
main ()
{
if (sizeof (int16_t))
return 0;
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <inttypes.h>
 
int
main ()
{
if (sizeof ((int16_t)))
return 0;
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
:
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_type_int16_t=yes
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
 
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_type_int16_t" >&5
$as_echo "$ac_cv_type_int16_t" >&6; }
if test "x$ac_cv_type_int16_t" = x""yes; then
 
cat >>confdefs.h <<_ACEOF
#define HAVE_INT16_T 1
_ACEOF
12555,104 → 11170,10
 
 
fi
{ $as_echo "$as_me:$LINENO: checking for int32_t" >&5
$as_echo_n "checking for int32_t... " >&6; }
if test "${ac_cv_type_int32_t+set}" = set; then
$as_echo_n "(cached) " >&6
else
ac_cv_type_int32_t=no
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <inttypes.h>
ac_fn_c_check_type "$LINENO" "int32_t" "ac_cv_type_int32_t" "#include <inttypes.h>
"
if test "x$ac_cv_type_int32_t" = x""yes; then :
 
int
main ()
{
if (sizeof (int32_t))
return 0;
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
cat >conftest.$ac_ext <<_ACEOF
/* confdefs.h. */
_ACEOF
cat confdefs.h >>conftest.$ac_ext
cat >>conftest.$ac_ext <<_ACEOF
/* end confdefs.h. */
#include <inttypes.h>
 
int
main ()
{
if (sizeof ((int32_t)))
return 0;
;
return 0;
}
_ACEOF
rm -f conftest.$ac_objext
if { (ac_try="$ac_compile"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
$as_echo "$ac_try_echo") >&5
(eval "$ac_compile") 2>conftest.er1
ac_status=$?
grep -v '^ *+' conftest.er1 >conftest.err
rm -f conftest.er1
cat conftest.err >&5
$as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest.$ac_objext; then
:
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
ac_cv_type_int32_t=yes
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
 
 
fi
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:$LINENO: result: $ac_cv_type_int32_t" >&5
$as_echo "$ac_cv_type_int32_t" >&6; }
if test "x$ac_cv_type_int32_t" = x""yes; then
 
cat >>confdefs.h <<_ACEOF
#define HAVE_INT32_T 1
_ACEOF
12664,24 → 11185,16
# Checking sizeof doesn't really work, since it needs to run compiled code. So
# we do it by hand.
 
cat >>confdefs.h <<\_ACEOF
#define SIZEOF_CHAR 1
_ACEOF
$as_echo "#define SIZEOF_CHAR 1" >>confdefs.h
 
 
cat >>confdefs.h <<\_ACEOF
#define SIZEOF_SHORT 2
_ACEOF
$as_echo "#define SIZEOF_SHORT 2" >>confdefs.h
 
 
cat >>confdefs.h <<\_ACEOF
#define SIZEOF_INT 4
_ACEOF
$as_echo "#define SIZEOF_INT 4" >>confdefs.h
 
 
cat >>confdefs.h <<\_ACEOF
#define SIZEOF_LONG 4
_ACEOF
$as_echo "#define SIZEOF_LONG 4" >>confdefs.h
 
 
ac_config_files="$ac_config_files Makefile acv-gpio/Makefile acv-uart/Makefile basic/Makefile cache/Makefile cbasic/Makefile cfg/Makefile dhry/Makefile dmatest/Makefile eth/Makefile except/Makefile except-test/Makefile exit/Makefile ext/Makefile fbtest/Makefile functest/Makefile flag/Makefile int-test/Makefile int-logger/Makefile inst-set-test/Makefile kbdtest/Makefile local-global/Makefile loop/Makefile mc-async/Makefile mc-dram/Makefile mc-ssram/Makefile mc-sync/Makefile mc-common/Makefile mem-test/Makefile mmu/Makefile mul/Makefile mycompress/Makefile support/Makefile tick/Makefile uos/Makefile upcalls/Makefile"
12714,13 → 11227,13
case $ac_val in #(
*${as_nl}*)
case $ac_var in #(
*_cv_*) { $as_echo "$as_me:$LINENO: WARNING: cache variable $ac_var contains a newline" >&5
*_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
esac
case $ac_var in #(
_ | IFS | as_nl) ;; #(
BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
*) $as_unset $ac_var ;;
*) { eval $ac_var=; unset $ac_var;} ;;
esac ;;
esac
done
12728,8 → 11241,8
(set) 2>&1 |
case $as_nl`(ac_space=' '; set) 2>&1` in #(
*${as_nl}ac_space=\ *)
# `set' does not quote correctly, so add quotes (double-quote
# substitution turns \\\\ into \\, and sed turns \\ into \).
# `set' does not quote correctly, so add quotes: double-quote
# substitution turns \\\\ into \\, and sed turns \\ into \.
sed -n \
"s/'/'\\\\''/g;
s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12752,11 → 11265,11
if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
if test -w "$cache_file"; then
test "x$cache_file" != "x/dev/null" &&
{ $as_echo "$as_me:$LINENO: updating cache $cache_file" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
$as_echo "$as_me: updating cache $cache_file" >&6;}
cat confcache >$cache_file
else
{ $as_echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
fi
fi
12776,8 → 11289,8
ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
# 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR
# will be set to the directory where LIBOBJS objects are built.
ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
done
LIBOBJS=$ac_libobjs
 
12785,18 → 11298,12
 
 
if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
{ { $as_echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.
Usually this means the macro was only invoked conditionally." >&5
$as_echo "$as_me: error: conditional \"AMDEP\" was never defined.
Usually this means the macro was only invoked conditionally." >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "conditional \"AMDEP\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
{ { $as_echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.
Usually this means the macro was only invoked conditionally." >&5
$as_echo "$as_me: error: conditional \"am__fastdepCC\" was never defined.
Usually this means the macro was only invoked conditionally." >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "conditional \"am__fastdepCC\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
if test -n "$EXEEXT"; then
am__EXEEXT_TRUE=
12807,18 → 11314,12
fi
 
if test -z "${BUILD_ALL_TESTS_TRUE}" && test -z "${BUILD_ALL_TESTS_FALSE}"; then
{ { $as_echo "$as_me:$LINENO: error: conditional \"BUILD_ALL_TESTS\" was never defined.
Usually this means the macro was only invoked conditionally." >&5
$as_echo "$as_me: error: conditional \"BUILD_ALL_TESTS\" was never defined.
Usually this means the macro was only invoked conditionally." >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "conditional \"BUILD_ALL_TESTS\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
if test -z "${am__fastdepCCAS_TRUE}" && test -z "${am__fastdepCCAS_FALSE}"; then
{ { $as_echo "$as_me:$LINENO: error: conditional \"am__fastdepCCAS\" was never defined.
Usually this means the macro was only invoked conditionally." >&5
$as_echo "$as_me: error: conditional \"am__fastdepCCAS\" was never defined.
Usually this means the macro was only invoked conditionally." >&2;}
{ (exit 1); exit 1; }; }
as_fn_error "conditional \"am__fastdepCCAS\" was never defined.
Usually this means the macro was only invoked conditionally." "$LINENO" 5
fi
 
: ${CONFIG_STATUS=./config.status}
12825,9 → 11326,10
ac_write_fail=0
ac_clean_files_save=$ac_clean_files
ac_clean_files="$ac_clean_files $CONFIG_STATUS"
{ $as_echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
cat >$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
as_write_fail=0
cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
#! $SHELL
# Generated by $as_me.
# Run this file to recreate the current configuration.
12837,17 → 11339,18
debug=false
ac_cs_recheck=false
ac_cs_silent=false
 
SHELL=\${CONFIG_SHELL-$SHELL}
_ACEOF
export SHELL
_ASEOF
cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
## -------------------- ##
## M4sh Initialization. ##
## -------------------- ##
 
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
## --------------------- ##
## M4sh Initialization. ##
## --------------------- ##
 
# Be more Bourne compatible
DUALCASE=1; export DUALCASE # for MKS sh
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
emulate sh
NULLCMD=:
# Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
12855,23 → 11358,15
alias -g '${1+"$@"}'='"$@"'
setopt NO_GLOB_SUBST
else
case `(set -o) 2>/dev/null` in
*posix*) set -o posix ;;
case `(set -o) 2>/dev/null` in #(
*posix*) :
set -o posix ;; #(
*) :
;;
esac
 
fi
 
 
 
 
# PATH needs CR
# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits
 
as_nl='
'
export as_nl
12879,7 → 11374,13
as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
if (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
# Prefer a ksh shell builtin over an external printf program on Solaris,
# but without wasting forks for bash or zsh.
if test -z "$BASH_VERSION$ZSH_VERSION" \
&& (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
as_echo='print -r --'
as_echo_n='print -rn --'
elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
as_echo='printf %s\n'
as_echo_n='printf %s'
else
12890,7 → 11391,7
as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
as_echo_n_body='eval
arg=$1;
case $arg in
case $arg in #(
*"$as_nl"*)
expr "X$arg" : "X\\(.*\\)$as_nl";
arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
12913,14 → 11414,7
}
fi
 
# Support unset when possible.
if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
as_unset=unset
else
as_unset=false
fi
 
 
# IFS
# We need space, tab and new line, in precisely that order. Quoting is
# there to prevent editors from complaining about space-tab.
12929,7 → 11423,7
IFS=" "" $as_nl"
 
# Find who we are. Look in the path if we contain no directory separator.
case $0 in
case $0 in #((
*[\\/]* ) as_myself=$0 ;;
*) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
12936,8 → 11430,8
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
done
test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
done
IFS=$as_save_IFS
 
;;
12949,12 → 11443,16
fi
if test ! -f "$as_myself"; then
$as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
{ (exit 1); exit 1; }
exit 1
fi
 
# Work around bugs in pre-3.0 UWIN ksh.
for as_var in ENV MAIL MAILPATH
do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
# Unset variables that we do not need and which cause bugs (e.g. in
# pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1"
# suppresses any "Segmentation fault" message there. '((' could
# trigger a bug in pdksh 5.2.14.
for as_var in BASH_ENV ENV MAIL MAILPATH
do eval test x\${$as_var+set} = xset \
&& ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
done
PS1='$ '
PS2='> '
12966,7 → 11464,89
LANGUAGE=C
export LANGUAGE
 
# Required to use basename.
# CDPATH.
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 
 
# as_fn_error ERROR [LINENO LOG_FD]
# ---------------------------------
# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
# script with status $?, using 1 if that was 0.
as_fn_error ()
{
as_status=$?; test $as_status -eq 0 && as_status=1
if test "$3"; then
as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
$as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3
fi
$as_echo "$as_me: error: $1" >&2
as_fn_exit $as_status
} # as_fn_error
 
 
# as_fn_set_status STATUS
# -----------------------
# Set $? to STATUS, without forking.
as_fn_set_status ()
{
return $1
} # as_fn_set_status
 
# as_fn_exit STATUS
# -----------------
# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
as_fn_exit ()
{
set +e
as_fn_set_status $1
exit $1
} # as_fn_exit
 
# as_fn_unset VAR
# ---------------
# Portably unset VAR.
as_fn_unset ()
{
{ eval $1=; unset $1;}
}
as_unset=as_fn_unset
# as_fn_append VAR VALUE
# ----------------------
# Append the text in VALUE to the end of the definition contained in VAR. Take
# advantage of any shell optimizations that allow amortized linear growth over
# repeated appends, instead of the typical quadratic growth present in naive
# implementations.
if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
eval 'as_fn_append ()
{
eval $1+=\$2
}'
else
as_fn_append ()
{
eval $1=\$$1\$2
}
fi # as_fn_append
 
# as_fn_arith ARG...
# ------------------
# Perform arithmetic evaluation on the ARGs, and store the result in the
# global $as_val. Take advantage of shells that can avoid forks. The arguments
# must be portable across $(()) and expr.
if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
eval 'as_fn_arith ()
{
as_val=$(( $* ))
}'
else
as_fn_arith ()
{
as_val=`expr "$@" || test $? -eq 1`
}
fi # as_fn_arith
 
 
if expr a : '\(a\)' >/dev/null 2>&1 &&
test "X`expr 00001 : '.*\(...\)'`" = X001; then
as_expr=expr
12980,8 → 11560,12
as_basename=false
fi
 
if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
as_dirname=dirname
else
as_dirname=false
fi
 
# Name of the executable.
as_me=`$as_basename -- "$0" ||
$as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
X"$0" : 'X\(//\)$' \| \
13001,76 → 11585,25
}
s/.*/./; q'`
 
# CDPATH.
$as_unset CDPATH
# Avoid depending upon Character Ranges.
as_cr_letters='abcdefghijklmnopqrstuvwxyz'
as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
as_cr_Letters=$as_cr_letters$as_cr_LETTERS
as_cr_digits='0123456789'
as_cr_alnum=$as_cr_Letters$as_cr_digits
 
 
 
as_lineno_1=$LINENO
as_lineno_2=$LINENO
test "x$as_lineno_1" != "x$as_lineno_2" &&
test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
 
# Create $as_me.lineno as a copy of $as_myself, but with $LINENO
# uniformly replaced by the line number. The first 'sed' inserts a
# line-number line after each line using $LINENO; the second 'sed'
# does the real work. The second script uses 'N' to pair each
# line-number line with the line containing $LINENO, and appends
# trailing '-' during substitution so that $LINENO is not a special
# case at line end.
# (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
# scripts with optimization help from Paolo Bonzini. Blame Lee
# E. McMahon (1931-1989) for sed's syntax. :-)
sed -n '
p
/[$]LINENO/=
' <$as_myself |
sed '
s/[$]LINENO.*/&-/
t lineno
b
:lineno
N
:loop
s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
t loop
s/-\n.*//
' >$as_me.lineno &&
chmod +x "$as_me.lineno" ||
{ $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
{ (exit 1); exit 1; }; }
 
# Don't try to exec as it changes $[0], causing all sort of problems
# (the dirname of $[0] is not the place where we might find the
# original and so on. Autoconf is especially sensitive to this).
. "./$as_me.lineno"
# Exit status is that of the last command.
exit
}
 
 
if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
as_dirname=dirname
else
as_dirname=false
fi
 
ECHO_C= ECHO_N= ECHO_T=
case `echo -n x` in
case `echo -n x` in #(((((
-n*)
case `echo 'x\c'` in
case `echo 'xy\c'` in
*c*) ECHO_T=' ';; # ECHO_T is single tab character.
*) ECHO_C='\c';;
xy) ECHO_C='\c';;
*) echo `echo ksh88 bug on AIX 6.1` > /dev/null
ECHO_T=' ';;
esac;;
*)
ECHO_N='-n';;
esac
if expr a : '\(a\)' >/dev/null 2>&1 &&
test "X`expr 00001 : '.*\(...\)'`" = X001; then
as_expr=expr
else
as_expr=false
fi
 
rm -f conf$$ conf$$.exe conf$$.file
if test -d conf$$.dir; then
13099,8 → 11632,56
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
rmdir conf$$.dir 2>/dev/null
 
 
# as_fn_mkdir_p
# -------------
# Create "$as_dir" as a directory, including parents if necessary.
as_fn_mkdir_p ()
{
 
case $as_dir in #(
-*) as_dir=./$as_dir;;
esac
test -d "$as_dir" || eval $as_mkdir_p || {
as_dirs=
while :; do
case $as_dir in #(
*\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
*) as_qdir=$as_dir;;
esac
as_dirs="'$as_qdir' $as_dirs"
as_dir=`$as_dirname -- "$as_dir" ||
$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
X"$as_dir" : 'X\(//\)[^/]' \| \
X"$as_dir" : 'X\(//\)$' \| \
X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
$as_echo X"$as_dir" |
sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
s//\1/
q
}
/^X\(\/\/\)[^/].*/{
s//\1/
q
}
/^X\(\/\/\)$/{
s//\1/
q
}
/^X\(\/\).*/{
s//\1/
q
}
s/.*/./; q'`
test -d "$as_dir" && break
done
test -z "$as_dirs" || eval "mkdir $as_dirs"
} || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir"
 
 
} # as_fn_mkdir_p
if mkdir -p . 2>/dev/null; then
as_mkdir_p=:
as_mkdir_p='mkdir -p "$as_dir"'
else
test -d ./-p && rmdir ./-p
as_mkdir_p=false
13119,10 → 11700,10
if test -d "$1"; then
test -d "$1/.";
else
case $1 in
case $1 in #(
-*)set "./$1";;
esac;
case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
???[sx]*):;;*)false;;esac;fi
'\'' sh
'
13137,13 → 11718,19
 
 
exec 6>&1
## ----------------------------------- ##
## Main body of $CONFIG_STATUS script. ##
## ----------------------------------- ##
_ASEOF
test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
 
# Save the log message, to keep $[0] and so on meaningful, and to
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# Save the log message, to keep $0 and so on meaningful, and to
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
This file was extended by or1ksim-testsuite $as_me 0.4.0rc1, which was
generated by GNU Autoconf 2.63. Invocation command line was
generated by GNU Autoconf 2.65. Invocation command line was
 
CONFIG_FILES = $CONFIG_FILES
CONFIG_HEADERS = $CONFIG_HEADERS
13175,13 → 11762,15
 
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
ac_cs_usage="\
\`$as_me' instantiates files from templates according to the
current configuration.
\`$as_me' instantiates files and other configuration actions
from templates according to the current configuration. Unless the files
and actions are specified as TAGs, all are instantiated by default.
 
Usage: $0 [OPTION]... [FILE]...
Usage: $0 [OPTION]... [TAG]...
 
-h, --help print this help, then exit
-V, --version print version number and configuration settings, then exit
--config print configuration, then exit
-q, --quiet, --silent
do not print progress messages
-d, --debug don't remove temporary files
13200,16 → 11789,17
Configuration commands:
$config_commands
 
Report bugs to <bug-autoconf@gnu.org>."
Report bugs to <openrisc@opencores.org>."
 
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
or1ksim-testsuite config.status 0.4.0rc1
configured by $0, generated by GNU Autoconf 2.63,
with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
configured by $0, generated by GNU Autoconf 2.65,
with options \\"\$ac_cs_config\\"
 
Copyright (C) 2008 Free Software Foundation, Inc.
Copyright (C) 2009 Free Software Foundation, Inc.
This config.status script is free software; the Free Software Foundation
gives unlimited permission to copy, distribute and modify it."
 
13245,6 → 11835,8
ac_cs_recheck=: ;;
--version | --versio | --versi | --vers | --ver | --ve | --v | -V )
$as_echo "$ac_cs_version"; exit ;;
--config | --confi | --conf | --con | --co | --c )
$as_echo "$ac_cs_config"; exit ;;
--debug | --debu | --deb | --de | --d | -d )
debug=: ;;
--file | --fil | --fi | --f )
13252,7 → 11844,7
case $ac_optarg in
*\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
esac
CONFIG_FILES="$CONFIG_FILES '$ac_optarg'"
as_fn_append CONFIG_FILES " '$ac_optarg'"
ac_need_defaults=false;;
--header | --heade | --head | --hea )
$ac_shift
13259,13 → 11851,12
case $ac_optarg in
*\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
esac
CONFIG_HEADERS="$CONFIG_HEADERS '$ac_optarg'"
as_fn_append CONFIG_HEADERS " '$ac_optarg'"
ac_need_defaults=false;;
--he | --h)
# Conflict between --help and --header
{ $as_echo "$as_me: error: ambiguous option: $1
Try \`$0 --help' for more information." >&2
{ (exit 1); exit 1; }; };;
as_fn_error "ambiguous option: \`$1'
Try \`$0 --help' for more information.";;
--help | --hel | -h )
$as_echo "$ac_cs_usage"; exit ;;
-q | -quiet | --quiet | --quie | --qui | --qu | --q \
13273,11 → 11864,10
ac_cs_silent=: ;;
 
# This is an error.
-*) { $as_echo "$as_me: error: unrecognized option: $1
Try \`$0 --help' for more information." >&2
{ (exit 1); exit 1; }; } ;;
-*) as_fn_error "unrecognized option: \`$1'
Try \`$0 --help' for more information." ;;
 
*) ac_config_targets="$ac_config_targets $1"
*) as_fn_append ac_config_targets " $1"
ac_need_defaults=false ;;
 
esac
13623,9 → 12213,7
"uos/Makefile") CONFIG_FILES="$CONFIG_FILES uos/Makefile" ;;
"upcalls/Makefile") CONFIG_FILES="$CONFIG_FILES upcalls/Makefile" ;;
 
*) { { $as_echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
$as_echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
{ (exit 1); exit 1; }; };;
*) as_fn_error "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
esac
done
 
13652,7 → 12240,7
trap 'exit_status=$?
{ test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
' 0
trap '{ (exit 1); exit 1; }' 1 2 13 15
trap 'as_fn_exit 1' 1 2 13 15
}
# Create a (secure) tmp directory for tmp files.
 
13663,11 → 12251,7
{
tmp=./conf$$-$RANDOM
(umask 077 && mkdir "$tmp")
} ||
{
$as_echo "$as_me: cannot create a temporary directory in ." >&2
{ (exit 1); exit 1; }
}
} || as_fn_error "cannot create a temporary directory in ." "$LINENO" 5
 
# Set up the scripts for CONFIG_FILES section.
# No need to generate them if there are no CONFIG_FILES.
13675,11 → 12259,16
if test -n "$CONFIG_FILES"; then
 
 
-' +ac_cr=`echo X | tr X '\015'` +# On cygwin, bash can eat \r inside `` if the user requested igncr. +# But we know of no other shell where ac_cr would be empty at this +# point, so we can use a bashism as a fallback. +if test "x$ac_cr" = x; then + eval ac_cr=\$\'\\r\' +fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then - ac_cs_awk_cr='\\r' + ac_cs_awk_cr='\r' else ac_cs_awk_cr=$ac_cr fi @@ -13693,24 +12282,18 @@ echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && echo "_ACEOF" } >conf$$subs.sh || - { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5 -$as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;} - { (exit 1); exit 1; }; } + as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_num=`echo "$ac_subst_vars" | grep -c '$'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || - { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5 -$as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;} - { (exit 1); exit 1; }; } + as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then - { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5 -$as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;} - { (exit 1); exit 1; }; } + as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi @@ -13732,7 +12315,7 @@ t delim :nl h -s/\(.\{148\}\).*/\1/ +s/\(.\{148\}\)..*/\1/ t more1 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ p @@ -13746,7 +12329,7 @@ t nl :delim h -s/\(.\{148\}\).*/\1/ +s/\(.\{148\}\)..*/\1/ t more2 s/["\\]/\\&/g; s/^/"/; s/$/"/ p @@ -13799,9 +12382,7 @@ else cat fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \ - || { { $as_echo "$as_me:$LINENO: error: could not setup config files machinery" >&5 -$as_echo "$as_me: error: could not setup config files machinery" >&2;} - { (exit 1); exit 1; }; } + || as_fn_error "could not setup config files machinery" "$LINENO" 5 _ACEOF # VPATH may cause trouble with some makes, so we remove $(srcdir), @@ -13842,9 +12423,7 @@ if test -z "$ac_t"; then break elif $ac_last_try; then - { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_HEADERS" >&5 -$as_echo "$as_me: error: could not make $CONFIG_HEADERS" >&2;} - { (exit 1); exit 1; }; } + as_fn_error "could not make $CONFIG_HEADERS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi @@ -13929,9 +12508,7 @@ _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 - { { $as_echo "$as_me:$LINENO: error: could not setup config headers machinery" >&5 -$as_echo "$as_me: error: could not setup config headers machinery" >&2;} - { (exit 1); exit 1; }; } + as_fn_error "could not setup config headers machinery" "$LINENO" 5 fi # test -n "$CONFIG_HEADERS" @@ -13944,9 +12521,7 @@ esac case $ac_mode$ac_tag in :[FHL]*:*);; - :L* | :C*:*) { { $as_echo "$as_me:$LINENO: error: invalid tag $ac_tag" >&5 -$as_echo "$as_me: error: invalid tag $ac_tag" >&2;} - { (exit 1); exit 1; }; };; + :L* | :C*:*) as_fn_error "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac @@ -13974,12 +12549,10 @@ [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || - { { $as_echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5 -$as_echo "$as_me: error: cannot find input file: $ac_f" >&2;} - { (exit 1); exit 1; }; };; + as_fn_error "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac - ac_file_inputs="$ac_file_inputs '$ac_f'" + as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't @@ -13990,7 +12563,7 @@ `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" - { $as_echo "$as_me:$LINENO: creating $ac_file" >&5 + { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. @@ -14003,9 +12576,7 @@ case $ac_tag in *:-:* | *:-) cat >"$tmp/stdin" \ - || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5 -$as_echo "$as_me: error: could not create $ac_file" >&2;} - { (exit 1); exit 1; }; } ;; + || as_fn_error "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac @@ -14033,47 +12604,7 @@ q } s/.*/./; q'` - { as_dir="$ac_dir" - case $as_dir in #( - -*) as_dir=./$as_dir;; - esac - test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || { - as_dirs= - while :; do - case $as_dir in #( - *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( - *) as_qdir=$as_dir;; - esac - as_dirs="'$as_qdir' $as_dirs" - as_dir=`$as_dirname -- "$as_dir" || -$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$as_dir" : 'X\(//\)[^/]' \| \ - X"$as_dir" : 'X\(//\)$' \| \ - X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$as_dir" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - test -d "$as_dir" && break - done - test -z "$as_dirs" || eval "mkdir $as_dirs" - } || test -d "$as_dir" || { { $as_echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5 -$as_echo "$as_me: error: cannot create directory $as_dir" >&2;} - { (exit 1); exit 1; }; }; } + as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in @@ -14130,7 +12661,6 @@ # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= - ac_sed_dataroot=' /datarootdir/ { p @@ -14140,12 +12670,11 @@ /@docdir@/p /@infodir@/p /@localedir@/p -/@mandir@/p -' +/@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) - { $as_echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 @@ -14155,7 +12684,7 @@ s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g - s&\\\${datarootdir}&$datarootdir&g' ;; + s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF @@ -14184,14 +12713,12 @@ $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \ - || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5 -$as_echo "$as_me: error: could not create $ac_file" >&2;} - { (exit 1); exit 1; }; } + || as_fn_error "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } && - { $as_echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir' + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined." >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined." >&2;} @@ -14201,9 +12728,7 @@ -) cat "$tmp/out" && rm -f "$tmp/out";; *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";; esac \ - || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5 -$as_echo "$as_me: error: could not create $ac_file" >&2;} - { (exit 1); exit 1; }; } + || as_fn_error "could not create $ac_file" "$LINENO" 5 ;; :H) # @@ -14214,25 +12739,19 @@ $as_echo "/* $configure_input */" \ && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" } >"$tmp/config.h" \ - || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5 -$as_echo "$as_me: error: could not create $ac_file" >&2;} - { (exit 1); exit 1; }; } + || as_fn_error "could not create $ac_file" "$LINENO" 5 if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then - { $as_echo "$as_me:$LINENO: $ac_file is unchanged" >&5 + { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 $as_echo "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" mv "$tmp/config.h" "$ac_file" \ - || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5 -$as_echo "$as_me: error: could not create $ac_file" >&2;} - { (exit 1); exit 1; }; } + || as_fn_error "could not create $ac_file" "$LINENO" 5 fi else $as_echo "/* $configure_input */" \ && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \ - || { { $as_echo "$as_me:$LINENO: error: could not create -" >&5 -$as_echo "$as_me: error: could not create -" >&2;} - { (exit 1); exit 1; }; } + || as_fn_error "could not create -" "$LINENO" 5 fi # Compute "$ac_file"'s index in $config_headers. _am_arg="$ac_file" @@ -14270,7 +12789,7 @@ s/.*/./; q'`/stamp-h$_am_stamp_count ;; - :C) { $as_echo "$as_me:$LINENO: executing $ac_file commands" >&5 + :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5 $as_echo "$as_me: executing $ac_file commands" >&6;} ;; esac @@ -15000,47 +13519,7 @@ q } s/.*/./; q'` - { as_dir=$dirpart/$fdir - case $as_dir in #( - -*) as_dir=./$as_dir;; - esac - test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || { - as_dirs= - while :; do - case $as_dir in #( - *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( - *) as_qdir=$as_dir;; - esac - as_dirs="'$as_qdir' $as_dirs" - as_dir=`$as_dirname -- "$as_dir" || -$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ - X"$as_dir" : 'X\(//\)[^/]' \| \ - X"$as_dir" : 'X\(//\)$' \| \ - X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || -$as_echo X"$as_dir" | - sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ - s//\1/ - q - } - /^X\(\/\/\)[^/].*/{ - s//\1/ - q - } - /^X\(\/\/\)$/{ - s//\1/ - q - } - /^X\(\/\).*/{ - s//\1/ - q - } - s/.*/./; q'` - test -d "$as_dir" && break - done - test -z "$as_dirs" || eval "mkdir $as_dirs" - } || test -d "$as_dir" || { { $as_echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5 -$as_echo "$as_me: error: cannot create directory $as_dir" >&2;} - { (exit 1); exit 1; }; }; } + as_dir=$dirpart/$fdir; as_fn_mkdir_p # echo "creating $dirpart/$file" echo '# dummy' > "$dirpart/$file" done @@ -15052,15 +13531,12 @@ done # for ac_tag -{ (exit 0); exit 0; } +as_fn_exit 0 _ACEOF -chmod +x $CONFIG_STATUS ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || - { { $as_echo "$as_me:$LINENO: error: write failure creating $CONFIG_STATUS" >&5 -$as_echo "$as_me: error: write failure creating $CONFIG_STATUS" >&2;} - { (exit 1); exit 1; }; } + as_fn_error "write failure creating $CONFIG_STATUS" "$LINENO" 5 # configure is writing to config.log, and then calls config.status. @@ -15081,10 +13557,10 @@ exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. - $ac_cs_success || { (exit 1); exit 1; } + $ac_cs_success || as_fn_exit $? fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then - { $as_echo "$as_me:$LINENO: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 + { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi
/test-code-or1k/basic/Makefile.in
154,6 → 154,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/Makefile.in
185,6 → 185,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/cbasic/Makefile.in
149,6 → 149,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/mc-common/Makefile.in
151,6 → 151,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/except/Makefile.in
151,6 → 151,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/tick/Makefile.in
149,6 → 149,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/functest/Makefile.in
149,6 → 149,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/mem-test/Makefile.in
149,6 → 149,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/ext/Makefile.in
154,6 → 154,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/kbdtest/Makefile.in
149,6 → 149,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/mycompress/Makefile.in
149,6 → 149,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/upcalls/Makefile.in
157,6 → 157,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/cache/Makefile.in
154,6 → 154,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/int-logger/Makefile.in
157,6 → 157,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/loop/Makefile.in
15,7 → 15,7
 
@SET_MAKE@
 
# Makefile.am for or1ksim OR1K test program: loop
# Makefile.am for or1ksim OR1K various loop test programs.
 
# Copyright (C) Embecosm Limited, 2010
 
58,7 → 58,7
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
check_PROGRAMS = loop$(EXEEXT)
check_PROGRAMS = loop$(EXEEXT) loop-init$(EXEEXT) loop-report$(EXEEXT)
subdir = loop
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
78,6 → 78,19
loop_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(loop_LDFLAGS) \
$(LDFLAGS) -o $@
am_loop_init_OBJECTS = loop-init.$(OBJEXT)
loop_init_OBJECTS = $(am_loop_init_OBJECTS)
loop_init_DEPENDENCIES = ../except/except.lo ../support/libsupport.la
loop_init_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
$(loop_init_LDFLAGS) $(LDFLAGS) -o $@
am_loop_report_OBJECTS = loop-report.$(OBJEXT)
loop_report_OBJECTS = $(am_loop_report_OBJECTS)
loop_report_DEPENDENCIES = ../except/except.lo \
../support/libsupport.la
loop_report_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
$(loop_report_LDFLAGS) $(LDFLAGS) -o $@
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/../../depcomp
am__depfiles_maybe = depfiles
91,8 → 104,9
LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
$(LDFLAGS) -o $@
SOURCES = $(loop_SOURCES)
DIST_SOURCES = $(loop_SOURCES)
SOURCES = $(loop_SOURCES) $(loop_init_SOURCES) $(loop_report_SOURCES)
DIST_SOURCES = $(loop_SOURCES) $(loop_init_SOURCES) \
$(loop_report_SOURCES)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
149,6 → 163,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
210,11 → 225,27
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
 
# Simple loop
loop_SOURCES = loop.c
loop_LDFLAGS = -T$(srcdir)/../default.ld
loop_LDADD = ../except/except.lo \
../support/libsupport.la
 
 
# Loop with initialization
loop_init_SOURCES = loop-init.c
loop_init_LDFLAGS = -T$(srcdir)/../default.ld
loop_init_LDADD = ../except/except.lo \
../support/libsupport.la
 
 
# Loop with reporting
loop_report_SOURCES = loop-report.c
loop_report_LDFLAGS = -T$(srcdir)/../default.ld
loop_report_LDADD = ../except/except.lo \
../support/libsupport.la
 
all: all-am
 
.SUFFIXES:
261,6 → 292,12
loop$(EXEEXT): $(loop_OBJECTS) $(loop_DEPENDENCIES)
@rm -f loop$(EXEEXT)
$(loop_LINK) $(loop_OBJECTS) $(loop_LDADD) $(LIBS)
loop-init$(EXEEXT): $(loop_init_OBJECTS) $(loop_init_DEPENDENCIES)
@rm -f loop-init$(EXEEXT)
$(loop_init_LINK) $(loop_init_OBJECTS) $(loop_init_LDADD) $(LIBS)
loop-report$(EXEEXT): $(loop_report_OBJECTS) $(loop_report_DEPENDENCIES)
@rm -f loop-report$(EXEEXT)
$(loop_report_LINK) $(loop_report_OBJECTS) $(loop_report_LDADD) $(LIBS)
 
mostlyclean-compile:
-rm -f *.$(OBJEXT)
268,6 → 305,8
distclean-compile:
-rm -f *.tab.c
 
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/loop-init.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/loop-report.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/loop.Po@am__quote@
 
.c.o:
/test-code-or1k/loop/loop-report.c
0,0 → 1,265
/* loop-report.c. Or1ksim simple C loop program which reports changes.
 
Copyright (C) 1999-2006 OpenCores
Copyright (C) 2010 Embecosm Limited
 
Contributors various OpenCores participants
Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
This file is part of OpenRISC 1000 Architectural Simulator.
 
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 <http: www.gnu.org/licenses/>. */
 
/* ----------------------------------------------------------------------------
This code is commented throughout for use with Doxygen.
--------------------------------------------------------------------------*/
 
/* A program which initializes memory and SPR, then just loops. Used in
testing libor1ksim JTAG read functionality. */
 
#include "support.h"
#include "spr-defs.h"
 
/*---------------------------------------------------------------------------*/
/*!main program
 
We have two blocks of memory of interest (0x00000000 - 0x00200000,
0xffe0000 - 0xffffffff) and two SPRs of interest (MACLO, 0x2801 and MACHI,
0x2802). We monitor for any changes in the first 16 and last 16 bytes of
each memory block, the middle 16 of the first memory block and both SPRs,
having first initialized them to zero.
 
We have to be careful about strobing. We sit in a loop looking for changes,
but only print out the changes after we have had one loop with no changes.
 
@return The return code from the program (of no interest to us). */
/*---------------------------------------------------------------------------*/
int
main ()
{
/* Useful constants */
unsigned char *b0_start_addr = (unsigned char *) 0x00000000;
unsigned char *b0_mid_addr = (unsigned char *) 0x00100000;
unsigned char *b0_end_addr = (unsigned char *) 0x001ffff0;
unsigned char *b1_start_addr = (unsigned char *) 0xffe00000;
unsigned char *b1_end_addr = (unsigned char *) 0xfffffff0;
/* General purpose */
unsigned long int r;
int i;
 
/* Values remembered */
unsigned long int maclo;
unsigned long int machi;
 
unsigned char b0_start[16];
unsigned char b0_mid[16];
unsigned char b0_end[16];
unsigned char b1_start[16];
unsigned char b1_end[16];
 
/* Flags indicating change */
int maclo_f;
int machi_f;
 
int b0_start_f[16];
int b0_mid_f[16];
int b0_end_f[16];
int b1_start_f[16];
int b1_end_f[16];
 
int changed_since_print;
 
/* Set the SR to have SUMRA bit set, so that we can access certain regs in
user mode. */
r = mfspr (SPR_SR);
mtspr (SPR_SR, r | SPR_SR_SUMRA);
 
/* Initialize remembered values and flags */
maclo = 0;
machi = 0;
 
maclo_f = 0;
machi_f = 0;
 
for (i = 0; i < 16; i++)
{
b0_start[i] = 0;
b0_mid[i] = 0;
b0_end[i] = 0;
b1_start[i] = 0;
b1_end[i] = 0;
 
b0_start_f[i] = 0;
b0_mid_f[i] = 0;
b0_end_f[i] = 0;
b1_start_f[i] = 0;
b1_end_f[i] = 0;
}
 
/* Set the values in SPR and memory */
mtspr (SPR_MACLO, maclo);
mtspr (SPR_MACHI, machi);
 
for (i = 0; i < 16; i++)
{
b0_start_addr[i] = b0_start[i];
b0_mid_addr[i] = b0_mid[i];
b0_end_addr[i] = b0_end[i];
b1_start_addr[i] = b1_start[i];
b1_end_addr[i] = b1_end[i];
}
 
/* Loop for ever checking if any values have changed. */
changed_since_print = 0;
 
while (1)
{
int changed_this_loop = 0;
 
/* Check SPRs */
if (mfspr (SPR_MACLO) != maclo)
{
maclo = mfspr (SPR_MACLO);
maclo_f = 1;
changed_since_print = 1;
changed_this_loop = 1;
}
 
if (mfspr (SPR_MACHI) != machi)
{
machi = mfspr (SPR_MACHI);
machi_f = 1;
changed_since_print = 1;
changed_this_loop = 1;
}
 
/* Check memory blocks */
for (i = 0; i < 16; i++)
{
if (b0_start_addr[i] != b0_start[i])
{
b0_start[i] = b0_start_addr[i];
b0_start_f[i] = 1;
changed_since_print = 1;
changed_this_loop = 1;
}
 
if (b0_mid_addr[i] != b0_mid[i])
{
b0_mid[i] = b0_mid_addr[i];
b0_mid_f[i] = 1;
changed_since_print = 1;
changed_this_loop = 1;
}
 
if (b0_end_addr[i] != b0_end[i])
{
b0_end[i] = b0_end_addr[i];
b0_end_f[i] = 1;
changed_since_print = 1;
changed_this_loop = 1;
}
 
if (b1_start_addr[i] != b1_start[i])
{
b1_start[i] = b1_start_addr[i];
b1_start_f[i] = 1;
changed_since_print = 1;
changed_this_loop = 1;
}
 
if (b1_end_addr[i] != b1_end[i])
{
b1_end[i] = b1_end_addr[i];
b1_end_f[i] = 1;
changed_since_print = 1;
changed_this_loop = 1;
}
}
 
/* Only print out if there have been changes since the last print, but
not during this loop. This makes sure we don't strobe with writing
from JTAG. */
if (changed_since_print && !changed_this_loop)
{
/* Print any changed SPRs */
if (maclo_f)
{
printf ("New MACLO 0x%08lx\n", maclo);
maclo_f = 0;
}
 
if (machi_f)
{
printf ("New MACHI 0x%08lx\n", machi);
machi_f = 0;
}
 
/* Print any changed memory. Each in its own loop to give ascending
order. */
for (i = 0; i < 16; i++)
{
if (b0_start_f[i])
{
printf ("New byte at 0x%08lx = 0x%02x\n",
(unsigned long int) &b0_start_addr[i], b0_start[i]);
b0_start_f[i] = 0;
}
}
 
for (i = 0; i < 16; i++)
{
if (b0_mid_f[i])
{
printf ("New byte at 0x%08lx = 0x%02x\n",
(unsigned long int) &b0_mid_addr[i], b0_mid[i]);
b0_mid_f[i] = 0;
}
}
 
for (i = 0; i < 16; i++)
{
if (b0_end_f[i])
{
printf ("New byte at 0x%08lx = 0x%02x\n",
(unsigned long int) &b0_end_addr[i], b0_end[i]);
b0_end_f[i] = 0;
}
}
 
for (i = 0; i < 16; i++)
{
if (b1_start_f[i])
{
printf ("New byte at 0x%08lx = 0x%02x\n",
(unsigned long int) &b1_start_addr[i], b1_start[i]);
b1_start_f[i] = 0;
}
}
 
for (i = 0; i < 16; i++)
{
if (b1_end_f[i])
{
printf ("New byte at 0x%08lx = 0x%02x\n",
(unsigned long int) &b1_end_addr[i], b1_end[i]);
b1_end_f[i] = 0;
}
}
 
changed_since_print = 0; /* Start it all again */
}
}
} /* main () */
test-code-or1k/loop/loop-report.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: test-code-or1k/loop/Makefile.am =================================================================== --- test-code-or1k/loop/Makefile.am (revision 97) +++ test-code-or1k/loop/Makefile.am (revision 98) @@ -1,4 +1,4 @@ -# Makefile.am for or1ksim OR1K test program: loop +# Makefile.am for or1ksim OR1K various loop test programs. # Copyright (C) Embecosm Limited, 2010 @@ -24,9 +24,15 @@ # ----------------------------------------------------------------------------- -# A test program which just loops. -check_PROGRAMS = loop +# Test programs which just loop. One does nothing, one initializes certain +# addresses and SPR's (for testing reading through JTAG), one reports certain +# addresses and SPR's which have been changed (for testing writing through +# JTAG). +check_PROGRAMS = loop \ + loop-init \ + loop-report +# Simple loop loop_SOURCES = loop.c loop_LDFLAGS = -T$(srcdir)/../default.ld @@ -33,3 +39,19 @@ loop_LDADD = ../except/except.lo \ ../support/libsupport.la + +# Loop with initialization +loop_init_SOURCES = loop-init.c + +loop_init_LDFLAGS = -T$(srcdir)/../default.ld + +loop_init_LDADD = ../except/except.lo \ + ../support/libsupport.la + +# Loop with reporting +loop_report_SOURCES = loop-report.c + +loop_report_LDFLAGS = -T$(srcdir)/../default.ld + +loop_report_LDADD = ../except/except.lo \ + ../support/libsupport.la
/test-code-or1k/loop/loop-init.c
0,0 → 1,99
/* loop-init.c. Or1ksim simple C loop program which initializes data.
 
Copyright (C) 1999-2006 OpenCores
Copyright (C) 2010 Embecosm Limited
 
Contributors various OpenCores participants
Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
This file is part of OpenRISC 1000 Architectural Simulator.
 
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 <http: www.gnu.org/licenses/>. */
 
/* ----------------------------------------------------------------------------
This code is commented throughout for use with Doxygen.
--------------------------------------------------------------------------*/
 
/* A program which initializes memory and SPR, then just loops. Used in
testing libor1ksim JTAG read functionality. */
 
#include "support.h"
#include "spr-defs.h"
 
int
main ()
{
unsigned long int r;
int i;
 
/* Set the SR to have SUMRA bit set, so that we can access certain regs in
user mode. */
r = mfspr (SPR_SR);
mtspr (SPR_SR, r | SPR_SR_SUMRA);
 
/* Set the MACLO and MACHI regs */
mtspr (SPR_MACLO, 0xdeadbeef);
mtspr (SPR_MACHI, 0xcafebabe);
 
/* Set main memory starting at 0x100000. Set at later intervals 2^16 bytes
further on as well. */
for (i = 0; i < 16; i++)
{
unsigned char *block0 = (unsigned char *) (0x100000 + i);
unsigned char *block1 = (unsigned char *) (0x110000 + i);
unsigned char *block2 = (unsigned char *) (0x120000 + i);
 
*block0 = 16 + i;
*block1 = 32 + i;
*block2 = 48 + i;
}
 
/* Set the top of each memory block and the bottom of the second memory
block to a defined sequence. */
unsigned char *mem1top = (unsigned char *) (0x001ffff8);
unsigned char *mem2bot = (unsigned char *) (0xffe00000);
unsigned char *mem2top = (unsigned char *) (0xfffffff8);
 
mem1top[0] = 0xde;
mem1top[1] = 0xad;
mem1top[2] = 0xbe;
mem1top[3] = 0xef;
mem1top[4] = 0xca;
mem1top[5] = 0xfe;
mem1top[6] = 0xba;
mem1top[7] = 0xbe;
 
mem2bot[0] = 0xde;
mem2bot[1] = 0xad;
mem2bot[2] = 0xbe;
mem2bot[3] = 0xef;
mem2bot[4] = 0xca;
mem2bot[5] = 0xfe;
mem2bot[6] = 0xba;
mem2bot[7] = 0xbe;
 
mem2top[0] = 0xde;
mem2top[1] = 0xad;
mem2top[2] = 0xbe;
mem2top[3] = 0xef;
mem2top[4] = 0xca;
mem2top[5] = 0xfe;
mem2top[6] = 0xba;
mem2top[7] = 0xbe;
 
/* Loop for ever doing stuff */
while (1)
{
}
} /* main () */
test-code-or1k/loop/loop-init.c Property changes : Added: svn:eol-style ## -0,0 +1 ## +native \ No newline at end of property Added: svn:keywords ## -0,0 +1 ## +Id \ No newline at end of property Index: test-code-or1k/mc-dram/Makefile.in =================================================================== --- test-code-or1k/mc-dram/Makefile.in (revision 97) +++ test-code-or1k/mc-dram/Makefile.in (revision 98) @@ -150,6 +150,7 @@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ Index: test-code-or1k/mc-ssram/Makefile.in =================================================================== --- test-code-or1k/mc-ssram/Makefile.in (revision 97) +++ test-code-or1k/mc-ssram/Makefile.in (revision 98) @@ -150,6 +150,7 @@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ Index: test-code-or1k/acv-uart/Makefile.in =================================================================== --- test-code-or1k/acv-uart/Makefile.in (revision 97) +++ test-code-or1k/acv-uart/Makefile.in (revision 98) @@ -151,6 +151,7 @@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ Index: test-code-or1k/inst-set-test/Makefile.in =================================================================== --- test-code-or1k/inst-set-test/Makefile.in (revision 97) +++ test-code-or1k/inst-set-test/Makefile.in (revision 98) @@ -150,6 +150,7 @@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ Index: test-code-or1k/ChangeLog =================================================================== --- test-code-or1k/ChangeLog (revision 97) +++ test-code-or1k/ChangeLog (revision 98) @@ -1,3 +1,16 @@ +2010-05-18 Jeremy Bennett + * loop/loop-init.c (main): Initialize top of each memory block. + * loop/loop-report.c (main): Rewritten to ensure reliable + reporting of results. + +2010-05-11 Jeremy Bennett + * loop/loop-init.c: Looping program with SPR and memory + initialization. + * loop/loop-report.c: Looping program which reports changes to SPR + and memory. + * loop/Makefile.am: Update for new programs. + * loop/Makefile.in: Regenerated. + 2010-04-28 Jeremy Bennett * int-logger/int-logger-edge.c: Created. * int-logger/Makefile.am: Added int-logger-edge. Index: test-code-or1k/fbtest/Makefile.in =================================================================== --- test-code-or1k/fbtest/Makefile.in (revision 97) +++ test-code-or1k/fbtest/Makefile.in (revision 98) @@ -149,6 +149,7 @@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ Index: test-code-or1k/local-global/Makefile.in =================================================================== --- test-code-or1k/local-global/Makefile.in (revision 97) +++ test-code-or1k/local-global/Makefile.in (revision 98) @@ -150,6 +150,7 @@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ Index: test-code-or1k/mul/Makefile.in =================================================================== --- test-code-or1k/mul/Makefile.in (revision 97) +++ test-code-or1k/mul/Makefile.in (revision 98) @@ -149,6 +149,7 @@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ Index: test-code-or1k/mmu/Makefile.in =================================================================== --- test-code-or1k/mmu/Makefile.in (revision 97) +++ test-code-or1k/mmu/Makefile.in (revision 98) @@ -154,6 +154,7 @@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ Index: test-code-or1k/cfg/Makefile.in =================================================================== --- test-code-or1k/cfg/Makefile.in (revision 97) +++ test-code-or1k/cfg/Makefile.in (revision 98) @@ -154,6 +154,7 @@ PACKAGE_NAME = @PACKAGE_NAME@ PACKAGE_STRING = @PACKAGE_STRING@ PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ RANLIB = @RANLIB@ Index: test-code-or1k/config.h.in =================================================================== --- test-code-or1k/config.h.in (revision 97) +++ test-code-or1k/config.h.in (revision 98) @@ -76,6 +76,9 @@ /* Define to the one symbol short name of this package. */ #undef PACKAGE_TARNAME +/* Define to the home page for this package. */ +#undef PACKAGE_URL + /* Define to the version of this package. */ #undef PACKAGE_VERSION
/test-code-or1k/dmatest/Makefile.in
149,6 → 149,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/except-test/Makefile.in
154,6 → 154,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/acv-gpio/Makefile.in
151,6 → 151,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/dhry/Makefile.in
149,6 → 149,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/uos/Makefile.in
157,6 → 157,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/int-test/Makefile.in
154,6 → 154,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/flag/Makefile.in
154,6 → 154,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/exit/Makefile.in
149,6 → 149,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/mc-sync/Makefile.in
150,6 → 150,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/mc-async/Makefile.in
150,6 → 150,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/support/Makefile.in
146,6 → 146,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
/test-code-or1k/aclocal.m4
13,8 → 13,8
 
m4_ifndef([AC_AUTOCONF_VERSION],
[m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.63],,
[m4_warning([this file was generated for autoconf 2.63.
m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.65],,
[m4_warning([this file was generated for autoconf 2.65.
You have another version of autoconf. It may work, but is not guaranteed to.
If you have problems, you may need to regenerate the build system entirely.
To do so, use the procedure documented by the package, typically `autoreconf'.])])
/Makefile.in
183,6 → 183,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
POW_LIB = @POW_LIB@
/config/Makefile.in
140,6 → 140,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
POW_LIB = @POW_LIB@
/lib/Makefile.in
140,6 → 140,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
POW_LIB = @POW_LIB@
/or1ksim.tests/Makefile.in
140,6 → 140,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
POW_LIB = @POW_LIB@
/ChangeLog
1,3 → 1,56
2010-05-19 Jeremy Bennett <jeremy.bennett@embecosm.com>
* libsim.tests/Makefile.am: upcalls.exp added to distribution.
* libsim.tests/Makefile.in: Regenerated.
 
2010-05-18 Jeremy Bennett <jeremy.bennett@embecosm.com>
* libsim.tests/default.cfg: Disabled MC, replaced with memory block
and set CPU to take vectors at high address.
* test-code/lib-jtag/lib-jtag-full.c: Increase time quanta to 3ms to
allow time for messages.
 
2010-05-16 Jeremy Bennett <jeremy.bennett@embecosm.com>
* libsim.tests/Makefile.am: Added new test files to dist
* libsim.tests/Makefile: Regenerated.
* libsim.tests/jtag-go-command-read.exp: New file.
* libsim.tests/jtag-go-command-write.exp: New file.
* libsim.tests/jtag-read-command.exp: Tests updated for new interface.
* libsim.tests/jtag-read-control.exp: New file.
* libsim.tests/jtag-select-module.exp: Tests updated for new
interface. All tests related to subsequent commands moved to their own
tests.
* libsim.tests/jtag-write-command.exp: Tests updated for new interface.
* libsim.tests/jtag-write-control.exp: New file.
* test-code/lib-jtag/lib-jtag.c: Interface changed to allow use of new
JTAG library interface with bit lengths.
* test-code/lib-jtag/lib-jtag-full.c: Use new JTAG library interface
with bit lengths.
 
 
2010-05-14 Jeremy Bennett <jeremy.bennett@embecosm.com>
* libsim.tests/jtag-read-command.exp: Better test naming.
* libsim.tests/jtag-select-module.exp: Better test naming.
* libsim.tests/jtag-write-command.exp: Better test naming.
* libsim.tests/jtag-select-module.exp
<SELECT_MODULE READ_COMMAND WB>: Check for correct access type.
<SELECT_MODULE READ_COMMAND CPU0>: Check for correct access type.
<SELECT_MODULE READ_COMMAND CPU1>: Check for correct access type.
<SELECT_MODULE READ_COMMAND module 4>: Check for correct access type.
<SELECT_MODULE READ_COMMAND module 14>: Check for correct access
type.
 
2010-05-13 Jeremy Bennett <jeremy.bennett@embecosm.com>
* libsim.tests/default.cfg: Add memory block at top of memory.
* libsim.tests/lib-jtag-full.c: Corrected some error messages.
* libsim.tests/Makefile.am: Added new JTAG test files.
* libsim.tests/Makefile.in: Regenerated.
* libsim.tests/jtag-read-command.exp: Break out READ_COMMAND tests.
* libsim.tests/jtag-select-module.exp: Break out SELECT_MODULE tests.
* libsim.tests/jtag-write-command.exp: Break out WRITE_COMMAND tests.
* README: Updated with new tests.
* test-code/lib-jtag/lib-jtag-full.c (process_read_command):
Corrected printout of access_type.
 
2010-05-04 Jeremy Bennett <jeremy.bennett@embecosm.com>
* configure.ac: lib-jtag/Makefile.am added as output
* configure: Regenerated
/test-code/Makefile.in
179,6 → 179,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
POW_LIB = @POW_LIB@
/test-code/lib-iftest/Makefile.in
159,6 → 159,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
POW_LIB = @POW_LIB@
/test-code/lib-upcalls/Makefile.in
156,6 → 156,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
POW_LIB = @POW_LIB@
/test-code/lib-jtag/Makefile.in
159,6 → 159,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
POW_LIB = @POW_LIB@
/test-code/lib-jtag/lib-jtag-full.c
201,7 → 201,7
 
dump_jreg (" shifting in", jreg, 1);
 
double t = or1ksim_jtag_shift_ir (jreg);
double t = or1ksim_jtag_shift_ir (jreg, 4);
 
dump_jreg (" shifted out", jreg, 1);
printf (" time taken: %.12fs\n", t);
295,7 → 295,7
 
/* Note what we are shifting in and shift it. */
dump_jreg (" shifting in", jreg, num_bytes);
double t = or1ksim_jtag_shift_dr (jreg);
double t = or1ksim_jtag_shift_dr (jreg, 32 + 4 + 32 + 4 + 1);
 
/* Diagnose what we are shifting out. */
dump_jreg (" shifted out", jreg, num_bytes);
397,11 → 397,16
return 0;
}
 
if (len > 0xffff)
if ((len + 1) < 0x1)
{
printf ("ERROR: WRITE_COMMAND length 0x%lx too large\n", len);
printf ("ERROR: WRITE_COMMAND length 0x%lx too small\n", len + 1);
return 0;
}
else if ((len + 1) > 0x10000)
{
printf ("ERROR: WRITE_COMMAND length 0x%lx too large\n", len + 1);
return 0;
}
 
/* Compute the CRC */
unsigned long int crc_in;
466,7 → 471,7
 
/* Note what we are shifting in and shift it. */
dump_jreg (" shifting in", jreg, num_bytes);
double t = or1ksim_jtag_shift_dr (jreg);
double t = or1ksim_jtag_shift_dr (jreg, 32 + 4 + 32 + 16 + 32 + 4 + 4 + 1);
 
/* Diagnose what we are shifting out. */
dump_jreg (" shifted out", jreg, num_bytes);
581,7 → 586,7
 
/* Note what we are shifting in and shift it. */
dump_jreg (" shifting in", jreg, num_bytes);
double t = or1ksim_jtag_shift_dr (jreg);
double t = or1ksim_jtag_shift_dr (jreg, 32 + 4 + 16 + 32 + 4 + 32 + 4 + 1);
 
/* Diagnose what we are shifting out. */
dump_jreg (" shifted out", jreg, num_bytes);
594,7 → 599,6
unsigned long int crc_out;
 
access_type = ((jreg[4] >> 5) | (jreg[5] << 3)) & 0xf ;
 
addr = ((unsigned long int) jreg[ 5] >> 1) |
((unsigned long int) jreg[ 6] << 7) |
((unsigned long int) jreg[ 7] << 15) |
631,7 → 635,7
 
/* Log the results. Remember the length is 1 greater than the value
returned. */
printf (" access_type: 0x%x\n", status);
printf (" access_type: 0x%x\n", access_type);
printf (" address: 0x%lx\n", addr);
printf (" length: 0x%lx\n", len + 1);
printf (" status: 0x%x\n", status);
658,7 → 662,7
 
GO_COMMAND_WRITE <data>
 
The one argument is a string of bytes to be written, MS byte first.
The one argument is a string of bytes to be written, LS byte first.
 
Like all the JTAG fields, each data byte must be reversed, so it is shifted
MS bit first. It also requires a 32-bit CRC.
691,7 → 695,7
 
char *data_str = argv[next_jreg];
int data_len = strlen (data_str);
int data_bytes = (data_len + 1) / 2;
int data_bytes = data_len / 2;
unsigned char *data = malloc (data_bytes);
 
if (NULL == data)
700,18 → 704,24
return 0;
}
 
if (1 == (data_len % 2))
{
printf ("Warning: GO_COMMAND_WRITE odd char ignored\n");
}
 
int i;
 
for (i = 0; i < data_bytes; i++)
{
int ch_off_ls = data_len - (i * 2) - 1;
int ch_off_ms = (0 == ch_off_ls) ? 0 : ch_off_ls - 1;
int j;
int ch_off_ms = i * 2;
int ch_off_ls = i * 2 + 1;
 
/* Get each nybble in turn, remembering that we may not have a MS nybble
if the data string has an odd number of chars. */
data[i] = 0;
 
int j;
 
for (j = ch_off_ms; j <= ch_off_ls; j++)
{
char c = data_str[j];
792,7 → 802,8
 
/* Note what we are shifting in and shift it. */
dump_jreg (" shifting in", jreg, num_bytes);
double t = or1ksim_jtag_shift_dr (jreg);
double t = or1ksim_jtag_shift_dr (jreg,
32 + 4 + 32 + data_bytes * 8 + 4 + 1);
 
/* Diagnose what we are shifting out. */
dump_jreg (" shifted out", jreg, num_bytes);
877,8 → 888,13
unsigned long int cmd = 0; /* GO_COMMAND */
unsigned long int data_bytes = strtoul (argv[next_jreg], NULL, 16);
 
if (data_bytes > 0x10000)
if (data_bytes < 0)
{
printf ("ERROR: GO_COMMAND_READ length 0x%lx too small\n", data_bytes);
return 0;
}
else if (data_bytes > 0x10000)
{
printf ("ERROR: GO_COMMAND_READ length 0x%lx too large\n", data_bytes);
return 0;
}
924,7 → 940,8
 
/* Note what we are shifting in and shift it. */
dump_jreg (" shifting in", jreg, num_bytes);
double t = or1ksim_jtag_shift_dr (jreg);
double t = or1ksim_jtag_shift_dr (jreg,
32 + 4 + data_bytes * 8 + 32 + 4 + 1);
 
/* Diagnose what we are shifting out. */
dump_jreg (" shifted out", jreg, num_bytes);
936,7 → 953,7
 
if (NULL == data)
{
printf ("ERROR: data malloc for GO_COMMAND_WRITE register failed.\n");
printf ("ERROR: data malloc for GO_COMMAND_READ register failed.\n");
free (jreg);
return 0;
}
975,10 → 992,12
crc_computed = crc32 (status, 4, crc_computed);
 
/* Log the results, ignoring a leading zero on the MS byte */
printf (" data: 0x%x", data[data_bytes - 1]);
/* Log the results, remembering these are bytes, so endianness is not a
factor here. Since the OR1K is big endian, the lowest numbered byte will
be the least significant, and the first printed */
printf (" data: ");
 
for (i = data_bytes - 2; i >= 0; i--)
for (i = 0; i < data_bytes; i++)
{
printf ("%02x", data[i]);
}
1113,7 → 1132,7
 
/* Note what we are shifting in and shift it. */
dump_jreg (" shifting in", jreg, num_bytes);
double t = or1ksim_jtag_shift_dr (jreg);
double t = or1ksim_jtag_shift_dr (jreg, 32 + 4 + 32 + 52 + 4 + 1);
 
/* Diagnose what we are shifting out. */
dump_jreg (" shifted out", jreg, num_bytes);
1228,7 → 1247,7
 
/* Note what we are shifting in and shift it. */
dump_jreg (" shifting in", jreg, num_bytes);
double t = or1ksim_jtag_shift_dr (jreg);
double t = or1ksim_jtag_shift_dr (jreg, 32 + 4 + 52 + 32 + 4 + 1);
 
/* Diagnose what we are shifting out. */
dump_jreg (" shifted out", jreg, num_bytes);
1320,6 → 1339,8
main (int argc,
char *argv[])
{
const double QUANTUM = 5.0e-3; /* Time in sec for each step. */
 
/* Check we have minimum number of args. */
if (argc < 4)
{
1340,13 → 1361,13
return 1;
}
 
/* Run repeatedly for 1 millisecond until we have processed all JTAG
/* Run repeatedly for 10 milliseconds until we have processed all JTAG
registers */
int next_jreg = 3; /* Offset to next JTAG register */
 
do
{
switch (or1ksim_run (1.0e-3))
switch (or1ksim_run (QUANTUM))
{
case OR1KSIM_RC_OK:
printf ("Execution step completed OK.\n");
1467,7 → 1488,7
while (next_jreg < argc);
 
/* A little longer to allow response to last upcall to be handled. */
switch (or1ksim_run (1.0e-3))
switch (or1ksim_run (QUANTUM))
{
case OR1KSIM_RC_OK:
printf ("Execution step completed OK.\n");
/test-code/lib-jtag/lib-jtag.c
109,8 → 109,8
 
@param[in] type 'D' if this is a data register, 'I' if an instruction
register.
@param[in] next_jreg Offset into argv of the next JTAG register hex
string.
@param[in] next_jreg Offset into argv of the next JTAG register length
field.
@param[in] argc argc from the main program (for checking next_jref).
@param[in] argv argv from the main program.
 
124,26 → 124,34
{
const char *long_name = ('D' == type) ? "data" : "instruction";
 
/* Do we have the arg? */
if (next_jreg > argc)
/* Do we have the arg (length and value)? */
if ((next_jreg + 1) > argc)
{
printf ("ERROR: no %s register found.\n", long_name);
return 0;
}
 
/* Get the length field */
int bit_len = strtol (argv[next_jreg++], NULL, 0);
 
if (0 == bit_len)
{
printf ("ERROR: invalid register length\n");
return 0;
}
 
/* Is the reg an exact number of bytes? */
char *hex_str = argv[next_jreg];
int num_chars = strlen (hex_str);
int num_bytes = (bit_len + 7) / 8;
 
if (0 != (num_chars % 2))
if (num_chars > (2 * num_bytes))
{
printf ("ERROR: %s register not exact number of bytes.\n", long_name);
return 0;
printf ("Warning: Too many digits for register: truncated.\n");
}
 
/* Allocate space */
int num_bytes = num_chars / 2;
unsigned char *jreg = malloc (num_bytes);
/* Allocate and clear space */
unsigned char *jreg = malloc (num_bytes);
 
if (NULL == jreg)
{
151,33 → 159,27
return 0;
}
 
memset (jreg, 0, num_bytes);
 
/* Initialize the register. The hex presentation is MS byte of the string on
the left (i.e. at offset 0), but the internal representation is LS byte
at the lowest address. */
int i;
for (i = 0; i < num_bytes; i++)
for (i = num_chars - 1; i >= 0; i--)
{
int byte_off = num_bytes - i - 1;
int ch_off = i * 2;
int j;
int dig_num = num_chars - 1 - i; /* Which digit */
int dig_val = hexch2val (hex_str[i]);
 
/* Each nybble in turn */
for (j = 0; j < 2; j++)
if (dig_val < 0)
{
char c = hex_str[ch_off + j];
int c_val = hexch2val (c);
printf ("ERROR: %c not valid hex digit.\n", hex_str[i]);
free (jreg);
return 0;
}
 
if (c_val < 0)
{
printf ("ERROR: %c not valid hex digit.\n", c);
free (jreg);
return 0;
}
 
jreg[byte_off] <<= 4;
jreg[byte_off] |= c_val;
}
/* MS digits are the odd numbered ones */
jreg[dig_num / 2] |= (0 == (dig_num % 2)) ? dig_val : dig_val << 4;
}
 
/* Note what we are doing */
187,11 → 189,11
 
if ('D' == type)
{
t = or1ksim_jtag_shift_dr (jreg);
t = or1ksim_jtag_shift_dr (jreg, bit_len);
}
else
{
t = or1ksim_jtag_shift_ir (jreg);
t = or1ksim_jtag_shift_ir (jreg, bit_len);
}
 
dump_jreg (" shifted out", jreg, num_bytes);
209,16 → 211,18
Build an or1ksim program using the library which loads a program and config
from the command line which will drive JTAG.
 
lib-jtag <config-file> <image> <jtype> [<reg>] [<jtype> [<reg>]] ...
lib-jtag <config-file> <image> <jtype> [<bitlen> <reg>]
[<jtype> [<bitlen> <reg>]] ...
 
- config-file An Or1ksim configuration file.
- image A OpenRISC binary image to load into Or1ksim
- jtype One of 'R' (JTAG reset), 'I' (JTAG instruction register) or
'D' (JTAG data register).
- bitlen If jtype is 'D' or 'I', the number of bits in the JTAG
register.
- reg If jtype is 'D' or 'I', a JTAG register specified in
hex. Must be an even number of digits (i.e. exact number of
bytes), and use leading zeros if null bytes are needed at
the MS end.
hex. Specified LS digit on the right, and leading zeros may
be omitted.
 
The target program is run in bursts of 1ms execution, and the type of
return (OK, hit breakpoint) noted. Between each burst of execution, the
237,8 → 241,8
/* Check we have minimum number of args. */
if (argc < 4)
{
printf ("usage: lib-jtag <config-file> <image> <jtype> <reg> [<jtype> "
"<reg>] ...\n");
printf ("usage: lib-jtag <config-file> <image> <jtype> [<bitlen> <reg>] "
"[<jtype> [<bitlen> <reg>]] ...\n");
return 1;
}
 
286,18 → 290,26
case 'I':
printf ("Shifting instruction register.\n");
 
if (!process_jreg ('I', next_jreg++, argc, argv))
if (process_jreg ('I', next_jreg, argc, argv))
{
next_jreg += 2;
}
else
{
return 1; /* Something went wrong */
}
 
break;
 
case 'D':
printf ("Shifting data register.\n");
 
if (!process_jreg ('D', next_jreg++, argc, argv))
if (process_jreg ('D', next_jreg, argc, argv))
{
next_jreg += 2;
}
else
{
return 1; /* Something went wrong */
}
 
/test-code/lib-inttest/Makefile.in
160,6 → 160,7
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
POW_LIB = @POW_LIB@
/README
45,18 → 45,24
Working tests
=============
 
A total of 63 tests of the libsim library:
A total of 264 tests of the libsim library:
 
int-edge: 6 tests of edge triggered interrupts.
int-level: 5 tests of level triggered interrupts.
lib-iftest: A test of the basic library interface functions.
jtag-basic: 17 tests of JTAG reset and instruction selection
jtag-full: 32 tests of higher level JTAG functions
upcalls: 2 tests of the upcall interface.
int-edge: 6 tests of edge triggered interrupts.
int-level: 5 tests of level triggered interrupts.
lib-iftest: 1 test of the basic library interface functions.
jtag-basic: 17 tests of JTAG reset and instruction selection
jtag-go-command-read: 60 tests of JTAG GO_COMMAND for reading
jtag-go-command-write: 54 tests of JTAG GO_COMMAND for writing
jtag-read-command: 18 tests of JTAG READ_COMMAND
jtag-read-control: 8 tests of JTAG READ_CONTROL
jtag-select-module: 20 tests of JTAG module selection
jtag-write-command: 58 tests of JTAG WRITE_COMMAND
jtag-write-control: 13 tests of JTAG WRITE_CONTROL
upcalls: 2 tests of the upcall interface.
 
A total of 21 tests of standalone Or1ksim:
 
basic: A test or a wide range of instructions and registers.
basic: A test of a wide range of instructions and registers.
cache: A test of the Or1ksim cache modeling
cbasic: A minimal test in C
cfg: A test of the OR1K configuration register

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.