+2016-12-23 Luis Machado <lgustavo@codesourcery.com>
+
+ Fix test names for the following files:
+
+ * gdb.ada/exec_changed.exp
+ * gdb.ada/info_types.exp
+ * gdb.arch/aarch64-atomic-inst.exp
+ * gdb.arch/aarch64-fp.exp
+ * gdb.arch/altivec-abi.exp
+ * gdb.arch/altivec-regs.exp
+ * gdb.arch/amd64-byte.exp
+ * gdb.arch/amd64-disp-step.exp
+ * gdb.arch/amd64-dword.exp
+ * gdb.arch/amd64-entry-value-inline.exp
+ * gdb.arch/amd64-entry-value-param.exp
+ * gdb.arch/amd64-entry-value-paramref.exp
+ * gdb.arch/amd64-entry-value.exp
+ * gdb.arch/amd64-i386-address.exp
+ * gdb.arch/amd64-invalid-stack-middle.exp
+ * gdb.arch/amd64-invalid-stack-top.exp
+ * gdb.arch/amd64-optimout-repeat.exp
+ * gdb.arch/amd64-prologue-skip.exp
+ * gdb.arch/amd64-prologue-xmm.exp
+ * gdb.arch/amd64-stap-special-operands.exp
+ * gdb.arch/amd64-stap-wrong-subexp.exp
+ * gdb.arch/amd64-tailcall-cxx.exp
+ * gdb.arch/amd64-tailcall-noret.exp
+ * gdb.arch/amd64-tailcall-ret.exp
+ * gdb.arch/amd64-tailcall-self.exp
+ * gdb.arch/amd64-word.exp
+ * gdb.arch/arm-bl-branch-dest.exp
+ * gdb.arch/arm-disp-step.exp
+ * gdb.arch/arm-neon.exp
+ * gdb.arch/arm-single-step-kernel-helper.exp
+ * gdb.arch/avr-flash-qualifier.exp
+ * gdb.arch/disp-step-insn-reloc.exp
+ * gdb.arch/e500-abi.exp
+ * gdb.arch/e500-regs.exp
+ * gdb.arch/ftrace-insn-reloc.exp
+ * gdb.arch/i386-avx512.exp
+ * gdb.arch/i386-bp_permanent.exp
+ * gdb.arch/i386-byte.exp
+ * gdb.arch/i386-cfi-notcurrent.exp
+ * gdb.arch/i386-disp-step.exp
+ * gdb.arch/i386-dr3-watch.exp
+ * gdb.arch/i386-float.exp
+ * gdb.arch/i386-gnu-cfi.exp
+ * gdb.arch/i386-mpx-map.exp
+ * gdb.arch/i386-mpx-sigsegv.exp
+ * gdb.arch/i386-mpx-simple_segv.exp
+ * gdb.arch/i386-mpx.exp
+ * gdb.arch/i386-permbkpt.exp
+ * gdb.arch/i386-prologue.exp
+ * gdb.arch/i386-signal.exp
+ * gdb.arch/i386-size-overlap.exp
+ * gdb.arch/i386-unwind.exp
+ * gdb.arch/i386-word.exp
+ * gdb.arch/mips-fcr.exp
+ * gdb.arch/powerpc-d128-regs.exp
+ * gdb.arch/powerpc-stackless.exp
+ * gdb.arch/ppc64-atomic-inst.exp
+ * gdb.arch/s390-stackless.exp
+ * gdb.arch/s390-tdbregs.exp
+ * gdb.arch/s390-vregs.exp
+ * gdb.arch/sparc-sysstep.exp
+ * gdb.arch/thumb-bx-pc.exp
+ * gdb.arch/thumb-singlestep.exp
+ * gdb.arch/thumb2-it.exp
+ * gdb.arch/vsx-regs.exp
+ * gdb.asm/asm-source.exp
+ * gdb.base/a2-run.exp
+ * gdb.base/advance.exp
+ * gdb.base/all-bin.exp
+ * gdb.base/anon.exp
+ * gdb.base/args.exp
+ * gdb.base/arithmet.exp
+ * gdb.base/async-shell.exp
+ * gdb.base/async.exp
+ * gdb.base/attach-pie-noexec.exp
+ * gdb.base/attach-twice.exp
+ * gdb.base/auto-load.exp
+ * gdb.base/bang.exp
+ * gdb.base/bitfields.exp
+ * gdb.base/break-always.exp
+ * gdb.base/break-caller-line.exp
+ * gdb.base/break-entry.exp
+ * gdb.base/break-inline.exp
+ * gdb.base/break-on-linker-gcd-function.exp
+ * gdb.base/break-probes.exp
+ * gdb.base/break.exp
+ * gdb.base/breakpoint-shadow.exp
+ * gdb.base/call-ar-st.exp
+ * gdb.base/call-sc.exp
+ * gdb.base/call-signal-resume.exp
+ * gdb.base/call-strs.exp
+ * gdb.base/callfuncs.exp
+ * gdb.base/catch-fork-static.exp
+ * gdb.base/catch-gdb-caused-signals.exp
+ * gdb.base/catch-load.exp
+ * gdb.base/catch-signal-fork.exp
+ * gdb.base/catch-signal.exp
+ * gdb.base/catch-syscall.exp
+ * gdb.base/charset.exp
+ * gdb.base/checkpoint.exp
+ * gdb.base/chng-syms.exp
+ * gdb.base/code-expr.exp
+ * gdb.base/code_elim.exp
+ * gdb.base/commands.exp
+ * gdb.base/completion.exp
+ * gdb.base/complex.exp
+ * gdb.base/cond-expr.exp
+ * gdb.base/condbreak.exp
+ * gdb.base/consecutive.exp
+ * gdb.base/continue-all-already-running.exp
+ * gdb.base/coredump-filter.exp
+ * gdb.base/corefile.exp
+ * gdb.base/dbx.exp
+ * gdb.base/debug-expr.exp
+ * gdb.base/define.exp
+ * gdb.base/del.exp
+ * gdb.base/disabled-location.exp
+ * gdb.base/disasm-end-cu.exp
+ * gdb.base/disasm-optim.exp
+ * gdb.base/display.exp
+ * gdb.base/duplicate-bp.exp
+ * gdb.base/ena-dis-br.exp
+ * gdb.base/ending-run.exp
+ * gdb.base/enumval.exp
+ * gdb.base/environ.exp
+ * gdb.base/eu-strip-infcall.exp
+ * gdb.base/eval-avoid-side-effects.exp
+ * gdb.base/eval-skip.exp
+ * gdb.base/exitsignal.exp
+ * gdb.base/expand-psymtabs.exp
+ * gdb.base/filesym.exp
+ * gdb.base/find-unmapped.exp
+ * gdb.base/finish.exp
+ * gdb.base/float.exp
+ * gdb.base/foll-exec-mode.exp
+ * gdb.base/foll-exec.exp
+ * gdb.base/foll-fork.exp
+ * gdb.base/fortran-sym-case.exp
+ * gdb.base/freebpcmd.exp
+ * gdb.base/func-ptr.exp
+ * gdb.base/func-ptrs.exp
+ * gdb.base/funcargs.exp
+ * gdb.base/gcore-buffer-overflow.exp
+ * gdb.base/gcore-relro-pie.exp
+ * gdb.base/gcore-relro.exp
+ * gdb.base/gcore.exp
+ * gdb.base/gdb1090.exp
+ * gdb.base/gdb11530.exp
+ * gdb.base/gdb11531.exp
+ * gdb.base/gdb1821.exp
+ * gdb.base/gdbindex-stabs.exp
+ * gdb.base/gdbvars.exp
+ * gdb.base/hbreak.exp
+ * gdb.base/hbreak2.exp
+ * gdb.base/included.exp
+ * gdb.base/infcall-input.exp
+ * gdb.base/inferior-died.exp
+ * gdb.base/infnan.exp
+ * gdb.base/info-macros.exp
+ * gdb.base/info-os.exp
+ * gdb.base/info-proc.exp
+ * gdb.base/info-shared.exp
+ * gdb.base/info-target.exp
+ * gdb.base/infoline.exp
+ * gdb.base/interp.exp
+ * gdb.base/interrupt.exp
+ * gdb.base/jit-reader.exp
+ * gdb.base/jit-simple.exp
+ * gdb.base/kill-after-signal.exp
+ * gdb.base/kill-detach-inferiors-cmd.exp
+ * gdb.base/label.exp
+ * gdb.base/langs.exp
+ * gdb.base/ldbl_e308.exp
+ * gdb.base/line-symtabs.exp
+ * gdb.base/linespecs.exp
+ * gdb.base/list.exp
+ * gdb.base/long_long.exp
+ * gdb.base/longest-types.exp
+ * gdb.base/maint.exp
+ * gdb.base/max-value-size.exp
+ * gdb.base/memattr.exp
+ * gdb.base/mips_pro.exp
+ * gdb.base/morestack.exp
+ * gdb.base/moribund-step.exp
+ * gdb.base/multi-forks.exp
+ * gdb.base/nested-addr.exp
+ * gdb.base/nextoverexit.exp
+ * gdb.base/noreturn-finish.exp
+ * gdb.base/noreturn-return.exp
+ * gdb.base/nostdlib.exp
+ * gdb.base/offsets.exp
+ * gdb.base/opaque.exp
+ * gdb.base/pc-fp.exp
+ * gdb.base/permissions.exp
+ * gdb.base/print-symbol-loading.exp
+ * gdb.base/prologue-include.exp
+ * gdb.base/psymtab.exp
+ * gdb.base/ptype.exp
+ * gdb.base/random-signal.exp
+ * gdb.base/randomize.exp
+ * gdb.base/range-stepping.exp
+ * gdb.base/readline-ask.exp
+ * gdb.base/recpar.exp
+ * gdb.base/recurse.exp
+ * gdb.base/relational.exp
+ * gdb.base/restore.exp
+ * gdb.base/return-nodebug.exp
+ * gdb.base/return.exp
+ * gdb.base/run-after-attach.exp
+ * gdb.base/save-bp.exp
+ * gdb.base/scope.exp
+ * gdb.base/sect-cmd.exp
+ * gdb.base/set-lang-auto.exp
+ * gdb.base/set-noassign.exp
+ * gdb.base/setvar.exp
+ * gdb.base/sigall.exp
+ * gdb.base/sigbpt.exp
+ * gdb.base/siginfo-addr.exp
+ * gdb.base/siginfo-infcall.exp
+ * gdb.base/siginfo-obj.exp
+ * gdb.base/siginfo.exp
+ * gdb.base/signals-state-child.exp
+ * gdb.base/signest.exp
+ * gdb.base/sigstep.exp
+ * gdb.base/sizeof.exp
+ * gdb.base/skip.exp
+ * gdb.base/solib-corrupted.exp
+ * gdb.base/solib-nodir.exp
+ * gdb.base/solib-search.exp
+ * gdb.base/stack-checking.exp
+ * gdb.base/stale-infcall.exp
+ * gdb.base/stap-probe.exp
+ * gdb.base/start.exp
+ * gdb.base/step-break.exp
+ * gdb.base/step-bt.exp
+ * gdb.base/step-line.exp
+ * gdb.base/step-over-exit.exp
+ * gdb.base/step-over-syscall.exp
+ * gdb.base/step-resume-infcall.exp
+ * gdb.base/step-test.exp
+ * gdb.base/store.exp
+ * gdb.base/structs3.exp
+ * gdb.base/sym-file.exp
+ * gdb.base/symbol-without-target_section.exp
+ * gdb.base/term.exp
+ * gdb.base/testenv.exp
+ * gdb.base/ui-redirect.exp
+ * gdb.base/until.exp
+ * gdb.base/unwindonsignal.exp
+ * gdb.base/value-double-free.exp
+ * gdb.base/vla-datatypes.exp
+ * gdb.base/vla-ptr.exp
+ * gdb.base/vla-sideeffect.exp
+ * gdb.base/volatile.exp
+ * gdb.base/watch-cond-infcall.exp
+ * gdb.base/watch-cond.exp
+ * gdb.base/watch-non-mem.exp
+ * gdb.base/watch-read.exp
+ * gdb.base/watch-vfork.exp
+ * gdb.base/watchpoint-cond-gone.exp
+ * gdb.base/watchpoint-delete.exp
+ * gdb.base/watchpoint-hw-hit-once.exp
+ * gdb.base/watchpoint-hw.exp
+ * gdb.base/watchpoint-stops-at-right-insn.exp
+ * gdb.base/watchpoints.exp
+ * gdb.base/wchar.exp
+ * gdb.base/whatis-exp.exp
+ * gdb.btrace/buffer-size.exp
+ * gdb.btrace/data.exp
+ * gdb.btrace/delta.exp
+ * gdb.btrace/dlopen.exp
+ * gdb.btrace/enable.exp
+ * gdb.btrace/exception.exp
+ * gdb.btrace/function_call_history.exp
+ * gdb.btrace/gcore.exp
+ * gdb.btrace/instruction_history.exp
+ * gdb.btrace/nohist.exp
+ * gdb.btrace/reconnect.exp
+ * gdb.btrace/record_goto-step.exp
+ * gdb.btrace/record_goto.exp
+ * gdb.btrace/rn-dl-bind.exp
+ * gdb.btrace/segv.exp
+ * gdb.btrace/step.exp
+ * gdb.btrace/stepi.exp
+ * gdb.btrace/tailcall-only.exp
+ * gdb.btrace/tailcall.exp
+ * gdb.btrace/tsx.exp
+ * gdb.btrace/unknown_functions.exp
+ * gdb.btrace/vdso.exp
+ * gdb.compile/compile-ifunc.exp
+ * gdb.compile/compile-ops.exp
+ * gdb.compile/compile-print.exp
+ * gdb.compile/compile-setjmp.exp
+ * gdb.cp/abstract-origin.exp
+ * gdb.cp/ambiguous.exp
+ * gdb.cp/annota2.exp
+ * gdb.cp/annota3.exp
+ * gdb.cp/anon-ns.exp
+ * gdb.cp/anon-struct.exp
+ * gdb.cp/anon-union.exp
+ * gdb.cp/arg-reference.exp
+ * gdb.cp/baseenum.exp
+ * gdb.cp/bool.exp
+ * gdb.cp/breakpoint.exp
+ * gdb.cp/bs15503.exp
+ * gdb.cp/call-c.exp
+ * gdb.cp/casts.exp
+ * gdb.cp/chained-calls.exp
+ * gdb.cp/class2.exp
+ * gdb.cp/classes.exp
+ * gdb.cp/cmpd-minsyms.exp
+ * gdb.cp/converts.exp
+ * gdb.cp/cp-relocate.exp
+ * gdb.cp/cpcompletion.exp
+ * gdb.cp/cpexprs.exp
+ * gdb.cp/cplabel.exp
+ * gdb.cp/cplusfuncs.exp
+ * gdb.cp/cpsizeof.exp
+ * gdb.cp/ctti.exp
+ * gdb.cp/derivation.exp
+ * gdb.cp/destrprint.exp
+ * gdb.cp/dispcxx.exp
+ * gdb.cp/enum-class.exp
+ * gdb.cp/exception.exp
+ * gdb.cp/exceptprint.exp
+ * gdb.cp/expand-psymtabs-cxx.exp
+ * gdb.cp/expand-sals.exp
+ * gdb.cp/extern-c.exp
+ * gdb.cp/filename.exp
+ * gdb.cp/formatted-ref.exp
+ * gdb.cp/fpointer.exp
+ * gdb.cp/gdb1355.exp
+ * gdb.cp/gdb2495.exp
+ * gdb.cp/hang.exp
+ * gdb.cp/impl-this.exp
+ * gdb.cp/infcall-dlopen.exp
+ * gdb.cp/inherit.exp
+ * gdb.cp/iostream.exp
+ * gdb.cp/koenig.exp
+ * gdb.cp/local.exp
+ * gdb.cp/m-data.exp
+ * gdb.cp/m-static.exp
+ * gdb.cp/mb-ctor.exp
+ * gdb.cp/mb-inline.exp
+ * gdb.cp/mb-templates.exp
+ * gdb.cp/member-name.exp
+ * gdb.cp/member-ptr.exp
+ * gdb.cp/meth-typedefs.exp
+ * gdb.cp/method.exp
+ * gdb.cp/method2.exp
+ * gdb.cp/minsym-fallback.exp
+ * gdb.cp/misc.exp
+ * gdb.cp/namelessclass.exp
+ * gdb.cp/namespace-enum.exp
+ * gdb.cp/namespace-nested-import.exp
+ * gdb.cp/namespace.exp
+ * gdb.cp/nextoverthrow.exp
+ * gdb.cp/no-dmgl-verbose.exp
+ * gdb.cp/non-trivial-retval.exp
+ * gdb.cp/noparam.exp
+ * gdb.cp/nsdecl.exp
+ * gdb.cp/nsimport.exp
+ * gdb.cp/nsnested.exp
+ * gdb.cp/nsnoimports.exp
+ * gdb.cp/nsrecurs.exp
+ * gdb.cp/nsstress.exp
+ * gdb.cp/nsusing.exp
+ * gdb.cp/operator.exp
+ * gdb.cp/oranking.exp
+ * gdb.cp/overload-const.exp
+ * gdb.cp/overload.exp
+ * gdb.cp/ovldbreak.exp
+ * gdb.cp/ovsrch.exp
+ * gdb.cp/paren-type.exp
+ * gdb.cp/parse-lang.exp
+ * gdb.cp/pass-by-ref.exp
+ * gdb.cp/pr-1023.exp
+ * gdb.cp/pr-1210.exp
+ * gdb.cp/pr-574.exp
+ * gdb.cp/pr10687.exp
+ * gdb.cp/pr12028.exp
+ * gdb.cp/pr17132.exp
+ * gdb.cp/pr17494.exp
+ * gdb.cp/pr9067.exp
+ * gdb.cp/pr9167.exp
+ * gdb.cp/pr9631.exp
+ * gdb.cp/printmethod.exp
+ * gdb.cp/psmang.exp
+ * gdb.cp/psymtab-parameter.exp
+ * gdb.cp/ptype-cv-cp.exp
+ * gdb.cp/ptype-flags.exp
+ * gdb.cp/re-set-overloaded.exp
+ * gdb.cp/ref-types.exp
+ * gdb.cp/rtti.exp
+ * gdb.cp/scope-err.exp
+ * gdb.cp/shadow.exp
+ * gdb.cp/smartp.exp
+ * gdb.cp/static-method.exp
+ * gdb.cp/static-print-quit.exp
+ * gdb.cp/temargs.exp
+ * gdb.cp/templates.exp
+ * gdb.cp/try_catch.exp
+ * gdb.cp/typedef-operator.exp
+ * gdb.cp/typeid.exp
+ * gdb.cp/userdef.exp
+ * gdb.cp/using-crash.exp
+ * gdb.cp/var-tag.exp
+ * gdb.cp/virtbase.exp
+ * gdb.cp/virtfunc.exp
+ * gdb.cp/virtfunc2.exp
+ * gdb.cp/vla-cxx.exp
+ * gdb.disasm/t01_mov.exp
+ * gdb.disasm/t02_mova.exp
+ * gdb.disasm/t03_add.exp
+ * gdb.disasm/t04_sub.exp
+ * gdb.disasm/t05_cmp.exp
+ * gdb.disasm/t06_ari2.exp
+ * gdb.disasm/t07_ari3.exp
+ * gdb.disasm/t08_or.exp
+ * gdb.disasm/t09_xor.exp
+ * gdb.disasm/t10_and.exp
+ * gdb.disasm/t11_logs.exp
+ * gdb.disasm/t12_bit.exp
+ * gdb.disasm/t13_otr.exp
+ * gdb.dlang/circular.exp
+ * gdb.dwarf2/arr-stride.exp
+ * gdb.dwarf2/arr-subrange.exp
+ * gdb.dwarf2/atomic-type.exp
+ * gdb.dwarf2/bad-regnum.exp
+ * gdb.dwarf2/bitfield-parent-optimized-out.exp
+ * gdb.dwarf2/callframecfa.exp
+ * gdb.dwarf2/clztest.exp
+ * gdb.dwarf2/corrupt.exp
+ * gdb.dwarf2/data-loc.exp
+ * gdb.dwarf2/dup-psym.exp
+ * gdb.dwarf2/dw2-anon-mptr.exp
+ * gdb.dwarf2/dw2-anonymous-func.exp
+ * gdb.dwarf2/dw2-bad-mips-linkage-name.exp
+ * gdb.dwarf2/dw2-bad-unresolved.exp
+ * gdb.dwarf2/dw2-basic.exp
+ * gdb.dwarf2/dw2-canonicalize-type.exp
+ * gdb.dwarf2/dw2-case-insensitive.exp
+ * gdb.dwarf2/dw2-common-block.exp
+ * gdb.dwarf2/dw2-compdir-oldgcc.exp
+ * gdb.dwarf2/dw2-compressed.exp
+ * gdb.dwarf2/dw2-const.exp
+ * gdb.dwarf2/dw2-cp-infcall-ref-static.exp
+ * gdb.dwarf2/dw2-cu-size.exp
+ * gdb.dwarf2/dw2-dup-frame.exp
+ * gdb.dwarf2/dw2-entry-value.exp
+ * gdb.dwarf2/dw2-icycle.exp
+ * gdb.dwarf2/dw2-ifort-parameter.exp
+ * gdb.dwarf2/dw2-inline-break.exp
+ * gdb.dwarf2/dw2-inline-param.exp
+ * gdb.dwarf2/dw2-intercu.exp
+ * gdb.dwarf2/dw2-intermix.exp
+ * gdb.dwarf2/dw2-lexical-block-bare.exp
+ * gdb.dwarf2/dw2-linkage-name-trust.exp
+ * gdb.dwarf2/dw2-minsym-in-cu.exp
+ * gdb.dwarf2/dw2-noloc.exp
+ * gdb.dwarf2/dw2-op-call.exp
+ * gdb.dwarf2/dw2-op-out-param.exp
+ * gdb.dwarf2/dw2-opt-structptr.exp
+ * gdb.dwarf2/dw2-param-error.exp
+ * gdb.dwarf2/dw2-producer.exp
+ * gdb.dwarf2/dw2-ranges-base.exp
+ * gdb.dwarf2/dw2-ref-missing-frame.exp
+ * gdb.dwarf2/dw2-reg-undefined.exp
+ * gdb.dwarf2/dw2-regno-invalid.exp
+ * gdb.dwarf2/dw2-restore.exp
+ * gdb.dwarf2/dw2-restrict.exp
+ * gdb.dwarf2/dw2-single-line-discriminators.exp
+ * gdb.dwarf2/dw2-strp.exp
+ * gdb.dwarf2/dw2-undefined-ret-addr.exp
+ * gdb.dwarf2/dw2-unresolved.exp
+ * gdb.dwarf2/dw2-var-zero-addr.exp
+ * gdb.dwarf2/dw4-sig-types.exp
+ * gdb.dwarf2/dwz.exp
+ * gdb.dwarf2/dynarr-ptr.exp
+ * gdb.dwarf2/enum-type.exp
+ * gdb.dwarf2/gdb-index.exp
+ * gdb.dwarf2/implptr-64bit.exp
+ * gdb.dwarf2/implptr-optimized-out.exp
+ * gdb.dwarf2/implptr.exp
+ * gdb.dwarf2/implref-array.exp
+ * gdb.dwarf2/implref-const.exp
+ * gdb.dwarf2/implref-global.exp
+ * gdb.dwarf2/implref-struct.exp
+ * gdb.dwarf2/mac-fileno.exp
+ * gdb.dwarf2/main-subprogram.exp
+ * gdb.dwarf2/member-ptr-forwardref.exp
+ * gdb.dwarf2/method-ptr.exp
+ * gdb.dwarf2/missing-sig-type.exp
+ * gdb.dwarf2/nonvar-access.exp
+ * gdb.dwarf2/opaque-type-lookup.exp
+ * gdb.dwarf2/pieces-optimized-out.exp
+ * gdb.dwarf2/pieces.exp
+ * gdb.dwarf2/pr10770.exp
+ * gdb.dwarf2/pr13961.exp
+ * gdb.dwarf2/staticvirtual.exp
+ * gdb.dwarf2/subrange.exp
+ * gdb.dwarf2/symtab-producer.exp
+ * gdb.dwarf2/trace-crash.exp
+ * gdb.dwarf2/typeddwarf.exp
+ * gdb.dwarf2/valop.exp
+ * gdb.dwarf2/watch-notconst.exp
+ * gdb.fortran/array-element.exp
+ * gdb.fortran/charset.exp
+ * gdb.fortran/common-block.exp
+ * gdb.fortran/complex.exp
+ * gdb.fortran/derived-type-function.exp
+ * gdb.fortran/derived-type.exp
+ * gdb.fortran/logical.exp
+ * gdb.fortran/module.exp
+ * gdb.fortran/multi-dim.exp
+ * gdb.fortran/nested-funcs.exp
+ * gdb.fortran/print-formatted.exp
+ * gdb.fortran/subarray.exp
+ * gdb.fortran/vla-alloc-assoc.exp
+ * gdb.fortran/vla-datatypes.exp
+ * gdb.fortran/vla-history.exp
+ * gdb.fortran/vla-ptr-info.exp
+ * gdb.fortran/vla-ptype-sub.exp
+ * gdb.fortran/vla-ptype.exp
+ * gdb.fortran/vla-sizeof.exp
+ * gdb.fortran/vla-type.exp
+ * gdb.fortran/vla-value-sub-arbitrary.exp
+ * gdb.fortran/vla-value-sub-finish.exp
+ * gdb.fortran/vla-value-sub.exp
+ * gdb.fortran/vla-value.exp
+ * gdb.fortran/whatis_type.exp
+ * gdb.go/chan.exp
+ * gdb.go/handcall.exp
+ * gdb.go/hello.exp
+ * gdb.go/integers.exp
+ * gdb.go/methods.exp
+ * gdb.go/package.exp
+ * gdb.go/strings.exp
+ * gdb.go/types.exp
+ * gdb.go/unsafe.exp
+ * gdb.guile/scm-arch.exp
+ * gdb.guile/scm-block.exp
+ * gdb.guile/scm-breakpoint.exp
+ * gdb.guile/scm-cmd.exp
+ * gdb.guile/scm-disasm.exp
+ * gdb.guile/scm-equal.exp
+ * gdb.guile/scm-frame-args.exp
+ * gdb.guile/scm-frame-inline.exp
+ * gdb.guile/scm-frame.exp
+ * gdb.guile/scm-iterator.exp
+ * gdb.guile/scm-math.exp
+ * gdb.guile/scm-objfile.exp
+ * gdb.guile/scm-ports.exp
+ * gdb.guile/scm-symbol.exp
+ * gdb.guile/scm-symtab.exp
+ * gdb.guile/scm-value-cc.exp
+ * gdb.guile/types-module.exp
+ * gdb.linespec/break-ask.exp
+ * gdb.linespec/cpexplicit.exp
+ * gdb.linespec/explicit.exp
+ * gdb.linespec/keywords.exp
+ * gdb.linespec/linespec.exp
+ * gdb.linespec/ls-dollar.exp
+ * gdb.linespec/ls-errs.exp
+ * gdb.linespec/skip-two.exp
+ * gdb.linespec/thread.exp
+ * gdb.mi/mi-async.exp
+ * gdb.mi/mi-basics.exp
+ * gdb.mi/mi-break.exp
+ * gdb.mi/mi-catch-load.exp
+ * gdb.mi/mi-cli.exp
+ * gdb.mi/mi-cmd-param-changed.exp
+ * gdb.mi/mi-console.exp
+ * gdb.mi/mi-detach.exp
+ * gdb.mi/mi-disassemble.exp
+ * gdb.mi/mi-eval.exp
+ * gdb.mi/mi-file-transfer.exp
+ * gdb.mi/mi-file.exp
+ * gdb.mi/mi-fill-memory.exp
+ * gdb.mi/mi-inheritance-syntax-error.exp
+ * gdb.mi/mi-linespec-err-cp.exp
+ * gdb.mi/mi-logging.exp
+ * gdb.mi/mi-memory-changed.exp
+ * gdb.mi/mi-read-memory.exp
+ * gdb.mi/mi-record-changed.exp
+ * gdb.mi/mi-reg-undefined.exp
+ * gdb.mi/mi-regs.exp
+ * gdb.mi/mi-return.exp
+ * gdb.mi/mi-reverse.exp
+ * gdb.mi/mi-simplerun.exp
+ * gdb.mi/mi-solib.exp
+ * gdb.mi/mi-stack.exp
+ * gdb.mi/mi-stepi.exp
+ * gdb.mi/mi-syn-frame.exp
+ * gdb.mi/mi-until.exp
+ * gdb.mi/mi-var-block.exp
+ * gdb.mi/mi-var-child.exp
+ * gdb.mi/mi-var-cmd.exp
+ * gdb.mi/mi-var-cp.exp
+ * gdb.mi/mi-var-display.exp
+ * gdb.mi/mi-var-invalidate.exp
+ * gdb.mi/mi-var-list-children-invalid-grandchild.exp
+ * gdb.mi/mi-vla-fortran.exp
+ * gdb.mi/mi-watch.exp
+ * gdb.mi/mi2-var-child.exp
+ * gdb.mi/user-selected-context-sync.exp
+ * gdb.modula2/unbounded-array.exp
+ * gdb.multi/dummy-frame-restore.exp
+ * gdb.multi/multi-arch-exec.exp
+ * gdb.multi/multi-arch.exp
+ * gdb.multi/tids.exp
+ * gdb.multi/watchpoint-multi.exp
+ * gdb.opencl/callfuncs.exp
+ * gdb.opencl/convs_casts.exp
+ * gdb.opencl/datatypes.exp
+ * gdb.opencl/operators.exp
+ * gdb.opencl/vec_comps.exp
+ * gdb.opt/clobbered-registers-O2.exp
+ * gdb.opt/inline-break.exp
+ * gdb.opt/inline-bt.exp
+ * gdb.opt/inline-cmds.exp
+ * gdb.opt/inline-locals.exp
+ * gdb.pascal/case-insensitive-symbols.exp
+ * gdb.pascal/floats.exp
+ * gdb.pascal/gdb11492.exp
+ * gdb.python/lib-types.exp
+ * gdb.python/py-arch.exp
+ * gdb.python/py-as-string.exp
+ * gdb.python/py-bad-printers.exp
+ * gdb.python/py-block.exp
+ * gdb.python/py-breakpoint-create-fail.exp
+ * gdb.python/py-breakpoint.exp
+ * gdb.python/py-caller-is.exp
+ * gdb.python/py-cmd.exp
+ * gdb.python/py-explore-cc.exp
+ * gdb.python/py-explore.exp
+ * gdb.python/py-finish-breakpoint.exp
+ * gdb.python/py-finish-breakpoint2.exp
+ * gdb.python/py-frame-args.exp
+ * gdb.python/py-frame-inline.exp
+ * gdb.python/py-frame.exp
+ * gdb.python/py-framefilter-mi.exp
+ * gdb.python/py-infthread.exp
+ * gdb.python/py-lazy-string.exp
+ * gdb.python/py-linetable.exp
+ * gdb.python/py-mi-events.exp
+ * gdb.python/py-mi-objfile.exp
+ * gdb.python/py-mi.exp
+ * gdb.python/py-objfile.exp
+ * gdb.python/py-pp-integral.exp
+ * gdb.python/py-pp-maint.exp
+ * gdb.python/py-pp-re-notag.exp
+ * gdb.python/py-pp-registration.exp
+ * gdb.python/py-recurse-unwind.exp
+ * gdb.python/py-strfns.exp
+ * gdb.python/py-symbol.exp
+ * gdb.python/py-symtab.exp
+ * gdb.python/py-sync-interp.exp
+ * gdb.python/py-typeprint.exp
+ * gdb.python/py-unwind-maint.exp
+ * gdb.python/py-unwind.exp
+ * gdb.python/py-value-cc.exp
+ * gdb.python/py-xmethods.exp
+ * gdb.reverse/amd64-tailcall-reverse.exp
+ * gdb.reverse/break-precsave.exp
+ * gdb.reverse/break-reverse.exp
+ * gdb.reverse/consecutive-precsave.exp
+ * gdb.reverse/consecutive-reverse.exp
+ * gdb.reverse/finish-precsave.exp
+ * gdb.reverse/finish-reverse-bkpt.exp
+ * gdb.reverse/finish-reverse.exp
+ * gdb.reverse/fstatat-reverse.exp
+ * gdb.reverse/getresuid-reverse.exp
+ * gdb.reverse/i386-precsave.exp
+ * gdb.reverse/i386-reverse.exp
+ * gdb.reverse/i386-sse-reverse.exp
+ * gdb.reverse/i387-env-reverse.exp
+ * gdb.reverse/i387-stack-reverse.exp
+ * gdb.reverse/insn-reverse.exp
+ * gdb.reverse/machinestate-precsave.exp
+ * gdb.reverse/machinestate.exp
+ * gdb.reverse/next-reverse-bkpt-over-sr.exp
+ * gdb.reverse/pipe-reverse.exp
+ * gdb.reverse/readv-reverse.exp
+ * gdb.reverse/recvmsg-reverse.exp
+ * gdb.reverse/rerun-prec.exp
+ * gdb.reverse/s390-mvcle.exp
+ * gdb.reverse/step-precsave.exp
+ * gdb.reverse/step-reverse.exp
+ * gdb.reverse/time-reverse.exp
+ * gdb.reverse/until-precsave.exp
+ * gdb.reverse/until-reverse.exp
+ * gdb.reverse/waitpid-reverse.exp
+ * gdb.reverse/watch-precsave.exp
+ * gdb.reverse/watch-reverse.exp
+ * gdb.rust/generics.exp
+ * gdb.rust/methods.exp
+ * gdb.rust/modules.exp
+ * gdb.rust/simple.exp
+ * gdb.server/connect-with-no-symbol-file.exp
+ * gdb.server/ext-attach.exp
+ * gdb.server/ext-restart.exp
+ * gdb.server/ext-wrapper.exp
+ * gdb.server/file-transfer.exp
+ * gdb.server/server-exec-info.exp
+ * gdb.server/server-kill.exp
+ * gdb.server/server-mon.exp
+ * gdb.server/wrapper.exp
+ * gdb.stabs/exclfwd.exp
+ * gdb.stabs/gdb11479.exp
+ * gdb.threads/clone-new-thread-event.exp
+ * gdb.threads/corethreads.exp
+ * gdb.threads/current-lwp-dead.exp
+ * gdb.threads/dlopen-libpthread.exp
+ * gdb.threads/gcore-thread.exp
+ * gdb.threads/sigstep-threads.exp
+ * gdb.threads/watchpoint-fork.exp
+ * gdb.trace/actions-changed.exp
+ * gdb.trace/backtrace.exp
+ * gdb.trace/change-loc.exp
+ * gdb.trace/circ.exp
+ * gdb.trace/collection.exp
+ * gdb.trace/disconnected-tracing.exp
+ * gdb.trace/ftrace.exp
+ * gdb.trace/mi-trace-frame-collected.exp
+ * gdb.trace/mi-trace-unavailable.exp
+ * gdb.trace/mi-traceframe-changed.exp
+ * gdb.trace/mi-tsv-changed.exp
+ * gdb.trace/no-attach-trace.exp
+ * gdb.trace/passc-dyn.exp
+ * gdb.trace/qtro.exp
+ * gdb.trace/range-stepping.exp
+ * gdb.trace/read-memory.exp
+ * gdb.trace/save-trace.exp
+ * gdb.trace/signal.exp
+ * gdb.trace/status-stop.exp
+ * gdb.trace/tfile.exp
+ * gdb.trace/trace-break.exp
+ * gdb.trace/trace-buffer-size.exp
+ * gdb.trace/trace-condition.exp
+ * gdb.trace/tracefile-pseudo-reg.exp
+ * gdb.trace/tstatus.exp
+ * gdb.trace/unavailable.exp
+ * gdb.trace/while-dyn.exp
+ * gdb.trace/while-stepping.exp
+
2016-12-22 Doug Evans <xdje42@gmail.com>
* gdb.base/maint.exp: Update tests for maint print symbols, psymbols
# This testcase verifies the behavior of the `start' command, which
# does not work when we use the gdb stub...
if [target_info exists use_gdb_stub] {
- untested exec_changed.exp
+ untested "skipping tests due to use_gdb_stub"
return
}
standard_testfile .c
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
set compile_flags "debug nowarnings $extra_flags"
if { [gdb_compile ${srcdir}/${subdir}/${srcfile} ${binfile} executable $compile_flags] != "" } {
- untested altivec-abi.exp
+ untested "failed to compile"
return -1
}
# Run to `main' where we begin our tests.
if ![runto_main] then {
- untested altivec-abi.exp
+ untested "could not run to main"
return -1
}
}
if { [gdb_compile ${srcdir}/${subdir}/${srcfile} ${binfile} executable $compile_flags] != "" } {
- untested altivec-regs.exp
+ untested "failed to compile"
return -1
}
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug]] != "" } {
- untested ${testfile}
+ untested "failed to compile"
return
}
set additional_flags "-Wa,-g"
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug $additional_flags]] != "" } {
- untested amd64-disp-step.exp
+ untested "failed to compile"
return -1
}
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug]] != "" } {
- untested ${testfile}
+ untested "failed to compile"
return
}
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $opts] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} $opts] } {
return -1
}
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $opts] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} $opts] } {
return -1
}
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} "c++"] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} "c++"] } {
return -1
}
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $opts] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} $opts] } {
return -1
}
return
}
-if [prepare_for_testing amd64-i386-address.exp amd64-i386-address amd64-i386-address.S [list debug "additional_flags=-m32 -nostdlib"]] {
+if [prepare_for_testing "failed to prepare" amd64-i386-address amd64-i386-address.S [list debug "additional_flags=-m32 -nostdlib"]] {
return -1
}
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $opts] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} $opts] } {
return -1
}
verbose "Skipping ${testfile}."
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $opts] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} $opts] } {
return -1
}
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $opts] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} $opts] } {
return -1
}
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" object {debug}] != "" } {
- untested ${testfile}
+ untested "failed to compile"
return
}
return 0
}
-if {[prepare_for_testing ${testfile}.exp ${binfile} $srcfile $opts]} {
+if {[prepare_for_testing "failed to prepare" ${binfile} $srcfile $opts]} {
return -1
}
standard_testfile amd64-stap-triplet.S
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
- untested amd64-stap-special-operands.exp
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile amd64-stap-three-arg-disp.S
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
- untested amd64-stap-special-operands.exp
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile amd64-stap-wrong-subexp.S
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
- untested amd64-stap-wrong-subexp.exp
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} "${srcfile} ${srcfile2}" $opts] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} "${srcfile} ${srcfile2}" $opts] } {
return -1
}
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $opts] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} $opts] } {
return -1
}
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $opts] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} $opts] } {
return -1
}
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {}] } {
return -1
}
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug]] != "" } {
- untested ${testfile}
+ untested "failed to compile"
return
}
# on ARM, causing the PC to acquire a wrong value. That's why we use
# the "-Wl,-Ttext-segment" option compile the binary.
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
[list debug ldflags=-Wl,-Ttext-segment=0xb0000000]] } {
return -1
}
set additional_flags "-Wa,-g"
-if { [prepare_for_testing $testfile.exp $testfile $srcfile [list debug $additional_flags]] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile [list debug $additional_flags]] } {
return -1
}
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug quiet}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug quiet}] } {
unsupported "ARM NEON is not supported"
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
[list debug]] } {
return -1
}
}
standard_testfile
-if {[prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}]} {
+if {[prepare_for_testing "failed to prepare" ${testfile} ${srcfile}]} {
return -1
}
# Some targets have leading underscores on assembly symbols.
set additional_flags [gdb_target_symbol_prefix_flags]
-if [prepare_for_testing $expfile $executable $srcfile \
+if [prepare_for_testing "failed to prepare" $executable $srcfile \
[list debug $additional_flags]] {
- untested "failed to prepare for tests"
return -1
}
set src1 ${srcdir}/${subdir}/${testfile}.c
if { [gdb_compile ${src1} ${binfile} executable {debug nowarnings}] != "" } {
- untested e500-abi.exp
+ untested "failed to compile"
return -1
}
set src1 ${srcdir}/${subdir}/${testfile}.c
if { [gdb_compile ${src1} ${binfile} executable {debug nowarnings}] != "" } {
- untested e500-regs.exp
+ untested "failed to compile"
return -1
}
# Some targets have leading underscores on assembly symbols.
set additional_flags [gdb_target_symbol_prefix_flags]
-if [prepare_for_testing $expfile $executable $srcfile \
+if [prepare_for_testing "failed to prepare" $executable $srcfile \
[list debug $additional_flags]] {
- untested "failed to prepare for trace tests"
return -1
}
set comp_flags "-mavx512f -I${srcdir}/../nat"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
[list debug nowarnings additional_flags=${comp_flags}]] } {
return -1
}
# Don't use "debug", so that we don't have line information for the assembly
# fragments.
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list $additional_flags]] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug]] != "" } {
- untested ${testfile}
+ untested "failed to compile"
return
}
set testfile "i386-cfi-notcurrent"
set srcfile ${testfile}.S
-if [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {nodebug}] {
+if [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {nodebug}] {
return -1
}
set additional_flags "-Wa,-g"
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug $additional_flags]] != "" } {
- untested i386-disp-step.exp
+ untested "failed to compile"
return -1
}
standard_testfile
-if [prepare_for_testing ${testfile}.exp ${binfile} ${srcfile} {debug $additional_flags}] {
- untested "failed to compile"
+if [prepare_for_testing "failed to prepare" ${binfile} ${srcfile} {debug $additional_flags}] {
return -1
}
# some targets have leading underscores on assembly symbols.
set additional_flags [gdb_target_symbol_prefix_flags_asm]
-if { [prepare_for_testing break.exp $testfile $srcfile [list debug $additional_flags]] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile [list debug $additional_flags]] } {
return -1
}
set additional_flags [gdb_target_symbol_prefix_flags]
if { [gdb_compile "${srcdir}/${subdir}/${srcfilec} ${srcdir}/${subdir}/${srcfileasm}" "${binfile}" executable [list debug $additional_flags]] != "" } {
- untested i386-gnu-cfi.exp
+ untested "failed to compile"
return -1
}
set comp_flags "-mmpx -fcheck-pointer-bounds -I${srcdir}/../nat/"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
[list debug nowarnings additional_flags=${comp_flags}]] } {
return -1
}
set comp_flags "-mmpx -fcheck-pointer-bounds -I${srcdir}/../nat/"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
[list debug nowarnings additional_flags=${comp_flags}]] } {
return -1
}
set comp_flags "-mmpx -fcheck-pointer-bounds -I${srcdir}/../nat/"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
[list debug nowarnings additional_flags=${comp_flags}]] } {
return -1
}
set comp_flags "-mmpx -fcheck-pointer-bounds -I${srcdir}/../nat/"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
[list debug nowarnings additional_flags=${comp_flags}]] } {
return -1
}
set additional_flags [gdb_target_symbol_prefix_flags_asm]
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug $additional_flags]] != "" } {
- untested i386-permbkpt.exp
+ untested "failed to compile"
return -1
}
# Don't use "debug", so that we don't have line information for the assembly
# fragments.
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list $additional_flags]] != "" } {
- untested i386-prologue.exp
+ untested "failed to compile"
return -1
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" \
executable { debug }] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" \
executable [list debug $additional_flags]] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
set additional_flags [gdb_target_symbol_prefix_flags]
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug $additional_flags]] != "" } {
- untested i386-unwind.exp
+ untested "failed to compile"
return -1
}
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug]] != "" } {
- untested ${testfile}
+ untested "failed to compile"
return
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile}] } {
return
}
standard_testfile
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {quiet debug}] != "" } {
- untested powerpc-d128-regs.exp
+ untested "failed to compile"
return -1
}
standard_testfile .S
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
- untested powerpc-stackless.exp
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile .S
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug quiet}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug quiet}] } {
return -1
}
standard_testfile .S
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile .c
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
remote_exec build "mkdir $coredir"
}
-if { [prepare_for_testing ${testfile}.exp $testfile $srcfile \
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile \
[list "additional_flags=-mzarch"]] } {
return -1
}
set binfile ${objdir}/${subdir}/${testfile}
set opts {}
-if {[prepare_for_testing ${testfile}.exp ${binfile} $srcfile {additional_flags=-g}]} {
+if {[prepare_for_testing "failed to prepare" ${binfile} $srcfile {additional_flags=-g}]} {
return -1
}
set srcfile ${testfile}.S
set opts {}
-if [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $opts] {
- untested "failed to compile"
+if [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} $opts] {
return -1
}
set srcfile ${testfile}.S
set additional_flags "additional_flags=-mthumb"
-if [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} [list debug $additional_flags]] {
- untested ${testfile}.exp
+if [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} [list debug $additional_flags]] {
return -1
}
if ![runto_main] then {
- untested ${testfile}.exp
+ untested "could not run to main"
return -1
}
standard_testfile .S
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable debug] != "" } {
- untested thumb2-it.exp
+ untested "failed to compile"
return -1
}
gdb_load ${binfile}
if ![runto_main] then {
- untested thumb2-it.exp
+ untested "could not run to main"
return -1
}
gdb_test_multiple "list" "list main" {
-re ".*@ No Thumb-2.*$gdb_prompt $" {
pass "list main"
- untested thumb2-it.exp
+ untested "skipping tests due to lack of Thumb-2"
return -1
}
-re ".*@ Thumb-2 OK.*$gdb_prompt $" {
}
if { [gdb_compile ${srcdir}/${subdir}/${srcfile} ${binfile} executable $compile_flags] != "" } {
- untested vsx-regs.exp
+ untested "failed to compile"
return -1
}
}
if { "${asm-arch}" == "" } {
- untested asm-source.exp
+ untested "skipping tests due to no asm architecture"
return -1
}
if [board_info $dest exists multilib_flags] {
set multilib_flags [board_info $dest multilib_flags]
if { "${multilib_flags}" != "" } {
- untested asm-source.exp
+ untested "failed to compile"
return -1
return
}
set asm2obj [standard_output_file asmrc2.o]
if {[target_assemble ${srcdir}/${subdir}/${srcfile} $asm1obj "${asm-flags} ${debug-flags}"] != ""} then {
- untested asm-source.exp
+ untested "failed to assemble"
return -1
}
if {[target_assemble ${srcdir}/${subdir}/${srcfile2} $asm2obj "${asm-flags} ${debug-flags}"] != ""} then {
- untested asm-source.exp
+ untested "failed to assemble"
return -1
}
# also avoids a lot of problems on many systems, most notably on
# *-*-*bsd* and *-*-solaris2*.
if {[target_link [list $asm1obj $asm2obj] "${binfile}" ${link-flags}] != "" } then {
- untested asm-source.exp
+ untested "failed to link"
return -1
}
standard_testfile run.c
-if { [prepare_for_testing ${testfile}.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile .c
-if { [prepare_for_testing $testfile.exp $testfile $srcfile {debug}] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile {debug}] } {
return -1
}
if {[build_executable $testfile.exp $testfile \
$srcfile {debug nowarnings}] == -1} {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
standard_testfile int-type.c
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug nowarnings}]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug nowarnings}]} {
return -1
}
return 0
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} $srcfile] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} $srcfile] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile .c
set executable ${testfile}
-if { [prepare_for_testing ${testfile}.exp $executable "" [list debug "additional_flags=-fPIE -pie"]] } {
+if { [prepare_for_testing "failed to prepare" $executable "" [list debug "additional_flags=-fPIE -pie"]] } {
return -1
}
pass $test
}
-re "No shared libraries loaded at this time\\.\r\n$gdb_prompt $" {
- untested ${testfile}.exp
+ untested "no shared libraries loaded"
}
}
gdb_exit
if {$arch == ""} {
- untested ${testfile}.exp
+ untested "no architecture set"
return 0
}
standard_testfile
set executable ${testfile}
-if { [prepare_for_testing ${testfile}.exp $executable] } {
+if { [prepare_for_testing "failed to prepare" $executable] } {
return -1
}
remote_exec host "rm -rf ${targetdir}"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile args.c
-if {[prepare_for_testing $testfile.exp ${testfile}! $srcfile \
+if {[prepare_for_testing "failed to prepare" ${testfile}! $srcfile \
{debug nowarnings}]} {
- untested "failed to compile"
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
# Also verifies that breakpoint enabling/disabling works properly
# with duplicated breakpoints.
-if { [prepare_for_testing break-always.exp break-always break-always.c] } {
+if { [prepare_for_testing "failed to prepare" break-always break-always.c] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile}] } {
return -1
}
standard_testfile start.c
if [target_info exists use_gdb_stub] {
- untested ${testfile}.exp
+ untested "skipping tests due to use_gdb_stub"
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} $srcfile {additional_flags=-static}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} $srcfile {additional_flags=-static}] } {
return -1
}
}
}
if {$entry == ""} {
- untested ${testfile}.exp
+ untested "no entrypoint"
return
}
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [prepare_for_testing break-inline.exp "break-inline" {} {debug nowarnings optimize=-O2}] } {
+if { [prepare_for_testing "failed to prepare" "break-inline" {} {debug nowarnings optimize=-O2}] } {
return -1
}
if {[build_executable_from_specs $testfile.exp $testfile \
{c++ additional_flags=-Wl,--gc-sections} \
$srcfile {debug c++ additional_flags=-ffunction-sections}]} {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
return -1
}
-if { [prepare_for_testing $testfile.exp $testfile $srcfile \
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile \
[list additional_flags=-DSHLIB_NAME=\"$binfile_lib\" libs=-ldl]] } {
return -1
}
# This file was written by Rob Savoye. (rob@cygnus.com)
-if { [prepare_for_testing break.exp "break" {break.c break1.c} {debug nowarnings}] } {
+if { [prepare_for_testing "failed to prepare" "break" {break.c break1.c} {debug nowarnings}] } {
return -1
}
set srcfile break.c
# build a new file with optimization enabled so that we can try breakpoints
# on targets with optimized prologues
-if { [prepare_for_testing break.exp "breako2" {break.c break1.c} {debug nowarnings optimize=-O2}] } {
+if { [prepare_for_testing "failed to prepare" "breako2" {break.c break1.c} {debug nowarnings optimize=-O2}] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
set skip_float_test [gdb_skip_float_test]
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
# built the second test case since we can't use prototypes
warning "Prototypes not supported, rebuilding with -DNO_PROTOTYPES"
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable "${flags} additional_flags=-DNO_PROTOTYPES"] != "" } {
- untested call-sc.exp
+ untested "failed to compile"
return -1
}
}
standard_testfile call-signals.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested call-signal-resume.exp
+ untested "failed to compile"
return -1
}
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
# Perform all tests with and without function prototypes.
-if { ![prepare_for_testing ${testfile}.exp $testfile $srcfile "$compile_flags additional_flags=-DPROTOTYPES"] } {
+if { ![prepare_for_testing "failed to prepare" $testfile $srcfile "$compile_flags additional_flags=-DPROTOTYPES"] } {
perform_all_tests
}
-if { ![prepare_for_testing ${testfile}.exp $testfile $srcfile "$compile_flags additional_flags=-DNO_PROTOTYPES"] } {
+if { ![prepare_for_testing "failed to prepare" $testfile $srcfile "$compile_flags additional_flags=-DNO_PROTOTYPES"] } {
with_test_prefix "noproto" perform_all_tests
}
# Reusing foll-fork.c since it's a simple forking program.
standard_testfile foll-fork.c
-if { [prepare_for_testing ${testfile}.exp ${testfile} $srcfile \
+if { [prepare_for_testing "failed to prepare" ${testfile} $srcfile \
{additional_flags=-static}] } {
return -1
}
set dp_location [gdb_get_line_number "set dprintf here"]
set bp_location [gdb_get_line_number "set breakpoint here"]
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
#
if {[skip_shlib_tests]} {
- untested catch-load.exp
+ untested "skipping shared library tests"
return -1
}
if {[get_compiler_info]} {
warning "Could not get compiler info"
- untested catch-load.exp
+ untested "no compiler info"
return -1
}
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug shlib_load}] != "" } {
- untested catch-load.exp
+ untested "failed to compile"
return -1
}
set binfile2 [standard_output_file ${testfile2}.so]
set binfile2_dlopen [shlib_target_file ${testfile2}.so]
if { [gdb_compile_shlib "${srcdir}/${subdir}/${srcfile2}" ${binfile2} {debug}] != "" } {
- untested catch-load.exp
+ untested "failed to compile shared library"
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp $testfile ${testfile}.c] } {
- untested catch-syscall.exp
+if { [prepare_for_testing "failed to prepare" $testfile ${testfile}.c] } {
return -1
}
standard_testfile .c charset-malloc.c
-if { [prepare_for_testing ${testfile}.exp ${testfile} [list $srcfile $srcfile2]] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} [list $srcfile $srcfile2]] } {
return -1
}
set copy1_txt [standard_output_file copy1.txt]
}
-if {[prepare_for_testing ${testfile}.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
[list debug "additional_flags=-DPI_TXT=\"$pi_txt\" -DCOPY1_TXT=\"$copy1_txt\""]]} {
- untested "failed to compile"
return -1
}
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-DVARIABLE=var1}] != "" } {
- untested chng-syms.exp
+ untested "failed to compile"
return -1
}
standard_testfile cvexpr.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested code-expr.exp
+ untested "failed to compile"
return -1
}
remote_exec build "rm -f ${binfile2}"
if { [gdb_compile "${srcdir}/${subdir}/${srcfile1}" "${binfile1}" executable $opts] != "" } {
- untested code_elim.exp
+ untested "failed to compile"
return -1
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile2}" "${binfile2}" executable $opts] != "" } {
- untested code_elim.exp
+ untested "failed to compile"
return -1
}
standard_testfile
-if { [prepare_for_testing commands.exp commands run.c {debug additional_flags=-DFAKEARGV}] } {
+if { [prepare_for_testing "failed to prepare" commands run.c {debug additional_flags=-DFAKEARGV}] } {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug nowarnings}]} {
- untested $testfile.exp
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile int-type.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug nowarnings}] != "" } {
- untested cond-expr.exp
+ untested "failed to compile"
return -1
}
standard_testfile break.c break1.c
-if {[prepare_for_testing ${testfile}.exp $testfile [list $srcfile $srcfile2] \
+if {[prepare_for_testing "failed to prepare" $testfile [list $srcfile $srcfile2] \
{debug nowarnings}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug nowarnings}]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug nowarnings}]} {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} $srcfile] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} $srcfile] } {
return -1
}
}
if { [prepare_for_testing "failed to prepare" $testfile $srcfile debug] } {
- untested "failed to compile"
return -1
}
}
if {[build_executable $testfile.exp $testfile $srcfile debug] == -1} {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
if {[build_executable $testfile.exp $testfile \
[list $srcfile $srcfile2] debug] == -1} {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
standard_testfile .c
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug}]} {
return -1
}
standard_testfile break.c break1.c
-if {[prepare_for_testing ${testfile}.exp ${testfile} \
+if {[prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $srcfile2] {debug nowarnings}]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile}] } {
return -1
}
# units displaying source lines. This checks that the disassemble routine
# can handle our use of line number 0 to mark the end of sequence.
-if { [prepare_for_testing disasm-end-cu.exp "disasm-end-cu" {disasm-end-cu-1.c disasm-end-cu-2.c} {debug}] } {
+if { [prepare_for_testing "failed to prepare" "disasm-end-cu" {disasm-end-cu-1.c disasm-end-cu-2.c} {debug}] } {
return -1
}
standard_testfile .S
-if { [prepare_for_testing ${testfile}.exp $testfile ${testfile}.S {nodebug}] } {
+if { [prepare_for_testing "failed to prepare" $testfile ${testfile}.S {nodebug}] } {
return -1
}
#
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
{debug nowarnings}]} {
- untested "failed to compile"
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile}] } {
return -1
}
standard_testfile break.c break1.c
-if {[prepare_for_testing ${testfile}.exp ${testfile} \
+if {[prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $srcfile2] {debug nowarnings}]} {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp $testfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile] } {
return -1
}
remote_exec build "rm -f core"
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile break.c break1.c
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug nowarnings}]} {
- untested $testfile.exp
return -1
}
set test "eu-strip"
set status [remote_exec build "eu-strip -f ${binfile}.debug $binfile"]
if {[lindex $status 0] != 0} {
- untested ${testfile}.exp
+ untested "failed to compile"
return 0
}
standard_testfile int-type.c
-if { [prepare_for_testing ${testfile}.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile int-type.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug nowarnings}] != "" } {
- untested eval-skip.exp
+ untested "failed to compile"
return -1
}
standard_testfile segv.c
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
# inferior execution.
standard_testfile normal.c
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
}
# We intentionally compile the source file in twice.
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile debug $srcfile {debug additional_flags=-DFIRST} \
$srcfile debug]]} {
return -1
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile}] } {
return -1
}
set skip_float_test [gdb_skip_float_test]
# re-use the program from the "return2" test.
-if { [prepare_for_testing finish.exp finish return2.c] } {
+if { [prepare_for_testing "failed to prepare" finish return2.c] } {
return -1
}
#
-if { [prepare_for_testing float.exp float float.c] } {
+if { [prepare_for_testing "failed to prepare" float float.c] } {
return -1
}
# build the first test case
if { [gdb_compile "${srcdir}/${subdir}/${srcfile2}" "${binfile2}" executable $compile_options] != "" } {
- untested foll-exec-mode.exp
+ untested "failed to compile"
return -1
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable $compile_options] != "" } {
- untested foll-exec-mode.exp
+ untested "failed to compile"
return -1
}
# build the first test case
if { [gdb_compile "${srcdir}/${subdir}/${srcfile2}" "${binfile2}" executable $compile_options] != "" } {
- untested foll-exec.exp
+ untested "failed to compile"
return -1
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable $compile_options] != "" } {
- untested foll-exec.exp
+ untested "failed to compile"
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile .c
-if { [prepare_for_testing ${testfile}.exp ${testfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile}] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
# Trying to print foo->bar if foo is a pointer to a typedef of a pointer
# to a function will put gdb into an infinite loop.
-if { [prepare_for_testing func-ptr.exp "func-ptr" {func-ptr.c} {debug}] } {
+if { [prepare_for_testing "failed to prepare" "func-ptr" {func-ptr.c} {debug}] } {
return -1
}
set testname func-ptrs
set srcfile ${testname}.c
-if { [prepare_for_testing ${testname}.exp ${testname} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testname} ${srcfile}] } {
return -1
}
if { ![runto_main] } {
- untested ${testname}.exp
+ untested "could not run to main"
return -1
}
set skip_float_test [gdb_skip_float_test]
-if {[prepare_for_testing $testfile.exp $testfile $srcfile $compile_flags]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile $compile_flags]} {
return -1
}
append binfile -${pattern}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
"set buffer exceeding arguments"
if { ! [ runto_main ] } then {
- untested gcore-buffer-overflow.exp
+ untested "could not run to main"
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug additional_flags=-fpie "ldflags=-pie -Wl,-z,relro"}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug additional_flags=-fpie "ldflags=-pie -Wl,-z,relro"}]} {
return -1
}
if { [gdb_compile_shlib ${srcdir}/${subdir}/${srcfile_lib} ${binfile_lib} {debug}] != ""
|| [gdb_compile ${srcdir}/${subdir}/${srcfile} ${objfile} object {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
set opts [list debug shlib=${binfile_lib} additional_flags=-Wl,-z,relro]
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested "failed to compile"
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
return 0
}
-if { [prepare_for_testing $testfile.exp $testfile $testfile.c {debug}] } {
+if { [prepare_for_testing "failed to prepare" $testfile $testfile.c {debug}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $testfile.c {debug}] } {
+if { [prepare_for_testing "failed to prepare" $testfile $testfile.c {debug}] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
if {[gdb_compile "${srcdir}/${subdir}/${srcfile_stabs}" ${objfile_stabs} object {additional_flags=-gstabs}] != ""
|| [gdb_compile "${srcdir}/${subdir}/${srcfile_dwarf}" ${objfile_dwarf} object {additional_flags=-gdwarf-2}] != ""
|| [gdb_compile "${objfile_stabs} ${objfile_dwarf}" ${binfile} executable {nodebug}] != ""} {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
set test hbreak
set srcfile ${test}.c
-if { [prepare_for_testing ${test}.exp ${test} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${test} ${srcfile}] } {
return -1
}
# the number available.
-if { [prepare_for_testing hbreak2.exp "hbreak2" {break.c break1.c} {debug nowarnings}] } {
+if { [prepare_for_testing "failed to prepare" "hbreak2" {break.c break1.c} {debug nowarnings}] } {
return -1
}
set srcfile break.c
# Build a new file with optimization enabled so that we can try breakpoints
# on targets with optimized prologues.
-if { [prepare_for_testing hbreak2.exp "hbreak2o2" {break.c break1.c} {debug nowarnings optimize=-O2}] } {
+if { [prepare_for_testing "failed to prepare" "hbreak2o2" {break.c break1.c} {debug nowarnings optimize=-O2}] } {
return -1
}
# along with this program. If not, see <http://www.gnu.org/licenses/>.
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
continue
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested "failed to compile"
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile .c
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${testfile}.c] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${testfile}.c] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
# Fission doesn't support macros yet. Bug 15954.
if [using_fission] {
- untested ${testfile}.exp
+ untested "fission does not support macros yet"
return -1
}
get_compiler_info
if ![test_compiler_info gcc*] {
- untested ${testfile}.exp
+ untested "no compiler info"
return -1
}
# command line, possibly overriding "-g3" (depending on gcc version).
set options "additional_flags=-g3"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $options] } {
- untested ${testfile}.exp
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} $options] } {
return -1
}
if ![runto_main] {
- untested ${testfile}.exp
+ untested "could not run to main"
return -1
}
}
# Compile test program.
-if { [prepare_for_testing ${testfile}.exp $testfile $srcfile {debug additional_flags=-lpthread}] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile {debug additional_flags=-lpthread}] } {
fail "cannot compile test program"
return -1
}
standard_testfile break.c break1.c
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug nowarnings}]} {
- untested $testfile.exp
return -1
}
}
if { ! [ runto_main ] } then {
- untested info-proc.exp
+ untested "could not run to main"
return -1
}
}
set cflags "$define1 $define2"
-if { [prepare_for_testing $testfile.exp $testfile $srcfile \
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile \
[list additional_flags=$cflags libs=-ldl]] } {
return -1
}
standard_testfile start.c
-if { [prepare_for_testing ${testfile}.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} $srcfile {debug}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} $srcfile {debug}] } {
return -1
}
}
if {[build_executable $testfile.exp $testfile $srcfile $options] == -1} {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
if { [gdb_compile "${srcdir}/${subdir}/${jit_host_src}" "${jit_host_bin}" \
executable [list debug additional_flags=$jit_reader_flag]] != "" } {
- untested jit-reader.exp
+ untested "failed to compile"
return -1
}
if { [gdb_compile_shlib "${srcdir}/${subdir}/${jit_reader_src}" "${jit_reader_bin}" \
[list debug additional_flags=$jit_reader_flag]] != "" } {
- untested jit-reader.exp
+ untested "failed to compile"
return -1
}
# address between runs.
if {[skip_shlib_tests]} {
- untested jit-simple.exp
+ untested "skipping shared library tests"
return -1
}
set options [list debug shlib=${binfile_lib}]
if {[gdb_compile ${srcdir}/${subdir}/${srcfile_dl} $binfile_dl executable \
[list debug shlib=$binfile_lib]] == -1 } {
- untested jit-simple.exp
+ untested "failed to compile"
return -1
}
standard_testfile .c
if { ![can_single_step_to_signal_handler] } {
- untested ${testfile}.exp
+ untested "cannot single-step to signal handler"
return
}
continue
}
-if [prepare_for_testing ${testfile}.exp ${testfile}] {
+if [prepare_for_testing "failed to prepare" ${testfile}] {
return -1
}
standard_testfile
set executable $testfile
-if [prepare_for_testing $testfile.exp $executable] {
+if [prepare_for_testing "failed to prepare" $executable] {
return -1
}
standard_testfile .c
-if { [prepare_for_testing ${testfile}.exp $testfile ${srcfile} debug] } {
- untested "failed to compile"
+if { [prepare_for_testing "failed to prepare" $testfile ${srcfile} debug] } {
return -1
}
}
-if {[prepare_for_testing ${testfile}.exp ${testfile} \
+if {[prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $srcfile2 $srcfile3] {debug}]} {
return -1
}
set testfile ldbl_e308
set srcfile ${testfile}.c
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
if ![runto_main] {
- untested ${testfile}.exp
+ untested "could not run to main"
return -1
}
standard_testfile .c line-symtabs.h
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
# We don't currently need our own test case for testing, so grab
# another one.
-if {[prepare_for_testing linespecs.exp linespecs memattr.c]} {
+if {[prepare_for_testing "failed to prepare" linespecs memattr.c]} {
return -1
}
# Need to download the header to the host.
gdb_remote_download host ${srcdir}/${subdir}/list0.h
-if {[prepare_for_testing $testfile.exp $testfile [list $srcfile $srcfile2] \
+if {[prepare_for_testing "failed to prepare" $testfile [list $srcfile $srcfile2] \
{debug}]} {
return -1
}
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [concat debug nowarnings]] != "" } {
- untested long_long.exp
+ untested "failed to compile"
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} $srcfile {debug quiet}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} $srcfile {debug quiet}] } {
return -1
}
standard_testfile break.c break1.c
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug nowarnings}]} {
- untested $testfile.exp
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile .c
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
lappend options additional_flags=-O2 additional_flags=-fno-inline
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile $options]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile $options]} {
return -1
}
# -fuse-ld=gold is used for calling printf code built without -fsplit-stack
# which could crash otherwise. See GCC documentation of -fsplit-stack.
set opts "additional_flags=-fsplit-stack"
-if { [prepare_for_testing ${testfile}.exp ${testfile} $srcfile [list $opts additional_flags=-fuse-ld=gold]] \
- && [prepare_for_testing ${testfile}.exp ${testfile} $srcfile $opts] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} $srcfile [list $opts additional_flags=-fuse-ld=gold]] \
+ && [prepare_for_testing "failed to prepare" ${testfile} $srcfile $opts] } {
return -1
}
return -1
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} $srcfile] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} $srcfile] } {
return -1
}
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested multi-forks.exp
+ untested "failed to compile"
return -1
}
standard_testfile
-if {[prepare_for_testing "${testfile}.exp" "${testfile}" "${srcfile}"]} {
+if {[prepare_for_testing "failed to prepare" "${testfile}" "${srcfile}"]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $testfile.c]} {
+if {[prepare_for_testing "failed to prepare" $testfile $testfile.c]} {
return -1
}
global gdb_prompt
if { ! [ runto_main ] } then {
- untested ${testfile}.exp
+ untested "could not run to main"
return -1
}
global gdb_prompt
if { ! [ runto_main ] } then {
- untested ${testfile}.exp
+ untested "could not run to main"
return -1
}
# See also the comment in break-entry.exp.
if [target_info exists use_gdb_stub] {
- untested ${testfile}.exp
+ untested "skipping tests due to use_gdb_stub"
return
}
unset_board_info mathlib
}
if {$err != ""} {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
if { [prepare_for_testing "failed to prepare for testing large offsets" \
${testfile} ${srcfile}] } {
- untested "failed to compile"
return -1
}
standard_testfile opaque0.c opaque1.c
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] debug]} {
- untested $testfile.exp
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug nowarnings}]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug nowarnings}]} {
return -1
}
if {[build_executable $testfile.exp $testfile \
$srcfile {debug nowarnings}] == -1} {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
if { [gdb_compile_shlib ${srcdir}/${subdir}/${srcfile_lib} ${binfile_lib} {debug}] != ""
|| [gdb_compile ${srcdir}/${subdir}/${srcfile} ${objfile} object {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
set opts [list debug shlib=${binfile_lib}]
if { [gdb_compile ${objfile} ${binfile} executable $opts] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile}] } {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] debug]} {
- untested $testfile.exp
return -1
}
standard_testfile .c ptype1.c
-if {[prepare_for_testing ${testfile}.exp ${testfile} \
+if {[prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $srcfile2] {debug nowarnings}]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
set executable $testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile {debug}] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile {debug}] } {
return -1
}
set inputrc ${srcdir}/${subdir}/${testfile}.inputrc
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" object {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile .c
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
if ![runto_main] {
- untested ${testfile}.exp
+ untested "could not run to main"
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
# test running programs
#
-if { [prepare_for_testing relational.exp relational int-type.c {debug nowarnings}] } {
+if { [prepare_for_testing "failed to prepare" relational int-type.c {debug nowarnings}] } {
return -1
}
standard_testfile
set executable $testfile
-if { [prepare_for_testing $testfile.exp $executable $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $executable $srcfile] } {
return -1
}
set additional_flags "additional_flags=-DTYPE=$typeesc"
- if {[prepare_for_testing_full $testfile.exp \
+ if {[prepare_for_testing_full "failed to prepare" \
[list ${testfile}-${typenospace} debug \
$srcfile [list debug $additional_flags] \
$srcfile2 [list $additional_flags]]]} {
# This file was written by Jeff Law. (law@cs.utah.edu)
-if { [prepare_for_testing return.exp "return"] } {
+if { [prepare_for_testing "failed to prepare" "return"] } {
return -1
}
standard_testfile
set executable $testfile
-if [prepare_for_testing $testfile.exp $executable] {
+if [prepare_for_testing "failed to prepare" $executable] {
return -1
}
standard_testfile .c
-if { [prepare_for_testing ${testfile}.exp ${testfile} $srcfile] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} $srcfile] } {
return -1
}
if ![runto_main] {
- untested ${testfile}.exp
+ untested "could not run to main"
return -1
}
# Delete all breakpoints so that the "runto_main" breakpoint above
standard_testfile scope0.c scope1.c
-if {[prepare_for_testing ${testfile}.exp ${testfile} \
+if {[prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $srcfile2] {debug}]} {
return -1
}
set binfile ${objdir}/${subdir}/${testfile}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}0.o" object {debug nowarnings}] != "" } {
- untested sect-cmd.exp
+ untested "failed to compile"
return -1
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile1}" "${binfile}1.o" object {debug nowarnings}] != "" } {
- untested sect-cmd.exp
+ untested "failed to compile"
return -1
}
if { [gdb_compile "${binfile}0.o ${binfile}1.o" "${binfile}" executable {debug nowarnings}] != "" } {
- untested sect-cmd.exp
+ untested "failed to compile"
return -1
}
standard_testfile start.c
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [prepare_for_testing set-noassign.exp "set-noassign" start.c {debug nowarnings}] } {
+if { [prepare_for_testing "failed to prepare" "set-noassign" start.c {debug nowarnings}] } {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested "failed to compile"
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile .c
-if { [prepare_for_testing ${testfile}.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
set options [list debug "additional_flags=-DOUTPUT_TXT=\"$gdb_txt\""]
if {[build_executable $testfile.exp $testfile $srcfile $options]} {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
set options [list debug "additional_flags=-DOUTPUT_TXT=\"$standalone_txt\""]
if {[build_executable $testfile.exp $testfile-standalone $srcfile $options]} {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
clean_restart $binfile
if { ! [ runto_main ] } then {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
return -1
}
-if [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug}] {
- untested ${testfile}.exp
+if [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug}] {
return -1
}
if ![runto_main] then {
- untested ${testfile}.exp
+ untested "could not run to main"
return -1
}
standard_testfile
if {[build_executable $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
# This file was written by Justin Lebar. (justin.lebar@gmail.com)
# And further hacked on by Doug Evans. (dje@google.com)
-if { [prepare_for_testing skip.exp "skip" \
+if { [prepare_for_testing "failed to prepare" "skip" \
{skip.c skip1.c } \
{debug nowarnings}] } {
return -1
set testfile "solib-corrupted"
set srcfile start.c
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
- untested ${testfile}.exp
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
|| [gdb_gnu_strip_debug $binlibfile]
|| [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${objfile}" object {debug}] != ""
|| [gdb_compile "${objfile} ${binlibfile}" "${binfile}" executable {}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
# is properly reset when the path is changed.
if {[is_remote target] || [skip_shlib_tests]} {
- untested solib-search.exp
+ untested "skipping remote target and shared library tests"
return -1
}
# This is required by gdb_compile_shlib.
if {[get_compiler_info]} {
warning "Could not get compiler info"
- untested solib-search.exp
+ untested "no compiler info"
return 1
}
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [concat debug additional_flags=-fstack-check nowarnings]] != "" } {
- untested stack-checking.exp
+ untested "failed to compile"
return -1
}
standard_testfile .c
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
proc stap_test {exec_name {arg ""}} {
global testfile hex srcfile
- if {[prepare_for_testing ${testfile}.exp ${exec_name} $srcfile \
+ if {[prepare_for_testing "failed to prepare" ${exec_name} $srcfile \
[concat $arg debug]]} {
return -1
}
proc stap_test_no_debuginfo {exec_name {arg ""}} {
global testfile hex
- if {[prepare_for_testing ${testfile}.exp ${exec_name} ${testfile}.c \
+ if {[prepare_for_testing "failed to prepare" ${exec_name} ${testfile}.c \
{$arg nodebug optimize=-O2}]} {
return -1
}
with_test_prefix "without semaphore, not optimized" {
if {[stap_test "stap-probe-nosem-noopt"] == -1} {
- untested stap-probe.exp
+ untested "stap probe test failed"
return -1
}
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested step-break.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
set linefile ${testfile}.inp
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
set testfile "step-over-$syscall"
if [build_executable ${testfile}.exp ${testfile} ${testfile}.c {debug}] {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} $srcfile] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} $srcfile] } {
return -1
}
remote_exec build "rm -f ${binfile}"
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested step-test.exp
+ untested "failed to compile"
return -1
}
standard_testfile
set executable $testfile
-if { [prepare_for_testing $testfile.exp $executable $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $executable $srcfile] } {
return -1
}
standard_testfile .c
-if { [prepare_for_testing structs3.exp "structs3" "" {debug}] } {
+if { [prepare_for_testing "failed to prepare" "structs3" "" {debug}] } {
return -1
}
}
if {[gdb_compile_shlib $libsrc $lib_so {debug}] != ""} {
- untested ${testfile}
+ untested "failed to compile shared library"
return
}
-if {[prepare_for_testing $testfile $binfile "$srcfile $srcfile2" $exec_opts]} {
+if {[prepare_for_testing "failed to prepare" $binfile "$srcfile $srcfile2" $exec_opts]} {
return
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile2}" \
[standard_output_file ${binlibfile}] object {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
if {[build_executable ${testfile}.exp ${testfile} ${srcfile} {debug}] == -1} {
continue
}
-if { [prepare_for_testing term.exp term term.c] } {
+if { [prepare_for_testing "failed to prepare" term term.c] } {
return -1
}
# Compile binary
# and start with a fresh gdb
-if { [prepare_for_testing ${testfile}.exp ${binfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${binfile} ${srcfile}] } {
return -1
}
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [prepare_for_testing ui-redirect.exp ui-redirect start.c] } {
+if { [prepare_for_testing "failed to prepare" ui-redirect start.c] } {
return -1
}
# until.exp -- Expect script to test 'until' in gdb
set srcfile break.c
-if { [prepare_for_testing until.exp "until" {break.c break1.c} {debug nowarnings}] } {
+if { [prepare_for_testing "failed to prepare" "until" {break.c break1.c} {debug nowarnings}] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
# Use the same test program constvars.c.
-if { [prepare_for_testing volatile.exp volatile constvars.c] } {
+if { [prepare_for_testing "failed to prepare" volatile constvars.c] } {
return -1
}
standard_testfile
if { [build_executable ${testfile}.exp ${testfile} ${testfile}.c {debug}] } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile .c
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
- untested ${testfile}.exp
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
- untested ${testfile}.exp
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
return 0
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
- untested ${testfile}.exp
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile .c
if { [build_executable ${testfile}.exp ${testfile} $srcfile {debug}] } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
# Stepping into a dynamic function trampoline or stepping out of MAIN may work
# but it is not a reliable FAIL case.
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile debug $srcfile debug $srcfile2 {}]]} {
- untested $testfile.exp
return -1
}
standard_testfile .c
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
- untested ${testfile}.exp
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
set test watchpoint-hw-hit-once
set srcfile ${test}.c
-if { [prepare_for_testing ${test}.exp ${test} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${test} ${srcfile}] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
return -1
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
- untested ${testfile}.exp
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile .c
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
# test running programs
#
-if { [prepare_for_testing whatis-exp.exp whatis-exp int-type.c {debug nowarnings}] } {
+if { [prepare_for_testing "failed to prepare" whatis-exp int-type.c {debug nowarnings}] } {
return -1
}
# start inferior
standard_testfile record_goto.c
-if [prepare_for_testing $testfile.exp $testfile $srcfile] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile] {
return -1
}
# start inferior
standard_testfile
-if [prepare_for_testing $testfile.exp $testfile $srcfile] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile] {
return -1
}
if ![runto_main] {
# start inferior
standard_testfile record_goto.c
-if [prepare_for_testing delta.exp $testfile $srcfile] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile] {
return -1
}
if ![runto_main] {
return -1
}
-if { [prepare_for_testing $testfile.exp $testfile $srcfile \
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile \
[list additional_flags=-DDSO_NAME=\"$binfile_lib\" libs=-ldl]] } {
return -1
}
# start inferior
standard_testfile
-if [prepare_for_testing $testfile.exp $testfile {} {debug}] {
+if [prepare_for_testing "failed to prepare" $testfile {} {debug}] {
return -1
}
if ![runto_main] {
# start inferior
standard_testfile exception.cc
-if [prepare_for_testing $testfile.exp $testfile $srcfile {c++ debug}] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile {c++ debug}] {
return -1
}
if ![runto_main] {
# start inferior
standard_testfile
-if [prepare_for_testing function_call_history.exp $testfile {} {debug}] {
+if [prepare_for_testing "failed to prepare" $testfile {} {debug}] {
return -1
}
if ![runto_main] {
# start inferior
standard_testfile record_goto.c
-if [prepare_for_testing gcore.exp $testfile $srcfile] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile] {
return -1
}
# compile and run to main
standard_testfile .c .S
-if [prepare_for_testing $testfile.exp $testfile "$srcfile $srcfile2" {debug}] {
+if [prepare_for_testing "failed to prepare" $testfile "$srcfile $srcfile2" {debug}] {
return -1
}
if ![runto_main] {
# start inferior
standard_testfile record_goto.c
-if [prepare_for_testing nohist.exp $testfile $srcfile] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile] {
return -1
}
if { [skip_gdbserver_tests] } { return -1 }
standard_testfile
-if [prepare_for_testing $testfile.exp $testfile $srcfile] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile] {
return -1
}
standard_testfile record_goto.c
# start inferior
-if [prepare_for_testing record_goto-step.exp $testfile $srcfile] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile] {
return -1
}
return -1
}
-if [prepare_for_testing record_goto.exp $testfile $srcfile $opts] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile $opts] {
return -1
}
if ![runto_main] {
# start inferior
standard_testfile
-if [prepare_for_testing $testfile.exp $testfile $srcfile {c++ debug}] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile {c++ debug}] {
return -1
}
if ![runto_main] {
# start inferior
standard_testfile
-if [prepare_for_testing $testfile.exp $testfile $srcfile] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile] {
return -1
}
if ![runto_main] {
standard_testfile record_goto.c
# start inferior
-if [prepare_for_testing step.exp $testfile $srcfile] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile] {
return -1
}
}
# start inferior
-if [prepare_for_testing stepi.exp $testfile $srcfile] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile] {
return -1
}
return -1
}
-if [prepare_for_testing tailcall-only.exp $testfile $srcfile $opts] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile $opts] {
return -1
}
if ![runto_main] {
return -1
}
-if [prepare_for_testing tailcall.exp $testfile $srcfile $opts] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile $opts] {
return -1
}
if ![runto_main] {
# compile and run to main
standard_testfile .c x86-tsx.S
-if [prepare_for_testing tsx.exp $testfile "$srcfile $srcfile2" {debug}] {
+if [prepare_for_testing "failed to prepare" $testfile "$srcfile $srcfile2" {debug}] {
return -1
}
if ![runto_main] {
# discard local symbols
set ldflags "additional_flags=-Wl,-x"
-if [prepare_for_testing $testfile.exp $testfile $srcfile $ldflags] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile $ldflags] {
return -1
}
if ![runto test] {
# start inferior
standard_testfile
-if [prepare_for_testing $testfile.exp $testfile $srcfile] {
+if [prepare_for_testing "failed to prepare" $testfile $srcfile] {
return -1
}
if ![runto_main] {
with_test_prefix "nodebug" {
- if { [prepare_for_testing ${testfile}.exp "$testfile-nodebug" $srcfile {}] } {
+ if { [prepare_for_testing "failed to prepare" "$testfile-nodebug" $srcfile {}] } {
return -1
}
with_test_prefix "debug" {
- if { [prepare_for_testing ${testfile}.exp "$testfile-debug" $srcfile] } {
+ if { [prepare_for_testing "failed to prepare" "$testfile-debug" $srcfile] } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp "$testfile"] } {
+if { [prepare_for_testing "failed to prepare" "$testfile"] } {
return -1
}
standard_testfile .c compile-setjmp-mod.c
-if { [prepare_for_testing ${testfile}.exp $testfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile] } {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
if { [test_compiler_info gcc-*] } then { continue }
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
{debug c++ nowarnings}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
{debug c++ nowarnings}]} {
return -1
}
standard_testfile .cc anon-ns2.cc
-if {[prepare_for_testing $testfile $testfile "$srcfile $srcfile2" {c++ debug}]} {
+if {[prepare_for_testing "failed to prepare" $testfile "$srcfile $srcfile2" {c++ debug}]} {
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++}] } {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
if {[gdb_compile "$srcdir/$subdir/${srcfile2}" "${objfilec}" object {debug}] != ""
|| [gdb_compile "$srcdir/$subdir/${srcfile}" "${objfilecpp}" object {c++ debug}] != ""
|| [gdb_compile "${objfilecpp} ${objfilec}" "${binfile}" executable {c++ debug}] != ""} {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
" = \\(Gamma \\*\\) $nonzero_hex" \
"dynamic_cast to sibling"
-if {[prepare_for_testing $testfile.exp ${testfile}03 $srcfile2 \
+if {[prepare_for_testing "failed to prepare" ${testfile}03 $srcfile2 \
{debug c++ additional_flags=-std=c++03}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
# Do NOT compile with debug flag.
-if {[prepare_for_testing $testfile $testfile $srcfile {c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {c++}]} {
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++}] } {
return -1
}
if { [skip_cplus_tests] } { continue }
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" object {c++ debug}] != "" } {
- untested cp-relocate.exp
+ untested "failed to compile"
return -1
}
standard_testfile pr9594.cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing "$testfile.exp" $testfile $srcfile {c++ debug}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {c++ debug}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
if {[skip_cplus_tests]} { continue }
-if {[prepare_for_testing ${testfile}.exp $testfile $srcfile {debug c++}] } {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}] } {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2 $srcfile3 $srcfile4] {debug c++}]} {
return -1
}
standard_testfile derivation.cc derivation2.cc
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
{debug c++ additional_flags=-std=c++11}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
set executable ${testfile}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" object {debug c++} ] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
if { [skip_cplus_tests] } { continue }
set srcfile expand-sals.cc
-if { [prepare_for_testing expand-sals.exp expand-sals $srcfile {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" expand-sals $srcfile {debug c++}] } {
return -1
}
if ![runto_main] {
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++}] } {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
continue
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile hang1.cc hang2.cc hang3.cc
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2 $srcfile3] {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
# Use completely arbitrary file for $libfile source.
if { [gdb_compile_shlib ${srcdir}/${subdir}/${srcfile2} ${libfile} {debug c++}] != ""
- || [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++ shlib_load}] } {
+ || [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++ shlib_load}] } {
return -1
}
standard_testfile misc.cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++}] } {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
# Tests for c++/12266 et al
standard_testfile .cc
-if {[prepare_for_testing $testfile $testfile $srcfile {c++ debug}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {c++ debug}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
- untested "failed to compile"
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
if {[gdb_compile $srcdir/$subdir/$srcfile $objfile object {}] != ""
|| [gdb_compile $srcdir/$subdir/$srcfile2 $objmainfile object {debug}] != ""
|| [gdb_compile "$objfile $objmainfile" $binfile executable {c++}] != ""} {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .S
set csrcfile "${testfile}.cc"
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {nodebug}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {nodebug}]} {
return -1
}
standard_testfile .cc namespace-enum-main.cc
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
set xfail_class_types 1
}
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
if { [skip_cplus_tests] } { continue }
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}.o" object {c++ debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-if { [prepare_for_testing noparam.exp "noparam" "noparam.cc" {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" "noparam" "noparam.cc" {debug c++}] } {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++}] } {
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++}] } {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++}] } {
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++}] } {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile $testfile $testfile.cc {c++ debug}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $testfile.cc {c++ debug}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
# Test for c++/11734
standard_testfile ovsrch1.cc ovsrch2.cc ovsrch3.cc ovsrch4.cc
-if {[prepare_for_testing $testfile $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2 $srcfile3 $srcfile4] {c++ debug}]} {
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${testfile}.cc {c++ debug}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${testfile}.cc {c++ debug}] } {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++}] } {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug c++}]} {
return -1
}
standard_testfile .cc
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}.x" object {debug c++}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++}] } {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
if { [gdb_compile_shlib $srcdir/$subdir/$srcfile2 $sofile {debug c++}] != ""
|| [gdb_compile $srcdir/$subdir/$srcfile $binfile executable [list debug "c++" shlib=${sofile}]] != ""} {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug c++}]} {
return -1
}
standard_testfile .cc
set exefile $testfile
-if {[prepare_for_testing $testfile $exefile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $exefile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++}] } {
return -1
}
# Tests for c++/12750
standard_testfile .cc
-if {[prepare_for_testing $testfile $testfile $srcfile {c++ debug}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {c++ debug}]} {
return -1
}
standard_testfile .cc
if { [gdb_compile $srcdir/$subdir/$srcfile $binfile.o object {debug c++}] != ""} {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
}
-re "\r\n---Type <return>" {
# gdb-7.1 did not crash with this testcase but it had the same bug.
- untested ${testfile}.exp
+ untested "bug does not reproduce"
return 0
}
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile $testfile $srcfile {c++ debug}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {c++ debug}]} {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile var-tag.cc var-tag-2.cc var-tag-3.cc var-tag-4.cc
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2 $srcfile3 $srcfile4] {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t01_mov.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t01_mov.exp
+ untested "failed to link"
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t02_mova.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t02_mova.exp
+ untested "failed to link"
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t03_add.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t03_add.exp
+ untested "failed to link"
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t04_sub.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t04_sub.exp
+ untested "failed to link"
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t05_cmp.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t05_cmp.exp
+ untested "failed to link"
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t06_ari2.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t06_ari2.exp
+ untested "failed to link"
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t07_ari3.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t07_ari3.exp
+ untested "failed to link"
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t08_or.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t08_or.exp
+ untested "failed to link"
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t09_xor.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t09_xor.exp
+ untested "failed to link"
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t10_and.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t10_and.exp
+ untested "failed to link"
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t11_logs.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t11_logs.exp
+ untested "failed to link"
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t12_bit.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t12_bit.exp
+ untested "failed to link"
return -1
}
if {[target_assemble $srcfile $objfile "${asm-flags}"] != ""} then {
- untested t13_otr.exp
+ untested "failed to assemble"
return -1
}
if {[target_link $objfile $binfile "${link-flags}"] != ""} then {
- untested t13_otr.exp
+ untested "failed to link"
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
}
}
-if [prepare_for_testing ${testfile}.exp $executable "${asm_file} ${srcfile}" {}] {
+if [prepare_for_testing "failed to prepare" $executable "${asm_file} ${srcfile}" {}] {
return -1
}
standard_testfile .S
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
[list {additional_flags=-nostdlib}]]} {
return -1
}
return 0
}
-if { [prepare_for_testing "${test}.exp" "${test}" ${test}.S {nodebug additional_flags=-nostdlib}] } {
+if { [prepare_for_testing "failed to prepare" "${test}" ${test}.S {nodebug additional_flags=-nostdlib}] } {
return -1
}
}
}
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $asm_file] {nodebug}]} {
return -1
}
# Any program would do, but since we already have data-loc.c
# specifically for this testcase, might as well use that.
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
- untested ${testfile}.exp
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
# program using our debug info instead of the info generated by
# the compiler.
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
standard_testfile .S
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile {debug} main.c debug $srcfile nodebug]]} {
return -1
}
if {[gdb_compile [file join $srcdir $subdir $srcfile] $binfile \
object {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile .S
set dwarf_srcfile "file1.txt"
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile debug main.c debug $srcfile nodebug]]} {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
standard_testfile .S
set dwarf_srcfile "file1.txt"
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile debug main.c debug $srcfile nodebug]]} {
return -1
}
standard_testfile .S
set executable ${testfile}
-if [prepare_for_testing $testfile.exp $testfile $srcfile \
+if [prepare_for_testing "failed to prepare" $testfile $srcfile \
[list nodebug $additional_flags]] {
return -1
}
set ptrbits 64
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $srcfile2] \
[list nodebug additional_flags=-DPTRBITS=$ptrbits]] } {
return -1
standard_testfile .S
-if { [prepare_for_testing "${testfile}.exp" "${testfile}" $srcfile \
+if { [prepare_for_testing "failed to prepare" "${testfile}" $srcfile \
{nodebug f90}] } {
return -1
}
set additional_flags [gdb_target_symbol_prefix_flags_asm]
standard_testfile .S
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
$additional_flags]} {
return -1
}
standard_testfile .S
set dwarf_srcfile "file1.txt"
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile \
{debug additional_flags=-static additional_flags=-nostdlib} \
main.c -g0 $srcfile nodebug]]} {
standard_testfile .S
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile debug main.c debug $srcfile nodebug]]} {
return -1
}
standard_testfile .S dw2-cp-infcall-ref-static-main.c
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile2 $srcfile] {}] } {
return -1
}
standard_testfile .S
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile debug main.c debug $srcfile nodebug]]} {
return -1
}
standard_testfile .S
-if { [prepare_for_testing $testfile.exp $testfile $srcfile {nodebug}] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile {nodebug}] } {
return -1
}
return 0
}
-if { [prepare_for_testing dw2-entry-value.exp "dw2-entry-value" {dw2-entry-value-main.c dw2-entry-value.S} {nodebug}] } {
+if { [prepare_for_testing "failed to prepare" "dw2-entry-value" {dw2-entry-value-main.c dw2-entry-value.S} {nodebug}] } {
return -1
}
standard_testfile .S .c
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $srcfile2] {nodebug}] } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
standard_testfile .S
-if { [prepare_for_testing $testfile.exp $testfile $srcfile {nodebug}] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile {nodebug}] } {
return -1
}
standard_testfile .S dw2-inline-param-main.c
-if { [prepare_for_testing ${testfile}.exp "${testfile}" \
+if { [prepare_for_testing "failed to prepare" "${testfile}" \
[list $srcfile2 $srcfile] {nodebug}] } {
return -1
}
standard_testfile .S
set dwarf_srcfile "file1.txt"
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile debug main.c debug $srcfile nodebug]]} {
return -1
}
standard_testfile .S
set dwarf_srcfile "file1.txt"
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile debug main.c debug $srcfile nodebug]]} {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile2 $asm_file] {nodebug}] } {
return -1
}
standard_testfile .S
set executable ${testfile}
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile c++ $testfile-main.cc {c++ debug} \
$srcfile {}]]} {
return -1
standard_testfile .S
-if [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
${additional_flags}] {
return -1
}
return 0
}
-if { [prepare_for_testing dw2-noloc.exp "dw2-noloc" {dw2-noloc-main.c dw2-noloc.S} {nodebug}] } {
+if { [prepare_for_testing "failed to prepare" "dw2-noloc" {dw2-noloc-main.c dw2-noloc.S} {nodebug}] } {
return -1
}
standard_testfile .S main.c
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $srcfile2] {nodebug}] } {
return -1
}
return 0
}
-if { [prepare_for_testing "${test}.exp" "${test}" ${test}.S {nodebug}] } {
+if { [prepare_for_testing "failed to prepare" "${test}" ${test}.S {nodebug}] } {
return -1
}
set sources "$srcfile $asm_file"
if {[build_executable $testfile.exp $testfile $sources {nodebug}]} {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
}
standard_testfile .S dw2-param-error-main.c
-if { [prepare_for_testing ${testfile}.exp "${testfile}" \
+if { [prepare_for_testing "failed to prepare" "${testfile}" \
[list $srcfile2 $srcfile] {nodebug}] } {
return -1
}
standard_testfile .S
set dwarf_srcfile "file1.txt"
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile debug main.c debug $srcfile nodebug]]} {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
set srcmainfile ${testfile}-main.c
set executable ${testfile}
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile {} $srcfile {} $srcfuncfile {} \
$srcmainfile debug]]} {
return -1
standard_testfile .S
-if { [prepare_for_testing $testfile.exp $testfile $srcfile {nodebug}] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile {nodebug}] } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile2 $asm_file] {nodebug}] } {
return -1
}
}
standard_testfile .S
-if {[prepare_for_testing $testfile.exp $testfile [list $srcfile] \
+if {[prepare_for_testing "failed to prepare" $testfile [list $srcfile] \
[list {additional_flags=-nostdlib}]]} {
return -1
}
standard_testfile .S
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {nodebug}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {nodebug}]} {
return -1
}
standard_testfile .S
set csrcfile ${testfile}.c
-if { [prepare_for_testing "${testfile}.exp" "${testfile}" $srcfile {nodebug}] } {
+if { [prepare_for_testing "failed to prepare" "${testfile}" $srcfile {nodebug}] } {
return -1
}
standard_testfile .S
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile debug main.c debug $srcfile nodebug]]} {
return -1
}
return 0
}
-if {[prepare_for_testing "$testfile.exp" "$testfile" $srcfile {nodebug}]} {
+if {[prepare_for_testing "failed to prepare" "$testfile" $srcfile {nodebug}]} {
return -1
}
# Some targets have leading underscores on assembly symbols.
set additional_flags [gdb_target_symbol_prefix_flags_asm]
-if { [prepare_for_testing dw2-unresolved.exp "dw2-unresolved" \
+if { [prepare_for_testing "failed to prepare" "dw2-unresolved" \
{dw2-unresolved-main.c dw2-unresolved.S} \
[list nodebug $additional_flags]] } {
return -1
standard_testfile .S main.c
-if [prepare_for_testing ${testfile}.exp ${testfile} \
+if [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $srcfile2] {nodebug}] {
return -1
}
# Since we pass an explicit -gdwarf-4 -fdebug-types-section to the compiler,
# we let that be the test of whether the target supports it.
-if { [prepare_for_testing "${testfile}.exp" "${testfile}" \
+if { [prepare_for_testing "failed to prepare" "${testfile}" \
[list $srcfile $srcfile2] \
{debug c++ additional_flags=-gdwarf-4 additional_flags=-fdebug-types-section}] } {
return -1
}
}
-if [prepare_for_testing ${testfile}.exp $testfile "${asm_file} ${srcfile}" {}] {
+if [prepare_for_testing "failed to prepare" $testfile "${asm_file} ${srcfile}" {}] {
return -1
}
# Any program would do, but since we already have dynarr-ptr.c
# specifically for this testcase, might as well use that.
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
- untested ${testfile}.exp
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
# program using our debug info instead of the info generated by
# the compiler.
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
standard_testfile main.c
-if { [prepare_for_testing "${testfile}.exp" "${testfile}" \
+if { [prepare_for_testing "failed to prepare" "${testfile}" \
[list ${srcfile}]] } {
return -1
}
set name "d${dwarf_version}o${offset_size}a${addr_size}r${ref_addr_size}t${two_cu}"
set executable ${testfile}-${name}
- if [prepare_for_testing ${testfile}.exp $executable "${srcfile} ${mainfile}" $opts] {
+ if [prepare_for_testing "failed to prepare" $executable "${srcfile} ${mainfile}" $opts] {
return -1
}
}
}
-if [prepare_for_testing ${testfile}.exp $executable "${asm_file} ${srcfile}" {}] {
+if [prepare_for_testing "failed to prepare" $executable "${asm_file} ${srcfile}" {}] {
return -1
}
return 0
}
-if {[prepare_for_testing ${testfile}.exp ${testfile} $srcfile $opts]} {
+if {[prepare_for_testing "failed to prepare" ${testfile} $srcfile $opts]} {
return -1
}
# For that, we ask GDB by debugging our implref-array program.
# Any program would do, but since we already have implref-array
# specifically for this testcase, might as well use that.
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
- untested ${testfile}.exp
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
}
}
-if [prepare_for_testing ${testfile}.exp ${executable} [list ${asm_file} ${srcfile}] {}] {
+if [prepare_for_testing "failed to prepare" ${executable} [list ${asm_file} ${srcfile}] {}] {
return -1
}
# For that, we ask GDB by debugging our implref-const program.
# Any program would do, but since we already have implref-const
# specifically for this testcase, might as well use that.
-if [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] {
- untested ${testfile}.exp
+if [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] {
return -1
}
}
}
-if [prepare_for_testing ${testfile}.exp ${executable} [list ${asm_file} ${srcfile}] {}] {
+if [prepare_for_testing "failed to prepare" ${executable} [list ${asm_file} ${srcfile}] {}] {
return -1
}
# For that, we ask GDB by debugging our implref-global program.
# Any program would do, but since we already have implref-global
# specifically for this testcase, might as well use that.
-if [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] {
- untested ${testfile}.exp
+if [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] {
return -1
}
}
}
-if [prepare_for_testing ${testfile}.exp ${executable} [list ${asm_file} ${srcfile}] {}] {
+if [prepare_for_testing "failed to prepare" ${executable} [list ${asm_file} ${srcfile}] {}] {
return -1
}
# For that, we ask GDB by debugging our implref-struct program.
# Any program would do, but since we already have implref-struct
# specifically for this testcase, might as well use that.
-if [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug c++}] {
- untested ${testfile}.exp
+if [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug c++}] {
return -1
}
}
}
-if [prepare_for_testing ${testfile}.exp ${executable} [list ${asm_file} ${srcfile}] {}] {
+if [prepare_for_testing "failed to prepare" ${executable} [list ${asm_file} ${srcfile}] {}] {
return -1
}
standard_testfile .S
set dwarf_srcfile "file1.txt"
-if {[prepare_for_testing_full $testfile.exp \
+if {[prepare_for_testing_full "failed to prepare" \
[list $testfile debug main.c debug $srcfile nodebug]]} {
return -1
}
}
}
-if {[prepare_for_testing ${testfile}.exp ${testfile} \
+if {[prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}]} {
return -1
}
standard_testfile .S
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" ${binfile} object {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
}
}
-if [prepare_for_testing ${testfile}.exp $testfile "${asm_file} ${srcfile} ${srcfile3}" {nodebug}] {
+if [prepare_for_testing "failed to prepare" $testfile "${asm_file} ${srcfile} ${srcfile3}" {nodebug}] {
return -1
}
standard_testfile .S
set csrcfile ${testfile}.c
-if {[prepare_for_testing ${testfile}.exp ${testfile} $srcfile]} {
+if {[prepare_for_testing "failed to prepare" ${testfile} $srcfile]} {
return -1
}
standard_testfile .S
set csrcfile ${testfile}.c
-if {[prepare_for_testing ${testfile}.exp ${testfile} $srcfile]} {
+if {[prepare_for_testing "failed to prepare" ${testfile} $srcfile]} {
return -1
}
standard_testfile
-if {[prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}]} {
+if {[prepare_for_testing "failed to prepare" ${testfile} ${srcfile}]} {
return 0
}
standard_testfile .S
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
${additional_flags}] == -1 } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
}
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
return -1
}
set saved_gdbflags $GDBFLAGS
set GDBFLAGS "$GDBFLAGS -readnow"
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
[list $srcfile $asm_file] {nodebug}] } {
set GDBFLAGS $saved_gdbflags
return -1
standard_testfile .S
-if {[prepare_for_testing "${testfile}.exp" "${testfile}" ${testfile}.S \
+if {[prepare_for_testing "failed to prepare" "${testfile}" ${testfile}.S \
nodebug]} {
return -1
}
return 0
}
-if { [prepare_for_testing "${test}.exp" "${test}" ${sfile} {nodebug additional_flags=-nostdlib}] } {
+if { [prepare_for_testing "failed to prepare" "${test}" ${sfile} {nodebug additional_flags=-nostdlib}] } {
return -1
}
standard_testfile .S
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile] [list {additional_flags=-nostdlib}]]} {
return -1
}
return 0
}
-if { [prepare_for_testing "${test}.exp" "${test}" \
+if { [prepare_for_testing "failed to prepare" "${test}" \
{watch-notconst.c watch-notconst2.S} {nodebug}] } {
return -1
}
standard_testfile .f
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug f90}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug f90}]} {
return -1
}
if { [skip_fortran_tests] } { return -1 }
standard_testfile .f90
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug additional_flags=-fbackslash f90}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug additional_flags=-fbackslash f90}] } {
return -1
}
standard_testfile .f90
load_lib "fortran.exp"
-if {[prepare_for_testing ${testfile}.exp ${testfile} \
+if {[prepare_for_testing "failed to prepare" ${testfile} \
$srcfile {debug f90 quiet}]} {
return -1
}
standard_testfile .f
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug f90 quiet}]} {
- untested "failed to compile"
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug f90 quiet}]} {
return -1
}
standard_testfile .f90
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug f90}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug f90}]} {
return -1
}
standard_testfile .f90
load_lib "fortran.exp"
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug f90}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug f90}]} {
return -1
}
standard_testfile .f90
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug f90 quiet}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug f90 quiet}]} {
return -1
}
standard_testfile .f90
-if { [prepare_for_testing $testfile.exp $testfile $srcfile {debug f90}] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile {debug f90}] } {
return -1
}
standard_testfile .f90
load_lib "fortran.exp"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug f90}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug f90}] } {
return -1
}
standard_testfile .f90\r
load_lib "fortran.exp"\r
\r
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug f90}]} {\r
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug f90}]} {\r
return -1\r
}\r
\r
standard_testfile .f90
-if { [prepare_for_testing $testfile.exp $testfile $srcfile {debug f90}] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile {debug f90}] } {
return -1
}
standard_testfile .f
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug f90}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug f90}]} {
return -1
}
standard_testfile "vla.f90"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
{debug f90 quiet}] } {
return -1
}
standard_testfile ".f90"
load_lib "fortran.exp"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
{debug f90 quiet}] } {
return -1
}
standard_testfile "vla.f90"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
{debug f90 quiet}] } {
return -1
}
standard_testfile "vla.f90"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
{debug f90 quiet}] } {
return -1
}
standard_testfile "vla-sub.f90"
load_lib "fortran.exp"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
{debug f90 quiet}] } {
return -1
}
standard_testfile "vla.f90"
load_lib "fortran.exp"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
{debug f90 quiet}] } {
return -1
}
standard_testfile "vla.f90"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
{debug f90 quiet}] } {
return -1
}
standard_testfile ".f90"
load_lib "fortran.exp"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
{debug f90 quiet}] } {
return -1
}
standard_testfile "vla-sub.f90"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
{debug f90 quiet}] } {
return -1
}
standard_testfile "vla-sub.f90"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
{debug f90 quiet}] } {
return -1
}
standard_testfile "vla-sub.f90"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
{debug f90 quiet}] } {
return -1
}
standard_testfile "vla.f90"
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
{debug f90 quiet}] } {
return -1
}
standard_testfile type.f90
load_lib "fortran.exp"
-if { [prepare_for_testing ${testfile}.exp ${testfile} \
+if { [prepare_for_testing "failed to prepare" ${testfile} \
${srcfile} {debug f90}] } {
return -1
}
standard_testfile .go
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug go}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug go}] } {
return -1
}
set bp_location2 [gdb_get_line_number "set breakpoint 2 here"]
if { [go_runto_main] < 0 } {
- untested $testfile
+ untested "could not run to main"
return -1
}
standard_testfile .go
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug go}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug go}] } {
return -1
}
if { [go_runto_main] < 0 } {
- untested $testfile
+ untested "could not run to main"
return -1
}
standard_testfile .go
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug go}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug go}] } {
return -1
}
set bp_location1 [gdb_get_line_number "set breakpoint 1 here"]
if { [go_runto_main] < 0 } {
- untested $testfile
+ untested "could not run to main"
return -1
}
standard_testfile .go
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug go}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug go}] } {
return -1
}
set bp_location2 [gdb_get_line_number "set breakpoint 2 here"]
if { [go_runto_main] < 0 } {
- untested $testfile
+ untested "could not run to main"
return -1
}
standard_testfile .go
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug go}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug go}] } {
return -1
}
set bp_location2_regexp {\(*main.T\).Bar}
if { [go_runto_main] < 0 } {
- untested $testfile
+ untested "could not run to main"
return -1
}
standard_testfile package1.go package2.go
if { [gdb_compile "${srcdir}/${subdir}/${testfile}2.go" "${binfile}2.o" object {debug go}] != "" } {
- untested $testfile
+ untested "failed to compile"
return -1
}
if { [gdb_compile "${srcdir}/${subdir}/${testfile}1.go ${binfile}2.o" "${binfile}" executable "debug go libdir=[standard_output_file {}]"] != "" } {
- untested $testfile
+ untested "failed to compile"
return -1
}
standard_testfile .go
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug go}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug go}] } {
return -1
}
if { [go_runto_main] < 0 } {
- untested $testfile
+ untested "could not run to main"
return -1
}
standard_testfile .go
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug go}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug go}] } {
return -1
}
if { [go_runto_main] < 0 } {
- untested $testfile
+ untested "could not run to main"
return -1
}
standard_testfile .go
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug go}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug go}] } {
return -1
}
if { [go_runto_main] < 0 } {
- untested $testfile
+ untested "could not run to main"
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
"#t" "greater or equal, greater"
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c}]} {
return
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile scm-symtab.c scm-symtab-2.c
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] debug]} {
return
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return
}
standard_testfile .cc
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile lspec.cc
if {[skip_cplus_tests]} {
- unsupported ${testfile}.exp
+ unsupported "skipping C++ tests"
return
}
standard_testfile .cc
set exefile $testfile
-if {[prepare_for_testing $testfile $exefile $srcfile \
+if {[prepare_for_testing "failed to prepare" $exefile $srcfile \
{c++ debug nowarnings}]} {
return -1
}
standard_testfile explicit.c explicit2.c 3explicit.c
set exefile $testfile
-if {[prepare_for_testing $testfile $exefile \
+if {[prepare_for_testing "failed to prepare" $exefile \
[list $srcfile $srcfile2 $srcfile3] {debug nowarnings}]} {
return -1
}
standard_testfile
set exefile $testfile
-if {[prepare_for_testing $testfile $exefile $srcfile {debug}]} {
+if {[prepare_for_testing "failed to prepare" $exefile $srcfile {debug}]} {
return -1
}
return
}
-if {[prepare_for_testing ${testfile}.exp $exefile \
+if {[prepare_for_testing "failed to prepare" $exefile \
[list $srcfile $baseone $basetwo] \
{debug nowarnings c++}]} {
return -1
return
}
-if {[prepare_for_testing $testfile $exefile $srcfile \
+if {[prepare_for_testing "failed to prepare" $exefile $srcfile \
{debug nowarnings c++}]} {
return -1
}
lappend options "c++"
}
- if {[prepare_for_testing $testfile $exefile $srcfile $options]} {
+ if {[prepare_for_testing "failed to prepare" $exefile $srcfile $options]} {
return -1
}
set basetwo base/two/thefile.cc
if {[skip_cplus_tests]} {
- unsupported ${testfile}.exp
+ unsupported "skipping C++ tests"
return
}
-if {[prepare_for_testing ${testfile}.exp $execfile \
+if {[prepare_for_testing "failed to prepare" $execfile \
[list $srcfile $baseone $basetwo] \
{debug nowarnings c++}]} {
return -1
standard_testfile
set exefile $testfile
-if {[prepare_for_testing $testfile $exefile $srcfile {debug}]} {
+if {[prepare_for_testing "failed to prepare" $exefile $srcfile {debug}]} {
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-async.exp
+ untested "failed to compile"
return -1
}
set envirodir [string_to_regexp $testsubdir]
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-basics.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-break.exp
+ untested "failed to compile"
return -1
}
if {[get_compiler_info]} {
warning "Could not get compiler info"
- untested mi-catch-load.exp
+ untested "no compiler info"
return -1
}
standard_testfile mi-catch-load.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug shlib_load}] != "" } {
- untested mi-catch-load.exp
+ untested "failed to compile"
return -1
}
set binfile2 [standard_output_file ${testfile2}.so]
set binfile2_dlopen [shlib_target_file ${testfile2}.so]
if { [gdb_compile_shlib "${srcdir}/${subdir}/${srcfile2}" ${binfile2} {debug}] != "" } {
- untested mi-catch-load.exp
+ untested "failed to compile shared library"
return -1
}
mi_run_to_main
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-cli.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-cmd-param-changed.exp
+ untested "failed to compile"
return -1
}
standard_testfile
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-console.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if {[build_executable $testfile.exp $testfile $srcfile {debug}] == -1} {
- untested mi-detach.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-disassemble.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-eval.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-file-transfer.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-file.exp
+ untested "failed to compile"
return -1
}
standard_testfile "mi-read-memory"
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}.c" "${binfile}" executable {debug}] != "" } {
- untested mi-fill-memory.exp
+ untested "failed to compile"
return -1
}
}
if {[gdb_compile $srcdir/$subdir/$srcfile $binfile executable {debug c++}] != ""} {
- untested mi-inheritance-syntax-error.exp
+ untested "failed to compile"
return -1
}
standard_testfile .cc
set exefile $testfile
-if {[prepare_for_testing $testfile $exefile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $exefile $srcfile {debug c++}]} {
return -1
}
set opts {debug}
if [build_executable $testfile.exp $testfile $srcfile $opts] {
- untested mi-logging.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile \
executable {debug nowarnings}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-read-memory.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile \
executable {debug nowarnings}] != "" } {
- untested mi-record-changed.exp
+ untested "failed to compile"
return -1
}
standard_testfile .S
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-reg-undefined.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-regs.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-return.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-simplerun.exp
+ untested "failed to compile"
return -1
}
set MIFLAGS "-i=mi2"
if {[skip_shlib_tests]} {
- untested mi-solib.exp
+ untested "skipping shared library tests"
return -1
}
standard_testfile
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-stack.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-stepi.exp
+ untested "failed to compile"
return -1
}
standard_testfile
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-syn-frame.exp
+ untested "failed to compile"
return -1
}
standard_testfile until.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-until.exp
+ untested "failed to compile"
return -1
}
standard_testfile var-cmd.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-var-block.exp
+ untested "failed to compile"
return -1
}
standard_testfile
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-var-child.exp
+ untested "failed to compile"
return -1
}
standard_testfile var-cmd.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-var-cmd.exp
+ untested "failed to compile"
return -1
}
}
if {[gdb_compile $srcdir/$subdir/$srcfile $binfile executable {debug c++}] != ""} {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
standard_testfile var-cmd.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-var-display.exp
+ untested "failed to compile"
return -1
}
standard_testfile var-cmd.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-var-invalidate.exp
+ untested "failed to compile"
return -1
}
# Just change the output binary.
set binfile_bis [standard_output_file mi-var-invalidate_bis]
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile_bis}" executable {debug}] != "" } {
- untested mi-var-invalidate.exp
+ untested "failed to compile"
return -1
}
set srcfile2 ${testfile2}.c
set binfile2 [standard_output_file ${testfile2}]
if { [gdb_compile "${srcdir}/${subdir}/${srcfile2}" "${binfile2}" executable {debug}] != "" } {
- untested mi-var-invalidate.exp
+ untested "failed to compile"
return -1
}
standard_testfile
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-var-list-children-invalid-grandchild.exp
+ untested "failed to compile"
return -1
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable \
{debug f90}] != "" } {
- untested mi-vla-fortran.exp
+ untested "failed to compile"
return -1
}
standard_testfile basics.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi-watch.exp
+ untested "failed to compile"
return -1
}
standard_testfile var-cmd.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested mi2-var-child.exp
+ untested "failed to compile"
return -1
}
# Multiple inferiors are needed, therefore only native gdb and extended
# gdbserver modes are supported.
if [use_gdb_stub] {
- untested ${testfile}.exp
+ untested "using gdb stub"
return
}
standard_testfile unbounded1.c
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug quiet}]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug quiet}]} {
return -1
}
return
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug}]} {
return -1
}
set march2 "-m32"
}
-if { [prepare_for_testing ${testfile}.exp ${exec1} "${srcfile1}" \
+if { [prepare_for_testing "failed to prepare" ${exec1} "${srcfile1}" \
[list debug \
additional_flags=${march1}]] } {
return -1
lappend options "additional_flags=${march2}"
}
-if { [prepare_for_testing ${testfile}.exp ${exec2} "${srcfile2}" \
+if { [prepare_for_testing "failed to prepare" ${exec2} "${srcfile2}" \
$options] } {
return -1
}
set march2 "-m32"
}
-if { [prepare_for_testing ${testfile}.exp ${exec1} "${srcfile1}" \
+if { [prepare_for_testing "failed to prepare" ${exec1} "${srcfile1}" \
[list debug additional_flags=${march1}]] } {
return -1
}
lappend options "additional_flags=${march2}"
}
-if { [prepare_for_testing ${testfile}.exp ${exec2} "${srcfile2}" \
+if { [prepare_for_testing "failed to prepare" ${exec2} "${srcfile2}" \
$options]} {
return -1
}
# gdbserver modes are supported. Only non-extended gdbserver is not
# supported.
if [target_info exists use_gdb_stub] {
- untested ${testfile}.exp
+ untested "using gdb stub"
return
}
# Multiple inferiors are needed, therefore both native and extended gdbserver
# modes are supported. Only non-extended gdbserver is not supported.
if [target_info exists use_gdb_stub] {
- untested ${testfile}.exp
+ untested "using gdb stub"
return
}
}
if { [gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
# Compile the generic OpenCL host app
if { [gdb_compile_opencl_hostapp "${clprogram}" "${testfile}" "" ] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
# Compile the generic OpenCL host app
if { [gdb_compile_opencl_hostapp "${clprogram}" "${testfile}" "" ] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
# Compile the generic OpenCL host app
if { [gdb_compile_opencl_hostapp "${clprogram}" "${testfile}" "" ] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
# Compile the generic OpenCL host app
if { [gdb_compile_opencl_hostapp "${clprogram}" "${testfile}" "" ] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
# Compile the generic OpenCL host app
if { [gdb_compile_opencl_hostapp "${clprogram}" "${testfile}" "" ] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
{debug optimize=-O2 nowarnings}]} {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile \
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile \
{debug additional_flags=-Winline}] } {
return -1
}
standard_testfile .c inline-markers.c
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] \
{debug additional_flags=-Winline}]} {
return -1
get_compiler_info
get_debug_format
if { [skip_inline_frame_tests] } {
- untested inline-bt.exp
+ untested "skipping inline frame tests"
return
}
standard_testfile .c inline-markers.c
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug additional_flags=-Winline}]} {
return -1
}
get_compiler_info
get_debug_format
if { [skip_inline_frame_tests] } {
- untested inline-cmds.exp
+ untested "skipping inline frame tests"
return
}
standard_testfile .c inline-markers.c
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] {debug additional_flags=-Winline}]} {
return -1
}
standard_testfile .pas
if {[gdb_compile_pascal "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug class]] != "" } {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
standard_testfile .pas
if {[gdb_compile_pascal "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug ]] != "" } {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
standard_testfile .pas
if {[gdb_compile_pascal "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug ]] != "" } {
- untested $testfile.exp
+ untested "failed to compile"
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
load_lib gdb-python.exp
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile py-explore.cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
# exposing values to Python.
if {[skip_shlib_tests]} {
- untested py-finish-breakpoint.exp
+ untested "skipping shared library tests"
return 0
}
if { $gdb_py_is_py24 == 1 } {
# Python 2.4, 2.5 do not support the "ValueError as e" syntax used in
# the py-finish-breakpoint.py script.
- untested py-finish-breakpoint.exp
+ untested "missing support on Python 2.4 and 2.5"
return 0
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
set pyfile py-framefilter.py
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-DMI}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $opts] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} $opts] } {
return -1
}
set pyfile ${testfile}-gdb.py
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
set pyfile ${testfile}-gdb.py
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile py-prettyprint.c
set pyfile py-prettyprint.py
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-DMI}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
# Now build another copy of the testcase, this time without debug info.
-if { [prepare_for_testing ${testfile}.exp ${testfile}2 ${srcfile} {nodebug ldflags=-Wl,--strip-debug}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile}2 ${srcfile} {nodebug ldflags=-Wl,--strip-debug}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile py-symbol.c
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
if { [skip_python_tests] } { continue }
gdb_exit
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile
-if {[prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if {[prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
return -1
}
standard_testfile .cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
standard_testfile py-xmethods.cc
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug c++}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug c++}]} {
return -1
}
return
}
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} $opts] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} $opts] } {
return -1
}
standard_testfile break-reverse.c
set precsave [standard_output_file break.precsave]
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile consecutive-reverse.c
set precsave [standard_output_file consecutive.precsave]
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile finish-reverse.c
set precsave [standard_output_file finish.precsave]
-if { [prepare_for_testing $testfile.exp "$testfile" $srcfile] } {
+if { [prepare_for_testing "failed to prepare" "$testfile" $srcfile] } {
return -1
}
standard_testfile finish-reverse.c
-if { [prepare_for_testing $testfile.exp "$testfile" $srcfile] } {
+if { [prepare_for_testing "failed to prepare" "$testfile" $srcfile] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp "$testfile" $srcfile] } {
+if { [prepare_for_testing "failed to prepare" "$testfile" $srcfile] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
# some targets have leading underscores on assembly symbols.
set additional_flags [gdb_target_symbol_prefix_flags]
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
[list debug $additional_flags]]} {
return -1
}
# some targets have leading underscores on assembly symbols.
set additional_flags [gdb_target_symbol_prefix_flags]
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
[list debug $additional_flags]]} {
return -1
}
# some targets have leading underscores on assembly symbols.
set additional_flags [gdb_target_symbol_prefix_flags]
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
[list debug $additional_flags]]} {
return -1
}
# some targets have leading underscores on assembly symbols.
set additional_flags [gdb_target_symbol_prefix_flags]
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
[list debug $additional_flags]]} {
return -1
}
# some targets have leading underscores on assembly symbols.
set additional_flags [gdb_target_symbol_prefix_flags]
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
[list debug $additional_flags]]} {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
[list debug]]} {
- untested ${testfile}.exp
return -1
}
if { ![runto main] } then {
standard_testfile machinestate.c ms1.c
set precsave [standard_output_file machinestate.precsave]
-if { [prepare_for_testing $testfile.exp $testfile \
+if { [prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2]] } {
return -1
}
standard_testfile .c ms1.c
-if { [prepare_for_testing $testfile.exp $testfile \
+if { [prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2]] } {
return -1
}
standard_testfile step-reverse.c
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile [list $srcfile]]} {
+if {[prepare_for_testing "failed to prepare" $testfile [list $srcfile]]} {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile step-reverse.c
set precsave [standard_output_file step.precsave]
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile until-reverse.c ur1.c
set precsave [standard_output_file until.precsave]
-if { [prepare_for_testing $testfile.exp $testfile \
+if { [prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2]] } {
return -1
}
standard_testfile .c ur1.c
-if { [prepare_for_testing $testfile.exp $testfile \
+if { [prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2]] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile watch-reverse.c
set precsave [standard_output_file watch.precsave]
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
standard_testfile
-if { [prepare_for_testing $testfile.exp $testfile $srcfile] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
return -1
}
}
standard_testfile .rs
-if {[prepare_for_testing ${testfile}.exp $testfile $srcfile {debug rust}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug rust}]} {
return -1
}
set line [gdb_get_line_number "set breakpoint here"]
if {![runto ${srcfile}:$line]} {
- untested $testfile
+ untested "could not run to breakpoint"
return -1
}
}
standard_testfile .rs
-if {[prepare_for_testing ${testfile}.exp $testfile $srcfile {debug rust}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug rust}]} {
return -1
}
set line [gdb_get_line_number "set breakpoint 1 here"]
if {![runto ${srcfile}:$line]} {
- untested $testfile
+ untested "could not run to breakpoint"
return -1
}
}
standard_testfile .rs
-if {[prepare_for_testing ${testfile}.exp $testfile $srcfile {debug rust}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug rust}]} {
return -1
}
set line [gdb_get_line_number "set breakpoint here"]
if {![runto ${srcfile}:$line]} {
- untested $testfile
+ untested "could not run to breakpoint"
return -1
}
}
standard_testfile .rs
-if {[prepare_for_testing ${testfile}.exp $testfile $srcfile {debug rust}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug rust}]} {
return -1
}
set line [gdb_get_line_number "set breakpoint here"]
if {![runto ${srcfile}:$line]} {
- untested $testfile
+ untested "could not run to breakpoint"
return -1
}
return 0
}
-if { [prepare_for_testing $testfile.exp $testfile $srcfile debug] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile debug] } {
return -1
}
return 0
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
return 0
}
-if { [prepare_for_testing $testfile.exp $testfile $srcfile debug] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile debug] } {
return -1
}
return -1
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
return 0
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
}
standard_testfile server.c
-if [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile}] {
+if [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] {
return -1
}
return 0
}
-if { [prepare_for_testing ${testfile}.exp ${testfile}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile}] } {
return -1
}
return 0
}
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
return -1
}
-if { [prepare_for_testing $testfile.exp $testfile $srcfile debug] } {
+if { [prepare_for_testing "failed to prepare" $testfile $srcfile debug] } {
return -1
}
standard_testfile exclfwd1.c exclfwd2.c
-if {[prepare_for_testing $testfile.exp $testfile \
+if {[prepare_for_testing "failed to prepare" $testfile \
[list $srcfile $srcfile2] debug]} {
return -1
}
gdb_test "print sizeof (*e)" "= \[1-9\]*" "sizeof (*e) in test $version"
}
-if { [prepare_for_testing $testfile.exp $testfile $testfile.c {debug additional_flags=-gstabs}] == 0 } {
+if { [prepare_for_testing "failed to prepare" $testfile $testfile.c {debug additional_flags=-gstabs}] == 0 } {
do_test forced_stabs
}
# by GDB which can generate a compilation failure.
gdb_exit
-if { [prepare_for_testing $testfile.exp $testfile $testfile.c {debug}] == 0 } {
+if { [prepare_for_testing "failed to prepare" $testfile $testfile.c {debug}] == 0 } {
do_test natural_debug_format
}
return
}
-if { [prepare_for_testing clone-new-thread-event.exp clone-new-thread-event] } {
+if { [prepare_for_testing "failed to prepare" clone-new-thread-event] } {
return -1
}
standard_testfile
set executable ${testfile}
if { [gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
return
}
-if { [prepare_for_testing current-lwp-dead.exp current-lwp-dead] } {
+if { [prepare_for_testing "failed to prepare" current-lwp-dead] } {
return -1
}
if {[runto_main] <= 0} {
- untested current-lwp-dead.exp
+ untested "could not run to main"
return -1
}
set relink_args [build_executable_own_libs ${testfile}.exp ${executable}.so $srclibfile {debug shlib_pthreads} no]
if {$relink_args == "" || ![prelink_no $relink_args]
- || [prepare_for_testing ${testfile}.exp ${executable} ${srcmainfile} {debug shlib_load}] } {
+ || [prepare_for_testing "failed to prepare" ${executable} ${srcmainfile} {debug shlib_load}] } {
return -1
}
gdb_load_shlib $binfile_lib
}
-re "No probes matched\\.\r\n$gdb_prompt $" {
xfail $test
- untested ${testfile}.exp
+ untested "no matching probes"
return
}
}
set timeout 30
if { ! [ runto_main ] } then {
- untested gcore-thread.exp
+ untested "could not run to main"
return -1
}
set executable ${testfile}
if { [gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
set executable ${testfile}-${type}-mt
set srcfile_main ${srcdir}/${subdir}/${testfile}-mt.c
if { [gdb_compile_pthreads "${srcfile_main} ${srcfile_type}" [standard_output_file ${executable}] executable [list debug "additional_flags=-D$symbol -DTHREAD"]] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return
}
clean_restart $executable
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
set executable $testfile
set expfile $testfile.exp
-if [prepare_for_testing $expfile $executable $srcfile \
+if [prepare_for_testing "failed to prepare" $executable $srcfile \
[list debug nowarnings]] {
- untested "failed to prepare for trace tests"
return -1
}
if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile executable \
[list debug nowarnings shlib=$libipa shlib=$lib_sl1 shlib_load] ] != "" } {
- untested change-loc.exp
+ untested "failed to compile"
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug nowarnings}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug nowarnings}]} {
return -1
}
standard_testfile
set executable $testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile {debug nowarnings}]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile {debug nowarnings}]} {
return -1
}
return -1
}
-if [prepare_for_testing $expfile $executable $srcfile \
+if [prepare_for_testing "failed to prepare" $executable $srcfile \
{debug nowarnings}] {
- untested "failed to prepare for trace tests"
return -1
}
# Some targets have leading underscores on assembly symbols.
set additional_flags [gdb_target_symbol_prefix_flags]
-if [prepare_for_testing $expfile $executable $srcfile \
+if [prepare_for_testing "failed to prepare" $executable $srcfile \
[list debug $additional_flags]] {
- untested "failed to prepare for trace tests"
return -1
}
standard_testfile actions.c
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug}] } {
return -1
}
standard_testfile trace-unavailable.c
-if { [prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} {debug}] } {
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} {debug}] } {
return -1
}
[list debug nowarnings \
"additional_flags=-DTFILE_DIR=\"$tfile_dir\""]] \
!= "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" \
executable {debug nowarnings}] != "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
standard_testfile actions.c
if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile \
executable {debug nowarnings}] != "" } {
- untested mi-tsv-changed.exp
+ untested "failed to compile"
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile actions.c
if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile \
executable {debug nowarnings}] != "" } {
- untested passc-dyn.exp
+ untested "failed to compile"
return -1
}
gdb_load $binfile
gdb_test "tfind none" ".*" ""
if [gdb_test "printf \"x \%d x\\n\", \$trace_frame" "x -1 x" ""] {
- untested passc-dyn.exp
+ untested "skipping further tests due to print failure"
return -1
}
gdb_test "tfind tracepoint $tdp2" ".*" ""
if [gdb_test "printf \"x \%d x\\n\", \$trace_frame" "x 0 x" ""] {
- untested passc-dyn.exp
+ untested "skipping further tests due to print failure"
return -1
}
gdb_test "tfind tracepoint $tdp3" ".*" ""
if [gdb_test "printf \"x \%d x\\n\", \$trace_frame" "x 1 x" ""] {
- untested passc-dyn.exp
+ untested "skipping further tests due to print failure"
return -1
}
gdb_test "tfind tracepoint $tdp4" ".*" ""
if [gdb_test "printf \"x \%d x\\n\", \$trace_frame" "x 2 x" ""] {
- untested passc-dyn.exp
+ untested "skipping further tests due to print failure"
return -1
}
gdb_test "tfind tracepoint $tdp2" ".*" ""
if [gdb_test "printf \"x \%d x\\n\", \$trace_frame" "x 3 x" ""] {
- untested passc-dyn.exp
+ untested "skipping further tests due to print failure"
return -1
}
gdb_test "tfind tracepoint $tdp3" ".*" ""
if [gdb_test "printf \"x \%d x\\n\", \$trace_frame" "x 4 x" ""] {
- untested passc-dyn.exp
+ untested "skipping further tests due to print failure"
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
clean_restart $testfile
standard_testfile
set executable $testfile
-if [prepare_for_testing $testfile.exp $executable $srcfile \
+if [prepare_for_testing "failed to prepare" $executable $srcfile \
{debug nowarnings}] {
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
standard_testfile actions.c
if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile \
executable {debug nowarnings}] != "" } {
- untested save-trace.exp
+ untested "failed to compile"
return -1
}
gdb_reinitialize_dir $srcdir/$subdir
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile debug]} {
- untested $testfile.exp
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
return -1
}
set expfile $testfile.exp
-if [prepare_for_testing $expfile $executable $srcfile \
+if [prepare_for_testing "failed to prepare" $executable $srcfile \
{debug nowarnings}] {
- untested "failed to prepare for trace tests"
return -1
}
[list debug \
"additional_flags=-DTFILE_DIR=\"$tfile_dir\""]] \
!= "" } {
- untested ${testfile}.exp
+ untested "failed to compile"
return -1
}
# Some targets have leading underscores on assembly symbols.
set additional_flags [gdb_target_symbol_prefix_flags]
-if [prepare_for_testing $expfile $executable $srcfile \
+if [prepare_for_testing "failed to prepare" $executable $srcfile \
[list debug $additional_flags]] {
- untested "failed to prepare for trace tests"
return -1
}
standard_testfile
-if [prepare_for_testing ${testfile}.exp $testfile $srcfile \
+if [prepare_for_testing "failed to prepare" $testfile $srcfile \
{debug nowarnings}] {
- untested "failed to prepare for trace tests"
return -1
}
# Some targets have leading underscores on assembly symbols.
set additional_flags [gdb_target_symbol_prefix_flags]
-if [prepare_for_testing $expfile $executable $srcfile \
+if [prepare_for_testing "failed to prepare" $executable $srcfile \
[list debug $additional_flags]] {
- untested "failed to prepare for trace tests"
return -1
}
standard_testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
[list debug additional_flags=-mavx]]} {
return -1
}
set executable $testfile
set expfile tstatus.exp
-if [prepare_for_testing $expfile $executable $srcfile \
+if [prepare_for_testing "failed to prepare" $executable $srcfile \
[list debug]] {
- untested "failed to prepare for trace tests"
return -1
}
standard_testfile unavailable.cc
set executable $testfile
-if {[prepare_for_testing $testfile.exp $testfile $srcfile \
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile \
{debug nowarnings c++}]} {
return -1
}
set executable $testfile
if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile \
executable {debug nowarnings}] != "" } {
- untested while-dyn.exp
+ untested "failed to compile"
return -1
}
gdb_load $binfile
standard_testfile actions.c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" $binfile \
executable {debug nowarnings}] != "" } {
- untested while-stepping.exp
+ untested "failed to compile"
return -1
}
gdb_reinitialize_dir $srcdir/$subdir
projects / deliverable / binutils-gdb.git / commitdiff
