This user support forum is the place to ask questions and consult with fellow developers on topics related to all of Intel's debug solutions. Please feel free to submit questions and start discussions at

Debug Solutions User Forum

http://software.intel.com/en-us/forums/debug-solutions/

The topics may range from GDB*, Intel JTAG Debugger, Intel Debugger, Intel Parallel Debugger Extension, and Intel Fortran Expression Evaluation to Debug Methodologies, and Tips and Tricks.

Please let us know your debugger questions.

Documentation

• Debugging with GDB*
• GDB* Release Notes
• Debugging Intel® Xeon Phi™ Applications on Linux* Host
• Debugging Intel® Xeon Phi™ Applications on Windows* Host
• Intel Debugger for Linux*
• Intel Debugger for Linux* Overview
• Intel Parallel Debugger Extension for Windows* Overview
• Intel Parallel Debugger Extension
• Intel® JTAG Debugger 2014 - Installation Guide and Release Notes
• Use Cases for the Intel® JTAG Debugger
• Intel® JTAG Debugger Quickstart Guide

Hi,

I am trying to use idb to debug a simple mpi program (Fortran) that write hostname of each rank, to see how it works, but i have a problem.

First, i set IDB_HOME, IDB_PARALLEL_SHELL and MPIEXEC_DEBUG=1.

Then i try to start idb:

[cscppm59@imip15 MPI-INTEL]$ mpiexec.hydra -idb -f ./dbg.hosts -n 2 a.out
mpiexec: idb -pid 17765 -mpi2 -parallel mpiexec.hydra
Intel(R) Debugger for applications running on Intel(R) 64, Version 13.0, Build [80.483.23]
Attaching to program: /opt/intel/impi/4.1.3.048/intel64/bin/mpiexec.hydra, process 17765
[New Thread 17765 (LWP 17765)]
Reading symbols from /opt/intel/impi/4.1.3.048/intel64/bin/mpiexec.hydra...done.
__select_nocancel () in /lib64/libc-2.12.so
Continuing.
MPIR_Breakpoint () at /tmp/7b663e0dc22b2304e487307e376dc132.xtmpdir.nnlmpicl211.25617_32e/mpi4.32e.nnlmpibld11.20140124/dev/src/pm/hydra/tools/debugger/debugger.c:24
No source file named /tmp/7b663e0dc22b2304e487307e376dc132.xtmpdir.nnlmpicl211.25617_32e/mpi4.32e.nnlmpibld11.20140124/dev/src/pm/hydra/tools/debugger/debugger.c.
(idb)
   [0:1] Intel(R) Debugger for applications running on Intel(R) 64, Version 13.0, Build [80.483.23]
%1 [0:1] Attaching to program: /home/users/cscppm59/Prove/MPI-INTEL/a.out, process [17770;17771]
%2 [0:1] [New Thread [17770;17771] (LWP [17770;17771])]
   [0:1] Reading symbols from /home/users/cscppm59/Prove/MPI-INTEL/a.out...done.
   [0:1] MPIR_WaitForDebugger () at /tmp/7b663e0dc22b2304e487307e376dc132.xtmpdir.nnlmpicl211.25617_32e/mpi4.32e.nnlmpibld11.20140124/dev/src/mpi/debugger/dbginit.c:270
   [0:1] No source file named /tmp/7b663e0dc22b2304e487307e376dc132.xtmpdir.nnlmpicl211.25617_32e/mpi4.32e.nnlmpibld11.20140124/dev/src/mpi/debugger/dbginit.c.

(idb)
   [0:1] error: cannot return to function main

(idb)
   [0:1] Source file not found or not readable, tried...
   [0:1]     /tmp/7b663e0dc22b2304e487307e376dc132.xtmpdir.nnlmpicl211.25617_32e/mpi4.32e.nnlmpibld11.20140124/dev/src/mpi/debugger/dbginit.c
   [0:1]     ./dbginit.c
   [0:1]     /home/users/cscppm59/Prove/MPI-INTEL/dbginit.c

(idb)

Using commands 'where' and 'up' i am able to set a breakpoint, and it works fine:

(idb) where
(idb)
%3 [0:1] #0  0x00007f05ab36234b in MPIR_WaitForDebugger () at /tmp/76630222304487307376132b211.25617324.3211.20140124e270dcbeedc.xtmpdir.nnlmpicl_e/mpie.nnlmpibld/dev/src/mpi/debugger/dbginit.c:
%4 [0:1] #1  0x00007f05ab3e1870 in MPIR_Init_thread (argc=0x0, argv=0x0, required=0, provided=0x7fff8b16f25c) at /tmp/76630222304487307376132b211.25617324.3211.20140124e733dcbeedc.xtmpdir.nnlmpicl_e/mpie.nnlmpibld%5 [0:1] #2  0x00007f05ab3ce290 in PMPI_Init (argc=0x0, argv=0x0) at /tmp/76630222304487307376132b211.25617324.3211.20140124e195dcbeedc.xtmpdir.nnlmpicl_e/mpie.nnlmpibld/dev/src/mpi/init/init.c:%6 [0:1] #3  0x00007f05ab99531f in mpi_init_ () in /opt/intel/impi/4.1.3.048/intel64/lib/libmpigf.so..4.1
   [0:1] #4  0x0000000000401140 in mpitest () at /home/users/cscppm59/Prove/MPI-INTEL/mpi.f:9

(idb) up
(idb)
%7 [0:1] #1  0x00007f63613ad870 in MPIR_Init_thread (argc=0x0, argv=0x0, required=0, provided=0x7fff16c203dc) at /tmp/76630222304487307376132b211.25617324.3211.20140124e733dcbeedc.xtmpdir.nnlmpicl_e/mpie.nnlmpibld   [0:1] No source file named /tmp/7b663e0dc22b2304e487307e376dc132.xtmpdir.nnlmpicl211.25617_32e/mpi4.32e.nnlmpibld11.20140124/dev/src/mpi/init/initthread.c.

(idb)
(idb)
%8 [0:1] #2  0x00007f05ab3ce290 in PMPI_Init (argc=0x0, argv=0x0) at /tmp/76630222304487307376132b211.25617324.3211.20140124e195dcbeedc.xtmpdir.nnlmpicl_e/mpie.nnlmpibld/dev/src/mpi/init/init.c:   [0:1] No source file named /tmp/7b663e0dc22b2304e487307e376dc132.xtmpdir.nnlmpicl211.25617_32e/mpi4.32e.nnlmpibld11.20140124/dev/src/mpi/init/init.c.

(idb)
(idb)
%9 [0:1] #3  0x00007f636196131f in mpi_init_ () in /opt/intel/impi/4.1.3.048/intel64/lib/libmpigf.so..4.1

(idb)
(idb)
    [0:1] #4  0x0000000000401140 in mpitest () at /home/users/cscppm59/Prove/MPI-INTEL/mpi.f:9
    [0:1] 9	      call MPI_INIT(ierr)

(idb) b 15
(idb)
    [0:1] Breakpoint 1 at 0x401316: file /home/users/cscppm59/Prove/MPI-INTEL/mpi.f, line 15.

(idb) c
(idb)
    [0:1] Continuing.
    [0:1]
    [0:1] Breakpoint 1, mpitest () at /home/users/cscppm59/Prove/MPI-INTEL/mpi.f:15
    [0:1] 15	      aus=0.87

(idb) where
(idb)
    [0:1] #0  0x0000000000401316 in mpitest () at /home/users/cscppm59/Prove/MPI-INTEL/mpi.f:15

(idb) n
(idb)
    [0:1] 17	      do j=1,1

(idb) p aus
(idb)
    [0:1] $1 = 0.870000005

(idb)

This is a simple program without error. 

 If i try simply to quit idb, program exits normally:

(idb) q
imip15.ba.imip.cnr.it
imip15.ba.imip.cnr.it
[cscppm59@imip15 MPI-INTEL]$

Instead, if i try to continue, i obtain 'program exited normally' like when i use gdb, but idb starts to write on the screen infinitely (idb) in a way like this:

(idb) c
(idb)
    [0:1] Continuing.
imip15.ba.imip.cnr.it
imip15.ba.imip.cnr.it
    [0:1] Program exited normally.

(idb) (idb) (idb) [cscppm59@imip15 MPI-INTEL]$ (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb) (idb)

To stop this i must kill the process.

1) Is there a way to avoid this?

2) Is there a way to start an MPI parallel debug session in GUI mode?

Thanks 

Pierpaolo

Hi Intel System Studio Support Team,

I have a question about Intel XDP3 JTAG interface which is supported by Intel JTAG Debugger.

Does Intel provide any development environments (Free tools or low cost tools) which supports

the JTAG debugging by Intel XDP3 JTAG interface other than Intel System Studio?

Thank you,

Dear all,

some weeks ago I subscribed and installed the Intel Parallel Studio XE 2015 beta in order to evaluate it. During this time I have followed the included tutorials and now I am reading a book about Parallel Studio (Parallel Programming with Intel Parallel Studio XE - Stephen Blair Chappell, Andrew Stockes)

In one of the chapters the book describes how to use the Parallel Debugger Extension, but I have not been able to found it inside VS2012, this extension was deprecated?.

Thanks for your help!

Hi all, appreciate your perspective :

I have just started to use WRF V3.6 and opened my idb to find that I can only see some *.c or *.h files, but no FORTRAN source files at all (please see the attached figure).

The flags from the CONFIGURE.WRF are as follows -

====================

DMPARALLEL      =        1

OMPCPP          =       # -D_OPENMP

OMP             =       # -openmp -fpp -auto

OMPCC           =       # -openmp -fpp -auto

SFC             =       ifort

SCC             =       icc

CCOMP           =       icc

DM_FC           =       mpif90 -f90=$(SFC)

DM_CC           =       mpicc -cc=$(SCC) -DMPI2_SUPPORT

FC              =        $(DM_FC)

CC              =       $(DM_CC) -DFSEEKO64_OK 

LD              =       $(FC)

RWORDSIZE       =       $(NATIVE_RWORDSIZE)

PROMOTION       =       -i4

ARCH_LOCAL      =       -DNONSTANDARD_SYSTEM_FUNC -DWRF_USE_CLM

CFLAGS_LOCAL    =       -w -O3 -ip #-xHost -fp-model fast=2 -no-prec-div -no-prec-sqrt -ftz -no-multibyte-chars

LDFLAGS_LOCAL   =       -ip #-xHost -fp-model fast=2 -no-prec-div -no-prec-sqrt -ftz -align all -fno-alias -fno-common

CPLUSPLUSLIB    =       

ESMF_LDFLAG     =       $(CPLUSPLUSLIB)

FCOPTIM         =       -O3

FCREDUCEDOPT    =       $(FCOPTIM)

FCNOOPT        =       -O0 -fno-inline -fno-ip

FCDEBUG         =       # -g $(FCNOOPT) -traceback # -fpe0 -check all -ftrapuv -unroll0 -u

FORMAT_FIXED    =       -FI

FORMAT_FREE     =       -FR

FCSUFFIX        =

BYTESWAPIO      =       -convert big_endian

FCBASEOPTS_NO_G =       -ip -fp-model precise -w -ftz -align all -fno-alias $(FORMAT_FREE) $(BYTESWAPIO) #-xHost -fp-model fast=2 -no-heap-arrays -no-prec-div -no-prec-sqrt -fno-common

FCBASEOPTS      =       $(FCBASEOPTS_NO_G) $(FCDEBUG)

MODULE_SRCH_FLAG =     

TRADFLAG        =      -traditional

CPP             =      /lib/cpp -P

AR              =      ar

ARFLAGS         =      ru

M4              =      m4

RANLIB          =      ranlib

CC_TOOLS        =      $(SCC) 

=========================

Am I doing something wrong here ? 

Thanks in advance,

Jack.

Hi all,

I haven't seen a coherent/official OpenMP debugging post by the Intel guys.

How can I debug an OpenMP Fortran code with idb ? Are there any compilation flag(s) required in order to ''serialize'' the code first ?

Any suggested manual/links that you know off ?

Appreciate your time and your answers.

Best regards,

Jack.

I have an Intel-Fortran-project that calls an unmanaged Code (in VB).

I want to debug my Program under Visual Studio 2010. Which Properties must be set for debugging the called VB-Subroutine?

I have selected the "Enable unmanaged code debugging" check box for Visual Basic Project.

Under Visual Studio Properties->Debugging->Debugger Type is deactivated. I mean I can't change Attribute and set it to Mixed or Auto!

Hi all,

I'm running a multiple file Fortran 90 code using IDB, and at some point I get  :

**Program received signal SIGFPE**

The problem is that the IDB throw me to the Assembly page and not to the line when it happend. I'm not familiar with assembly

I'm using the ''traceback'' option for compiling those files. Specifically :

**ifort -g -O3 -openmp -openmp-report -msse4.2 -fpconstant -fp-model strict -fpe0 -traceback -ftrapuv -convert big_endian**

Can anybody please advise on how to get the specific line of the source code ?

Thank you all,

Jack.

Trying to start up idb I get the crash below.

Probably hard to debug without the executable, but I can't send it without permission, so let me know if you need it and I'll see what I can do.

Intel(R) Debugger for applications running on Intel(R) 64, Version 13.0, Build [80.483.23]

------------------

object file name: <snip>

Reading symbols from <snip>

Intel(R) Debugger for applications running on Intel(R) 64, Version 13.0 caught signal "Segmentation fault" (11).

This is an unexpected condition and may indicate the presence of a defect.

If you wish to report this, please include the stack trace that follows.

/lib64/libc.so.6(+0x340e0) [0x7f438f92a0e0]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN23LoadableFileSymbolTable9mainEntryERK15UnrelocatedAddr+0x17) [0xb1b737]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN30PSD2_LineStateMachine_Consumer3runER21PSD2_LineStateMachineb+0x444) [0xadd584]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN15ParseSymsDwarf222emitLinesForCompilUnitERK11WalkCtxDIEsRK11AttrBindingRK12AttrBindings+0xb7a) [0xadcfba]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN15ParseSymsDwarf227emitSTForDIECompilationUnitER11WalkCtxDIEsbRK12AttrBindings+0x564) [0xadbea4]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN15ParseSymsDwarf212emitSTForDIEER11WalkCtxDIEsbRK12AttrBindings+0x3ac) [0xad58dc]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN15ParseSymsDwarf214walkTreeOfDIEsER11WalkCtxDIEs+0xd0) [0xada6a0]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN15ParseSymsDwarf214walkCommonUnitER16WalkCtxDebugInfo9CuSection+0x4de) [0xaca9ee]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN15ParseSymsDwarf220readTopLevelEntitiesEv+0x615) [0xac8745]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN15ParseSymsDwarf218readPartialSymbolsEb14PreferFileEnum+0x15d) [0xac7c7d]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN23LoadableFileSymbolTable18readPartialSymbolsEb+0xd6) [0xb1b4a6]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN10LoadedFile11readSymbolsERSob+0x166) [0x8f3f3c]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN11LoadedFiles8loadAOUTERSoPK6FileId+0x81) [0x8e2bdb]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN17WritableSymtabDef8loadAOUTEPK6FileId+0x1f) [0x8f4907]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN21ControlDefTargetAgent14getLoadedFilesEPK6FileId+0x10f) [0x92570b]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN12AddrSpaceDef10noteLoadedEPK6FileIdS2_P7Program+0xe1) [0x9b2779]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN10ProcessDef10noteExecedEPKc+0xe9) [0x9ac653]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN21ControlDefTargetAgent12startProcessEPKcRK7ArgListPK11EnvironmentS1_S1_S1_Ri+0xe95) [0x91c30f]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN14ProcessFactory22createLocalLiveProcessEP3JobP7ArgListPcS4_S4_22IsOrIsNotADummyProcess+0x1b8) [0x9a8688]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN3Job22createLocalLiveProcessEP7ArgListPcS2_S2_22IsOrIsNotADummyProcess+0x3e) [0x99a090]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN11SessionBase17startLocalProcessEP3JobP7ArgList22IsOrIsNotADummyProcess+0x8c) [0x948288]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_Z17StartDummyProcessP3Job+0xaf) [0x6891f9]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN7CmdLoad5do_itER19CmdExecutionContextRN10BaseForCmd9CmdResultE+0x274) [0x68b0a8]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN10BaseForCmd7executeEb+0xfc5) [0x65e469]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN3Cmd20executeAsInternalCmdEv+0x23) [0x62615f]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_ZN12InitialState10executeCmdEv+0x29) [0x61456d]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_Z15decladebug_initiPPKcS1_+0xff1) [0x611c47]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(_Z7idbMainiPPKcS1_+0x161) [0x60dfe7]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(main+0x3a) [0x60dd1a]

/lib64/libc.so.6(__libc_start_main+0xfd) [0x7f438f914e7d]

/opt/intel/composer_xe_2013_sp1.2.144/bin/intel64/iidb(__gxx_personality_v0+0x232) [0x60db8a]

Could not start process for <snip>

No image loaded ... Recovering ...

Fatal error: Segmentation fault

Hello,

the latest compiler version comes with gdb-ia or gdb-mic. Obviously idb has been dropped. This is not unexpected (see https://software.intel.com/en-us/forums/topic/326535).

But: Intels version of gdb (gdb-ia) seems to provide only a minimalistic text console interface. Not even a TUI like gdb.

Or am I missing something?

The text interface of gdb-ia reminds me of ladebug, the debugger of CFAL (Compaq Fortran for Alpha Linux) from 2001 (a noncommercial version of Digital Fortran). Déjà-vu!?

Is there a commitment to Linux development from Intel?

Markus

I want to start developing code for the Quark processor. I have an Intel Galileo Board that I have started working with.

I would like to know if there is a way to obtain the Intel ITP-XDP3 JTAG probe as an educator. My budget as an educator is limited.

It is a high end probe, but it seems to be the only probe available to debug the Quark's UEFI or any code from the reset vector on which is what I want to do.

A second question: what would be the best way to interface the Intel ITP-XDP3 with the Galileo board? The JTAG connector is different, so I know I will need an adapter; what would be the best way to do in terms of adapters?

I want to be able to debug the Quark SoC on the Intel Galileo Board from the reset vector (or close to it).

I know that OpenOCD can't do a direct reset/break debug since the ARM JTAG interface on the board doesn't include the two necessary pins for such procedure.

I am trying the latest beta version of the Intel System Studio 2015 and I am using OpenOCD to debug on the Intel XDB for the Quark. It was suggested that, once I had control of the target I can issue a soft reset that would stop the target on an address that would be very close to the reset vector if not the reset vector itself. I must say that I am pretty clueless about achieving this. I got access to the Quark and I am able to see the trace and the registers, but I don't understand how to get the XDB to do a soft reset on the target and stop just or on the reset vector.

I tried using the efi "loadthis" command on the XDB> command line; it didn't work since I don't know the address of the EFI header, but this may be the wrong approach.

If I manage to get the target to do a soft reset, how would I make it stop right after the reset? I may need to set a break point, but I don't know which address should I target for such break.

I would really appreciate any information on this issue since it is very important for me to do UEFI/BIOS debug for what I am trying to do.

Thank you beforehand for any help you may be able to provide.

Hi,

On previous, I have been used Visual Studio 2008 with Intel visual fortran 11.1.3463.2008 and move to Visual Studio 2013 and Intel Parallel Studio XE 2015 Composer  edition for fortran windows  on my 64 bit windows 7 computer. My problem is that in the debug mode the program doesn't move step by step as i shown on the figure and some time does not show the values of the variables. 

Run To Cursor at the first step :

After use F10 or Step Over  ( one time ) then move to third step :

Thanks for your help in advance. 

Does this adapter ( XDP to 10Pin JTAG Adapter Pins https://designintools.intel.com/product_p/itpxdp10pinjtagquark.htm) makes available the PRDY# and PREQ# pins that are necessary for debugging the Quark processor in reset break mode?

Since this adapter converts the ITP-XDP3 connector to the standard 10-pin ARM JTAG connector, these pins may not be available at the 10-pin side, but are they available for connection somewhere on the board?

I am asking this question because I know that the Intel Galileo board makes available these pins (PRDY_B and PREQ_B) as taps right at the bottom side of the board on the bottom of the processor rather than pins on any of the board's connectors. My intention is to get these pins connected to the ITP-XDP3 by soldering two wires from these pins on the Galileo to the   XDP to 10Pin JTAG Adapter Pins adapter. In this way, I think it would be possible to use the ITP-XDP3 to debug the Quark on the Galileo.

Is any of this possible?

For the moment I am using OpenOCD on Intel system Studio 2015 Beta (XDB) with the Olimex JTAG probe, but I need to do debugging from reset and using the ITP-XDP3 may be the best way to go, but I would like to have more information before committing to such a purchase. Or, I may decide to stay the course depending on the feedback I may get here.

thank you beforehand for any help or information you may be able to provide me.

Best regards.

I have recently purchase "Intel Parallel Studio XE Composer Edition for Fortran and C++ Windows* - Named-user Commercial (ESD)".

While i am installing i can see that the package "Intel Debugger Extension 7.7-8.0" is included (Marked yellow in first picture).

But at the very next step it shows the warning related to debugging package( shown in the second picture).

Is it compulsory to install Microsoft visual studio before installing  "Intel Parallel Studio XE Composer Edition for Fortran and C++ Windows* " ? If not then how can i install this product correctly without any warnings? 

How to use debugger without Microsoft visual studio after installation?

Thank you 

Is it possible to debug the Quark SoC with Intel System Studio 2015 (Beta) and an OpenOCD probe? 

The processor always stops at the address 0x0008:0xFFFFFA72 when following the steps state below. When the debugger halts the processor at address: 0x0008:FFFFFA72, the processor is already working in protected mode, so my technique of rewriting the EIP to go back to the address in memory pointed by the jmp instruction (see the steps below) at the reset vector is useless.

Is there a way of debugging in real mode or stopping the processor before it enters protected mode?

STEPS

This is what I have done:

I have tried the steps suggested in this comment: https://software.intel.com/en-us/comment/1799840#comment-1799840. 

So far, what is suggested in the comment works since it stops some few instructions after the jmp instruction declared at the reset vector; there are some tricks that have to be implemented though. These have been useless so far since by the time the processor stops it is already in protected mode. This is what I did step-by-step:

Before Anything

-------------------------------------------------------------------------------

1.) Connect the Olimex ARM-USB-OCD-H to the PC

2.) Use Zadig.exe, an automated driver installer. You can obtain the software

    at: http://zadig.akeo.ie

3.) In Zadig, set the Options -> List All Devices if no device is shown in the

    interface's drop down menu.

4.) In the drop down menu chose the "Olimex OpenOCD JTAG ARM-USB-OCD-H 

    (Interface 0)"

5.) Select the WinUSB (*Most recent version) and push the button.

6.) Do the same for interface 1 if the Olimex probe.

Start Debugging

-------------------------------------------------------------------------------

1.) Make sure the Galileo board is unplugged.

2.) Plug the Olimex probe to the Galileo board.

3.) Plug in the Galileo board's power supply.

4.) Star the OpenOCD debugger as suggested by Intel System Debugger (year)

    Installation Guide and Release Notes on the section concerning the Quark

    SoC and OpenOCD debugging.

5.) Star the Quark SoC (Using OpenOCD) batch (icon) provided by Intel System

    Studio.

6.) Connect the XDB to the device.

7.)    Hold the Reboot button on the Galileo Board.

8.) Click the "restart" button on the XDB.

9.) Make sure that it runs for as short as possible and hit the "halt" button.

10.) The XDB should stop very close to the address where the reset vector

     declares the first near jump. (In my case it stops at address 0x0008:0xFFFFFA72)

11.) Load the CS with this value: 0x0008

12.) Load the EIP with this value: 0xFFFFF668 (The address of the near jump at

     the reset vector).

13. Start debugging.

Note: I am using the Galileo's "Flash-missingPDAT_Release-1.0.2.bin" provided on the Galileo's download website. There is a new version, but changing the file will not make a difference in this case.

Is it possible to gain access to the Quark's Model-Specific Registers (MSR) via JTAG using the XDB?

If it is possible, in which way can I gain access to these registers?

The Quark Debug Operations Manual suggests this [Direct quote form the Quark Debug Ops Manual, Section 5.6.11]:

MSRs may be accessed (read and written) using the following flow:
1. Write the MSR index value to the ECX register using normal SRAM write operation.
2. Read:
a. Submit an ‘rdmsr’ instruction to the core via WRITEPIR and SUBMITPIR.
b. Bits 31:0 of the MSR data will be in EAX; bits 63:32 of the MSR data will be
EDX.
3. Write:
a. Move bits 31:0 of the data to be written to EAX; move bits 63:32 of the data
to EDX.
b. Submit a ‘wrmsr’ instruction to the core via WRITEPIR and SUBMITPIR.

 If this is the correct method to access the MSRs with XDB, how would I instruct the XDB to do this?

Thank you beforehand for any help you may be able to provide me.

Hello,

I'm using the Intel System Studio 2015 and using the hardware threads is there a way to look a multiple threads at the same time (code view) that is?

Thanks,
Larry

Is there any  way to force idb to generate a new core dump file for the programmed being debugged? The new core dump should reflect the state of the file at the cursor location as I step though a file.

When a Fortran program containing PARAMETER declarations is compiled with the /Zi /debug-parameters:used options, the parameters are displayed twice in the Locals window. Here is example code:

! test viewing PARAMETER values in debugger
!
program tst
implicit none
integer, parameter :: N=10,M=20,L=M+N
integer :: iv(M-N),i
!
do i=1,size(iv)
   iv(i)=N+i
end do
write(*,*)iv
end program

I have attached a screenshot of the duplicated display of the parameters in the debugger.