src/patches/suse-2.6.27.31/patches.suse/kdb-x86

   1 From: SGI KDB Development <kdb@oss.sgi.com>
   2 Subject: kdb-v4.4-2.6.27-rc8-x86-1
   3 References: FATE#303971
   4 X-URL: ftp://oss.sgi.com/www/projects/kdb/download/v4.4/
   5
   6 The KDB x86 code.
   7
   8 Acked-by: Bernhard Walle <bwalle@suse.de>
   9
  10 ---
  11  arch/x86/Kconfig.debug        |   88
  12  arch/x86/Makefile             |    3
  13  arch/x86/kdb/ChangeLog        |  230 +
  14  arch/x86/kdb/ChangeLog_32     |  865 ++++++
  15  arch/x86/kdb/ChangeLog_64     |  447 +++
  16  arch/x86/kdb/Makefile         |    5
  17  arch/x86/kdb/Makefile_32      |   25
  18  arch/x86/kdb/Makefile_64      |   25
  19  arch/x86/kdb/i386-dis.c       | 4686 +++++++++++++++++++++++++++++++++++
  20  arch/x86/kdb/kdb_cmds_32      |   17
  21  arch/x86/kdb/kdb_cmds_64      |   18
  22  arch/x86/kdb/kdba_bp_32.c     |  914 ++++++
  23  arch/x86/kdb/kdba_bp_64.c     |  912 ++++++
  24  arch/x86/kdb/kdba_bt.c        | 5597 ++++++++++++++++++++++++++++++++++++++++++
  25  arch/x86/kdb/kdba_id.c        |  261 +
  26  arch/x86/kdb/kdba_io.c        |  609 ++++
  27  arch/x86/kdb/kdba_support.c   |   59
  28  arch/x86/kdb/kdbasupport_32.c | 1072 ++++++++
  29  arch/x86/kdb/kdbasupport_64.c | 1022 +++++++
  30  arch/x86/kdb/pc_keyb.h        |  137 +
  31  arch/x86/kdb/x86_64-dis.c     | 4686 +++++++++++++++++++++++++++++++++++
  32  arch/x86/kernel/crash.c       |  110
  33  arch/x86/kernel/entry_32.S    |   20
  34  arch/x86/kernel/entry_64.S    |   27
  35  arch/x86/kernel/io_apic_32.c  |    8
  36  arch/x86/kernel/io_apic_64.c  |    8
  37  arch/x86/kernel/reboot.c      |   11
  38  arch/x86/kernel/traps_32.c    |   48
  39  arch/x86/kernel/traps_64.c    |    2
  40  include/asm-x86/ansidecl.h    |    5
  41  include/asm-x86/ansidecl_32.h |  383 ++
  42  include/asm-x86/ansidecl_64.h |  383 ++
  43  include/asm-x86/bfd.h         |    5
  44  include/asm-x86/bfd_32.h      | 4921 ++++++++++++++++++++++++++++++++++++
  45  include/asm-x86/bfd_64.h      | 4917 ++++++++++++++++++++++++++++++++++++
  46  include/asm-x86/irq_vectors.h |    6
  47  include/asm-x86/kdb.h         |  134 +
  48  include/asm-x86/kdbprivate.h  |  241 +
  49  include/asm-x86/kdebug.h      |    2
  50  include/asm-x86/kmap_types.h  |    3
  51  include/asm-x86/ptrace.h      |   23
  52  41 files changed, 32930 insertions(+), 5 deletions(-)
  53
  54 --- a/arch/x86/Kconfig.debug
  55 +++ b/arch/x86/Kconfig.debug
  56 @@ -302,5 +302,91 @@ config OPTIMIZE_INLINING
  57
  58           If unsure, say N.
  59
  60 -endmenu
  61 +config KDB
  62 +       bool "Built-in Kernel Debugger support"
  63 +       depends on DEBUG_KERNEL
  64 +       select KALLSYMS
  65 +       select KALLSYMS_ALL
  66 +       help
  67 +         This option provides a built-in kernel debugger.  The built-in
  68 +         kernel debugger contains commands which allow memory to be examined,
  69 +         instructions to be disassembled and breakpoints to be set.  For details,
  70 +         see Documentation/kdb/kdb.mm and the manual pages kdb_bt, kdb_ss, etc.
  71 +         Kdb can also be used via the serial port.  Set up the system to
  72 +         have a serial console (see Documentation/serial-console.txt).
  73 +         The key sequence <escape>KDB on the serial port will cause the
  74 +         kernel debugger to be entered with input from the serial port and
  75 +         output to the serial console.  If unsure, say N.
  76 +
  77 +config KDB_MODULES
  78 +       tristate "KDB modules"
  79 +       depends on KDB
  80 +       help
  81 +         KDB can be extended by adding your own modules, in directory
  82 +         kdb/modules.  This option selects the way that these modules should
  83 +         be compiled, as free standing modules (select M) or built into the
  84 +         kernel (select Y).  If unsure say M.
  85 +
  86 +config KDB_OFF
  87 +       bool "KDB off by default"
  88 +       depends on KDB
  89 +       help
  90 +         Normally kdb is activated by default, as long as CONFIG_KDB is set.
  91 +         If you want to ship a kernel with kdb support but only have kdb
  92 +         turned on when the user requests it then select this option.  When
  93 +         compiled with CONFIG_KDB_OFF, kdb ignores all events unless you boot
  94 +         with kdb=on or you echo "1" > /proc/sys/kernel/kdb.  This option also
  95 +         works in reverse, if kdb is normally activated, you can boot with
  96 +         kdb=off or echo "0" > /proc/sys/kernel/kdb to deactivate kdb. If
  97 +         unsure, say N.
  98 +
  99 +config KDB_CONTINUE_CATASTROPHIC
 100 +       int "KDB continues after catastrophic errors"
 101 +       depends on KDB
 102 +       default "0"
 103 +       help
 104 +         This integer controls the behaviour of kdb when the kernel gets a
 105 +         catastrophic error, i.e. for a panic, oops, NMI or other watchdog
 106 +         tripping.  CONFIG_KDB_CONTINUE_CATASTROPHIC interacts with
 107 +         /proc/sys/kernel/kdb and CONFIG_LKCD_DUMP (if your kernel has the
 108 +         LKCD patch).
 109 +         When KDB is active (/proc/sys/kernel/kdb == 1) and a catastrophic
 110 +         error occurs, nothing extra happens until you type 'go'.
 111 +         CONFIG_KDB_CONTINUE_CATASTROPHIC == 0 (default).  The first time
 112 +         you type 'go', kdb warns you.  The second time you type 'go', KDB
 113 +         tries to continue - no guarantees that the kernel is still usable.
 114 +         CONFIG_KDB_CONTINUE_CATASTROPHIC == 1.  KDB tries to continue - no
 115 +         guarantees that the kernel is still usable.
 116 +         CONFIG_KDB_CONTINUE_CATASTROPHIC == 2.  If your kernel has the LKCD
 117 +         patch and LKCD is configured to take a dump then KDB forces a dump.
 118 +         Whether or not a dump is taken, KDB forces a reboot.
 119 +         When KDB is not active (/proc/sys/kernel/kdb == 0) and a catastrophic
 120 +         error occurs, the following steps are automatic, no human
 121 +         intervention is required.
 122 +         CONFIG_KDB_CONTINUE_CATASTROPHIC == 0 (default) or 1.  KDB attempts
 123 +         to continue - no guarantees that the kernel is still usable.
 124 +         CONFIG_KDB_CONTINUE_CATASTROPHIC == 2.  If your kernel has the LKCD
 125 +         patch and LKCD is configured to take a dump then KDB automatically
 126 +         forces a dump.  Whether or not a dump is taken, KDB forces a
 127 +         reboot.
 128 +         If you are not sure, say 0.  Read Documentation/kdb/dump.txt before
 129 +         setting to 2.
 130
 131 +config KDB_USB
 132 +       bool "Support for USB Keyboard in KDB (OHCI and/or EHCI only)"
 133 +       depends on KDB && (USB_OHCI_HCD || USB_EHCI_HCD)
 134 +       help
 135 +         If you want to use kdb from USB keyboards then say Y here.  If you
 136 +         say N then kdb can only be used from a PC (AT) keyboard or a serial
 137 +         console.
 138 +
 139 +config KDB_KDUMP
 140 +       bool "Support for Kdump in KDB"
 141 +       depends on KDB
 142 +       select KEXEC
 143 +       default N
 144 +       help
 145 +         If you want to take Kdump kernel vmcore from KDB then say Y here.
 146 +         Of imsire. say N.
 147 +
 148 +endmenu
 149 --- /dev/null
 150 +++ b/arch/x86/kdb/ChangeLog
 151 @@ -0,0 +1,230 @@
 152 +2008-09-30 Jay Lan  <jlan@sgi.com>
 153 +
 154 +        * kdb-v4.4-2.6.27-rc8-x86-1.
 155 +
 156 +2008-09-22 Jay Lan  <jlan@sgi.com>
 157 +
 158 +        * kdb-v4.4-2.6.27-rc7-x86-1.
 159 +
 160 +2008-09-03 Jay Lan  <jlan@sgi.com>
 161 +
 162 +        * kdb-v4.4-2.6.27-rc5-x86-1.
 163 +
 164 +2008-08-19 Jay Lan  <jlan@sgi.com>
 165 +
 166 +        * kdb-v4.4-2.6.27-rc3-x86-1.
 167 +
 168 +2008-08-14 Jay Lan  <jlan@sgi.com>
 169 +
 170 +       * Support 'kdump' command to take a kdump vmcore from KDB,
 171 +           Dan Aloni (da-x@monatomic.org),
 172 +           Jason Xiao (jidong.xiao@gmail.com),
 173 +           Jay Lan (jlan@sgi.com)
 174 +       * kdb-v4.4-2.6.27-rc2-x86-2.
 175 +
 176 +2008-08-06 Jay Lan  <jlan@sgi.com>
 177 +
 178 +       * Fix up the NULL pointer deference issue in ohci_kdb_poll_char,
 179 +         Jason Xiao <jidong.xiao@gmail.com>
 180 +       * Backtrace on x86_64 and i386 were incomplete since 2.6.27-rc2.
 181 +       * kdb-v4.4-2.6.27-rc2-x86-1.
 182 +
 183 +2008-07-18 Jay Lan  <jlan@sgi.com>
 184 +
 185 +       * support Hardware Breakpoint (bph/bpha) commands
 186 +         IA64: Greg Banks <gnb@sgi.com>
 187 +         X86:  Konstantin Baydarov <kbaidarov@ru.mvista.com>
 188 +       * kdb-v4.4-2.6.26-x86-2.
 189 +
 190 +2008-07-14 Jay Lan  <jlan@sgi.com>
 191 +
 192 +        * kdb-v4.4-2.6.26-x86-1.
 193 +
 194 +2008-07-11 Jay Lan  <jlan@sgi.com>
 195 +
 196 +        * New commands and some fixups and enhancements,
 197 +          Joe Korty <joe.korty@ccur.com>
 198 +          John Blackwood <john.blackwood@ccur.com>
 199 +          Jim Houston <jim.houston@ccur.com>
 200 +          - Use the non-sleeping copy_from_user_atomic.
 201 +          - Enhance kdb_cmderror diagnostic output.
 202 +          - Expand the KDB 'duplicate command' error message.
 203 +          - Touch NMI watchdog in various KDB busy-loops.
 204 +          - Support IMB HS20 Blade 8843 platform.
 205 +          - Display exactly which cpus needed an NMI to get them into kdb.
 206 +          - Better document that kdb's 'ps A' command can be used to show
 207 +            _all_ processes and threads
 208 +          - Suppress KDB boottime INFO messages if quiet boot.
 209 +          - Add a KDB breakpoint to the OOPs path.
 210 +          - Add CONFIG_DISCONTIGMEM support to kdbm_memmap.
 211 +          - Extend the KDB task command to handle CONFIG_NUMA fields.
 212 +          - Extend the KDB vm command to support NUMA stuff.
 213 +          - Create the KDB mempolicy command.
 214 +          - Create a pgdat command for KDB.
 215 +          - Fix a hang on boot on some i386 systems.
 216 +        * kdb-v4.4-2.6.26-rc9-x86-1.
 217 +
 218 +2008-06-30 Jay Lan  <jlan@sgi.com>
 219 +
 220 +       * kdb-v4.4-2.6.26-rc8-x86-1.
 221 +
 222 +2008-06-25 Jay Lan  <jlan@sgi.com>
 223 +
 224 +       * kdb-v4.4-2.6.26-rc7-x86-1.
 225 +
 226 +2008-06-06 Jay Lan  <jlan@sgi.com>
 227 +
 228 +       * kdb-v4.4-2.6.26-rc5-x86-1.
 229 +
 230 +2008-05-30 Jay Lan  <jlan@sgi.com>
 231 +
 232 +       * kdb-v4.4-2.6.26-rc4-x86-1.
 233 +
 234 +2008-05-20 Jay Lan  <jlan@sgi.com>
 235 +
 236 +       * Merged <asm-x86/kdb_32.h> and <asm-x86/kdb_64.h> to <asm-x86/kdb.h>.
 237 +       * Merged <asm-x86/kdbprivate_32.h> and <asm-x86/kdbprivate_64.h> to
 238 +         <asm-x86/kdbprivate.h>.
 239 +       * kdb-v4.4-2.6.26-rc3-x86-1.
 240 +
 241 +2008-05-15 Jay Lan  <jlan@sgi.com>
 242 +
 243 +       * Fixed the i386 backtrace problem where KDB failed to find stacks
 244 +         in the kernel space.
 245 +       * kdb-v4.4-2.6.26-rc1-x86-3.
 246 +
 247 +2008-05-14 Jay Lan  <jlan@sgi.com>
 248 +
 249 +       * Fixed a bug that bb_all scans only odd number entries of kallsyms.
 250 +       * kdb-v4.4-2.6.26-rc1-x86-2.
 251 +
 252 +2008-05-13 Jay Lan  <jlan@sgi.com>
 253 +
 254 +       * Known problem: backtrace for i386 is broken since 2.6.25-rc1.
 255 +       * kdb-v4.4-2.6.26-rc1-x86-1.
 256 +
 257 +2008-05-13 Jay Lan  <jlan@sgi.com>
 258 +
 259 +       * Known problem: backtrace for i386 is broken since 2.6.25-rc1.
 260 +       * Fixed a couple of x86_64 problems:
 261 +         - "iret_label" are replaced by "irq_return".
 262 +         - bb1 failure on ia32_sysenter_target() & ia32_cstar_target()
 263 +       * kdb-v4.4-2.6.25-x86-2.
 264 +
 265 +2008-04-17 Jay Lan  <jlan@sgi.com>
 266 +
 267 +       * Known problem: backtrace for i386 is broken since 2.6.25-rc1.
 268 +       * kdb-v4.4-2.6.25-x86-1.
 269 +
 270 +2008-03-19 Jay Lan  <jlan@sgi.com>
 271 +
 272 +       * i386: systenter_entry was replaced with ia32_sysenter_target since
 273 +         2.6.25-rc1, Jay Lan <jlan@sgi.com>
 274 +       * Known problem: backtrace for i386 is broken since 2.6.25-rc1.
 275 +       * kdb-v4.4-2.6.25-rc6-x86-2.
 276 +
 277 +2008-03-16 Jay Lan  <jlan@sgi.com>
 278 +
 279 +       * Known problem: backtrace for i386 is broken since 2.6.25-rc1.
 280 +       * kdb-v4.4-2.6.25-rc6-x86-1.
 281 +
 282 +2008-03-03 Jay Lan  <jlan@sgi.com>
 283 +
 284 +       * Known problem: backtrace for i386 is broken since 2.6.25-rc1.
 285 +       * kdb-v4.4-2.6.25-rc3-x86-1.
 286 +
 287 +2008-02-26 Jay Lan  <jlan@sgi.com>
 288 +
 289 +       * remove 'fastcall' from kdb code.
 290 +       * Known problem: backtrace for i386 is broken since 2.6.25-rc1.
 291 +       * kdb-v4.4-2.6.25-rc2-x86-1.
 292 +
 293 +2008-02-19 Jay Lan  <jlan@sgi.com>
 294 +
 295 +       * Known problem: backtrace for i386 is broken.
 296 +       * kdb-v4.4-2.6.25-rc1-x86-1.
 297 +
 298 +2008-02-01 Jay Lan  <jlan@sgi.com>
 299 +
 300 +       * Backed out USB UHCI support since it caused dropped characters and
 301 +          broke OHCI.
 302 +       * Restored "archkdbcommon" commands for x86. It was lost at the x86
 303 +         merge.
 304 +       * Detecting if the HC was "busy", Aaron Young <ayoung@sgi.com>
 305 +       * kdb-v4.4-2.6.24-x86-2.
 306 +
 307 +2008-01-29 Jay Lan  <jlan@sgi.com>
 308 +
 309 +       * kdb-v4.4-2.6.24-x86-1.
 310 +
 311 +2008-01-22 Jay Lan  <jlan@sgi.com>
 312 +
 313 +       * USB UHCI kdb support, Konstantin Baydarov <kbaidarov@ru.mvista.com>
 314 +       * kdb-v4.4-2.6.24-rc8-x86-3.
 315 +
 316 +2008-01-18 Jay Lan  <jlan@sgi.com>
 317 +
 318 +       * USB EHCI kdb support,  Aaron Young <ayoung@sgi.com>
 319 +       * kdb-v4.4-2.6.24-rc8-x86-2.
 320 +
 321 +2008-01-18 Jay Lan  <jlan@sgi.com>
 322 +
 323 +       * kdb-v4.4-2.6.24-rc8-x86-1.
 324 +
 325 +2008-01-09 Jay Lan  <jlan@sgi.com>
 326 +
 327 +       * Merge arch/x86/kdb/kdba_io_64.c and arch/x86/kdb/kdba_io_32.c to
 328 +         arch/x86/kdb/kdba_io.c
 329 +       * Merge arch/x86/kdb/kdba_id_64.c and arch/x86/kdb/kdba_id_32.c to
 330 +         arch/x86/kdb/kdba_id.c
 331 +       * Merge arch/x86/kdb/pc_keyb_64.h and arch/x86/kdb/pc_keyb_32.h to
 332 +         arch/x86/kdb/pc_keyb.h
 333 +       * kdb-v4.4-2.6.24-rc7-x86-2.
 334 +
 335 +2008-01-07 Jay Lan  <jlan@sgi.com>
 336 +
 337 +       * kdb-v4.4-2.6.24-rc7-x86-1.
 338 +
 339 +2007-12-21 Jay Lan  <jlan@sgi.com>
 340 +
 341 +       * Renamed kdb/kdba_bt_x86.c to arch/x86/kdba_bt.c.
 342 +       * Find gcc options 'no-optimize-sibling-calls' & 'regparm' from
 343 +         $(KBUILD_CFLAGS) in arch/x86/kdb/Makefile_{32,64}. We used to
 344 +         get them from $(CFLAGS).
 345 +       * Default regparm to 3 on x86_32 if not defined.
 346 +       * kdb v4.4-2.6.24-rc6-x86-1.
 347 +
 348 +2007-12-12 Jay Lan  <jlan@sgi.com>
 349 +
 350 +       * Fixed a Makefile_32 error.
 351 +       * kdb v4.4-2.6.24-rc5-x86-1.
 352 +
 353 +2007-12-05 Jay Lan  <jlan@sgi.com>
 354 +
 355 +       * Fixed a 'sysctl table check failed' problem.
 356 +       * kdb v4.4-2.6.24-rc4-x86-1.
 357 +
 358 +2007-11-26 Jay Lan  <jlan@sgi.com>
 359 +
 360 +       * kdb v4.4-2.6.24-rc3-x86-1.
 361 +
 362 +2007-11-13 Jay Lan  <jlan@sgi.com>
 363 +
 364 +       * Back ported "New KDB USB interface" from Aaron Young in
 365 +         v4.4-2.6.23-{i386,x86_64}-2 to 2.6.24 kdb patchset.
 366 +       * Fixed a make problem at arch/x86/Makefile_{32,64}.
 367 +       * kdb v4.4-2.6.24-rc2-x86-2.
 368 +
 369 +2007-11-12 Jay Lan  <jlan@sgi.com>
 370 +
 371 +       * kdb v4.4-2.6.24-rc2-x86-1.
 372 +
 373 +2007-11-09 Jay Lan  <jlan@sgi.com>
 374 +
 375 +       * Rebase to 2.6.24-rc1 kernel
 376 +       *   - merged kdb-v4.4-2.6.23-i386-1 and kdb-v4.4-2.6.23-x86_64-1
 377 +       *     into kdb-v4.4-2.6.24-rc1-x86-1
 378 +       *   - Fields "done", "sglist_len", and "pid" are removed from
 379 +       *     struct scsi_cmnd. Thus, these fields are no longer displayed
 380 +       *     on "sc" command.
 381 +       * kdb v4.4-2.6.24-rc1-x86-1.
 382 --- /dev/null
 383 +++ b/arch/x86/kdb/ChangeLog_32
 384 @@ -0,0 +1,865 @@
 385 +2007-11-08 Jay Lan  <jlan@sgi.com>
 386 +
 387 +       * New KDB USB interface,  Aaron Young <ayoung@sgi.com>
 388 +       *  1. This patch allows KDB to work with any Host Contoller driver
 389 +       *     and call the correct HC driver poll routine (as long as the
 390 +       *     HC driver provides a .kdb_poll_char routine via it's
 391 +       *     associated hc_driver struct).
 392 +       *  2. Hotplugged keyboards are now recognized by KDB.
 393 +       *  3. Currently KDB can only make use of 1 USB type keyboard.
 394 +       *     New code can handle up to 8 attached keyboards - input is
 395 +       *     multiplexed from all of them while in kdb.
 396 +       * kdb v4.4-2.6.23-common-2.
 397 +
 398 +2007-10-24 Jay Lan  <jlan@sgi.com>
 399 +
 400 +       * kdb v4.4-2.6.23-i386-1.
 401 +
 402 +2007-09-26 Jay Lan  <jlan@sgi.com>
 403 +
 404 +       * kdb v4.4-2.6.23-rc8-i386-1.
 405 +
 406 +2007-09-21 Jay Lan  <jlan@sgi.com>
 407 +
 408 +       * kdb v4.4-2.6.23-rc7-i386-1.
 409 +
 410 +2007-09-12 Jay Lan  <jlan@sgi.com>
 411 +
 412 +       * kdb v4.4-2.6.23-rc6-i386-1.
 413 +
 414 +2007-09-06 Jay Lan  <jlan@sgi.com>
 415 +
 416 +       * kdb v4.4-2.6.23-rc5-i386-1.
 417 +
 418 +2007-08-30 Keith Owens  <kaos@sgi.com>
 419 +
 420 +       * New i386/x86_64 backtrace requires that kdb_save_running() does not
 421 +         exit until after kdb_main_loop() has completed.
 422 +       * kdb v4.4-2.6.23-rc4-i386-2.
 423 +
 424 +2007-08-30 Jay Lan  <jlan@sgi.com>
 425 +
 426 +       * kdb v4.4-2.6.23-rc4-i386-1.
 427 +
 428 +2007-08-24 Keith Owens  <kaos@sgi.com>
 429 +
 430 +       * kdb v4.4-2.6.23-rc3-i386-1.
 431 +
 432 +2007-08-07 Jay Lan  <jlan@sgi.com>
 433 +
 434 +       * kdb v4.4-2.6.23-rc2-i386-1.
 435 +
 436 +2007-07-31 Keith Owens  <kaos@sgi.com>
 437 +
 438 +       * Delete obsolete kdba_bt.c.
 439 +       * kdb v4.4-2.6.23-rc1-i386-2.
 440 +
 441 +2007-07-30 Keith Owens  <kaos@sgi.com>
 442 +
 443 +       * kdb v4.4-2.6.23-rc1-i386-1.
 444 +
 445 +2007-07-26 Keith Owens  <kaos@sgi.com>
 446 +
 447 +       * New x86 backtrace code.
 448 +       * kdb v4.4-2.6.22-i386-2.
 449 +
 450 +2007-07-09 Keith Owens  <kaos@sgi.com>
 451 +
 452 +       * kdb v4.4-2.6.22-i386-1.
 453 +
 454 +2007-07-02 Keith Owens  <kaos@sgi.com>
 455 +
 456 +       * kdb v4.4-2.6.22-rc7-i386-1.
 457 +
 458 +2007-06-20 Keith Owens  <kaos@sgi.com>
 459 +
 460 +       * kdb v4.4-2.6.22-rc5-i386-1.
 461 +
 462 +2007-06-08 Keith Owens  <kaos@sgi.com>
 463 +
 464 +       * kdb v4.4-2.6.22-rc4-i386-1.
 465 +
 466 +2007-05-28 Keith Owens  <kaos@sgi.com>
 467 +
 468 +       * kdb v4.4-2.6.22-rc3-i386-1.
 469 +
 470 +2007-05-22 Keith Owens  <kaos@sgi.com>
 471 +
 472 +       * Register KDBENTER_VECTOR early on the boot cpu.
 473 +       * kdb v4.4-2.6.22-rc2-i386-2.
 474 +
 475 +2007-05-22 Keith Owens  <kaos@sgi.com>
 476 +
 477 +       * kdb v4.4-2.6.22-rc2-i386-1.
 478 +
 479 +2007-05-22 Keith Owens  <kaos@sgi.com>
 480 +
 481 +       * kdb v4.4-2.6.22-rc1-i386-1.
 482 +
 483 +2007-05-17 Keith Owens  <kaos@sgi.com>
 484 +
 485 +       * Update dumpregs comments for rdmsr and wrmsr commands.
 486 +         Bernardo Innocenti.
 487 +       * kdb v4.4-2.6.21-i386-3.
 488 +
 489 +2007-05-15 Keith Owens  <kaos@sgi.com>
 490 +
 491 +       * Change kdba_late_init to kdba_arch_init so KDB_ENTER() can be used
 492 +         earlier.
 493 +       * kdb v4.4-2.6.21-i386-2.
 494 +
 495 +2007-04-29 Keith Owens  <kaos@sgi.com>
 496 +
 497 +       * kdb v4.4-2.6.21-i386-1.
 498 +
 499 +2007-04-16 Keith Owens  <kaos@sgi.com>
 500 +
 501 +       * kdb v4.4-2.6.21-rc7-i386-1.
 502 +
 503 +2007-04-10 Keith Owens  <kaos@sgi.com>
 504 +
 505 +       * kdb v4.4-2.6.21-rc6-i386-1.
 506 +
 507 +2007-04-02 Keith Owens  <kaos@sgi.com>
 508 +
 509 +       * kdb v4.4-2.6.21-rc5-i386-1.
 510 +
 511 +2007-03-19 Keith Owens  <kaos@sgi.com>
 512 +
 513 +       * kdb v4.4-2.6.21-rc4-i386-1.
 514 +
 515 +2007-03-14 Keith Owens  <kaos@sgi.com>
 516 +
 517 +       * kdb v4.4-2.6.21-rc3-i386-1.
 518 +
 519 +2007-03-14 Keith Owens  <kaos@sgi.com>
 520 +
 521 +       * kdb v4.4-2.6.21-rc2-i386-1.
 522 +
 523 +2007-03-01 Keith Owens  <kaos@sgi.com>
 524 +
 525 +       * kdb v4.4-2.6.21-rc1-i386-1.
 526 +
 527 +2007-03-01 Keith Owens  <kaos@sgi.com>
 528 +
 529 +       * Remove sparse warnings.
 530 +       * kdb v4.4-2.6.20-i386-3.
 531 +
 532 +2007-02-16 Keith Owens  <kaos@sgi.com>
 533 +
 534 +       * Initialise variable bits of struct disassemble_info each time.
 535 +       * kdb v4.4-2.6.20-i386-2.
 536 +
 537 +2007-02-06 Keith Owens  <kaos@sgi.com>
 538 +
 539 +       * kdb v4.4-2.6.20-i386-1.
 540 +
 541 +2007-02-01 Keith Owens  <kaos@sgi.com>
 542 +
 543 +       * kdb v4.4-2.6.20-rc7-i386-1.
 544 +
 545 +2007-01-08 Keith Owens  <kaos@sgi.com>
 546 +
 547 +       * kdb v4.4-2.6.20-rc4-i386-1.
 548 +
 549 +2007-01-02 Keith Owens  <kaos@sgi.com>
 550 +
 551 +       * kdb v4.4-2.6.20-rc3-i386-1.
 552 +
 553 +2006-12-20 Keith Owens  <kaos@sgi.com>
 554 +
 555 +       * kdb v4.4-2.6.20-rc1-i386-1.
 556 +
 557 +2006-11-30 Keith Owens  <kaos@sgi.com>
 558 +
 559 +       * kdb v4.4-2.6.19-i386-1.
 560 +
 561 +2006-11-27 Keith Owens  <kaos@sgi.com>
 562 +
 563 +       * Only use VT keyboard if the command line allows it and ACPI indicates
 564 +         that there is an i8042.
 565 +       * kdb v4.4-2.6.19-rc6-i386-2.
 566 +
 567 +2006-11-20 Keith Owens  <kaos@sgi.com>
 568 +
 569 +       * kdb v4.4-2.6.19-rc6-i386-1.
 570 +
 571 +2006-11-09 Keith Owens  <kaos@sgi.com>
 572 +
 573 +       * Change kdb() to fastcall.
 574 +       * Add unwind info to kdb_call().  Steve Lord.
 575 +       * Only use VT console if the command line allows it.
 576 +       * kdb v4.4-2.6.19-rc5-i386-2.
 577 +
 578 +2006-11-08 Keith Owens  <kaos@sgi.com>
 579 +
 580 +       * kdb v4.4-2.6.19-rc5-i386-1.
 581 +
 582 +2006-11-01 Keith Owens  <kaos@sgi.com>
 583 +
 584 +       * kdb v4.4-2.6.19-rc4-i386-1.
 585 +
 586 +2006-10-24 Keith Owens  <kaos@sgi.com>
 587 +
 588 +       * kdb v4.4-2.6.19-rc3-i386-1.
 589 +
 590 +2006-10-24 Keith Owens  <kaos@sgi.com>
 591 +
 592 +       * Remove redundant regs and envp parameters.
 593 +       * kdb v4.4-2.6.19-rc2-i386-2.
 594 +
 595 +2006-10-18 Keith Owens  <kaos@sgi.com>
 596 +
 597 +       * kdb v4.4-2.6.19-rc2-i386-1.
 598 +
 599 +2006-10-11 Keith Owens  <kaos@sgi.com>
 600 +
 601 +       * Move kdbm_x86.c from the i386 to the common KDB patch.
 602 +       * Make the KDBENTER_VECTOR an interrupt gate instead of a trap gate, it
 603 +         simplifies the code and disables interrupts on KDBENTER().
 604 +       * Exclude the KDBENTER_VECTOR from irq assignment.
 605 +       * kdb v4.4-2.6.19-rc1-i386-2.
 606 +
 607 +2006-10-09 Keith Owens  <kaos@sgi.com>
 608 +
 609 +       * kdb v4.4-2.6.19-rc1-i386-1.
 610 +
 611 +2006-10-06 Keith Owens  <kaos@sgi.com>
 612 +
 613 +       * Remove #include <linux/config.h>
 614 +       * kdb v4.4-2.6.18-i386-2.
 615 +
 616 +2006-09-20 Keith Owens  <kaos@sgi.com>
 617 +
 618 +       * kdb v4.4-2.6.18-i386-1.
 619 +
 620 +2006-09-15 Keith Owens  <kaos@sgi.com>
 621 +
 622 +       * kdb v4.4-2.6.18-rc7-i386-1.
 623 +
 624 +2006-08-30 Keith Owens  <kaos@sgi.com>
 625 +
 626 +       * Add warning for problems when following alternate stacks.
 627 +       * kdb v4.4-2.6.18-rc5-i386-3.
 628 +
 629 +2006-08-29 Keith Owens  <kaos@sgi.com>
 630 +
 631 +       * Rewrite all backtrace code.
 632 +       * kdb v4.4-2.6.18-rc5-i386-2.
 633 +
 634 +2006-08-28 Keith Owens  <kaos@sgi.com>
 635 +
 636 +       * kdb v4.4-2.6.18-rc5-i386-1.
 637 +
 638 +2006-08-08 Keith Owens  <kaos@sgi.com>
 639 +
 640 +       * kdb v4.4-2.6.18-rc4-i386-1.
 641 +
 642 +2006-08-04 Keith Owens  <kaos@sgi.com>
 643 +
 644 +       * kdb v4.4-2.6.18-rc3-i386-1.
 645 +
 646 +2006-07-18 Keith Owens  <kaos@sgi.com>
 647 +
 648 +       * kdb v4.4-2.6.18-rc2-i386-1.
 649 +
 650 +2006-07-12 Keith Owens  <kaos@sgi.com>
 651 +
 652 +       * Remove dead KDB_REASON codes.
 653 +       * sparse cleanups.
 654 +       * kdb v4.4-2.6.18-rc1-i386-2.
 655 +
 656 +2006-07-07 Keith Owens  <kaos@sgi.com>
 657 +
 658 +       * kdb v4.4-2.6.18-rc1-i386-1.
 659 +
 660 +2006-07-04 Keith Owens  <kaos@sgi.com>
 661 +
 662 +       * Make KDB rendezvous on i386 a two stage approach.
 663 +       * Clean up generation of KDB interrupt code.
 664 +       * Move smp_kdb_stop() and smp_kdb_interrupt() to kdbasupport.c.
 665 +       * Move setting of interrupt traps to kdbasupport.c.
 666 +       * Remove KDB hooks from arch/i386/kernel smp.c, smpboot.c, i8259.c,
 667 +         io_apic.c.
 668 +       * Add KDB_REASON_CPU_UP support.
 669 +       * Move per cpu setup to kdba_cpu_up().
 670 +       * Rework support for 4K stacks to make backtrace more accurate.
 671 +       * Add BTSP option to get the full backtrace, including kdb routines.
 672 +       * Delete kdba_enable_mce, architectures now do their own setup.
 673 +       * Delete kdba_enable_lbr, kdba_disable_lbr, kdba_print_lbr,
 674 +         page_fault_mca.  Only ever implemented on x86, difficult to maintain
 675 +         and rarely used in the field.
 676 +       * Replace #ifdef KDB_HAVE_LONGJMP with #ifdef kdba_setjmp.
 677 +       * kdb v4.4-2.6.17-i386-2.
 678 +
 679 +2006-06-19 Keith Owens  <kaos@sgi.com>
 680 +
 681 +       * kdb v4.4-2.6.17-i386-1.
 682 +
 683 +2006-05-25 Keith Owens  <kaos@sgi.com>
 684 +
 685 +       * kdb v4.4-2.6.17-rc5-i386-1.
 686 +
 687 +2006-05-15 Keith Owens  <kaos@sgi.com>
 688 +
 689 +       * Refresh bfd related files from binutils 2.16.91.0.2.
 690 +       * kdb v4.4-2.6.17-rc4-i386-2.
 691 +
 692 +2006-05-12 Keith Owens  <kaos@sgi.com>
 693 +
 694 +       * kdb v4.4-2.6.17-rc4-i386-1.
 695 +
 696 +2006-04-28 Keith Owens  <kaos@sgi.com>
 697 +
 698 +       * kdb v4.4-2.6.17-rc3-i386-1.
 699 +
 700 +2006-04-22 Keith Owens  <kaos@sgi.com>
 701 +
 702 +       * kdb v4.4-2.6.17-rc2-i386-1.
 703 +
 704 +2006-04-11 Keith Owens  <kaos@sgi.com>
 705 +
 706 +       * kdb v4.4-2.6.17-rc1-i386-1.
 707 +
 708 +2006-03-30 Keith Owens  <kaos@sgi.com>
 709 +
 710 +       * Change CONFIG_LKCD to CONFIG_LKCD_DUMP.
 711 +       * kdb v4.4-2.6.16-i386-3.
 712 +
 713 +2006-03-24 Keith Owens  <kaos@sgi.com>
 714 +
 715 +       * Define a dummy kdba_wait_for_cpus().
 716 +       * kdb v4.4-2.6.16-i386-2.
 717 +
 718 +2006-03-21 Keith Owens  <kaos@sgi.com>
 719 +
 720 +       * kdb v4.4-2.6.16-i386-1.
 721 +
 722 +2006-03-14 Nathan Scott  <nathans@sgi.com>
 723 +
 724 +       * kdb v4.4-2.6.16-rc6-i386-1.
 725 +
 726 +2006-02-28 Nathan Scott  <nathans@sgi.com>
 727 +
 728 +       * kdb v4.4-2.6.16-rc5-i386-1.
 729 +
 730 +2006-02-20 Nathan Scott  <nathans@sgi.com>
 731 +
 732 +       * kdb v4.4-2.6.16-rc4-i386-1.
 733 +
 734 +2006-02-06 Keith Owens  <kaos@sgi.com>
 735 +
 736 +       * Change CONFIG_CRASH_DUMP to CONFIG_LKCD.
 737 +       * kdb v4.4-2.6.16-rc2-i386-2.
 738 +
 739 +2006-02-06 Keith Owens  <kaos@sgi.com>
 740 +
 741 +       * kdb v4.4-2.6.16-rc2-i386-1.
 742 +
 743 +2006-01-18 Keith Owens  <kaos@sgi.com>
 744 +
 745 +       * kdb v4.4-2.6.16-rc1-i386-1.
 746 +
 747 +2006-01-08 Keith Owens  <kaos@sgi.com>
 748 +
 749 +       * Add DIE_KDEBUG_ENTER and DIE_KDEBUG_LEAVE to notify_die.
 750 +       * kdb v4.4-2.6.15-i386-2.
 751 +
 752 +2006-01-04 Keith Owens  <kaos@sgi.com>
 753 +
 754 +       * Remove some inlines and the last vestige of CONFIG_NUMA_REPLICATE.
 755 +       * Read the keyboard acknowledgment after sending a character.  SuSE
 756 +         Bugzilla 60240.
 757 +       * kdb v4.4-2.6.15-i386-1.
 758 +
 759 +2005-12-25 Keith Owens  <kaos@sgi.com>
 760 +
 761 +       * kdb v4.4-2.6.15-rc7-i386-1.
 762 +
 763 +2005-12-20 Keith Owens  <kaos@sgi.com>
 764 +
 765 +       * kdb v4.4-2.6.15-rc6-i386-1.
 766 +
 767 +2005-12-05 Keith Owens  <kaos@sgi.com>
 768 +
 769 +       * kdb v4.4-2.6.15-rc5-i386-1.
 770 +
 771 +2005-12-02 Keith Owens  <kaos@sgi.com>
 772 +
 773 +       * kdb v4.4-2.6.15-rc4-i386-1.
 774 +
 775 +2005-11-30 Keith Owens  <kaos@sgi.com>
 776 +
 777 +       * kdb v4.4-2.6.15-rc3-i386-1.
 778 +
 779 +2005-11-21 Keith Owens  <kaos@sgi.com>
 780 +
 781 +       * kdb v4.4-2.6.15-rc2-i386-1.
 782 +
 783 +2005-11-15 Keith Owens  <kaos@sgi.com>
 784 +
 785 +       * kdb v4.4-2.6.15-rc1-i386-1.
 786 +
 787 +2005-10-28 Keith Owens  <kaos@sgi.com>
 788 +
 789 +       * kdb v4.4-2.6.14-i386-1.
 790 +
 791 +2005-10-21 Keith Owens  <kaos@sgi.com>
 792 +
 793 +       * kdb v4.4-2.6.14-rc5-i386-1.
 794 +
 795 +2005-10-11 Keith Owens  <kaos@sgi.com>
 796 +
 797 +       * kdb v4.4-2.6.14-rc4-i386-1.
 798 +
 799 +2005-10-04 Keith Owens  <kaos@sgi.com>
 800 +
 801 +       * kdb v4.4-2.6.14-rc3-i386-1.
 802 +
 803 +2005-09-21 Keith Owens  <kaos@sgi.com>
 804 +
 805 +       * Support kdb_current_task in register display and modify commands.
 806 +       * kdb v4.4-2.6.14-rc2-i386-1.
 807 +
 808 +2005-09-20 Keith Owens  <kaos@sgi.com>
 809 +
 810 +       * Remove use of __STDC_VERSION__ in ansidecl.h.
 811 +       * kdb v4.4-2.6.14-rc1-i386-1.
 812 +
 813 +2005-08-29 Keith Owens  <kaos@sgi.com>
 814 +
 815 +       * kdb v4.4-2.6.13-i386-1.
 816 +
 817 +2005-08-24 Keith Owens  <kaos@sgi.com>
 818 +
 819 +       * kdb v4.4-2.6.13-rc7-i386-1.
 820 +
 821 +2005-08-08 Keith Owens  <kaos@sgi.com>
 822 +
 823 +       * kdb v4.4-2.6.13-rc6-i386-1.
 824 +
 825 +2005-08-02 Keith Owens  <kaos@sgi.com>
 826 +
 827 +       * kdb v4.4-2.6.13-rc5-i386-1.
 828 +
 829 +2005-07-30 Keith Owens  <kaos@sgi.com>
 830 +
 831 +       * kdb v4.4-2.6.13-rc4-i386-1.
 832 +
 833 +2005-07-22 Keith Owens  <kaos@sgi.com>
 834 +
 835 +       * Compile fix for kprobes.
 836 +       * kdb v4.4-2.6.13-rc3-i386-2.
 837 +
 838 +2005-07-19 Keith Owens  <kaos@sgi.com>
 839 +
 840 +       * Add support for USB keyboard (OHCI only).  Aaron Young, SGI.
 841 +       * kdb v4.4-2.6.13-rc3-i386-1.
 842 +
 843 +2005-07-08 Keith Owens  <kaos@sgi.com>
 844 +
 845 +       * kdb v4.4-2.6.13-rc2-i386-1.
 846 +
 847 +2005-07-01 Keith Owens  <kaos@sgi.com>
 848 +
 849 +       * kdb v4.4-2.6.13-rc1-i386-1.
 850 +
 851 +2005-06-19 Keith Owens  <kaos@sgi.com>
 852 +
 853 +       * gcc 4 compile fix, remove extern kdb_hardbreaks.  Steve Lord.
 854 +       * kdb v4.4-2.6.12-i386-2.
 855 +
 856 +2005-06-18 Keith Owens  <kaos@sgi.com>
 857 +
 858 +       * kdb v4.4-2.6.12-i386-1.
 859 +
 860 +2005-06-08 Keith Owens  <kaos@sgi.com>
 861 +
 862 +       * kdb v4.4-2.6.12-rc6-i386-1.
 863 +
 864 +2005-05-25 Keith Owens  <kaos@sgi.com>
 865 +
 866 +       * kdb v4.4-2.6.12-rc5-i386-1.
 867 +
 868 +2005-05-08 Keith Owens  <kaos@sgi.com>
 869 +
 870 +       * kdb v4.4-2.6.12-rc4-i386-1.
 871 +
 872 +2005-04-21 Keith Owens  <kaos@sgi.com>
 873 +
 874 +       * kdb v4.4-2.6.12-rc3-i386-1.
 875 +
 876 +2005-04-06 Keith Owens  <kaos@sgi.com>
 877 +
 878 +       * kdb v4.4-2.6.12-rc2-i386-1.
 879 +
 880 +2005-03-29 Keith Owens  <kaos@sgi.com>
 881 +
 882 +       * Replace __copy_to_user with __copy_to_user_inatomic.
 883 +       * kdb v4.4-2.6.12-rc1-i386-1.
 884 +
 885 +2005-03-08 Keith Owens  <kaos@sgi.com>
 886 +
 887 +       * Coexistence patches for lkcd.
 888 +       * kdb v4.4-2.6.11-i386-2.
 889 +
 890 +2005-03-03 Keith Owens  <kaos@sgi.com>
 891 +
 892 +       * kdb v4.4-2.6.11-i386-1.
 893 +
 894 +2005-02-14 Keith Owens  <kaos@sgi.com>
 895 +
 896 +       * kdb v4.4-2.6.11-rc4-i386-1.
 897 +
 898 +2005-02-08 Keith Owens  <kaos@sgi.com>
 899 +
 900 +       * kdb v4.4-2.6.11-rc3-bk4-i386-1.
 901 +
 902 +2005-02-03 Keith Owens  <kaos@sgi.com>
 903 +
 904 +       * kdb v4.4-2.6.11-rc3-i386-1.
 905 +
 906 +2005-01-27 Keith Owens  <kaos@sgi.com>
 907 +
 908 +       * kdb v4.4-2.6.11-rc2-i386-1.
 909 +
 910 +2005-01-12 Keith Owens  <kaos@sgi.com>
 911 +
 912 +       * kdb v4.4-2.6.11-rc1-i386-1.
 913 +
 914 +2004-12-25 Keith Owens  <kaos@sgi.com>
 915 +
 916 +       * kdb v4.4-2.6.10-i386-1.
 917 +
 918 +2004-12-07 Keith Owens  <kaos@sgi.com>
 919 +
 920 +       * kdb v4.4-2.6.10-rc3-i386-1.
 921 +
 922 +2004-11-23 Keith Owens  <kaos@sgi.com>
 923 +
 924 +       * Coexist with asmlinkage/fastcall changes.
 925 +       * kdb v4.4-2.6.10-rc2-i386-1.
 926 +
 927 +2004-10-29 Keith Owens  <kaos@sgi.com>
 928 +
 929 +       * Handle change defintions for hard and soft irq context.
 930 +       * Make stack switch in kdb backtrace look more like the oops output.
 931 +       * kdb v4.4-2.6.10-rc1-i386-1.
 932 +
 933 +2004-10-19 Keith Owens  <kaos@sgi.com>
 934 +
 935 +       * kdb v4.4-2.6.9-i386-1.
 936 +
 937 +2004-10-12 Keith Owens  <kaos@sgi.com>
 938 +
 939 +       * kdb v4.4-2.6.9-rc4-i386-1.
 940 +
 941 +2004-10-01 Keith Owens  <kaos@sgi.com>
 942 +
 943 +       * kdb v4.4-2.6.9-rc3-i386-1.
 944 +
 945 +2004-09-30 Keith Owens  <kaos@sgi.com>
 946 +
 947 +       * Add stackdepth command.
 948 +       * Handle backtrace with separate soft and hard irq stacks
 949 +         (CONFIG_4KSTACKS).
 950 +       * Work around RESTORE_ALL macro, which can only be used once.
 951 +       * Export kdba_dumpregs.  Bryan Cardillo, UPenn.
 952 +       * kdb v4.4-2.6.9-rc2-i386-2.
 953 +
 954 +2004-09-14 Keith Owens  <kaos@sgi.com>
 955 +
 956 +       * kdb v4.4-2.6.9-rc2-i386-1.
 957 +
 958 +2004-08-27 Keith Owens  <kaos@sgi.com>
 959 +
 960 +       * kdb v4.4-2.6.9-rc1-i386-1.
 961 +
 962 +2004-08-14 Keith Owens  <kaos@sgi.com>
 963 +
 964 +       * kdb v4.4-2.6.8-i386-1.
 965 +
 966 +2004-08-12 Keith Owens  <kaos@sgi.com>
 967 +
 968 +       * kdb v4.4-2.6.8-rc4-i386-1.
 969 +
 970 +2004-08-04 Keith Owens  <kaos@sgi.com>
 971 +
 972 +       * kdb v4.4-2.6.8-rc3-i386-1.
 973 +
 974 +2004-07-18 Keith Owens  <kaos@sgi.com>
 975 +
 976 +       * kdb v4.4-2.6.8-rc2-i386-1.
 977 +
 978 +2004-07-12 Keith Owens  <kaos@sgi.com>
 979 +
 980 +       * kdb v4.4-2.6.8-rc1-i386-1.
 981 +
 982 +2004-06-16 Keith Owens  <kaos@sgi.com>
 983 +
 984 +       * kdb v4.4-2.6.7-i386-1.
 985 +
 986 +2004-06-10 Keith Owens  <kaos@sgi.com>
 987 +
 988 +       * kdb v4.4-2.6.7-rc3-i386-1.
 989 +
 990 +2004-06-09 Keith Owens  <kaos@sgi.com>
 991 +
 992 +       * Namespace clean up.  Mark code/variables as static when it is only
 993 +         used in one file, delete dead code/variables.
 994 +       * kdb v4.4-2.6.7-rc2-i386-3.
 995 +
 996 +2004-06-08 Keith Owens  <kaos@sgi.com>
 997 +
 998 +       * Whitespace clean up, no code changes.
 999 +       * kdb v4.4-2.6.7-rc2-i386-2.
1000 +
1001 +2004-06-07 Keith Owens  <kaos@sgi.com>
1002 +
1003 +       * Force KALLSYMS and KALLSYMS_ALL for CONFIG_KDB.
1004 +       * kdb v4.4-2.6.7-rc2-i386-1.
1005 +
1006 +2004-06-06 Keith Owens  <kaos@sgi.com>
1007 +
1008 +       * Correct Kconfig help text.
1009 +       * Coexist with CONFIG_REGPARM.
1010 +       * Add standard archkdb commands.
1011 +       * Move kdb_{get,put}userarea_size definitions to linux/kdb.h.
1012 +       * kdb v4.4-2.6.6-i386-2.
1013 +
1014 +2004-05-23 Keith Owens  <kaos@sgi.com>
1015 +
1016 +       * Move bfd.h and ansidecl.h from arch/$(ARCH)/kdb to include/asm-$(ARCH).
1017 +       * Update copyright notices.
1018 +       * kdb v4.4-2.6.6-i386-1.
1019 +
1020 +2004-05-10 Keith Owens  <kaos@sgi.com>
1021 +
1022 +       * kdb v4.3-2.6.6-i386-1.
1023 +
1024 +2004-05-06 Keith Owens  <kaos@sgi.com>
1025 +
1026 +       * kdb v4.3-2.6.6-rc3-i386-1.
1027 +
1028 +2004-05-06 Keith Owens  <kaos@sgi.com>
1029 +
1030 +       * kdb v4.3-2.6.6-rc2-i386-1.
1031 +
1032 +2004-04-30 Keith Owens  <kaos@sgi.com>
1033 +
1034 +       * kdb v4.3-2.6.6-rc1-i386-1.
1035 +
1036 +2004-04-05 Keith Owens  <kaos@sgi.com>
1037 +
1038 +       * kdb v4.3-2.6-5-i386-1.
1039 +
1040 +2004-02-29 Keith Owens  <kaos@sgi.com>
1041 +
1042 +       * kdb v4.3-2.6-4-rc1-i386-1.
1043 +
1044 +2004-02-18 Keith Owens  <kaos@sgi.com>
1045 +
1046 +       * kdb v4.3-2.6-3-i386-1.
1047 +
1048 +2004-02-17 Keith Owens  <kaos@sgi.com>
1049 +
1050 +       * Pick up changes from Jim Houston for 2.6.
1051 +       * Sync with kdb v4.3-2.4.25-rc1-i386-1.
1052 +       * Adjust for LDT changes in i386 mainline.
1053 +       * Convert longjmp buffers from static to dynamic allocation, for large
1054 +         cpu counts.
1055 +       * Do not use USB keyboard if it has not been probed.
1056 +       * Do not print section data, 2.6 kallsyms does not support sections :(.
1057 +       * kdb v4.3-2.6-3-rc3-i386-1.
1058 +
1059 +2003-08-29 Keith Owens  <kaos@sgi.com>
1060 +
1061 +       * kdb v4.3-2.4.22-i386-1.
1062 +
1063 +2003-08-05 Keith Owens  <kaos@sgi.com>
1064 +
1065 +       * Remove duplicate setting of trap for machine_check.
1066 +       * Only reset keyboard when CONFIG_VT_CONSOLE is defined.
1067 +
1068 +2003-07-27 Keith Owens  <kaos@sgi.com>
1069 +
1070 +       * kdb v4.3-2.4.22-pre8-i386-5.
1071 +
1072 +2003-07-20 Keith Owens  <kaos@sgi.com>
1073 +
1074 +       * Remove compile warning on x86 commands.
1075 +       * kdb v4.3-2.4.21-i386-5.
1076 +
1077 +2003-07-08 Keith Owens  <kaos@sgi.com>
1078 +
1079 +       * Add new x86 commands - rdv, gdt, idt, ldt, ldtp, ptex.
1080 +         Vamsi Krishna S., IBM.
1081 +       * kdb v4.3-2.4.21-i386-4.
1082 +
1083 +2003-07-01 Keith Owens  <kaos@sgi.com>
1084 +
1085 +       * Convert kdba_find_return() to two passes to reduce false positives.
1086 +       * Correct jmp disp8 offset calculation for out of line lock code.
1087 +       * Use NMI for kdb IPI in clustered APIC mode.  Sachin Sant, IBM.
1088 +       * kdb v4.3-2.4.21-i386-3.
1089 +
1090 +2003-06-23 Keith Owens  <kaos@sgi.com>
1091 +
1092 +       * Sync with XFS 2.4.21 tree.
1093 +       * kdb v4.3-2.4.21-i386-2.
1094 +
1095 +2003-06-20 Keith Owens  <kaos@sgi.com>
1096 +
1097 +       * kdb v4.3-2.4.21-i386-1.
1098 +
1099 +2003-06-20 Keith Owens  <kaos@sgi.com>
1100 +
1101 +       * Add CONFIG_KDB_CONTINUE_CATASTROPHIC.
1102 +       * Correct KDB_ENTER() definition.
1103 +       * kdb v4.3-2.4.20-i386-1.
1104 +
1105 +2003-05-02 Keith Owens  <kaos@sgi.com>
1106 +
1107 +       * Add kdba_fp_value().
1108 +       * Limit backtrace size to catch loops.
1109 +       * Add read/write access to user pages.  Vamsi Krishna S., IBM
1110 +       * Clean up USB keyboard support.  Steven Dake.
1111 +       * kdb v4.2-2.4.20-i386-1.
1112 +
1113 +2003-04-04 Keith Owens  <kaos@sgi.com>
1114 +
1115 +       * Workarounds for scheduler bugs.
1116 +       * kdb v4.1-2.4.20-i386-1.
1117 +
1118 +2003-03-16 Keith Owens  <kaos@sgi.com>
1119 +
1120 +       * Each cpu saves its state as it enters kdb or before it enters code
1121 +         which cannot call kdb, converting kdb from a pull to a push model.
1122 +       * Clean up kdb interaction with CONFIG_SERIAL_CONSOLE.
1123 +       * Removal of special cases for i386 backtrace from common code
1124 +         simplifies the architecture code.
1125 +       * Add command to dump i386 struct pt_regs.
1126 +       * kdb v4.0-2.4.20-i386-1.
1127 +
1128 +2003-02-03 Keith Owens  <kaos@sgi.com>
1129 +
1130 +       * Register kdb commands early.
1131 +       * Handle KDB_ENTER() when kdb=off.
1132 +       * Optimize __kdba_getarea_size when width is a constant.
1133 +       * Decode oops via kallsyms if it is available.
1134 +       * Update copyright notices to 2003.
1135 +       * Handle call *disp32(%reg) in backtrace.
1136 +       * Correct keyboard freeze.  Ashish Kalra.
1137 +       * Add command history and editing.  Sonic Zhang.
1138 +       * kdb_toggleled is conditional on KDB_BLINK_LED.  Bernhard Fischer.
1139 +       * Allow tab on serial line for symbol completion.
1140 +       * Ignore KDB_ENTER() when kdb is already running.
1141 +       * kdb v3.0-2.4.20-i386-1.
1142 +
1143 +2002-11-29 Keith Owens  <kaos@sgi.com>
1144 +
1145 +       * Upgrade to 2.4.20.
1146 +       * kdb v2.5-2.4.20-i386-1.
1147 +
1148 +2002-11-14 Keith Owens  <kaos@sgi.com>
1149 +
1150 +       * Upgrade to 2.4.20-rc1.
1151 +       * kdb v2.5-2.4.20-rc1-i386-1.
1152 +
1153 +2002-11-14 Keith Owens  <kaos@sgi.com>
1154 +
1155 +       * General clean up of handling for breakpoints and single stepping over
1156 +         software breakpoints.
1157 +       * Accept ff 1x as well as ff dx for call *(%reg) in backtrace.
1158 +       * kdb v2.5-2.4.19-i386-1.
1159 +
1160 +2002-11-01 Keith Owens  <kaos@sgi.com>
1161 +
1162 +       * Prevent SMP IRQ overwriting KDB_ENTER().
1163 +       * kdb v2.4-2.4.19-i386-2.
1164 +
1165 +2002-10-31 Keith Owens  <kaos@sgi.com>
1166 +
1167 +       * Avoid KDB_VECTOR conflict with DUMP_VECTOR.
1168 +       * Remove kdb_eframe_t.
1169 +       * Sanity check if we have pt_regs.
1170 +       * Remove kdba_getcurrentframe().
1171 +       * Reinstate missing nmi_watchdog/kdb hook.
1172 +       * kdb v2.4-2.4.19-i386-1.
1173 +
1174 +2002-10-17 Keith Owens  <kaos@sgi.com>
1175 +
1176 +       * Correct compile with CONFIG_VT_CONSOLE=n.
1177 +       * kdb v2.3-2.4.19-i386-5.
1178 +
1179 +2002-10-04 Keith Owens  <kaos@sgi.com>
1180 +
1181 +       * Add USB keyboard option.
1182 +       * Minimize differences between patches for 2.4 and 2.5 kernels.
1183 +       * kdb v2.3-2.4.19-i386-4.
1184 +
1185 +2002-08-10 Keith Owens  <kaos@sgi.com>
1186 +
1187 +       * Replace kdb_port with kdb_serial to support memory mapped I/O.
1188 +         Note: This needs kdb v2.3-2.4.19-common-2 or later.
1189 +       * kdb v2.3-2.4.19-i386-3.
1190 +
1191 +2002-08-09 Keith Owens  <kaos@sgi.com>
1192 +
1193 +       * Use -fno-optimize-sibling-calls for kdb if gcc supports it.
1194 +       * .text.lock does not consume an activation frame.
1195 +       * kdb v2.3-2.4.19-i386-2.
1196 +
1197 +2002-08-07 Keith Owens  <kaos@sgi.com>
1198 +
1199 +       * Upgrade to 2.4.19.
1200 +       * Remove individual SGI copyrights, the general SGI copyright applies.
1201 +       * New .text.lock name.  Hugh Dickins.
1202 +       * Set KERNEL_CS in kdba_getcurrentframe.  Hugh Dickins.
1203 +       * Clean up disassembly layout.  Hugh Dickins, Keith Owens.
1204 +       * Replace hard coded stack size with THREAD_SIZE.  Hugh Dickins.
1205 +       * Better stack layout on bt with no frame pointers.  Hugh Dickins.
1206 +       * Make i386 IO breakpoints (bpha <address> IO) work again.
1207 +         Martin Wilck, Keith Owens.
1208 +       * Remove fixed KDB_MAX_COMMANDS size.
1209 +       * Add set_fs() around __copy_to_user on kernel addresses.
1210 +         Randolph Chung.
1211 +       * Position i386 for CONFIG_NUMA_REPLICATE.
1212 +       * kdb v2.3-2.4.19-i386-1.
1213 +
1214 +2002-07-09 Keith Owens  <kaos@sgi.com>
1215 +
1216 +       * Upgrade to 2.4.19-rc1.
1217 +
1218 +2002-06-14 Keith Owens  <kaos@sgi.com>
1219 +
1220 +       * Upgrade to 2.4.19-pre10.
1221 +       * kdb v2.1-2.4.19-pre10-i386-1.
1222 +
1223 +2002-04-09 Keith Owens  <kaos@sgi.com>
1224 +
1225 +       * Upgrade to 2.4.19-pre6.
1226 +       * kdb v2.1-2.4.19-pre6-i386-1.
1227 +
1228 +2002-02-26 Keith Owens  <kaos@sgi.com>
1229 +
1230 +       * Upgrade to 2.4.18.
1231 +       * kdb v2.1-2.4.18-i386-1.
1232 +
1233 +2002-01-18 Keith Owens  <kaos@sgi.com>
1234 +
1235 +       * Use new kdb_get/put functions.
1236 +       * Define kdba_{get,put}area_size functions for i386.
1237 +       * Remove over-engineered dblist callback functions.
1238 +       * Correctly handle failing call disp32 in backtrace.
1239 +       * Remove bp_instvalid flag, redundant code.
1240 +       * Remove dead code.
1241 +       * kdb v2.1-2.4.17-i386-1.
1242 +
1243 +2002-01-04 Keith Owens  <kaos@sgi.com>
1244 +
1245 +       * Sync xfs <-> kdb i386 code.
1246 +
1247 +2001-12-22 Keith Owens  <kaos@sgi.com>
1248 +
1249 +       * Split kdb for i386 as kdb v2.0-2.4.17-i386-1.
1250 --- /dev/null
1251 +++ b/arch/x86/kdb/ChangeLog_64
1252 @@ -0,0 +1,447 @@
1253 +2007-11-08 Jay Lan  <jlan@sgi.com>
1254 +
1255 +       * New KDB USB interface,  Aaron Young <ayoung@sgi.com>
1256 +       *  1. This patch allows KDB to work with any Host Contoller driver
1257 +       *     and call the correct HC driver poll routine (as long as the
1258 +       *     HC driver provides a .kdb_poll_char routine via it's
1259 +       *     associated hc_driver struct).
1260 +       *  2. Hotplugged keyboards are now recognized by KDB.
1261 +       *  3. Currently KDB can only make use of 1 USB type keyboard.
1262 +       *     New code can handle up to 8 attached keyboards - input is
1263 +       *     multiplexed from all of them while in kdb.
1264 +       * kdb v4.4-2.6.23-common-2.
1265 +
1266 +2007-10-24 Jay Lan  <jlan@sgi.com>
1267 +
1268 +       * kdb v4.4-2.6.23-x86_64-1.
1269 +
1270 +2007-09-26 Jay Lan  <jlan@sgi.com>
1271 +
1272 +       * kdb v4.4-2.6.23-rc8-x86_64-1.
1273 +
1274 +2007-09-21 Jay Lan  <jlan@sgi.com>
1275 +
1276 +       * kdb v4.4-2.6.23-rc7-x86_64-1.
1277 +
1278 +2007-09-12 Jay Lan  <jlan@sgi.com>
1279 +
1280 +       * kdb v4.4-2.6.23-rc6-x86_64-1.
1281 +
1282 +2007-09-06 Jay Lan  <jlan@sgi.com>
1283 +
1284 +       * kdb v4.4-2.6.23-rc5-x86_64-1.
1285 +
1286 +2007-08-30 Keith Owens  <kaos@sgi.com>
1287 +
1288 +       * New i386/x86_64 backtrace requires that kdb_save_running() does not
1289 +         exit until after kdb_main_loop() has completed.
1290 +       * kdb v4.4-2.6.23-rc4-x86_64-2.
1291 +
1292 +2007-08-30 Jay Lan  <jlan@sgi.com>
1293 +
1294 +       * kdb v4.4-2.6.23-rc4-x86_64-1.
1295 +
1296 +2007-08-24 Keith Owens  <kaos@sgi.com>
1297 +
1298 +       * kdb v4.4-2.6.23-rc3-x86_64-1.
1299 +
1300 +2007-08-07 Jay Lan  <jlan@sgi.com>
1301 +
1302 +       * v4.4-2.6.23-rc2-x86_64-1.
1303 +
1304 +2007-07-31 Keith Owens  <kaos@sgi.com>
1305 +
1306 +       * Delete obsolete kdba_bt.c.
1307 +       * kdb v4.4-2.6.23-rc1-x86_64-2.
1308 +
1309 +2007-07-30 Keith Owens  <kaos@sgi.com>
1310 +
1311 +       * kdb v4.4-2.6.23-rc1-x86_64-1.
1312 +
1313 +2007-07-26 Keith Owens  <kaos@sgi.com>
1314 +
1315 +       * New x86 backtrace code.
1316 +       * kdb v4.4-2.6.22-x86_64-2.
1317 +
1318 +2007-07-09 Keith Owens  <kaos@sgi.com>
1319 +
1320 +       * kdb v4.4-2.6.22-x86_64-1.
1321 +
1322 +2007-07-02 Keith Owens  <kaos@sgi.com>
1323 +
1324 +       * kdb v4.4-2.6.22-rc7-x86_64-1.
1325 +
1326 +2007-06-25 Keith Owens  <kaos@sgi.com>
1327 +
1328 +       * Hook into DIE_NMIWATCHDOG.
1329 +       * kdb v4.4-2.6.22-rc5-x86_64-2.
1330 +
1331 +2007-06-20 Keith Owens  <kaos@sgi.com>
1332 +
1333 +       * kdb v4.4-2.6.22-rc5-x86_64-1.
1334 +
1335 +2007-06-08 Keith Owens  <kaos@sgi.com>
1336 +
1337 +       * kdb v4.4-2.6.22-rc4-x86_64-1.
1338 +
1339 +2007-05-28 Keith Owens  <kaos@sgi.com>
1340 +
1341 +       * kdb v4.4-2.6.22-rc3-x86_64-1.
1342 +
1343 +2007-05-22 Keith Owens  <kaos@sgi.com>
1344 +
1345 +       * Register KDBENTER_VECTOR early on the boot cpu.
1346 +       * kdb v4.4-2.6.22-rc2-x86_64-2.
1347 +
1348 +2007-05-22 Keith Owens  <kaos@sgi.com>
1349 +
1350 +       * kdb v4.4-2.6.22-rc2-x86_64-1.
1351 +
1352 +2007-05-22 Keith Owens  <kaos@sgi.com>
1353 +
1354 +       * kdb v4.4-2.6.22-rc1-x86_64-1.
1355 +
1356 +2007-05-17 Keith Owens  <kaos@sgi.com>
1357 +
1358 +       * Update dumpregs comments for rdmsr and wrmsr commands.
1359 +         Bernardo Innocenti.
1360 +       * kdb v4.4-2.6.21-x86_64-3.
1361 +
1362 +2007-05-15 Keith Owens  <kaos@sgi.com>
1363 +
1364 +       * Change kdba_late_init to kdba_arch_init so KDB_ENTER() can be used
1365 +         earlier.
1366 +       * kdb v4.4-2.6.21-x86_64-2.
1367 +
1368 +2007-04-29 Keith Owens  <kaos@sgi.com>
1369 +
1370 +       * kdb v4.4-2.6.21-x86_64-1.
1371 +
1372 +2007-04-16 Keith Owens  <kaos@sgi.com>
1373 +
1374 +       * Select KALLSYMS and KALLSYMS_ALL when KDB is selected.
1375 +       * kdb v4.4-2.6.21-rc7-x86_64-2.
1376 +
1377 +2007-04-16 Keith Owens  <kaos@sgi.com>
1378 +
1379 +       * kdb v4.4-2.6.21-rc7-x86_64-1.
1380 +
1381 +2007-04-10 Keith Owens  <kaos@sgi.com>
1382 +
1383 +       * kdb v4.4-2.6.21-rc6-x86_64-1.
1384 +
1385 +2007-04-02 Keith Owens  <kaos@sgi.com>
1386 +
1387 +       * kdb v4.4-2.6.21-rc5-x86_64-1.
1388 +
1389 +2007-03-19 Keith Owens  <kaos@sgi.com>
1390 +
1391 +       * kdb v4.4-2.6.21-rc4-x86_64-1.
1392 +
1393 +2007-03-14 Keith Owens  <kaos@sgi.com>
1394 +
1395 +       * kdb v4.4-2.6.21-rc3-x86_64-1.
1396 +
1397 +2007-03-14 Keith Owens  <kaos@sgi.com>
1398 +
1399 +       * kdb v4.4-2.6.21-rc2-x86_64-1.
1400 +
1401 +2007-03-01 Keith Owens  <kaos@sgi.com>
1402 +
1403 +       * kdb v4.4-2.6.21-rc1-x86_64-1.
1404 +
1405 +2007-03-01 Keith Owens  <kaos@sgi.com>
1406 +
1407 +       * Remove sparse warnings.
1408 +       * kdb v4.4-2.6.20-x86_64-3.
1409 +
1410 +2007-02-16 Keith Owens  <kaos@sgi.com>
1411 +
1412 +       * Initialise variable bits of struct disassemble_info each time.
1413 +       * kdb v4.4-2.6.20-x86_64-2.
1414 +
1415 +2007-02-06 Keith Owens  <kaos@sgi.com>
1416 +
1417 +       * kdb v4.4-2.6.20-x86_64-1.
1418 +
1419 +2007-02-01 Keith Owens  <kaos@sgi.com>
1420 +
1421 +       * kdb v4.4-2.6.20-rc7-x86_64-1.
1422 +
1423 +2007-01-10 Keith Owens  <kaos@sgi.com>
1424 +
1425 +       * Correct setjmp for the FRAME_POINTER=y case.
1426 +       * Remove duplicate longjmp code for FRAME_POINTER=n/y.
1427 +       * kdb v4.4-2.6.20-rc4-x86_64-2.
1428 +
1429 +2007-01-08 Keith Owens  <kaos@sgi.com>
1430 +
1431 +       * kdb v4.4-2.6.20-rc4-x86_64-1.
1432 +
1433 +2007-01-02 Keith Owens  <kaos@sgi.com>
1434 +
1435 +       * kdb v4.4-2.6.20-rc3-x86_64-1.
1436 +
1437 +2006-12-20 Keith Owens  <kaos@sgi.com>
1438 +
1439 +       * kdb v4.4-2.6.20-rc1-x86_64-1.
1440 +
1441 +2006-12-07 Keith Owens  <kaos@sgi.com>
1442 +
1443 +       * Export kdba_dumpregs.
1444 +       * kdb v4.4-2.6.19-x86_64-2.
1445 +
1446 +2006-11-30 Keith Owens  <kaos@sgi.com>
1447 +
1448 +       * kdb v4.4-2.6.19-x86_64-1.
1449 +
1450 +2006-11-27 Keith Owens  <kaos@sgi.com>
1451 +
1452 +       * Only use VT keyboard if the command line allows it and ACPI indicates
1453 +         that there is an i8042.
1454 +       * kdb v4.4-2.6.19-rc6-x86_64-2.
1455 +
1456 +2006-11-20 Keith Owens  <kaos@sgi.com>
1457 +
1458 +       * kdb v4.4-2.6.19-rc6-x86_64-1.
1459 +
1460 +2006-11-09 Keith Owens  <kaos@sgi.com>
1461 +
1462 +       * Only use VT console if the command line allows it.
1463 +       * kdb v4.4-2.6.19-rc5-x86_64-2.
1464 +
1465 +2006-11-08 Keith Owens  <kaos@sgi.com>
1466 +
1467 +       * kdb v4.4-2.6.19-rc5-x86_64-1.
1468 +
1469 +2006-11-01 Keith Owens  <kaos@sgi.com>
1470 +
1471 +       * kdb v4.4-2.6.19-rc4-x86_64-1.
1472 +
1473 +2006-10-24 Keith Owens  <kaos@sgi.com>
1474 +
1475 +       * kdb v4.4-2.6.19-rc3-x86_64-1.
1476 +
1477 +2006-10-24 Keith Owens  <kaos@sgi.com>
1478 +
1479 +       * Remove redundant regs and envp parameters.
1480 +       * kdb v4.4-2.6.19-rc2-x86_64-2.
1481 +
1482 +2006-10-18 Keith Owens  <kaos@sgi.com>
1483 +
1484 +       * kdb v4.4-2.6.19-rc2-x86_64-1.
1485 +
1486 +2006-10-11 Keith Owens  <kaos@sgi.com>
1487 +
1488 +       * Make the KDBENTER_VECTOR an interrupt gate instead of a trap gate, it
1489 +         simplifies the code and disables interrupts on KDB_ENTER().
1490 +       * Exclude the KDBENTER_VECTOR from irq assignment.
1491 +       * Enable KDB_ENTER() again.
1492 +       * kdb v4.4-2.6.19-rc1-x86_64-2.
1493 +
1494 +2006-10-09 Keith Owens  <kaos@sgi.com>
1495 +
1496 +       * KDB_ENTER() is getting spurious activations on some x86_64 hardware.
1497 +         Deactivate KDB_ENTER() until it is fixed.
1498 +       * kdb v4.4-2.6.19-rc1-x86_64-1.
1499 +
1500 +2006-10-06 Keith Owens  <kaos@sgi.com>
1501 +
1502 +       * Remove #include <linux/config.h>
1503 +       * kdb v4.4-2.6.18-x86_64-2.
1504 +
1505 +2006-09-20 Keith Owens  <kaos@sgi.com>
1506 +
1507 +       * kdb v4.4-2.6.18-x86_64-1.
1508 +
1509 +2006-09-15 Keith Owens  <kaos@sgi.com>
1510 +
1511 +       * kdb v4.4-2.6.18-rc7-x86_64-1.
1512 +
1513 +2006-08-30 Keith Owens  <kaos@sgi.com>
1514 +
1515 +       * Do not print debugstackptr in cpu_pda, it will be deleted soon.
1516 +       * Add KDB_ENTER().
1517 +       * Add warning for problems when following alternate stacks.
1518 +       * kdb v4.4-2.6.18-rc5-x86_64-3.
1519 +
1520 +2006-08-29 Keith Owens  <kaos@sgi.com>
1521 +
1522 +       * Rewrite all backtrace code.
1523 +       * Add pt_regs and cpu_pda commands.
1524 +       * Include patch to define orig_ist, to be removed once that patch is in
1525 +         the community tree.
1526 +       * kdb v4.4-2.6.18-rc5-x86_64-2.
1527 +
1528 +2006-08-28 Keith Owens  <kaos@sgi.com>
1529 +
1530 +       * kdb v4.4-2.6.18-rc5-x86_64-1.
1531 +
1532 +2006-08-08 Keith Owens  <kaos@sgi.com>
1533 +
1534 +       * kdb v4.4-2.6.18-rc4-x86_64-1.
1535 +
1536 +2006-08-04 Keith Owens  <kaos@sgi.com>
1537 +
1538 +       * kdb v4.4-2.6.18-rc3-x86_64-1.
1539 +
1540 +2006-07-18 Keith Owens  <kaos@sgi.com>
1541 +
1542 +       * kdb v4.4-2.6.18-rc2-x86_64-1.
1543 +
1544 +2006-07-12 Keith Owens  <kaos@sgi.com>
1545 +
1546 +       * sparse cleanups
1547 +       * kdb v4.4-2.6.18-rc1-x86_64-2.
1548 +
1549 +2006-07-07 Keith Owens  <kaos@sgi.com>
1550 +
1551 +       * kdb v4.4-2.6.18-rc1-x86_64-1.
1552 +
1553 +2006-07-04 Keith Owens  <kaos@sgi.com>
1554 +
1555 +       * Make KDB rendezvous on x86_64 a two stage approach.
1556 +       * Move smp_kdb_stop() and smp_kdb_interrupt() to kdbasupport.c.
1557 +       * Move setting of interrupt traps to kdbasupport.c.
1558 +       * Add KDB_REASON_CPU_UP support.
1559 +       * Move per cpu setup to kdba_cpu_up().
1560 +       * Delete kdba_enable_mce, architectures now do their own setup.
1561 +       * Delete kdba_enable_lbr, kdba_disable_lbr, kdba_print_lbr,
1562 +         page_fault_mca.  Only ever implemented on x86, difficult to maintain
1563 +         and rarely used in the field.
1564 +       * Replace #ifdef KDB_HAVE_LONGJMP with #ifdef kdba_setjmp.
1565 +       * kdb v4.4-2.6.17-x86_64-2.
1566 +
1567 +2006-06-19 Keith Owens  <kaos@sgi.com>
1568 +
1569 +       * kdb v4.4-2.6.17-x86_64-1.
1570 +
1571 +2006-05-31 Keith Owens  <kaos@sgi.com>
1572 +
1573 +       * Define arch/x86_64/kdb/kdb_cmds.
1574 +       * kdb v4.4-2.6.17-rc5-x86_64-2.
1575 +
1576 +2006-05-25 Keith Owens  <kaos@sgi.com>
1577 +
1578 +       * kdb v4.4-2.6.17-rc5-x86_64-1.
1579 +
1580 +2006-05-15 Keith Owens  <kaos@sgi.com>
1581 +
1582 +       * Refresh bfd related files from binutils 2.16.91.0.2.
1583 +       * kdb v4.4-2.6.17-rc4-x86_64-2.
1584 +
1585 +2006-05-12 Keith Owens <kaos@sgi.com>
1586 +
1587 +       * kdb v4.4-2.6-17-rc4-x86_64-1.
1588 +
1589 +2006-04-22 Keith Owens <kaos@sgi.com>
1590 +
1591 +       * kdb v4.4-2.6-17-rc2-x86_64-1.
1592 +
1593 +2006-04-13 Keith Owens <kaos@sgi.com>
1594 +
1595 +       * Remove trailing white space.
1596 +       * kdb v4.4-2.6-17-rc1-x86_64-1.
1597 +
1598 +2006-03-25 Jack F. Vogel <jfv@bluesong.net>
1599 +       * Sync with Keith's changes for 2.6.16
1600 +       * code from Andi Kleen to support above
1601 +
1602 +2005-09-30 Jack F. Vogel <jfv@bluesong.net>
1603 +       * Port to 2.6.14-rc2
1604 +       * sync with a couple changes from Keith
1605 +       * Add backtrace code from Jim Houston
1606 +         (thanks Jim)
1607 +
1608 +2005-08-31 Jack F. Vogel <jfv@bluesong.net>
1609 +       * Change to linker script for kexec
1610 +         thanks to Steven Dake <sdake@mvista.com>
1611 +
1612 +2005-08-30 Jack F. Vogel <jfv@bluesong.net>
1613 +       * Notify struct should not be devinit
1614 +         thanks IWAMOTO Toshihiro <iwamoto@valinux.co.jp>
1615 +
1616 +2005-08-25 Jack F. Vogel <jfv@bluesong.net>
1617 +       * Update to 2.6.11
1618 +       * Fix to synchronize with the notify changes
1619 +         thanks to Jim Houston.
1620 +
1621 +2004-09-30 Keith Owens <kaos@sgi.com>
1622 +       * Port to 2.6.9-rc2
1623 +       * Fix line editting characters.  Jim Houston, Comcast.
1624 +       * kdb v4.4-2.6.9-rc2-x86-64-1.
1625 +
1626 +2004-08-15 Jack F. Vogel <jfv@bluesong.net>
1627 +       * Port to 2.6.8
1628 +       * tighten up the code, using the built-in
1629 +         die_chain notify interface, thanks to
1630 +         Andi Kleen for pointing this out.
1631 +
1632 +2004-05-15 Jack F. Vogel <jfv@bluesong.net>
1633 +       * port to 2.6.6 for x86_64
1634 +
1635 +2003-12-15 Cliff Neighbors <cliff@fabric7.com>
1636 +       * initial port from i386 to x86_64
1637 +
1638 +2002-08-10 Keith Owens  <kaos@sgi.com>
1639 +
1640 +       * Replace kdb_port with kdb_serial to support memory mapped I/O.
1641 +         Note: This needs kdb v2.3-2.4.19-common-2 or later.
1642 +       * kdb v2.3-2.4.19-i386-3.
1643 +
1644 +2002-08-09 Keith Owens  <kaos@sgi.com>
1645 +
1646 +       * Use -fno-optimize-sibling-calls for kdb if gcc supports it.
1647 +       * .text.lock does not consume an activation frame.
1648 +       * kdb v2.3-2.4.19-i386-2.
1649 +
1650 +2002-08-07 Keith Owens  <kaos@sgi.com>
1651 +
1652 +       * Upgrade to 2.4.19.
1653 +       * Remove individual SGI copyrights, the general SGI copyright applies.
1654 +       * New .text.lock name.  Hugh Dickins.
1655 +       * Set KERNEL_CS in kdba_getcurrentframe.  Hugh Dickins.
1656 +       * Clean up disassembly layout.  Hugh Dickins, Keith Owens.
1657 +       * Replace hard coded stack size with THREAD_SIZE.  Hugh Dickins.
1658 +       * Better stack layout on bt with no frame pointers.  Hugh Dickins.
1659 +       * Make i386 IO breakpoints (bpha <address> IO) work again.
1660 +         Martin Wilck, Keith Owens.
1661 +       * Remove fixed KDB_MAX_COMMANDS size.
1662 +       * Add set_fs() around __copy_to_user on kernel addresses.
1663 +         Randolph Chung.
1664 +       * Position i386 for CONFIG_NUMA_REPLICATE.
1665 +       * kdb v2.3-2.4.19-i386-1.
1666 +
1667 +2002-07-09 Keith Owens  <kaos@sgi.com>
1668 +
1669 +       * Upgrade to 2.4.19-rc1.
1670 +
1671 +2002-06-14 Keith Owens  <kaos@sgi.com>
1672 +
1673 +       * Upgrade to 2.4.19-pre10.
1674 +       * kdb v2.1-2.4.19-pre10-i386-1.
1675 +
1676 +2002-04-09 Keith Owens  <kaos@sgi.com>
1677 +
1678 +       * Upgrade to 2.4.19-pre6.
1679 +       * kdb v2.1-2.4.19-pre6-i386-1.
1680 +
1681 +2002-02-26 Keith Owens  <kaos@sgi.com>
1682 +
1683 +       * Upgrade to 2.4.18.
1684 +       * kdb v2.1-2.4.18-i386-1.
1685 +
1686 +2002-01-18 Keith Owens  <kaos@sgi.com>
1687 +
1688 +       * Use new kdb_get/put functions.
1689 +       * Define kdba_{get,put}area_size functions for i386.
1690 +       * Remove over-engineered dblist callback functions.
1691 +       * Correctly handle failing call disp32 in backtrace.
1692 +       * Remove bp_instvalid flag, redundant code.
1693 +       * Remove dead code.
1694 +       * kdb v2.1-2.4.17-i386-1.
1695 +
1696 +2002-01-04 Keith Owens  <kaos@sgi.com>
1697 +
1698 +       * Sync xfs <-> kdb i386 code.
1699 +
1700 --- /dev/null
1701 +++ b/arch/x86/kdb/i386-dis.c
1702 @@ -0,0 +1,4686 @@
1703 +/* Print i386 instructions for GDB, the GNU debugger.
1704 +   Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
1705 +   2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
1706 +
1707 +   This file is part of GDB.
1708 +
1709 +   This program is free software; you can redistribute it and/or modify
1710 +   it under the terms of the GNU General Public License as published by
1711 +   the Free Software Foundation; either version 2 of the License, or
1712 +   (at your option) any later version.
1713 +
1714 +   This program is distributed in the hope that it will be useful,
1715 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
1716 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1717 +   GNU General Public License for more details.
1718 +
1719 +   You should have received a copy of the GNU General Public License
1720 +   along with this program; if not, write to the Free Software
1721 +   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
1722 +
1723 +/* Extracted from binutils 2.16.91.0.2 (OpenSUSE 10.0) and modified for kdb use.
1724 + * Any trailing whitespace was removed and #ifdef/ifndef __KERNEL__ added as
1725 + * required.
1726 + * Keith Owens <kaos@sgi.com> 15 May 2006
1727 + */
1728 +
1729 +/* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
1730 +   July 1988
1731 +    modified by John Hassey (hassey@dg-rtp.dg.com)
1732 +    x86-64 support added by Jan Hubicka (jh@suse.cz)
1733 +    VIA PadLock support by Michal Ludvig (mludvig@suse.cz).  */
1734 +
1735 +/* The main tables describing the instructions is essentially a copy
1736 +   of the "Opcode Map" chapter (Appendix A) of the Intel 80386
1737 +   Programmers Manual.  Usually, there is a capital letter, followed
1738 +   by a small letter.  The capital letter tell the addressing mode,
1739 +   and the small letter tells about the operand size.  Refer to
1740 +   the Intel manual for details.  */
1741 +
1742 +#ifdef __KERNEL__
1743 +#include <linux/kernel.h>
1744 +#include <linux/string.h>
1745 +#include <linux/dis-asm.h>
1746 +#include <linux/kdb.h>
1747 +#define abort() BUG()
1748 +#else  /* __KERNEL__ */
1749 +#include "dis-asm.h"
1750 +#include "sysdep.h"
1751 +#include "opintl.h"
1752 +#endif /* __KERNEL__ */
1753 +
1754 +#define MAXLEN 20
1755 +
1756 +#ifndef __KERNEL__
1757 +#include <setjmp.h>
1758 +#endif /* __KERNEL__ */
1759 +
1760 +#ifndef UNIXWARE_COMPAT
1761 +/* Set non-zero for broken, compatible instructions.  Set to zero for
1762 +   non-broken opcodes.  */
1763 +#define UNIXWARE_COMPAT 1
1764 +#endif
1765 +
1766 +static int fetch_data (struct disassemble_info *, bfd_byte *);
1767 +static void ckprefix (void);
1768 +static const char *prefix_name (int, int);
1769 +static int print_insn (bfd_vma, disassemble_info *);
1770 +static void dofloat (int);
1771 +static void OP_ST (int, int);
1772 +static void OP_STi (int, int);
1773 +static int putop (const char *, int);
1774 +static void oappend (const char *);
1775 +static void append_seg (void);
1776 +static void OP_indirE (int, int);
1777 +static void print_operand_value (char *, int, bfd_vma);
1778 +static void OP_E (int, int);
1779 +static void OP_G (int, int);
1780 +static bfd_vma get64 (void);
1781 +static bfd_signed_vma get32 (void);
1782 +static bfd_signed_vma get32s (void);
1783 +static int get16 (void);
1784 +static void set_op (bfd_vma, int);
1785 +static void OP_REG (int, int);
1786 +static void OP_IMREG (int, int);
1787 +static void OP_I (int, int);
1788 +static void OP_I64 (int, int);
1789 +static void OP_sI (int, int);
1790 +static void OP_J (int, int);
1791 +static void OP_SEG (int, int);
1792 +static void OP_DIR (int, int);
1793 +static void OP_OFF (int, int);
1794 +static void OP_OFF64 (int, int);
1795 +static void ptr_reg (int, int);
1796 +static void OP_ESreg (int, int);
1797 +static void OP_DSreg (int, int);
1798 +static void OP_C (int, int);
1799 +static void OP_D (int, int);
1800 +static void OP_T (int, int);
1801 +static void OP_Rd (int, int);
1802 +static void OP_MMX (int, int);
1803 +static void OP_XMM (int, int);
1804 +static void OP_EM (int, int);
1805 +static void OP_EX (int, int);
1806 +static void OP_MS (int, int);
1807 +static void OP_XS (int, int);
1808 +static void OP_M (int, int);
1809 +static void OP_VMX (int, int);
1810 +static void OP_0fae (int, int);
1811 +static void OP_0f07 (int, int);
1812 +static void NOP_Fixup (int, int);
1813 +static void OP_3DNowSuffix (int, int);
1814 +static void OP_SIMD_Suffix (int, int);
1815 +static void SIMD_Fixup (int, int);
1816 +static void PNI_Fixup (int, int);
1817 +static void SVME_Fixup (int, int);
1818 +static void INVLPG_Fixup (int, int);
1819 +static void BadOp (void);
1820 +static void SEG_Fixup (int, int);
1821 +static void VMX_Fixup (int, int);
1822 +
1823 +struct dis_private {
1824 +  /* Points to first byte not fetched.  */
1825 +  bfd_byte *max_fetched;
1826 +  bfd_byte the_buffer[MAXLEN];
1827 +  bfd_vma insn_start;
1828 +  int orig_sizeflag;
1829 +#ifndef __KERNEL__
1830 +  jmp_buf bailout;
1831 +#endif /* __KERNEL__ */
1832 +};
1833 +
1834 +/* The opcode for the fwait instruction, which we treat as a prefix
1835 +   when we can.  */
1836 +#define FWAIT_OPCODE (0x9b)
1837 +
1838 +/* Set to 1 for 64bit mode disassembly.  */
1839 +static int mode_64bit;
1840 +
1841 +/* Flags for the prefixes for the current instruction.  See below.  */
1842 +static int prefixes;
1843 +
1844 +/* REX prefix the current instruction.  See below.  */
1845 +static int rex;
1846 +/* Bits of REX we've already used.  */
1847 +static int rex_used;
1848 +#define REX_MODE64     8
1849 +#define REX_EXTX       4
1850 +#define REX_EXTY       2
1851 +#define REX_EXTZ       1
1852 +/* Mark parts used in the REX prefix.  When we are testing for
1853 +   empty prefix (for 8bit register REX extension), just mask it
1854 +   out.  Otherwise test for REX bit is excuse for existence of REX
1855 +   only in case value is nonzero.  */
1856 +#define USED_REX(value)                                        \
1857 +  {                                                    \
1858 +    if (value)                                         \
1859 +      rex_used |= (rex & value) ? (value) | 0x40 : 0;  \
1860 +    else                                               \
1861 +      rex_used |= 0x40;                                        \
1862 +  }
1863 +
1864 +/* Flags for prefixes which we somehow handled when printing the
1865 +   current instruction.  */
1866 +static int used_prefixes;
1867 +
1868 +/* Flags stored in PREFIXES.  */
1869 +#define PREFIX_REPZ 1
1870 +#define PREFIX_REPNZ 2
1871 +#define PREFIX_LOCK 4
1872 +#define PREFIX_CS 8
1873 +#define PREFIX_SS 0x10
1874 +#define PREFIX_DS 0x20
1875 +#define PREFIX_ES 0x40
1876 +#define PREFIX_FS 0x80
1877 +#define PREFIX_GS 0x100
1878 +#define PREFIX_DATA 0x200
1879 +#define PREFIX_ADDR 0x400
1880 +#define PREFIX_FWAIT 0x800
1881 +
1882 +/* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
1883 +   to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
1884 +   on error.  */
1885 +#define FETCH_DATA(info, addr) \
1886 +  ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
1887 +   ? 1 : fetch_data ((info), (addr)))
1888 +
1889 +static int
1890 +fetch_data (struct disassemble_info *info, bfd_byte *addr)
1891 +{
1892 +  int status;
1893 +  struct dis_private *priv = (struct dis_private *) info->private_data;
1894 +  bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
1895 +
1896 +  status = (*info->read_memory_func) (start,
1897 +                                     priv->max_fetched,
1898 +                                     addr - priv->max_fetched,
1899 +                                     info);
1900 +  if (status != 0)
1901 +    {
1902 +      /* If we did manage to read at least one byte, then
1903 +        print_insn_i386 will do something sensible.  Otherwise, print
1904 +        an error.  We do that here because this is where we know
1905 +        STATUS.  */
1906 +      if (priv->max_fetched == priv->the_buffer)
1907 +       (*info->memory_error_func) (status, start, info);
1908 +#ifndef __KERNEL__
1909 +      longjmp (priv->bailout, 1);
1910 +#else  /* __KERNEL__ */
1911 +       /* XXX - what to do? */
1912 +       kdb_printf("Hmm. longjmp.\n");
1913 +#endif /* __KERNEL__ */
1914 +    }
1915 +  else
1916 +    priv->max_fetched = addr;
1917 +  return 1;
1918 +}
1919 +
1920 +#define XX NULL, 0
1921 +
1922 +#define Eb OP_E, b_mode
1923 +#define Ev OP_E, v_mode
1924 +#define Ed OP_E, d_mode
1925 +#define Eq OP_E, q_mode
1926 +#define Edq OP_E, dq_mode
1927 +#define Edqw OP_E, dqw_mode
1928 +#define indirEv OP_indirE, branch_v_mode
1929 +#define indirEp OP_indirE, f_mode
1930 +#define Em OP_E, m_mode
1931 +#define Ew OP_E, w_mode
1932 +#define Ma OP_E, v_mode
1933 +#define M OP_M, 0              /* lea, lgdt, etc. */
1934 +#define Mp OP_M, f_mode                /* 32 or 48 bit memory operand for LDS, LES etc */
1935 +#define Gb OP_G, b_mode
1936 +#define Gv OP_G, v_mode
1937 +#define Gd OP_G, d_mode
1938 +#define Gdq OP_G, dq_mode
1939 +#define Gm OP_G, m_mode
1940 +#define Gw OP_G, w_mode
1941 +#define Rd OP_Rd, d_mode
1942 +#define Rm OP_Rd, m_mode
1943 +#define Ib OP_I, b_mode
1944 +#define sIb OP_sI, b_mode      /* sign extened byte */
1945 +#define Iv OP_I, v_mode
1946 +#define Iq OP_I, q_mode
1947 +#define Iv64 OP_I64, v_mode
1948 +#define Iw OP_I, w_mode
1949 +#define I1 OP_I, const_1_mode
1950 +#define Jb OP_J, b_mode
1951 +#define Jv OP_J, v_mode
1952 +#define Cm OP_C, m_mode
1953 +#define Dm OP_D, m_mode
1954 +#define Td OP_T, d_mode
1955 +#define Sv SEG_Fixup, v_mode
1956 +
1957 +#define RMeAX OP_REG, eAX_reg
1958 +#define RMeBX OP_REG, eBX_reg
1959 +#define RMeCX OP_REG, eCX_reg
1960 +#define RMeDX OP_REG, eDX_reg
1961 +#define RMeSP OP_REG, eSP_reg
1962 +#define RMeBP OP_REG, eBP_reg
1963 +#define RMeSI OP_REG, eSI_reg
1964 +#define RMeDI OP_REG, eDI_reg
1965 +#define RMrAX OP_REG, rAX_reg
1966 +#define RMrBX OP_REG, rBX_reg
1967 +#define RMrCX OP_REG, rCX_reg
1968 +#define RMrDX OP_REG, rDX_reg
1969 +#define RMrSP OP_REG, rSP_reg
1970 +#define RMrBP OP_REG, rBP_reg
1971 +#define RMrSI OP_REG, rSI_reg
1972 +#define RMrDI OP_REG, rDI_reg
1973 +#define RMAL OP_REG, al_reg
1974 +#define RMAL OP_REG, al_reg
1975 +#define RMCL OP_REG, cl_reg
1976 +#define RMDL OP_REG, dl_reg
1977 +#define RMBL OP_REG, bl_reg
1978 +#define RMAH OP_REG, ah_reg
1979 +#define RMCH OP_REG, ch_reg
1980 +#define RMDH OP_REG, dh_reg
1981 +#define RMBH OP_REG, bh_reg
1982 +#define RMAX OP_REG, ax_reg
1983 +#define RMDX OP_REG, dx_reg
1984 +
1985 +#define eAX OP_IMREG, eAX_reg
1986 +#define eBX OP_IMREG, eBX_reg
1987 +#define eCX OP_IMREG, eCX_reg
1988 +#define eDX OP_IMREG, eDX_reg
1989 +#define eSP OP_IMREG, eSP_reg
1990 +#define eBP OP_IMREG, eBP_reg
1991 +#define eSI OP_IMREG, eSI_reg
1992 +#define eDI OP_IMREG, eDI_reg
1993 +#define AL OP_IMREG, al_reg
1994 +#define AL OP_IMREG, al_reg
1995 +#define CL OP_IMREG, cl_reg
1996 +#define DL OP_IMREG, dl_reg
1997 +#define BL OP_IMREG, bl_reg
1998 +#define AH OP_IMREG, ah_reg
1999 +#define CH OP_IMREG, ch_reg
2000 +#define DH OP_IMREG, dh_reg
2001 +#define BH OP_IMREG, bh_reg
2002 +#define AX OP_IMREG, ax_reg
2003 +#define DX OP_IMREG, dx_reg
2004 +#define indirDX OP_IMREG, indir_dx_reg
2005 +
2006 +#define Sw OP_SEG, w_mode
2007 +#define Ap OP_DIR, 0
2008 +#define Ob OP_OFF, b_mode
2009 +#define Ob64 OP_OFF64, b_mode
2010 +#define Ov OP_OFF, v_mode
2011 +#define Ov64 OP_OFF64, v_mode
2012 +#define Xb OP_DSreg, eSI_reg
2013 +#define Xv OP_DSreg, eSI_reg
2014 +#define Yb OP_ESreg, eDI_reg
2015 +#define Yv OP_ESreg, eDI_reg
2016 +#define DSBX OP_DSreg, eBX_reg
2017 +
2018 +#define es OP_REG, es_reg
2019 +#define ss OP_REG, ss_reg
2020 +#define cs OP_REG, cs_reg
2021 +#define ds OP_REG, ds_reg
2022 +#define fs OP_REG, fs_reg
2023 +#define gs OP_REG, gs_reg
2024 +
2025 +#define MX OP_MMX, 0
2026 +#define XM OP_XMM, 0
2027 +#define EM OP_EM, v_mode
2028 +#define EX OP_EX, v_mode
2029 +#define MS OP_MS, v_mode
2030 +#define XS OP_XS, v_mode
2031 +#define VM OP_VMX, q_mode
2032 +#define OPSUF OP_3DNowSuffix, 0
2033 +#define OPSIMD OP_SIMD_Suffix, 0
2034 +
2035 +#define cond_jump_flag NULL, cond_jump_mode
2036 +#define loop_jcxz_flag NULL, loop_jcxz_mode
2037 +
2038 +/* bits in sizeflag */
2039 +#define SUFFIX_ALWAYS 4
2040 +#define AFLAG 2
2041 +#define DFLAG 1
2042 +
2043 +#define b_mode 1  /* byte operand */
2044 +#define v_mode 2  /* operand size depends on prefixes */
2045 +#define w_mode 3  /* word operand */
2046 +#define d_mode 4  /* double word operand  */
2047 +#define q_mode 5  /* quad word operand */
2048 +#define t_mode 6  /* ten-byte operand */
2049 +#define x_mode 7  /* 16-byte XMM operand */
2050 +#define m_mode 8  /* d_mode in 32bit, q_mode in 64bit mode.  */
2051 +#define cond_jump_mode 9
2052 +#define loop_jcxz_mode 10
2053 +#define dq_mode 11 /* operand size depends on REX prefixes.  */
2054 +#define dqw_mode 12 /* registers like dq_mode, memory like w_mode.  */
2055 +#define f_mode 13 /* 4- or 6-byte pointer operand */
2056 +#define const_1_mode 14
2057 +#define branch_v_mode 15 /* v_mode for branch.  */
2058 +
2059 +#define es_reg 100
2060 +#define cs_reg 101
2061 +#define ss_reg 102
2062 +#define ds_reg 103
2063 +#define fs_reg 104
2064 +#define gs_reg 105
2065 +
2066 +#define eAX_reg 108
2067 +#define eCX_reg 109
2068 +#define eDX_reg 110
2069 +#define eBX_reg 111
2070 +#define eSP_reg 112
2071 +#define eBP_reg 113
2072 +#define eSI_reg 114
2073 +#define eDI_reg 115
2074 +
2075 +#define al_reg 116
2076 +#define cl_reg 117
2077 +#define dl_reg 118
2078 +#define bl_reg 119
2079 +#define ah_reg 120
2080 +#define ch_reg 121
2081 +#define dh_reg 122
2082 +#define bh_reg 123
2083 +
2084 +#define ax_reg 124
2085 +#define cx_reg 125
2086 +#define dx_reg 126
2087 +#define bx_reg 127
2088 +#define sp_reg 128
2089 +#define bp_reg 129
2090 +#define si_reg 130
2091 +#define di_reg 131
2092 +
2093 +#define rAX_reg 132
2094 +#define rCX_reg 133
2095 +#define rDX_reg 134
2096 +#define rBX_reg 135
2097 +#define rSP_reg 136
2098 +#define rBP_reg 137
2099 +#define rSI_reg 138
2100 +#define rDI_reg 139
2101 +
2102 +#define indir_dx_reg 150
2103 +
2104 +#define FLOATCODE 1
2105 +#define USE_GROUPS 2
2106 +#define USE_PREFIX_USER_TABLE 3
2107 +#define X86_64_SPECIAL 4
2108 +
2109 +#define FLOAT    NULL, NULL, FLOATCODE, NULL, 0, NULL, 0
2110 +
2111 +#define GRP1b    NULL, NULL, USE_GROUPS, NULL,  0, NULL, 0
2112 +#define GRP1S    NULL, NULL, USE_GROUPS, NULL,  1, NULL, 0
2113 +#define GRP1Ss   NULL, NULL, USE_GROUPS, NULL,  2, NULL, 0
2114 +#define GRP2b    NULL, NULL, USE_GROUPS, NULL,  3, NULL, 0
2115 +#define GRP2S    NULL, NULL, USE_GROUPS, NULL,  4, NULL, 0
2116 +#define GRP2b_one NULL, NULL, USE_GROUPS, NULL,  5, NULL, 0
2117 +#define GRP2S_one NULL, NULL, USE_GROUPS, NULL,  6, NULL, 0
2118 +#define GRP2b_cl  NULL, NULL, USE_GROUPS, NULL,  7, NULL, 0
2119 +#define GRP2S_cl  NULL, NULL, USE_GROUPS, NULL,  8, NULL, 0
2120 +#define GRP3b    NULL, NULL, USE_GROUPS, NULL,  9, NULL, 0
2121 +#define GRP3S    NULL, NULL, USE_GROUPS, NULL, 10, NULL, 0
2122 +#define GRP4     NULL, NULL, USE_GROUPS, NULL, 11, NULL, 0
2123 +#define GRP5     NULL, NULL, USE_GROUPS, NULL, 12, NULL, 0
2124 +#define GRP6     NULL, NULL, USE_GROUPS, NULL, 13, NULL, 0
2125 +#define GRP7     NULL, NULL, USE_GROUPS, NULL, 14, NULL, 0
2126 +#define GRP8     NULL, NULL, USE_GROUPS, NULL, 15, NULL, 0
2127 +#define GRP9     NULL, NULL, USE_GROUPS, NULL, 16, NULL, 0
2128 +#define GRP10    NULL, NULL, USE_GROUPS, NULL, 17, NULL, 0
2129 +#define GRP11    NULL, NULL, USE_GROUPS, NULL, 18, NULL, 0
2130 +#define GRP12    NULL, NULL, USE_GROUPS, NULL, 19, NULL, 0
2131 +#define GRP13    NULL, NULL, USE_GROUPS, NULL, 20, NULL, 0
2132 +#define GRP14    NULL, NULL, USE_GROUPS, NULL, 21, NULL, 0
2133 +#define GRPAMD   NULL, NULL, USE_GROUPS, NULL, 22, NULL, 0
2134 +#define GRPPADLCK1 NULL, NULL, USE_GROUPS, NULL, 23, NULL, 0
2135 +#define GRPPADLCK2 NULL, NULL, USE_GROUPS, NULL, 24, NULL, 0
2136 +
2137 +#define PREGRP0   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  0, NULL, 0
2138 +#define PREGRP1   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  1, NULL, 0
2139 +#define PREGRP2   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  2, NULL, 0
2140 +#define PREGRP3   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  3, NULL, 0
2141 +#define PREGRP4   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  4, NULL, 0
2142 +#define PREGRP5   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  5, NULL, 0
2143 +#define PREGRP6   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  6, NULL, 0
2144 +#define PREGRP7   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  7, NULL, 0
2145 +#define PREGRP8   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  8, NULL, 0
2146 +#define PREGRP9   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  9, NULL, 0
2147 +#define PREGRP10  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 10, NULL, 0
2148 +#define PREGRP11  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 11, NULL, 0
2149 +#define PREGRP12  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 12, NULL, 0
2150 +#define PREGRP13  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 13, NULL, 0
2151 +#define PREGRP14  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 14, NULL, 0
2152 +#define PREGRP15  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 15, NULL, 0
2153 +#define PREGRP16  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 16, NULL, 0
2154 +#define PREGRP17  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 17, NULL, 0
2155 +#define PREGRP18  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 18, NULL, 0
2156 +#define PREGRP19  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 19, NULL, 0
2157 +#define PREGRP20  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 20, NULL, 0
2158 +#define PREGRP21  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 21, NULL, 0
2159 +#define PREGRP22  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 22, NULL, 0
2160 +#define PREGRP23  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 23, NULL, 0
2161 +#define PREGRP24  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0
2162 +#define PREGRP25  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0
2163 +#define PREGRP26  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 26, NULL, 0
2164 +#define PREGRP27  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 27, NULL, 0
2165 +#define PREGRP28  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 28, NULL, 0
2166 +#define PREGRP29  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 29, NULL, 0
2167 +#define PREGRP30  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 30, NULL, 0
2168 +#define PREGRP31  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 31, NULL, 0
2169 +#define PREGRP32  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 32, NULL, 0
2170 +
2171 +#define X86_64_0  NULL, NULL, X86_64_SPECIAL, NULL,  0, NULL, 0
2172 +
2173 +typedef void (*op_rtn) (int bytemode, int sizeflag);
2174 +
2175 +struct dis386 {
2176 +  const char *name;
2177 +  op_rtn op1;
2178 +  int bytemode1;
2179 +  op_rtn op2;
2180 +  int bytemode2;
2181 +  op_rtn op3;
2182 +  int bytemode3;
2183 +};
2184 +
2185 +/* Upper case letters in the instruction names here are macros.
2186 +   'A' => print 'b' if no register operands or suffix_always is true
2187 +   'B' => print 'b' if suffix_always is true
2188 +   'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
2189 +   .      size prefix
2190 +   'E' => print 'e' if 32-bit form of jcxz
2191 +   'F' => print 'w' or 'l' depending on address size prefix (loop insns)
2192 +   'H' => print ",pt" or ",pn" branch hint
2193 +   'I' => honor following macro letter even in Intel mode (implemented only
2194 +   .      for some of the macro letters)
2195 +   'J' => print 'l'
2196 +   'L' => print 'l' if suffix_always is true
2197 +   'N' => print 'n' if instruction has no wait "prefix"
2198 +   'O' => print 'd', or 'o'
2199 +   'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
2200 +   .      or suffix_always is true.  print 'q' if rex prefix is present.
2201 +   'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always
2202 +   .      is true
2203 +   'R' => print 'w', 'l' or 'q' ("wd" or "dq" in intel mode)
2204 +   'S' => print 'w', 'l' or 'q' if suffix_always is true
2205 +   'T' => print 'q' in 64bit mode and behave as 'P' otherwise
2206 +   'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
2207 +   'W' => print 'b' or 'w' ("w" or "de" in intel mode)
2208 +   'X' => print 's', 'd' depending on data16 prefix (for XMM)
2209 +   'Y' => 'q' if instruction has an REX 64bit overwrite prefix
2210 +
2211 +   Many of the above letters print nothing in Intel mode.  See "putop"
2212 +   for the details.
2213 +
2214 +   Braces '{' and '}', and vertical bars '|', indicate alternative
2215 +   mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel
2216 +   modes.  In cases where there are only two alternatives, the X86_64
2217 +   instruction is reserved, and "(bad)" is printed.
2218 +*/
2219 +
2220 +static const struct dis386 dis386[] = {
2221 +  /* 00 */
2222 +  { "addB",            Eb, Gb, XX },
2223 +  { "addS",            Ev, Gv, XX },
2224 +  { "addB",            Gb, Eb, XX },
2225 +  { "addS",            Gv, Ev, XX },
2226 +  { "addB",            AL, Ib, XX },
2227 +  { "addS",            eAX, Iv, XX },
2228 +  { "push{T|}",                es, XX, XX },
2229 +  { "pop{T|}",         es, XX, XX },
2230 +  /* 08 */
2231 +  { "orB",             Eb, Gb, XX },
2232 +  { "orS",             Ev, Gv, XX },
2233 +  { "orB",             Gb, Eb, XX },
2234 +  { "orS",             Gv, Ev, XX },
2235 +  { "orB",             AL, Ib, XX },
2236 +  { "orS",             eAX, Iv, XX },
2237 +  { "push{T|}",                cs, XX, XX },
2238 +  { "(bad)",           XX, XX, XX },   /* 0x0f extended opcode escape */
2239 +  /* 10 */
2240 +  { "adcB",            Eb, Gb, XX },
2241 +  { "adcS",            Ev, Gv, XX },
2242 +  { "adcB",            Gb, Eb, XX },
2243 +  { "adcS",            Gv, Ev, XX },
2244 +  { "adcB",            AL, Ib, XX },
2245 +  { "adcS",            eAX, Iv, XX },
2246 +  { "push{T|}",                ss, XX, XX },
2247 +  { "popT|}",          ss, XX, XX },
2248 +  /* 18 */
2249 +  { "sbbB",            Eb, Gb, XX },
2250 +  { "sbbS",            Ev, Gv, XX },
2251 +  { "sbbB",            Gb, Eb, XX },
2252 +  { "sbbS",            Gv, Ev, XX },
2253 +  { "sbbB",            AL, Ib, XX },
2254 +  { "sbbS",            eAX, Iv, XX },
2255 +  { "push{T|}",                ds, XX, XX },
2256 +  { "pop{T|}",         ds, XX, XX },
2257 +  /* 20 */
2258 +  { "andB",            Eb, Gb, XX },
2259 +  { "andS",            Ev, Gv, XX },
2260 +  { "andB",            Gb, Eb, XX },
2261 +  { "andS",            Gv, Ev, XX },
2262 +  { "andB",            AL, Ib, XX },
2263 +  { "andS",            eAX, Iv, XX },
2264 +  { "(bad)",           XX, XX, XX },   /* SEG ES prefix */
2265 +  { "daa{|}",          XX, XX, XX },
2266 +  /* 28 */
2267 +  { "subB",            Eb, Gb, XX },
2268 +  { "subS",            Ev, Gv, XX },
2269 +  { "subB",            Gb, Eb, XX },
2270 +  { "subS",            Gv, Ev, XX },
2271 +  { "subB",            AL, Ib, XX },
2272 +  { "subS",            eAX, Iv, XX },
2273 +  { "(bad)",           XX, XX, XX },   /* SEG CS prefix */
2274 +  { "das{|}",          XX, XX, XX },
2275 +  /* 30 */
2276 +  { "xorB",            Eb, Gb, XX },
2277 +  { "xorS",            Ev, Gv, XX },
2278 +  { "xorB",            Gb, Eb, XX },
2279 +  { "xorS",            Gv, Ev, XX },
2280 +  { "xorB",            AL, Ib, XX },
2281 +  { "xorS",            eAX, Iv, XX },
2282 +  { "(bad)",           XX, XX, XX },   /* SEG SS prefix */
2283 +  { "aaa{|}",          XX, XX, XX },
2284 +  /* 38 */
2285 +  { "cmpB",            Eb, Gb, XX },
2286 +  { "cmpS",            Ev, Gv, XX },
2287 +  { "cmpB",            Gb, Eb, XX },
2288 +  { "cmpS",            Gv, Ev, XX },
2289 +  { "cmpB",            AL, Ib, XX },
2290 +  { "cmpS",            eAX, Iv, XX },
2291 +  { "(bad)",           XX, XX, XX },   /* SEG DS prefix */
2292 +  { "aas{|}",          XX, XX, XX },
2293 +  /* 40 */
2294 +  { "inc{S|}",         RMeAX, XX, XX },
2295 +  { "inc{S|}",         RMeCX, XX, XX },
2296 +  { "inc{S|}",         RMeDX, XX, XX },
2297 +  { "inc{S|}",         RMeBX, XX, XX },
2298 +  { "inc{S|}",         RMeSP, XX, XX },
2299 +  { "inc{S|}",         RMeBP, XX, XX },
2300 +  { "inc{S|}",         RMeSI, XX, XX },
2301 +  { "inc{S|}",         RMeDI, XX, XX },
2302 +  /* 48 */
2303 +  { "dec{S|}",         RMeAX, XX, XX },
2304 +  { "dec{S|}",         RMeCX, XX, XX },
2305 +  { "dec{S|}",         RMeDX, XX, XX },
2306 +  { "dec{S|}",         RMeBX, XX, XX },
2307 +  { "dec{S|}",         RMeSP, XX, XX },
2308 +  { "dec{S|}",         RMeBP, XX, XX },
2309 +  { "dec{S|}",         RMeSI, XX, XX },
2310 +  { "dec{S|}",         RMeDI, XX, XX },
2311 +  /* 50 */
2312 +  { "pushS",           RMrAX, XX, XX },
2313 +  { "pushS",           RMrCX, XX, XX },
2314 +  { "pushS",           RMrDX, XX, XX },
2315 +  { "pushS",           RMrBX, XX, XX },
2316 +  { "pushS",           RMrSP, XX, XX },
2317 +  { "pushS",           RMrBP, XX, XX },
2318 +  { "pushS",           RMrSI, XX, XX },
2319 +  { "pushS",           RMrDI, XX, XX },
2320 +  /* 58 */
2321 +  { "popS",            RMrAX, XX, XX },
2322 +  { "popS",            RMrCX, XX, XX },
2323 +  { "popS",            RMrDX, XX, XX },
2324 +  { "popS",            RMrBX, XX, XX },
2325 +  { "popS",            RMrSP, XX, XX },
2326 +  { "popS",            RMrBP, XX, XX },
2327 +  { "popS",            RMrSI, XX, XX },
2328 +  { "popS",            RMrDI, XX, XX },
2329 +  /* 60 */
2330 +  { "pusha{P|}",       XX, XX, XX },
2331 +  { "popa{P|}",                XX, XX, XX },
2332 +  { "bound{S|}",       Gv, Ma, XX },
2333 +  { X86_64_0 },
2334 +  { "(bad)",           XX, XX, XX },   /* seg fs */
2335 +  { "(bad)",           XX, XX, XX },   /* seg gs */
2336 +  { "(bad)",           XX, XX, XX },   /* op size prefix */
2337 +  { "(bad)",           XX, XX, XX },   /* adr size prefix */
2338 +  /* 68 */
2339 +  { "pushT",           Iq, XX, XX },
2340 +  { "imulS",           Gv, Ev, Iv },
2341 +  { "pushT",           sIb, XX, XX },
2342 +  { "imulS",           Gv, Ev, sIb },
2343 +  { "ins{b||b|}",      Yb, indirDX, XX },
2344 +  { "ins{R||R|}",      Yv, indirDX, XX },
2345 +  { "outs{b||b|}",     indirDX, Xb, XX },
2346 +  { "outs{R||R|}",     indirDX, Xv, XX },
2347 +  /* 70 */
2348 +  { "joH",             Jb, XX, cond_jump_flag },
2349 +  { "jnoH",            Jb, XX, cond_jump_flag },
2350 +  { "jbH",             Jb, XX, cond_jump_flag },
2351 +  { "jaeH",            Jb, XX, cond_jump_flag },
2352 +  { "jeH",             Jb, XX, cond_jump_flag },
2353 +  { "jneH",            Jb, XX, cond_jump_flag },
2354 +  { "jbeH",            Jb, XX, cond_jump_flag },
2355 +  { "jaH",             Jb, XX, cond_jump_flag },
2356 +  /* 78 */
2357 +  { "jsH",             Jb, XX, cond_jump_flag },
2358 +  { "jnsH",            Jb, XX, cond_jump_flag },
2359 +  { "jpH",             Jb, XX, cond_jump_flag },
2360 +  { "jnpH",            Jb, XX, cond_jump_flag },
2361 +  { "jlH",             Jb, XX, cond_jump_flag },
2362 +  { "jgeH",            Jb, XX, cond_jump_flag },
2363 +  { "jleH",            Jb, XX, cond_jump_flag },
2364 +  { "jgH",             Jb, XX, cond_jump_flag },
2365 +  /* 80 */
2366 +  { GRP1b },
2367 +  { GRP1S },
2368 +  { "(bad)",           XX, XX, XX },
2369 +  { GRP1Ss },
2370 +  { "testB",           Eb, Gb, XX },
2371 +  { "testS",           Ev, Gv, XX },
2372 +  { "xchgB",           Eb, Gb, XX },
2373 +  { "xchgS",           Ev, Gv, XX },
2374 +  /* 88 */
2375 +  { "movB",            Eb, Gb, XX },
2376 +  { "movS",            Ev, Gv, XX },
2377 +  { "movB",            Gb, Eb, XX },
2378 +  { "movS",            Gv, Ev, XX },
2379 +  { "movQ",            Sv, Sw, XX },
2380 +  { "leaS",            Gv, M, XX },
2381 +  { "movQ",            Sw, Sv, XX },
2382 +  { "popU",            Ev, XX, XX },
2383 +  /* 90 */
2384 +  { "nop",             NOP_Fixup, 0, XX, XX },
2385 +  { "xchgS",           RMeCX, eAX, XX },
2386 +  { "xchgS",           RMeDX, eAX, XX },
2387 +  { "xchgS",           RMeBX, eAX, XX },
2388 +  { "xchgS",           RMeSP, eAX, XX },
2389 +  { "xchgS",           RMeBP, eAX, XX },
2390 +  { "xchgS",           RMeSI, eAX, XX },
2391 +  { "xchgS",           RMeDI, eAX, XX },
2392 +  /* 98 */
2393 +  { "cW{tR||tR|}",     XX, XX, XX },
2394 +  { "cR{tO||tO|}",     XX, XX, XX },
2395 +  { "Jcall{T|}",       Ap, XX, XX },
2396 +  { "(bad)",           XX, XX, XX },   /* fwait */
2397 +  { "pushfT",          XX, XX, XX },
2398 +  { "popfT",           XX, XX, XX },
2399 +  { "sahf{|}",         XX, XX, XX },
2400 +  { "lahf{|}",         XX, XX, XX },
2401 +  /* a0 */
2402 +  { "movB",            AL, Ob64, XX },
2403 +  { "movS",            eAX, Ov64, XX },
2404 +  { "movB",            Ob64, AL, XX },
2405 +  { "movS",            Ov64, eAX, XX },
2406 +  { "movs{b||b|}",     Yb, Xb, XX },
2407 +  { "movs{R||R|}",     Yv, Xv, XX },
2408 +  { "cmps{b||b|}",     Xb, Yb, XX },
2409 +  { "cmps{R||R|}",     Xv, Yv, XX },
2410 +  /* a8 */
2411 +  { "testB",           AL, Ib, XX },
2412 +  { "testS",           eAX, Iv, XX },
2413 +  { "stosB",           Yb, AL, XX },
2414 +  { "stosS",           Yv, eAX, XX },
2415 +  { "lodsB",           AL, Xb, XX },
2416 +  { "lodsS",           eAX, Xv, XX },
2417 +  { "scasB",           AL, Yb, XX },
2418 +  { "scasS",           eAX, Yv, XX },
2419 +  /* b0 */
2420 +  { "movB",            RMAL, Ib, XX },
2421 +  { "movB",            RMCL, Ib, XX },
2422 +  { "movB",            RMDL, Ib, XX },
2423 +  { "movB",            RMBL, Ib, XX },
2424 +  { "movB",            RMAH, Ib, XX },
2425 +  { "movB",            RMCH, Ib, XX },
2426 +  { "movB",            RMDH, Ib, XX },
2427 +  { "movB",            RMBH, Ib, XX },
2428 +  /* b8 */
2429 +  { "movS",            RMeAX, Iv64, XX },
2430 +  { "movS",            RMeCX, Iv64, XX },
2431 +  { "movS",            RMeDX, Iv64, XX },
2432 +  { "movS",            RMeBX, Iv64, XX },
2433 +  { "movS",            RMeSP, Iv64, XX },
2434 +  { "movS",            RMeBP, Iv64, XX },
2435 +  { "movS",            RMeSI, Iv64, XX },
2436 +  { "movS",            RMeDI, Iv64, XX },
2437 +  /* c0 */
2438 +  { GRP2b },
2439 +  { GRP2S },
2440 +  { "retT",            Iw, XX, XX },
2441 +  { "retT",            XX, XX, XX },
2442 +  { "les{S|}",         Gv, Mp, XX },
2443 +  { "ldsS",            Gv, Mp, XX },
2444 +  { "movA",            Eb, Ib, XX },
2445 +  { "movQ",            Ev, Iv, XX },
2446 +  /* c8 */
2447 +  { "enterT",          Iw, Ib, XX },
2448 +  { "leaveT",          XX, XX, XX },
2449 +  { "lretP",           Iw, XX, XX },
2450 +  { "lretP",           XX, XX, XX },
2451 +  { "int3",            XX, XX, XX },
2452 +  { "int",             Ib, XX, XX },
2453 +  { "into{|}",         XX, XX, XX },
2454 +  { "iretP",           XX, XX, XX },
2455 +  /* d0 */
2456 +  { GRP2b_one },
2457 +  { GRP2S_one },
2458 +  { GRP2b_cl },
2459 +  { GRP2S_cl },
2460 +  { "aam{|}",          sIb, XX, XX },
2461 +  { "aad{|}",          sIb, XX, XX },
2462 +  { "(bad)",           XX, XX, XX },
2463 +  { "xlat",            DSBX, XX, XX },
2464 +  /* d8 */
2465 +  { FLOAT },
2466 +  { FLOAT },
2467 +  { FLOAT },
2468 +  { FLOAT },
2469 +  { FLOAT },
2470 +  { FLOAT },
2471 +  { FLOAT },
2472 +  { FLOAT },
2473 +  /* e0 */
2474 +  { "loopneFH",                Jb, XX, loop_jcxz_flag },
2475 +  { "loopeFH",         Jb, XX, loop_jcxz_flag },
2476 +  { "loopFH",          Jb, XX, loop_jcxz_flag },
2477 +  { "jEcxzH",          Jb, XX, loop_jcxz_flag },
2478 +  { "inB",             AL, Ib, XX },
2479 +  { "inS",             eAX, Ib, XX },
2480 +  { "outB",            Ib, AL, XX },
2481 +  { "outS",            Ib, eAX, XX },
2482 +  /* e8 */
2483 +  { "callT",           Jv, XX, XX },
2484 +  { "jmpT",            Jv, XX, XX },
2485 +  { "Jjmp{T|}",                Ap, XX, XX },
2486 +  { "jmp",             Jb, XX, XX },
2487 +  { "inB",             AL, indirDX, XX },
2488 +  { "inS",             eAX, indirDX, XX },
2489 +  { "outB",            indirDX, AL, XX },
2490 +  { "outS",            indirDX, eAX, XX },
2491 +  /* f0 */
2492 +  { "(bad)",           XX, XX, XX },   /* lock prefix */
2493 +  { "icebp",           XX, XX, XX },
2494 +  { "(bad)",           XX, XX, XX },   /* repne */
2495 +  { "(bad)",           XX, XX, XX },   /* repz */
2496 +  { "hlt",             XX, XX, XX },
2497 +  { "cmc",             XX, XX, XX },
2498 +  { GRP3b },
2499 +  { GRP3S },
2500 +  /* f8 */
2501 +  { "clc",             XX, XX, XX },
2502 +  { "stc",             XX, XX, XX },
2503 +  { "cli",             XX, XX, XX },
2504 +  { "sti",             XX, XX, XX },
2505 +  { "cld",             XX, XX, XX },
2506 +  { "std",             XX, XX, XX },
2507 +  { GRP4 },
2508 +  { GRP5 },
2509 +};
2510 +
2511 +static const struct dis386 dis386_twobyte[] = {
2512 +  /* 00 */
2513 +  { GRP6 },
2514 +  { GRP7 },
2515 +  { "larS",            Gv, Ew, XX },
2516 +  { "lslS",            Gv, Ew, XX },
2517 +  { "(bad)",           XX, XX, XX },
2518 +  { "syscall",         XX, XX, XX },
2519 +  { "clts",            XX, XX, XX },
2520 +  { "sysretP",         XX, XX, XX },
2521 +  /* 08 */
2522 +  { "invd",            XX, XX, XX },
2523 +  { "wbinvd",          XX, XX, XX },
2524 +  { "(bad)",           XX, XX, XX },
2525 +  { "ud2a",            XX, XX, XX },
2526 +  { "(bad)",           XX, XX, XX },
2527 +  { GRPAMD },
2528 +  { "femms",           XX, XX, XX },
2529 +  { "",                        MX, EM, OPSUF }, /* See OP_3DNowSuffix.  */
2530 +  /* 10 */
2531 +  { PREGRP8 },
2532 +  { PREGRP9 },
2533 +  { PREGRP30 },
2534 +  { "movlpX",          EX, XM, SIMD_Fixup, 'h' },
2535 +  { "unpcklpX",                XM, EX, XX },
2536 +  { "unpckhpX",                XM, EX, XX },
2537 +  { PREGRP31 },
2538 +  { "movhpX",          EX, XM, SIMD_Fixup, 'l' },
2539 +  /* 18 */
2540 +  { GRP14 },
2541 +  { "(bad)",           XX, XX, XX },
2542 +  { "(bad)",           XX, XX, XX },
2543 +  { "(bad)",           XX, XX, XX },
2544 +  { "(bad)",           XX, XX, XX },
2545 +  { "(bad)",           XX, XX, XX },
2546 +  { "(bad)",           XX, XX, XX },
2547 +  { "(bad)",           XX, XX, XX },
2548 +  /* 20 */
2549 +  { "movL",            Rm, Cm, XX },
2550 +  { "movL",            Rm, Dm, XX },
2551 +  { "movL",            Cm, Rm, XX },
2552 +  { "movL",            Dm, Rm, XX },
2553 +  { "movL",            Rd, Td, XX },
2554 +  { "(bad)",           XX, XX, XX },
2555 +  { "movL",            Td, Rd, XX },
2556 +  { "(bad)",           XX, XX, XX },
2557 +  /* 28 */
2558 +  { "movapX",          XM, EX, XX },
2559 +  { "movapX",          EX, XM, XX },
2560 +  { PREGRP2 },
2561 +  { "movntpX",         Ev, XM, XX },
2562 +  { PREGRP4 },
2563 +  { PREGRP3 },
2564 +  { "ucomisX",         XM,EX, XX },
2565 +  { "comisX",          XM,EX, XX },
2566 +  /* 30 */
2567 +  { "wrmsr",           XX, XX, XX },
2568 +  { "rdtsc",           XX, XX, XX },
2569 +  { "rdmsr",           XX, XX, XX },
2570 +  { "rdpmc",           XX, XX, XX },
2571 +  { "sysenter",                XX, XX, XX },
2572 +  { "sysexit",         XX, XX, XX },
2573 +  { "(bad)",           XX, XX, XX },
2574 +  { "(bad)",           XX, XX, XX },
2575 +  /* 38 */
2576 +  { "(bad)",           XX, XX, XX },
2577 +  { "(bad)",           XX, XX, XX },
2578 +  { "(bad)",           XX, XX, XX },
2579 +  { "(bad)",           XX, XX, XX },
2580 +  { "(bad)",           XX, XX, XX },
2581 +  { "(bad)",           XX, XX, XX },
2582 +  { "(bad)",           XX, XX, XX },
2583 +  { "(bad)",           XX, XX, XX },
2584 +  /* 40 */
2585 +  { "cmovo",           Gv, Ev, XX },
2586 +  { "cmovno",          Gv, Ev, XX },
2587 +  { "cmovb",           Gv, Ev, XX },
2588 +  { "cmovae",          Gv, Ev, XX },
2589 +  { "cmove",           Gv, Ev, XX },
2590 +  { "cmovne",          Gv, Ev, XX },
2591 +  { "cmovbe",          Gv, Ev, XX },
2592 +  { "cmova",           Gv, Ev, XX },
2593 +  /* 48 */
2594 +  { "cmovs",           Gv, Ev, XX },
2595 +  { "cmovns",          Gv, Ev, XX },
2596 +  { "cmovp",           Gv, Ev, XX },
2597 +  { "cmovnp",          Gv, Ev, XX },
2598 +  { "cmovl",           Gv, Ev, XX },
2599 +  { "cmovge",          Gv, Ev, XX },
2600 +  { "cmovle",          Gv, Ev, XX },
2601 +  { "cmovg",           Gv, Ev, XX },
2602 +  /* 50 */
2603 +  { "movmskpX",                Gdq, XS, XX },
2604 +  { PREGRP13 },
2605 +  { PREGRP12 },
2606 +  { PREGRP11 },
2607 +  { "andpX",           XM, EX, XX },
2608 +  { "andnpX",          XM, EX, XX },
2609 +  { "orpX",            XM, EX, XX },
2610 +  { "xorpX",           XM, EX, XX },
2611 +  /* 58 */
2612 +  { PREGRP0 },
2613 +  { PREGRP10 },
2614 +  { PREGRP17 },
2615 +  { PREGRP16 },
2616 +  { PREGRP14 },
2617 +  { PREGRP7 },
2618 +  { PREGRP5 },
2619 +  { PREGRP6 },
2620 +  /* 60 */
2621 +  { "punpcklbw",       MX, EM, XX },
2622 +  { "punpcklwd",       MX, EM, XX },
2623 +  { "punpckldq",       MX, EM, XX },
2624 +  { "packsswb",                MX, EM, XX },
2625 +  { "pcmpgtb",         MX, EM, XX },
2626 +  { "pcmpgtw",         MX, EM, XX },
2627 +  { "pcmpgtd",         MX, EM, XX },
2628 +  { "packuswb",                MX, EM, XX },
2629 +  /* 68 */
2630 +  { "punpckhbw",       MX, EM, XX },
2631 +  { "punpckhwd",       MX, EM, XX },
2632 +  { "punpckhdq",       MX, EM, XX },
2633 +  { "packssdw",                MX, EM, XX },
2634 +  { PREGRP26 },
2635 +  { PREGRP24 },
2636 +  { "movd",            MX, Edq, XX },
2637 +  { PREGRP19 },
2638 +  /* 70 */
2639 +  { PREGRP22 },
2640 +  { GRP10 },
2641 +  { GRP11 },
2642 +  { GRP12 },
2643 +  { "pcmpeqb",         MX, EM, XX },
2644 +  { "pcmpeqw",         MX, EM, XX },
2645 +  { "pcmpeqd",         MX, EM, XX },
2646 +  { "emms",            XX, XX, XX },
2647 +  /* 78 */
2648 +  { "vmread",          Em, Gm, XX },
2649 +  { "vmwrite",         Gm, Em, XX },
2650 +  { "(bad)",           XX, XX, XX },
2651 +  { "(bad)",           XX, XX, XX },
2652 +  { PREGRP28 },
2653 +  { PREGRP29 },
2654 +  { PREGRP23 },
2655 +  { PREGRP20 },
2656 +  /* 80 */
2657 +  { "joH",             Jv, XX, cond_jump_flag },
2658 +  { "jnoH",            Jv, XX, cond_jump_flag },
2659 +  { "jbH",             Jv, XX, cond_jump_flag },
2660 +  { "jaeH",            Jv, XX, cond_jump_flag },
2661 +  { "jeH",             Jv, XX, cond_jump_flag },
2662 +  { "jneH",            Jv, XX, cond_jump_flag },
2663 +  { "jbeH",            Jv, XX, cond_jump_flag },
2664 +  { "jaH",             Jv, XX, cond_jump_flag },
2665 +  /* 88 */
2666 +  { "jsH",             Jv, XX, cond_jump_flag },
2667 +  { "jnsH",            Jv, XX, cond_jump_flag },
2668 +  { "jpH",             Jv, XX, cond_jump_flag },
2669 +  { "jnpH",            Jv, XX, cond_jump_flag },
2670 +  { "jlH",             Jv, XX, cond_jump_flag },
2671 +  { "jgeH",            Jv, XX, cond_jump_flag },
2672 +  { "jleH",            Jv, XX, cond_jump_flag },
2673 +  { "jgH",             Jv, XX, cond_jump_flag },
2674 +  /* 90 */
2675 +  { "seto",            Eb, XX, XX },
2676 +  { "setno",           Eb, XX, XX },
2677 +  { "setb",            Eb, XX, XX },
2678 +  { "setae",           Eb, XX, XX },
2679 +  { "sete",            Eb, XX, XX },
2680 +  { "setne",           Eb, XX, XX },
2681 +  { "setbe",           Eb, XX, XX },
2682 +  { "seta",            Eb, XX, XX },
2683 +  /* 98 */
2684 +  { "sets",            Eb, XX, XX },
2685 +  { "setns",           Eb, XX, XX },
2686 +  { "setp",            Eb, XX, XX },
2687 +  { "setnp",           Eb, XX, XX },
2688 +  { "setl",            Eb, XX, XX },
2689 +  { "setge",           Eb, XX, XX },
2690 +  { "setle",           Eb, XX, XX },
2691 +  { "setg",            Eb, XX, XX },
2692 +  /* a0 */
2693 +  { "pushT",           fs, XX, XX },
2694 +  { "popT",            fs, XX, XX },
2695 +  { "cpuid",           XX, XX, XX },
2696 +  { "btS",             Ev, Gv, XX },
2697 +  { "shldS",           Ev, Gv, Ib },
2698 +  { "shldS",           Ev, Gv, CL },
2699 +  { GRPPADLCK2 },
2700 +  { GRPPADLCK1 },
2701 +  /* a8 */
2702 +  { "pushT",           gs, XX, XX },
2703 +  { "popT",            gs, XX, XX },
2704 +  { "rsm",             XX, XX, XX },
2705 +  { "btsS",            Ev, Gv, XX },
2706 +  { "shrdS",           Ev, Gv, Ib },
2707 +  { "shrdS",           Ev, Gv, CL },
2708 +  { GRP13 },
2709 +  { "imulS",           Gv, Ev, XX },
2710 +  /* b0 */
2711 +  { "cmpxchgB",                Eb, Gb, XX },
2712 +  { "cmpxchgS",                Ev, Gv, XX },
2713 +  { "lssS",            Gv, Mp, XX },
2714 +  { "btrS",            Ev, Gv, XX },
2715 +  { "lfsS",            Gv, Mp, XX },
2716 +  { "lgsS",            Gv, Mp, XX },
2717 +  { "movz{bR|x|bR|x}", Gv, Eb, XX },
2718 +  { "movz{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movzww ! */
2719 +  /* b8 */
2720 +  { "(bad)",           XX, XX, XX },
2721 +  { "ud2b",            XX, XX, XX },
2722 +  { GRP8 },
2723 +  { "btcS",            Ev, Gv, XX },
2724 +  { "bsfS",            Gv, Ev, XX },
2725 +  { "bsrS",            Gv, Ev, XX },
2726 +  { "movs{bR|x|bR|x}", Gv, Eb, XX },
2727 +  { "movs{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movsww ! */
2728 +  /* c0 */
2729 +  { "xaddB",           Eb, Gb, XX },
2730 +  { "xaddS",           Ev, Gv, XX },
2731 +  { PREGRP1 },
2732 +  { "movntiS",         Ev, Gv, XX },
2733 +  { "pinsrw",          MX, Edqw, Ib },
2734 +  { "pextrw",          Gdq, MS, Ib },
2735 +  { "shufpX",          XM, EX, Ib },
2736 +  { GRP9 },
2737 +  /* c8 */
2738 +  { "bswap",           RMeAX, XX, XX },
2739 +  { "bswap",           RMeCX, XX, XX },
2740 +  { "bswap",           RMeDX, XX, XX },
2741 +  { "bswap",           RMeBX, XX, XX },
2742 +  { "bswap",           RMeSP, XX, XX },
2743 +  { "bswap",           RMeBP, XX, XX },
2744 +  { "bswap",           RMeSI, XX, XX },
2745 +  { "bswap",           RMeDI, XX, XX },
2746 +  /* d0 */
2747 +  { PREGRP27 },
2748 +  { "psrlw",           MX, EM, XX },
2749 +  { "psrld",           MX, EM, XX },
2750 +  { "psrlq",           MX, EM, XX },
2751 +  { "paddq",           MX, EM, XX },
2752 +  { "pmullw",          MX, EM, XX },
2753 +  { PREGRP21 },
2754 +  { "pmovmskb",                Gdq, MS, XX },
2755 +  /* d8 */
2756 +  { "psubusb",         MX, EM, XX },
2757 +  { "psubusw",         MX, EM, XX },
2758 +  { "pminub",          MX, EM, XX },
2759 +  { "pand",            MX, EM, XX },
2760 +  { "paddusb",         MX, EM, XX },
2761 +  { "paddusw",         MX, EM, XX },
2762 +  { "pmaxub",          MX, EM, XX },
2763 +  { "pandn",           MX, EM, XX },
2764 +  /* e0 */
2765 +  { "pavgb",           MX, EM, XX },
2766 +  { "psraw",           MX, EM, XX },
2767 +  { "psrad",           MX, EM, XX },
2768 +  { "pavgw",           MX, EM, XX },
2769 +  { "pmulhuw",         MX, EM, XX },
2770 +  { "pmulhw",          MX, EM, XX },
2771 +  { PREGRP15 },
2772 +  { PREGRP25 },
2773 +  /* e8 */
2774 +  { "psubsb",          MX, EM, XX },
2775 +  { "psubsw",          MX, EM, XX },
2776 +  { "pminsw",          MX, EM, XX },
2777 +  { "por",             MX, EM, XX },
2778 +  { "paddsb",          MX, EM, XX },
2779 +  { "paddsw",          MX, EM, XX },
2780 +  { "pmaxsw",          MX, EM, XX },
2781 +  { "pxor",            MX, EM, XX },
2782 +  /* f0 */
2783 +  { PREGRP32 },
2784 +  { "psllw",           MX, EM, XX },
2785 +  { "pslld",           MX, EM, XX },
2786 +  { "psllq",           MX, EM, XX },
2787 +  { "pmuludq",         MX, EM, XX },
2788 +  { "pmaddwd",         MX, EM, XX },
2789 +  { "psadbw",          MX, EM, XX },
2790 +  { PREGRP18 },
2791 +  /* f8 */
2792 +  { "psubb",           MX, EM, XX },
2793 +  { "psubw",           MX, EM, XX },
2794 +  { "psubd",           MX, EM, XX },
2795 +  { "psubq",           MX, EM, XX },
2796 +  { "paddb",           MX, EM, XX },
2797 +  { "paddw",           MX, EM, XX },
2798 +  { "paddd",           MX, EM, XX },
2799 +  { "(bad)",           XX, XX, XX }
2800 +};
2801 +
2802 +static const unsigned char onebyte_has_modrm[256] = {
2803 +  /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
2804 +  /*       -------------------------------        */
2805 +  /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
2806 +  /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
2807 +  /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
2808 +  /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
2809 +  /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
2810 +  /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
2811 +  /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
2812 +  /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
2813 +  /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
2814 +  /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
2815 +  /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
2816 +  /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
2817 +  /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
2818 +  /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
2819 +  /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
2820 +  /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1  /* f0 */
2821 +  /*       -------------------------------        */
2822 +  /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
2823 +};
2824 +
2825 +static const unsigned char twobyte_has_modrm[256] = {
2826 +  /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
2827 +  /*       -------------------------------        */
2828 +  /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
2829 +  /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0, /* 1f */
2830 +  /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */
2831 +  /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
2832 +  /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
2833 +  /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
2834 +  /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
2835 +  /* 70 */ 1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, /* 7f */
2836 +  /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
2837 +  /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
2838 +  /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
2839 +  /* b0 */ 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1, /* bf */
2840 +  /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
2841 +  /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
2842 +  /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
2843 +  /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0  /* ff */
2844 +  /*       -------------------------------        */
2845 +  /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
2846 +};
2847 +
2848 +static const unsigned char twobyte_uses_SSE_prefix[256] = {
2849 +  /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
2850 +  /*       -------------------------------        */
2851 +  /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
2852 +  /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */
2853 +  /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0, /* 2f */
2854 +  /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
2855 +  /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
2856 +  /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
2857 +  /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */
2858 +  /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1, /* 7f */
2859 +  /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
2860 +  /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
2861 +  /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
2862 +  /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
2863 +  /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
2864 +  /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
2865 +  /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
2866 +  /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0  /* ff */
2867 +  /*       -------------------------------        */
2868 +  /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
2869 +};
2870 +
2871 +static char obuf[100];
2872 +static char *obufp;
2873 +static char scratchbuf[100];
2874 +static unsigned char *start_codep;
2875 +static unsigned char *insn_codep;
2876 +static unsigned char *codep;
2877 +static disassemble_info *the_info;
2878 +static int mod;
2879 +static int rm;
2880 +static int reg;
2881 +static unsigned char need_modrm;
2882 +
2883 +/* If we are accessing mod/rm/reg without need_modrm set, then the
2884 +   values are stale.  Hitting this abort likely indicates that you
2885 +   need to update onebyte_has_modrm or twobyte_has_modrm.  */
2886 +#define MODRM_CHECK  if (!need_modrm) abort ()
2887 +
2888 +static const char **names64;
2889 +static const char **names32;
2890 +static const char **names16;
2891 +static const char **names8;
2892 +static const char **names8rex;
2893 +static const char **names_seg;
2894 +static const char **index16;
2895 +
2896 +static const char *intel_names64[] = {
2897 +  "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2898 +  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2899 +};
2900 +static const char *intel_names32[] = {
2901 +  "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2902 +  "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2903 +};
2904 +static const char *intel_names16[] = {
2905 +  "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2906 +  "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2907 +};
2908 +static const char *intel_names8[] = {
2909 +  "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2910 +};
2911 +static const char *intel_names8rex[] = {
2912 +  "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2913 +  "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2914 +};
2915 +static const char *intel_names_seg[] = {
2916 +  "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2917 +};
2918 +static const char *intel_index16[] = {
2919 +  "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2920 +};
2921 +
2922 +static const char *att_names64[] = {
2923 +  "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2924 +  "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2925 +};
2926 +static const char *att_names32[] = {
2927 +  "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2928 +  "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2929 +};
2930 +static const char *att_names16[] = {
2931 +  "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2932 +  "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2933 +};
2934 +static const char *att_names8[] = {
2935 +  "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2936 +};
2937 +static const char *att_names8rex[] = {
2938 +  "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2939 +  "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2940 +};
2941 +static const char *att_names_seg[] = {
2942 +  "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2943 +};
2944 +static const char *att_index16[] = {
2945 +  "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2946 +};
2947 +
2948 +static const struct dis386 grps[][8] = {
2949 +  /* GRP1b */
2950 +  {
2951 +    { "addA",  Eb, Ib, XX },
2952 +    { "orA",   Eb, Ib, XX },
2953 +    { "adcA",  Eb, Ib, XX },
2954 +    { "sbbA",  Eb, Ib, XX },
2955 +    { "andA",  Eb, Ib, XX },
2956 +    { "subA",  Eb, Ib, XX },
2957 +    { "xorA",  Eb, Ib, XX },
2958 +    { "cmpA",  Eb, Ib, XX }
2959 +  },
2960 +  /* GRP1S */
2961 +  {
2962 +    { "addQ",  Ev, Iv, XX },
2963 +    { "orQ",   Ev, Iv, XX },
2964 +    { "adcQ",  Ev, Iv, XX },
2965 +    { "sbbQ",  Ev, Iv, XX },
2966 +    { "andQ",  Ev, Iv, XX },
2967 +    { "subQ",  Ev, Iv, XX },
2968 +    { "xorQ",  Ev, Iv, XX },
2969 +    { "cmpQ",  Ev, Iv, XX }
2970 +  },
2971 +  /* GRP1Ss */
2972 +  {
2973 +    { "addQ",  Ev, sIb, XX },
2974 +    { "orQ",   Ev, sIb, XX },
2975 +    { "adcQ",  Ev, sIb, XX },
2976 +    { "sbbQ",  Ev, sIb, XX },
2977 +    { "andQ",  Ev, sIb, XX },
2978 +    { "subQ",  Ev, sIb, XX },
2979 +    { "xorQ",  Ev, sIb, XX },
2980 +    { "cmpQ",  Ev, sIb, XX }
2981 +  },
2982 +  /* GRP2b */
2983 +  {
2984 +    { "rolA",  Eb, Ib, XX },
2985 +    { "rorA",  Eb, Ib, XX },
2986 +    { "rclA",  Eb, Ib, XX },
2987 +    { "rcrA",  Eb, Ib, XX },
2988 +    { "shlA",  Eb, Ib, XX },
2989 +    { "shrA",  Eb, Ib, XX },
2990 +    { "(bad)", XX, XX, XX },
2991 +    { "sarA",  Eb, Ib, XX },
2992 +  },
2993 +  /* GRP2S */
2994 +  {
2995 +    { "rolQ",  Ev, Ib, XX },
2996 +    { "rorQ",  Ev, Ib, XX },
2997 +    { "rclQ",  Ev, Ib, XX },
2998 +    { "rcrQ",  Ev, Ib, XX },
2999 +    { "shlQ",  Ev, Ib, XX },
3000 +    { "shrQ",  Ev, Ib, XX },
3001 +    { "(bad)", XX, XX, XX },
3002 +    { "sarQ",  Ev, Ib, XX },
3003 +  },
3004 +  /* GRP2b_one */
3005 +  {
3006 +    { "rolA",  Eb, I1, XX },
3007 +    { "rorA",  Eb, I1, XX },
3008 +    { "rclA",  Eb, I1, XX },
3009 +    { "rcrA",  Eb, I1, XX },
3010 +    { "shlA",  Eb, I1, XX },
3011 +    { "shrA",  Eb, I1, XX },
3012 +    { "(bad)", XX, XX, XX },
3013 +    { "sarA",  Eb, I1, XX },
3014 +  },
3015 +  /* GRP2S_one */
3016 +  {
3017 +    { "rolQ",  Ev, I1, XX },
3018 +    { "rorQ",  Ev, I1, XX },
3019 +    { "rclQ",  Ev, I1, XX },
3020 +    { "rcrQ",  Ev, I1, XX },
3021 +    { "shlQ",  Ev, I1, XX },
3022 +    { "shrQ",  Ev, I1, XX },
3023 +    { "(bad)", XX, XX, XX},
3024 +    { "sarQ",  Ev, I1, XX },
3025 +  },
3026 +  /* GRP2b_cl */
3027 +  {
3028 +    { "rolA",  Eb, CL, XX },
3029 +    { "rorA",  Eb, CL, XX },
3030 +    { "rclA",  Eb, CL, XX },
3031 +    { "rcrA",  Eb, CL, XX },
3032 +    { "shlA",  Eb, CL, XX },
3033 +    { "shrA",  Eb, CL, XX },
3034 +    { "(bad)", XX, XX, XX },
3035 +    { "sarA",  Eb, CL, XX },
3036 +  },
3037 +  /* GRP2S_cl */
3038 +  {
3039 +    { "rolQ",  Ev, CL, XX },
3040 +    { "rorQ",  Ev, CL, XX },
3041 +    { "rclQ",  Ev, CL, XX },
3042 +    { "rcrQ",  Ev, CL, XX },
3043 +    { "shlQ",  Ev, CL, XX },
3044 +    { "shrQ",  Ev, CL, XX },
3045 +    { "(bad)", XX, XX, XX },
3046 +    { "sarQ",  Ev, CL, XX }
3047 +  },
3048 +  /* GRP3b */
3049 +  {
3050 +    { "testA", Eb, Ib, XX },
3051 +    { "(bad)", Eb, XX, XX },
3052 +    { "notA",  Eb, XX, XX },
3053 +    { "negA",  Eb, XX, XX },
3054 +    { "mulA",  Eb, XX, XX },   /* Don't print the implicit %al register,  */
3055 +    { "imulA", Eb, XX, XX },   /* to distinguish these opcodes from other */
3056 +    { "divA",  Eb, XX, XX },   /* mul/imul opcodes.  Do the same for div  */
3057 +    { "idivA", Eb, XX, XX }    /* and idiv for consistency.               */
3058 +  },
3059 +  /* GRP3S */
3060 +  {
3061 +    { "testQ", Ev, Iv, XX },
3062 +    { "(bad)", XX, XX, XX },
3063 +    { "notQ",  Ev, XX, XX },
3064 +    { "negQ",  Ev, XX, XX },
3065 +    { "mulQ",  Ev, XX, XX },   /* Don't print the implicit register.  */
3066 +    { "imulQ", Ev, XX, XX },
3067 +    { "divQ",  Ev, XX, XX },
3068 +    { "idivQ", Ev, XX, XX },
3069 +  },
3070 +  /* GRP4 */
3071 +  {
3072 +    { "incA",  Eb, XX, XX },
3073 +    { "decA",  Eb, XX, XX },
3074 +    { "(bad)", XX, XX, XX },
3075 +    { "(bad)", XX, XX, XX },
3076 +    { "(bad)", XX, XX, XX },
3077 +    { "(bad)", XX, XX, XX },
3078 +    { "(bad)", XX, XX, XX },
3079 +    { "(bad)", XX, XX, XX },
3080 +  },
3081 +  /* GRP5 */
3082 +  {
3083 +    { "incQ",  Ev, XX, XX },
3084 +    { "decQ",  Ev, XX, XX },
3085 +    { "callT", indirEv, XX, XX },
3086 +    { "JcallT",        indirEp, XX, XX },
3087 +    { "jmpT",  indirEv, XX, XX },
3088 +    { "JjmpT", indirEp, XX, XX },
3089 +    { "pushU", Ev, XX, XX },
3090 +    { "(bad)", XX, XX, XX },
3091 +  },
3092 +  /* GRP6 */
3093 +  {
3094 +    { "sldtQ", Ev, XX, XX },
3095 +    { "strQ",  Ev, XX, XX },
3096 +    { "lldt",  Ew, XX, XX },
3097 +    { "ltr",   Ew, XX, XX },
3098 +    { "verr",  Ew, XX, XX },
3099 +    { "verw",  Ew, XX, XX },
3100 +    { "(bad)", XX, XX, XX },
3101 +    { "(bad)", XX, XX, XX }
3102 +  },
3103 +  /* GRP7 */
3104 +  {
3105 +    { "sgdtIQ", VMX_Fixup, 0, XX, XX },
3106 +    { "sidtIQ", PNI_Fixup, 0, XX, XX },
3107 +    { "lgdt{Q|Q||}",    M, XX, XX },
3108 +    { "lidt{Q|Q||}",    SVME_Fixup, 0, XX, XX },
3109 +    { "smswQ", Ev, XX, XX },
3110 +    { "(bad)", XX, XX, XX },
3111 +    { "lmsw",  Ew, XX, XX },
3112 +    { "invlpg",        INVLPG_Fixup, w_mode, XX, XX },
3113 +  },
3114 +  /* GRP8 */
3115 +  {
3116 +    { "(bad)", XX, XX, XX },
3117 +    { "(bad)", XX, XX, XX },
3118 +    { "(bad)", XX, XX, XX },
3119 +    { "(bad)", XX, XX, XX },
3120 +    { "btQ",   Ev, Ib, XX },
3121 +    { "btsQ",  Ev, Ib, XX },
3122 +    { "btrQ",  Ev, Ib, XX },
3123 +    { "btcQ",  Ev, Ib, XX },
3124 +  },
3125 +  /* GRP9 */
3126 +  {
3127 +    { "(bad)", XX, XX, XX },
3128 +    { "cmpxchg8b", Eq, XX, XX },
3129 +    { "(bad)", XX, XX, XX },
3130 +    { "(bad)", XX, XX, XX },
3131 +    { "(bad)", XX, XX, XX },
3132 +    { "(bad)", XX, XX, XX },
3133 +    { "",      VM, XX, XX },           /* See OP_VMX.  */
3134 +    { "vmptrst", Eq, XX, XX },
3135 +  },
3136 +  /* GRP10 */
3137 +  {
3138 +    { "(bad)", XX, XX, XX },
3139 +    { "(bad)", XX, XX, XX },
3140 +    { "psrlw", MS, Ib, XX },
3141 +    { "(bad)", XX, XX, XX },
3142 +    { "psraw", MS, Ib, XX },
3143 +    { "(bad)", XX, XX, XX },
3144 +    { "psllw", MS, Ib, XX },
3145 +    { "(bad)", XX, XX, XX },
3146 +  },
3147 +  /* GRP11 */
3148 +  {
3149 +    { "(bad)", XX, XX, XX },
3150 +    { "(bad)", XX, XX, XX },
3151 +    { "psrld", MS, Ib, XX },
3152 +    { "(bad)", XX, XX, XX },
3153 +    { "psrad", MS, Ib, XX },
3154 +    { "(bad)", XX, XX, XX },
3155 +    { "pslld", MS, Ib, XX },
3156 +    { "(bad)", XX, XX, XX },
3157 +  },
3158 +  /* GRP12 */
3159 +  {
3160 +    { "(bad)", XX, XX, XX },
3161 +    { "(bad)", XX, XX, XX },
3162 +    { "psrlq", MS, Ib, XX },
3163 +    { "psrldq",        MS, Ib, XX },
3164 +    { "(bad)", XX, XX, XX },
3165 +    { "(bad)", XX, XX, XX },
3166 +    { "psllq", MS, Ib, XX },
3167 +    { "pslldq",        MS, Ib, XX },
3168 +  },
3169 +  /* GRP13 */
3170 +  {
3171 +    { "fxsave", Ev, XX, XX },
3172 +    { "fxrstor", Ev, XX, XX },
3173 +    { "ldmxcsr", Ev, XX, XX },
3174 +    { "stmxcsr", Ev, XX, XX },
3175 +    { "(bad)", XX, XX, XX },
3176 +    { "lfence", OP_0fae, 0, XX, XX },
3177 +    { "mfence", OP_0fae, 0, XX, XX },
3178 +    { "clflush", OP_0fae, 0, XX, XX },
3179 +  },
3180 +  /* GRP14 */
3181 +  {
3182 +    { "prefetchnta", Ev, XX, XX },
3183 +    { "prefetcht0", Ev, XX, XX },
3184 +    { "prefetcht1", Ev, XX, XX },
3185 +    { "prefetcht2", Ev, XX, XX },
3186 +    { "(bad)", XX, XX, XX },
3187 +    { "(bad)", XX, XX, XX },
3188 +    { "(bad)", XX, XX, XX },
3189 +    { "(bad)", XX, XX, XX },
3190 +  },
3191 +  /* GRPAMD */
3192 +  {
3193 +    { "prefetch", Eb, XX, XX },
3194 +    { "prefetchw", Eb, XX, XX },
3195 +    { "(bad)", XX, XX, XX },
3196 +    { "(bad)", XX, XX, XX },
3197 +    { "(bad)", XX, XX, XX },
3198 +    { "(bad)", XX, XX, XX },
3199 +    { "(bad)", XX, XX, XX },
3200 +    { "(bad)", XX, XX, XX },
3201 +  },
3202 +  /* GRPPADLCK1 */
3203 +  {
3204 +    { "xstore-rng", OP_0f07, 0, XX, XX },
3205 +    { "xcrypt-ecb", OP_0f07, 0, XX, XX },
3206 +    { "xcrypt-cbc", OP_0f07, 0, XX, XX },
3207 +    { "xcrypt-ctr", OP_0f07, 0, XX, XX },
3208 +    { "xcrypt-cfb", OP_0f07, 0, XX, XX },
3209 +    { "xcrypt-ofb", OP_0f07, 0, XX, XX },
3210 +    { "(bad)", OP_0f07, 0, XX, XX },
3211 +    { "(bad)", OP_0f07, 0, XX, XX },
3212 +  },
3213 +  /* GRPPADLCK2 */
3214 +  {
3215 +    { "montmul", OP_0f07, 0, XX, XX },
3216 +    { "xsha1",   OP_0f07, 0, XX, XX },
3217 +    { "xsha256", OP_0f07, 0, XX, XX },
3218 +    { "(bad)",  OP_0f07, 0, XX, XX },
3219 +    { "(bad)",   OP_0f07, 0, XX, XX },
3220 +    { "(bad)",   OP_0f07, 0, XX, XX },
3221 +    { "(bad)",  OP_0f07, 0, XX, XX },
3222 +    { "(bad)",  OP_0f07, 0, XX, XX },
3223 +  }
3224 +};
3225 +
3226 +static const struct dis386 prefix_user_table[][4] = {
3227 +  /* PREGRP0 */
3228 +  {
3229 +    { "addps", XM, EX, XX },
3230 +    { "addss", XM, EX, XX },
3231 +    { "addpd", XM, EX, XX },
3232 +    { "addsd", XM, EX, XX },
3233 +  },
3234 +  /* PREGRP1 */
3235 +  {
3236 +    { "", XM, EX, OPSIMD },    /* See OP_SIMD_SUFFIX.  */
3237 +    { "", XM, EX, OPSIMD },
3238 +    { "", XM, EX, OPSIMD },
3239 +    { "", XM, EX, OPSIMD },
3240 +  },
3241 +  /* PREGRP2 */
3242 +  {
3243 +    { "cvtpi2ps", XM, EM, XX },
3244 +    { "cvtsi2ssY", XM, Ev, XX },
3245 +    { "cvtpi2pd", XM, EM, XX },
3246 +    { "cvtsi2sdY", XM, Ev, XX },
3247 +  },
3248 +  /* PREGRP3 */
3249 +  {
3250 +    { "cvtps2pi", MX, EX, XX },
3251 +    { "cvtss2siY", Gv, EX, XX },
3252 +    { "cvtpd2pi", MX, EX, XX },
3253 +    { "cvtsd2siY", Gv, EX, XX },
3254 +  },
3255 +  /* PREGRP4 */
3256 +  {
3257 +    { "cvttps2pi", MX, EX, XX },
3258 +    { "cvttss2siY", Gv, EX, XX },
3259 +    { "cvttpd2pi", MX, EX, XX },
3260 +    { "cvttsd2siY", Gv, EX, XX },
3261 +  },
3262 +  /* PREGRP5 */
3263 +  {
3264 +    { "divps", XM, EX, XX },
3265 +    { "divss", XM, EX, XX },
3266 +    { "divpd", XM, EX, XX },
3267 +    { "divsd", XM, EX, XX },
3268 +  },
3269 +  /* PREGRP6 */
3270 +  {
3271 +    { "maxps", XM, EX, XX },
3272 +    { "maxss", XM, EX, XX },
3273 +    { "maxpd", XM, EX, XX },
3274 +    { "maxsd", XM, EX, XX },
3275 +  },
3276 +  /* PREGRP7 */
3277 +  {
3278 +    { "minps", XM, EX, XX },
3279 +    { "minss", XM, EX, XX },
3280 +    { "minpd", XM, EX, XX },
3281 +    { "minsd", XM, EX, XX },
3282 +  },
3283 +  /* PREGRP8 */
3284 +  {
3285 +    { "movups", XM, EX, XX },
3286 +    { "movss", XM, EX, XX },
3287 +    { "movupd", XM, EX, XX },
3288 +    { "movsd", XM, EX, XX },
3289 +  },
3290 +  /* PREGRP9 */
3291 +  {
3292 +    { "movups", EX, XM, XX },
3293 +    { "movss", EX, XM, XX },
3294 +    { "movupd", EX, XM, XX },
3295 +    { "movsd", EX, XM, XX },
3296 +  },
3297 +  /* PREGRP10 */
3298 +  {
3299 +    { "mulps", XM, EX, XX },
3300 +    { "mulss", XM, EX, XX },
3301 +    { "mulpd", XM, EX, XX },
3302 +    { "mulsd", XM, EX, XX },
3303 +  },
3304 +  /* PREGRP11 */
3305 +  {
3306 +    { "rcpps", XM, EX, XX },
3307 +    { "rcpss", XM, EX, XX },
3308 +    { "(bad)", XM, EX, XX },
3309 +    { "(bad)", XM, EX, XX },
3310 +  },
3311 +  /* PREGRP12 */
3312 +  {
3313 +    { "rsqrtps", XM, EX, XX },
3314 +    { "rsqrtss", XM, EX, XX },
3315 +    { "(bad)", XM, EX, XX },
3316 +    { "(bad)", XM, EX, XX },
3317 +  },
3318 +  /* PREGRP13 */
3319 +  {
3320 +    { "sqrtps", XM, EX, XX },
3321 +    { "sqrtss", XM, EX, XX },
3322 +    { "sqrtpd", XM, EX, XX },
3323 +    { "sqrtsd", XM, EX, XX },
3324 +  },
3325 +  /* PREGRP14 */
3326 +  {
3327 +    { "subps", XM, EX, XX },
3328 +    { "subss", XM, EX, XX },
3329 +    { "subpd", XM, EX, XX },
3330 +    { "subsd", XM, EX, XX },
3331 +  },
3332 +  /* PREGRP15 */
3333 +  {
3334 +    { "(bad)", XM, EX, XX },
3335 +    { "cvtdq2pd", XM, EX, XX },
3336 +    { "cvttpd2dq", XM, EX, XX },
3337 +    { "cvtpd2dq", XM, EX, XX },
3338 +  },
3339 +  /* PREGRP16 */
3340 +  {
3341 +    { "cvtdq2ps", XM, EX, XX },
3342 +    { "cvttps2dq",XM, EX, XX },
3343 +    { "cvtps2dq",XM, EX, XX },
3344 +    { "(bad)", XM, EX, XX },
3345 +  },
3346 +  /* PREGRP17 */
3347 +  {
3348 +    { "cvtps2pd", XM, EX, XX },
3349 +    { "cvtss2sd", XM, EX, XX },
3350 +    { "cvtpd2ps", XM, EX, XX },
3351 +    { "cvtsd2ss", XM, EX, XX },
3352 +  },
3353 +  /* PREGRP18 */
3354 +  {
3355 +    { "maskmovq", MX, MS, XX },
3356 +    { "(bad)", XM, EX, XX },
3357 +    { "maskmovdqu", XM, EX, XX },
3358 +    { "(bad)", XM, EX, XX },
3359 +  },
3360 +  /* PREGRP19 */
3361 +  {
3362 +    { "movq", MX, EM, XX },
3363 +    { "movdqu", XM, EX, XX },
3364 +    { "movdqa", XM, EX, XX },
3365 +    { "(bad)", XM, EX, XX },
3366 +  },
3367 +  /* PREGRP20 */
3368 +  {
3369 +    { "movq", EM, MX, XX },
3370 +    { "movdqu", EX, XM, XX },
3371 +    { "movdqa", EX, XM, XX },
3372 +    { "(bad)", EX, XM, XX },
3373 +  },
3374 +  /* PREGRP21 */
3375 +  {
3376 +    { "(bad)", EX, XM, XX },
3377 +    { "movq2dq", XM, MS, XX },
3378 +    { "movq", EX, XM, XX },
3379 +    { "movdq2q", MX, XS, XX },
3380 +  },
3381 +  /* PREGRP22 */
3382 +  {
3383 +    { "pshufw", MX, EM, Ib },
3384 +    { "pshufhw", XM, EX, Ib },
3385 +    { "pshufd", XM, EX, Ib },
3386 +    { "pshuflw", XM, EX, Ib },
3387 +  },
3388 +  /* PREGRP23 */
3389 +  {
3390 +    { "movd", Edq, MX, XX },
3391 +    { "movq", XM, EX, XX },
3392 +    { "movd", Edq, XM, XX },
3393 +    { "(bad)", Ed, XM, XX },
3394 +  },
3395 +  /* PREGRP24 */
3396 +  {
3397 +    { "(bad)", MX, EX, XX },
3398 +    { "(bad)", XM, EX, XX },
3399 +    { "punpckhqdq", XM, EX, XX },
3400 +    { "(bad)", XM, EX, XX },
3401 +  },
3402 +  /* PREGRP25 */
3403 +  {
3404 +    { "movntq", EM, MX, XX },
3405 +    { "(bad)", EM, XM, XX },
3406 +    { "movntdq", EM, XM, XX },
3407 +    { "(bad)", EM, XM, XX },
3408 +  },
3409 +  /* PREGRP26 */
3410 +  {
3411 +    { "(bad)", MX, EX, XX },
3412 +    { "(bad)", XM, EX, XX },
3413 +    { "punpcklqdq", XM, EX, XX },
3414 +    { "(bad)", XM, EX, XX },
3415 +  },
3416 +  /* PREGRP27 */
3417 +  {
3418 +    { "(bad)", MX, EX, XX },
3419 +    { "(bad)", XM, EX, XX },
3420 +    { "addsubpd", XM, EX, XX },
3421 +    { "addsubps", XM, EX, XX },
3422 +  },
3423 +  /* PREGRP28 */
3424 +  {
3425 +    { "(bad)", MX, EX, XX },
3426 +    { "(bad)", XM, EX, XX },
3427 +    { "haddpd", XM, EX, XX },
3428 +    { "haddps", XM, EX, XX },
3429 +  },
3430 +  /* PREGRP29 */
3431 +  {
3432 +    { "(bad)", MX, EX, XX },
3433 +    { "(bad)", XM, EX, XX },
3434 +    { "hsubpd", XM, EX, XX },
3435 +    { "hsubps", XM, EX, XX },
3436 +  },
3437 +  /* PREGRP30 */
3438 +  {
3439 +    { "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */
3440 +    { "movsldup", XM, EX, XX },
3441 +    { "movlpd", XM, EX, XX },
3442 +    { "movddup", XM, EX, XX },
3443 +  },
3444 +  /* PREGRP31 */
3445 +  {
3446 +    { "movhpX", XM, EX, SIMD_Fixup, 'l' },
3447 +    { "movshdup", XM, EX, XX },
3448 +    { "movhpd", XM, EX, XX },
3449 +    { "(bad)", XM, EX, XX },
3450 +  },
3451 +  /* PREGRP32 */
3452 +  {
3453 +    { "(bad)", XM, EX, XX },
3454 +    { "(bad)", XM, EX, XX },
3455 +    { "(bad)", XM, EX, XX },
3456 +    { "lddqu", XM, M, XX },
3457 +  },
3458 +};
3459 +
3460 +static const struct dis386 x86_64_table[][2] = {
3461 +  {
3462 +    { "arpl", Ew, Gw, XX },
3463 +    { "movs{||lq|xd}", Gv, Ed, XX },
3464 +  },
3465 +};
3466 +
3467 +#ifdef __KERNEL__
3468 +#define INTERNAL_DISASSEMBLER_ERROR "<internal disassembler error>"
3469 +#else  /* __KERNEL__ */
3470 +#define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
3471 +#endif /* __KERNEL__ */
3472 +
3473 +static void
3474 +ckprefix (void)
3475 +{
3476 +  int newrex;
3477 +  rex = 0;
3478 +  prefixes = 0;
3479 +  used_prefixes = 0;
3480 +  rex_used = 0;
3481 +  while (1)
3482 +    {
3483 +      FETCH_DATA (the_info, codep + 1);
3484 +      newrex = 0;
3485 +      switch (*codep)
3486 +       {
3487 +       /* REX prefixes family.  */
3488 +       case 0x40:
3489 +       case 0x41:
3490 +       case 0x42:
3491 +       case 0x43:
3492 +       case 0x44:
3493 +       case 0x45:
3494 +       case 0x46:
3495 +       case 0x47:
3496 +       case 0x48:
3497 +       case 0x49:
3498 +       case 0x4a:
3499 +       case 0x4b:
3500 +       case 0x4c:
3501 +       case 0x4d:
3502 +       case 0x4e:
3503 +       case 0x4f:
3504 +           if (mode_64bit)
3505 +             newrex = *codep;
3506 +           else
3507 +             return;
3508 +         break;
3509 +       case 0xf3:
3510 +         prefixes |= PREFIX_REPZ;
3511 +         break;
3512 +       case 0xf2:
3513 +         prefixes |= PREFIX_REPNZ;
3514 +         break;
3515 +       case 0xf0:
3516 +         prefixes |= PREFIX_LOCK;
3517 +         break;
3518 +       case 0x2e:
3519 +         prefixes |= PREFIX_CS;
3520 +         break;
3521 +       case 0x36:
3522 +         prefixes |= PREFIX_SS;
3523 +         break;
3524 +       case 0x3e:
3525 +         prefixes |= PREFIX_DS;
3526 +         break;
3527 +       case 0x26:
3528 +         prefixes |= PREFIX_ES;
3529 +         break;
3530 +       case 0x64:
3531 +         prefixes |= PREFIX_FS;
3532 +         break;
3533 +       case 0x65:
3534 +         prefixes |= PREFIX_GS;
3535 +         break;
3536 +       case 0x66:
3537 +         prefixes |= PREFIX_DATA;
3538 +         break;
3539 +       case 0x67:
3540 +         prefixes |= PREFIX_ADDR;
3541 +         break;
3542 +       case FWAIT_OPCODE:
3543 +         /* fwait is really an instruction.  If there are prefixes
3544 +            before the fwait, they belong to the fwait, *not* to the
3545 +            following instruction.  */
3546 +         if (prefixes)
3547 +           {
3548 +             prefixes |= PREFIX_FWAIT;
3549 +             codep++;
3550 +             return;
3551 +           }
3552 +         prefixes = PREFIX_FWAIT;
3553 +         break;
3554 +       default:
3555 +         return;
3556 +       }
3557 +      /* Rex is ignored when followed by another prefix.  */
3558 +      if (rex)
3559 +       {
3560 +         oappend (prefix_name (rex, 0));
3561 +         oappend (" ");
3562 +       }
3563 +      rex = newrex;
3564 +      codep++;
3565 +    }
3566 +}
3567 +
3568 +/* Return the name of the prefix byte PREF, or NULL if PREF is not a
3569 +   prefix byte.  */
3570 +
3571 +static const char *
3572 +prefix_name (int pref, int sizeflag)
3573 +{
3574 +  switch (pref)
3575 +    {
3576 +    /* REX prefixes family.  */
3577 +    case 0x40:
3578 +      return "rex";
3579 +    case 0x41:
3580 +      return "rexZ";
3581 +    case 0x42:
3582 +      return "rexY";
3583 +    case 0x43:
3584 +      return "rexYZ";
3585 +    case 0x44:
3586 +      return "rexX";
3587 +    case 0x45:
3588 +      return "rexXZ";
3589 +    case 0x46:
3590 +      return "rexXY";
3591 +    case 0x47:
3592 +      return "rexXYZ";
3593 +    case 0x48:
3594 +      return "rex64";
3595 +    case 0x49:
3596 +      return "rex64Z";
3597 +    case 0x4a:
3598 +      return "rex64Y";
3599 +    case 0x4b:
3600 +      return "rex64YZ";
3601 +    case 0x4c:
3602 +      return "rex64X";
3603 +    case 0x4d:
3604 +      return "rex64XZ";
3605 +    case 0x4e:
3606 +      return "rex64XY";
3607 +    case 0x4f:
3608 +      return "rex64XYZ";
3609 +    case 0xf3:
3610 +      return "repz";
3611 +    case 0xf2:
3612 +      return "repnz";
3613 +    case 0xf0:
3614 +      return "lock";
3615 +    case 0x2e:
3616 +      return "cs";
3617 +    case 0x36:
3618 +      return "ss";
3619 +    case 0x3e:
3620 +      return "ds";
3621 +    case 0x26:
3622 +      return "es";
3623 +    case 0x64:
3624 +      return "fs";
3625 +    case 0x65:
3626 +      return "gs";
3627 +    case 0x66:
3628 +      return (sizeflag & DFLAG) ? "data16" : "data32";
3629 +    case 0x67:
3630 +      if (mode_64bit)
3631 +       return (sizeflag & AFLAG) ? "addr32" : "addr64";
3632 +      else
3633 +       return (sizeflag & AFLAG) ? "addr16" : "addr32";
3634 +    case FWAIT_OPCODE:
3635 +      return "fwait";
3636 +    default:
3637 +      return NULL;
3638 +    }
3639 +}
3640 +
3641 +static char op1out[100], op2out[100], op3out[100];
3642 +static int op_ad, op_index[3];
3643 +static int two_source_ops;
3644 +static bfd_vma op_address[3];
3645 +static bfd_vma op_riprel[3];
3646 +static bfd_vma start_pc;
3647 +\f
3648 +/*
3649 + *   On the 386's of 1988, the maximum length of an instruction is 15 bytes.
3650 + *   (see topic "Redundant prefixes" in the "Differences from 8086"
3651 + *   section of the "Virtual 8086 Mode" chapter.)
3652 + * 'pc' should be the address of this instruction, it will
3653 + *   be used to print the target address if this is a relative jump or call
3654 + * The function returns the length of this instruction in bytes.
3655 + */
3656 +
3657 +static char intel_syntax;
3658 +static char open_char;
3659 +static char close_char;
3660 +static char separator_char;
3661 +static char scale_char;
3662 +
3663 +/* Here for backwards compatibility.  When gdb stops using
3664 +   print_insn_i386_att and print_insn_i386_intel these functions can
3665 +   disappear, and print_insn_i386 be merged into print_insn.  */
3666 +int
3667 +print_insn_i386_att (bfd_vma pc, disassemble_info *info)
3668 +{
3669 +  intel_syntax = 0;
3670 +
3671 +  return print_insn (pc, info);
3672 +}
3673 +
3674 +int
3675 +print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
3676 +{
3677 +  intel_syntax = 1;
3678 +
3679 +  return print_insn (pc, info);
3680 +}
3681 +
3682 +int
3683 +print_insn_i386 (bfd_vma pc, disassemble_info *info)
3684 +{
3685 +  intel_syntax = -1;
3686 +
3687 +  return print_insn (pc, info);
3688 +}
3689 +
3690 +static int
3691 +print_insn (bfd_vma pc, disassemble_info *info)
3692 +{
3693 +  const struct dis386 *dp;
3694 +  int i;
3695 +  char *first, *second, *third;
3696 +  int needcomma;
3697 +  unsigned char uses_SSE_prefix, uses_LOCK_prefix;
3698 +  int sizeflag;
3699 +  const char *p;
3700 +  struct dis_private priv;
3701 +
3702 +  mode_64bit = (info->mach == bfd_mach_x86_64_intel_syntax
3703 +               || info->mach == bfd_mach_x86_64);
3704 +
3705 +  if (intel_syntax == (char) -1)
3706 +    intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
3707 +                   || info->mach == bfd_mach_x86_64_intel_syntax);
3708 +
3709 +  if (info->mach == bfd_mach_i386_i386
3710 +      || info->mach == bfd_mach_x86_64
3711 +      || info->mach == bfd_mach_i386_i386_intel_syntax
3712 +      || info->mach == bfd_mach_x86_64_intel_syntax)
3713 +    priv.orig_sizeflag = AFLAG | DFLAG;
3714 +  else if (info->mach == bfd_mach_i386_i8086)
3715 +    priv.orig_sizeflag = 0;
3716 +  else
3717 +    abort ();
3718 +
3719 +  for (p = info->disassembler_options; p != NULL; )
3720 +    {
3721 +      if (strncmp (p, "x86-64", 6) == 0)
3722 +       {
3723 +         mode_64bit = 1;
3724 +         priv.orig_sizeflag = AFLAG | DFLAG;
3725 +       }
3726 +      else if (strncmp (p, "i386", 4) == 0)
3727 +       {
3728 +         mode_64bit = 0;
3729 +         priv.orig_sizeflag = AFLAG | DFLAG;
3730 +       }
3731 +      else if (strncmp (p, "i8086", 5) == 0)
3732 +       {
3733 +         mode_64bit = 0;
3734 +         priv.orig_sizeflag = 0;
3735 +       }
3736 +      else if (strncmp (p, "intel", 5) == 0)
3737 +       {
3738 +         intel_syntax = 1;
3739 +       }
3740 +      else if (strncmp (p, "att", 3) == 0)
3741 +       {
3742 +         intel_syntax = 0;
3743 +       }
3744 +      else if (strncmp (p, "addr", 4) == 0)
3745 +       {
3746 +         if (p[4] == '1' && p[5] == '6')
3747 +           priv.orig_sizeflag &= ~AFLAG;
3748 +         else if (p[4] == '3' && p[5] == '2')
3749 +           priv.orig_sizeflag |= AFLAG;
3750 +       }
3751 +      else if (strncmp (p, "data", 4) == 0)
3752 +       {
3753 +         if (p[4] == '1' && p[5] == '6')
3754 +           priv.orig_sizeflag &= ~DFLAG;
3755 +         else if (p[4] == '3' && p[5] == '2')
3756 +           priv.orig_sizeflag |= DFLAG;
3757 +       }
3758 +      else if (strncmp (p, "suffix", 6) == 0)
3759 +       priv.orig_sizeflag |= SUFFIX_ALWAYS;
3760 +
3761 +      p = strchr (p, ',');
3762 +      if (p != NULL)
3763 +       p++;
3764 +    }
3765 +
3766 +  if (intel_syntax)
3767 +    {
3768 +      names64 = intel_names64;
3769 +      names32 = intel_names32;
3770 +      names16 = intel_names16;
3771 +      names8 = intel_names8;
3772 +      names8rex = intel_names8rex;
3773 +      names_seg = intel_names_seg;
3774 +      index16 = intel_index16;
3775 +      open_char = '[';
3776 +      close_char = ']';
3777 +      separator_char = '+';
3778 +      scale_char = '*';
3779 +    }
3780 +  else
3781 +    {
3782 +      names64 = att_names64;
3783 +      names32 = att_names32;
3784 +      names16 = att_names16;
3785 +      names8 = att_names8;
3786 +      names8rex = att_names8rex;
3787 +      names_seg = att_names_seg;
3788 +      index16 = att_index16;
3789 +      open_char = '(';
3790 +      close_char =  ')';
3791 +      separator_char = ',';
3792 +      scale_char = ',';
3793 +    }
3794 +
3795 +  /* The output looks better if we put 7 bytes on a line, since that
3796 +     puts most long word instructions on a single line.  */
3797 +  info->bytes_per_line = 7;
3798 +
3799 +  info->private_data = &priv;
3800 +  priv.max_fetched = priv.the_buffer;
3801 +  priv.insn_start = pc;
3802 +
3803 +  obuf[0] = 0;
3804 +  op1out[0] = 0;
3805 +  op2out[0] = 0;
3806 +  op3out[0] = 0;
3807 +
3808 +  op_index[0] = op_index[1] = op_index[2] = -1;
3809 +
3810 +  the_info = info;
3811 +  start_pc = pc;
3812 +  start_codep = priv.the_buffer;
3813 +  codep = priv.the_buffer;
3814 +
3815 +#ifndef __KERNEL__
3816 +  if (setjmp (priv.bailout) != 0)
3817 +    {
3818 +      const char *name;
3819 +
3820 +      /* Getting here means we tried for data but didn't get it.  That
3821 +        means we have an incomplete instruction of some sort.  Just
3822 +        print the first byte as a prefix or a .byte pseudo-op.  */
3823 +      if (codep > priv.the_buffer)
3824 +       {
3825 +         name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
3826 +         if (name != NULL)
3827 +           (*info->fprintf_func) (info->stream, "%s", name);
3828 +         else
3829 +           {
3830 +             /* Just print the first byte as a .byte instruction.  */
3831 +             (*info->fprintf_func) (info->stream, ".byte 0x%x",
3832 +                                    (unsigned int) priv.the_buffer[0]);
3833 +           }
3834 +
3835 +         return 1;
3836 +       }
3837 +
3838 +      return -1;
3839 +    }
3840 +#endif /* __KERNEL__ */
3841 +
3842 +  obufp = obuf;
3843 +  ckprefix ();
3844 +
3845 +  insn_codep = codep;
3846 +  sizeflag = priv.orig_sizeflag;
3847 +
3848 +  FETCH_DATA (info, codep + 1);
3849 +  two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
3850 +
3851 +  if ((prefixes & PREFIX_FWAIT)
3852 +      && ((*codep < 0xd8) || (*codep > 0xdf)))
3853 +    {
3854 +      const char *name;
3855 +
3856 +      /* fwait not followed by floating point instruction.  Print the
3857 +        first prefix, which is probably fwait itself.  */
3858 +      name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
3859 +      if (name == NULL)
3860 +       name = INTERNAL_DISASSEMBLER_ERROR;
3861 +      (*info->fprintf_func) (info->stream, "%s", name);
3862 +      return 1;
3863 +    }
3864 +
3865 +  if (*codep == 0x0f)
3866 +    {
3867 +      FETCH_DATA (info, codep + 2);
3868 +      dp = &dis386_twobyte[*++codep];
3869 +      need_modrm = twobyte_has_modrm[*codep];
3870 +      uses_SSE_prefix = twobyte_uses_SSE_prefix[*codep];
3871 +      uses_LOCK_prefix = (*codep & ~0x02) == 0x20;
3872 +    }
3873 +  else
3874 +    {
3875 +      dp = &dis386[*codep];
3876 +      need_modrm = onebyte_has_modrm[*codep];
3877 +      uses_SSE_prefix = 0;
3878 +      uses_LOCK_prefix = 0;
3879 +    }
3880 +  codep++;
3881 +
3882 +  if (!uses_SSE_prefix && (prefixes & PREFIX_REPZ))
3883 +    {
3884 +      oappend ("repz ");
3885 +      used_prefixes |= PREFIX_REPZ;
3886 +    }
3887 +  if (!uses_SSE_prefix && (prefixes & PREFIX_REPNZ))
3888 +    {
3889 +      oappend ("repnz ");
3890 +      used_prefixes |= PREFIX_REPNZ;
3891 +    }
3892 +  if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK))
3893 +    {
3894 +      oappend ("lock ");
3895 +      used_prefixes |= PREFIX_LOCK;
3896 +    }
3897 +
3898 +  if (prefixes & PREFIX_ADDR)
3899 +    {
3900 +      sizeflag ^= AFLAG;
3901 +      if (dp->bytemode3 != loop_jcxz_mode || intel_syntax)
3902 +       {
3903 +         if ((sizeflag & AFLAG) || mode_64bit)
3904 +           oappend ("addr32 ");
3905 +         else
3906 +           oappend ("addr16 ");
3907 +         used_prefixes |= PREFIX_ADDR;
3908 +       }
3909 +    }
3910 +
3911 +  if (!uses_SSE_prefix && (prefixes & PREFIX_DATA))
3912 +    {
3913 +      sizeflag ^= DFLAG;
3914 +      if (dp->bytemode3 == cond_jump_mode
3915 +         && dp->bytemode1 == v_mode
3916 +         && !intel_syntax)
3917 +       {
3918 +         if (sizeflag & DFLAG)
3919 +           oappend ("data32 ");
3920 +         else
3921 +           oappend ("data16 ");
3922 +         used_prefixes |= PREFIX_DATA;
3923 +       }
3924 +    }
3925 +
3926 +  if (need_modrm)
3927 +    {
3928 +      FETCH_DATA (info, codep + 1);
3929 +      mod = (*codep >> 6) & 3;
3930 +      reg = (*codep >> 3) & 7;
3931 +      rm = *codep & 7;
3932 +    }
3933 +
3934 +  if (dp->name == NULL && dp->bytemode1 == FLOATCODE)
3935 +    {
3936 +      dofloat (sizeflag);
3937 +    }
3938 +  else
3939 +    {
3940 +      int index;
3941 +      if (dp->name == NULL)
3942 +       {
3943 +         switch (dp->bytemode1)
3944 +           {
3945 +           case USE_GROUPS:
3946 +             dp = &grps[dp->bytemode2][reg];
3947 +             break;
3948 +
3949 +           case USE_PREFIX_USER_TABLE:
3950 +             index = 0;
3951 +             used_prefixes |= (prefixes & PREFIX_REPZ);
3952 +             if (prefixes & PREFIX_REPZ)
3953 +               index = 1;
3954 +             else
3955 +               {
3956 +                 used_prefixes |= (prefixes & PREFIX_DATA);
3957 +                 if (prefixes & PREFIX_DATA)
3958 +                   index = 2;
3959 +                 else
3960 +                   {
3961 +                     used_prefixes |= (prefixes & PREFIX_REPNZ);
3962 +                     if (prefixes & PREFIX_REPNZ)
3963 +                       index = 3;
3964 +                   }
3965 +               }
3966 +             dp = &prefix_user_table[dp->bytemode2][index];
3967 +             break;
3968 +
3969 +           case X86_64_SPECIAL:
3970 +             dp = &x86_64_table[dp->bytemode2][mode_64bit];
3971 +             break;
3972 +
3973 +           default:
3974 +             oappend (INTERNAL_DISASSEMBLER_ERROR);
3975 +             break;
3976 +           }
3977 +       }
3978 +
3979 +      if (putop (dp->name, sizeflag) == 0)
3980 +       {
3981 +         obufp = op1out;
3982 +         op_ad = 2;
3983 +         if (dp->op1)
3984 +           (*dp->op1) (dp->bytemode1, sizeflag);
3985 +
3986 +         obufp = op2out;
3987 +         op_ad = 1;
3988 +         if (dp->op2)
3989 +           (*dp->op2) (dp->bytemode2, sizeflag);
3990 +
3991 +         obufp = op3out;
3992 +         op_ad = 0;
3993 +         if (dp->op3)
3994 +           (*dp->op3) (dp->bytemode3, sizeflag);
3995 +       }
3996 +    }
3997 +
3998 +  /* See if any prefixes were not used.  If so, print the first one
3999 +     separately.  If we don't do this, we'll wind up printing an
4000 +     instruction stream which does not precisely correspond to the
4001 +     bytes we are disassembling.  */
4002 +  if ((prefixes & ~used_prefixes) != 0)
4003 +    {
4004 +      const char *name;
4005 +
4006 +      name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
4007 +      if (name == NULL)
4008 +       name = INTERNAL_DISASSEMBLER_ERROR;
4009 +      (*info->fprintf_func) (info->stream, "%s", name);
4010 +      return 1;
4011 +    }
4012 +  if (rex & ~rex_used)
4013 +    {
4014 +      const char *name;
4015 +      name = prefix_name (rex | 0x40, priv.orig_sizeflag);
4016 +      if (name == NULL)
4017 +       name = INTERNAL_DISASSEMBLER_ERROR;
4018 +      (*info->fprintf_func) (info->stream, "%s ", name);
4019 +    }
4020 +
4021 +  obufp = obuf + strlen (obuf);
4022 +  for (i = strlen (obuf); i < 6; i++)
4023 +    oappend (" ");
4024 +  oappend (" ");
4025 +  (*info->fprintf_func) (info->stream, "%s", obuf);
4026 +
4027 +  /* The enter and bound instructions are printed with operands in the same
4028 +     order as the intel book; everything else is printed in reverse order.  */
4029 +  if (intel_syntax || two_source_ops)
4030 +    {
4031 +      first = op1out;
4032 +      second = op2out;
4033 +      third = op3out;
4034 +      op_ad = op_index[0];
4035 +      op_index[0] = op_index[2];
4036 +      op_index[2] = op_ad;
4037 +    }
4038 +  else
4039 +    {
4040 +      first = op3out;
4041 +      second = op2out;
4042 +      third = op1out;
4043 +    }
4044 +  needcomma = 0;
4045 +  if (*first)
4046 +    {
4047 +      if (op_index[0] != -1 && !op_riprel[0])
4048 +       (*info->print_address_func) ((bfd_vma) op_address[op_index[0]], info);
4049 +      else
4050 +       (*info->fprintf_func) (info->stream, "%s", first);
4051 +      needcomma = 1;
4052 +    }
4053 +  if (*second)
4054 +    {
4055 +      if (needcomma)
4056 +       (*info->fprintf_func) (info->stream, ",");
4057 +      if (op_index[1] != -1 && !op_riprel[1])
4058 +       (*info->print_address_func) ((bfd_vma) op_address[op_index[1]], info);
4059 +      else
4060 +       (*info->fprintf_func) (info->stream, "%s", second);
4061 +      needcomma = 1;
4062 +    }
4063 +  if (*third)
4064 +    {
4065 +      if (needcomma)
4066 +       (*info->fprintf_func) (info->stream, ",");
4067 +      if (op_index[2] != -1 && !op_riprel[2])
4068 +       (*info->print_address_func) ((bfd_vma) op_address[op_index[2]], info);
4069 +      else
4070 +       (*info->fprintf_func) (info->stream, "%s", third);
4071 +    }
4072 +  for (i = 0; i < 3; i++)
4073 +    if (op_index[i] != -1 && op_riprel[i])
4074 +      {
4075 +       (*info->fprintf_func) (info->stream, "        # ");
4076 +       (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
4077 +                                               + op_address[op_index[i]]), info);
4078 +      }
4079 +  return codep - priv.the_buffer;
4080 +}
4081 +
4082 +static const char *float_mem[] = {
4083 +  /* d8 */
4084 +  "fadd{s||s|}",
4085 +  "fmul{s||s|}",
4086 +  "fcom{s||s|}",
4087 +  "fcomp{s||s|}",
4088 +  "fsub{s||s|}",
4089 +  "fsubr{s||s|}",
4090 +  "fdiv{s||s|}",
4091 +  "fdivr{s||s|}",
4092 +  /* d9 */
4093 +  "fld{s||s|}",
4094 +  "(bad)",
4095 +  "fst{s||s|}",
4096 +  "fstp{s||s|}",
4097 +  "fldenvIC",
4098 +  "fldcw",
4099 +  "fNstenvIC",
4100 +  "fNstcw",
4101 +  /* da */
4102 +  "fiadd{l||l|}",
4103 +  "fimul{l||l|}",
4104 +  "ficom{l||l|}",
4105 +  "ficomp{l||l|}",
4106 +  "fisub{l||l|}",
4107 +  "fisubr{l||l|}",
4108 +  "fidiv{l||l|}",
4109 +  "fidivr{l||l|}",
4110 +  /* db */
4111 +  "fild{l||l|}",
4112 +  "fisttp{l||l|}",
4113 +  "fist{l||l|}",
4114 +  "fistp{l||l|}",
4115 +  "(bad)",
4116 +  "fld{t||t|}",
4117 +  "(bad)",
4118 +  "fstp{t||t|}",
4119 +  /* dc */
4120 +  "fadd{l||l|}",
4121 +  "fmul{l||l|}",
4122 +  "fcom{l||l|}",
4123 +  "fcomp{l||l|}",
4124 +  "fsub{l||l|}",
4125 +  "fsubr{l||l|}",
4126 +  "fdiv{l||l|}",
4127 +  "fdivr{l||l|}",
4128 +  /* dd */
4129 +  "fld{l||l|}",
4130 +  "fisttp{ll||ll|}",
4131 +  "fst{l||l|}",
4132 +  "fstp{l||l|}",
4133 +  "frstorIC",
4134 +  "(bad)",
4135 +  "fNsaveIC",
4136 +  "fNstsw",
4137 +  /* de */
4138 +  "fiadd",
4139 +  "fimul",
4140 +  "ficom",
4141 +  "ficomp",
4142 +  "fisub",
4143 +  "fisubr",
4144 +  "fidiv",
4145 +  "fidivr",
4146 +  /* df */
4147 +  "fild",
4148 +  "fisttp",
4149 +  "fist",
4150 +  "fistp",
4151 +  "fbld",
4152 +  "fild{ll||ll|}",
4153 +  "fbstp",
4154 +  "fistp{ll||ll|}",
4155 +};
4156 +
4157 +static const unsigned char float_mem_mode[] = {
4158 +  /* d8 */
4159 +  d_mode,
4160 +  d_mode,
4161 +  d_mode,
4162 +  d_mode,
4163 +  d_mode,
4164 +  d_mode,
4165 +  d_mode,
4166 +  d_mode,
4167 +  /* d9 */
4168 +  d_mode,
4169 +  0,
4170 +  d_mode,
4171 +  d_mode,
4172 +  0,
4173 +  w_mode,
4174 +  0,
4175 +  w_mode,
4176 +  /* da */
4177 +  d_mode,
4178 +  d_mode,
4179 +  d_mode,
4180 +  d_mode,
4181 +  d_mode,
4182 +  d_mode,
4183 +  d_mode,
4184 +  d_mode,
4185 +  /* db */
4186 +  d_mode,
4187 +  d_mode,
4188 +  d_mode,
4189 +  d_mode,
4190 +  0,
4191 +  t_mode,
4192 +  0,
4193 +  t_mode,
4194 +  /* dc */
4195 +  q_mode,
4196 +  q_mode,
4197 +  q_mode,
4198 +  q_mode,
4199 +  q_mode,
4200 +  q_mode,
4201 +  q_mode,
4202 +  q_mode,
4203 +  /* dd */
4204 +  q_mode,
4205 +  q_mode,
4206 +  q_mode,
4207 +  q_mode,
4208 +  0,
4209 +  0,
4210 +  0,
4211 +  w_mode,
4212 +  /* de */
4213 +  w_mode,
4214 +  w_mode,
4215 +  w_mode,
4216 +  w_mode,
4217 +  w_mode,
4218 +  w_mode,
4219 +  w_mode,
4220 +  w_mode,
4221 +  /* df */
4222 +  w_mode,
4223 +  w_mode,
4224 +  w_mode,
4225 +  w_mode,
4226 +  t_mode,
4227 +  q_mode,
4228 +  t_mode,
4229 +  q_mode
4230 +};
4231 +
4232 +#define ST OP_ST, 0
4233 +#define STi OP_STi, 0
4234 +
4235 +#define FGRPd9_2 NULL, NULL, 0, NULL, 0, NULL, 0
4236 +#define FGRPd9_4 NULL, NULL, 1, NULL, 0, NULL, 0
4237 +#define FGRPd9_5 NULL, NULL, 2, NULL, 0, NULL, 0
4238 +#define FGRPd9_6 NULL, NULL, 3, NULL, 0, NULL, 0
4239 +#define FGRPd9_7 NULL, NULL, 4, NULL, 0, NULL, 0
4240 +#define FGRPda_5 NULL, NULL, 5, NULL, 0, NULL, 0
4241 +#define FGRPdb_4 NULL, NULL, 6, NULL, 0, NULL, 0
4242 +#define FGRPde_3 NULL, NULL, 7, NULL, 0, NULL, 0
4243 +#define FGRPdf_4 NULL, NULL, 8, NULL, 0, NULL, 0
4244 +
4245 +static const struct dis386 float_reg[][8] = {
4246 +  /* d8 */
4247 +  {
4248 +    { "fadd",  ST, STi, XX },
4249 +    { "fmul",  ST, STi, XX },
4250 +    { "fcom",  STi, XX, XX },
4251 +    { "fcomp", STi, XX, XX },
4252 +    { "fsub",  ST, STi, XX },
4253 +    { "fsubr", ST, STi, XX },
4254 +    { "fdiv",  ST, STi, XX },
4255 +    { "fdivr", ST, STi, XX },
4256 +  },
4257 +  /* d9 */
4258 +  {
4259 +    { "fld",   STi, XX, XX },
4260 +    { "fxch",  STi, XX, XX },
4261 +    { FGRPd9_2 },
4262 +    { "(bad)", XX, XX, XX },
4263 +    { FGRPd9_4 },
4264 +    { FGRPd9_5 },
4265 +    { FGRPd9_6 },
4266 +    { FGRPd9_7 },
4267 +  },
4268 +  /* da */
4269 +  {
4270 +    { "fcmovb",        ST, STi, XX },
4271 +    { "fcmove",        ST, STi, XX },
4272 +    { "fcmovbe",ST, STi, XX },
4273 +    { "fcmovu",        ST, STi, XX },
4274 +    { "(bad)", XX, XX, XX },
4275 +    { FGRPda_5 },
4276 +    { "(bad)", XX, XX, XX },
4277 +    { "(bad)", XX, XX, XX },
4278 +  },
4279 +  /* db */
4280 +  {
4281 +    { "fcmovnb",ST, STi, XX },
4282 +    { "fcmovne",ST, STi, XX },
4283 +    { "fcmovnbe",ST, STi, XX },
4284 +    { "fcmovnu",ST, STi, XX },
4285 +    { FGRPdb_4 },
4286 +    { "fucomi",        ST, STi, XX },
4287 +    { "fcomi", ST, STi, XX },
4288 +    { "(bad)", XX, XX, XX },
4289 +  },
4290 +  /* dc */
4291 +  {
4292 +    { "fadd",  STi, ST, XX },
4293 +    { "fmul",  STi, ST, XX },
4294 +    { "(bad)", XX, XX, XX },
4295 +    { "(bad)", XX, XX, XX },
4296 +#if UNIXWARE_COMPAT
4297 +    { "fsub",  STi, ST, XX },
4298 +    { "fsubr", STi, ST, XX },
4299 +    { "fdiv",  STi, ST, XX },
4300 +    { "fdivr", STi, ST, XX },
4301 +#else
4302 +    { "fsubr", STi, ST, XX },
4303 +    { "fsub",  STi, ST, XX },
4304 +    { "fdivr", STi, ST, XX },
4305 +    { "fdiv",  STi, ST, XX },
4306 +#endif
4307 +  },
4308 +  /* dd */
4309 +  {
4310 +    { "ffree", STi, XX, XX },
4311 +    { "(bad)", XX, XX, XX },
4312 +    { "fst",   STi, XX, XX },
4313 +    { "fstp",  STi, XX, XX },
4314 +    { "fucom", STi, XX, XX },
4315 +    { "fucomp",        STi, XX, XX },
4316 +    { "(bad)", XX, XX, XX },
4317 +    { "(bad)", XX, XX, XX },
4318 +  },
4319 +  /* de */
4320 +  {
4321 +    { "faddp", STi, ST, XX },
4322 +    { "fmulp", STi, ST, XX },
4323 +    { "(bad)", XX, XX, XX },
4324 +    { FGRPde_3 },
4325 +#if UNIXWARE_COMPAT
4326 +    { "fsubp", STi, ST, XX },
4327 +    { "fsubrp",        STi, ST, XX },
4328 +    { "fdivp", STi, ST, XX },
4329 +    { "fdivrp",        STi, ST, XX },
4330 +#else
4331 +    { "fsubrp",        STi, ST, XX },
4332 +    { "fsubp", STi, ST, XX },
4333 +    { "fdivrp",        STi, ST, XX },
4334 +    { "fdivp", STi, ST, XX },
4335 +#endif
4336 +  },
4337 +  /* df */
4338 +  {
4339 +    { "ffreep",        STi, XX, XX },
4340 +    { "(bad)", XX, XX, XX },
4341 +    { "(bad)", XX, XX, XX },
4342 +    { "(bad)", XX, XX, XX },
4343 +    { FGRPdf_4 },
4344 +    { "fucomip",ST, STi, XX },
4345 +    { "fcomip", ST, STi, XX },
4346 +    { "(bad)", XX, XX, XX },
4347 +  },
4348 +};
4349 +
4350 +static char *fgrps[][8] = {
4351 +  /* d9_2  0 */
4352 +  {
4353 +    "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4354 +  },
4355 +
4356 +  /* d9_4  1 */
4357 +  {
4358 +    "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
4359 +  },
4360 +
4361 +  /* d9_5  2 */
4362 +  {
4363 +    "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
4364 +  },
4365 +
4366 +  /* d9_6  3 */
4367 +  {
4368 +    "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
4369 +  },
4370 +
4371 +  /* d9_7  4 */
4372 +  {
4373 +    "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
4374 +  },
4375 +
4376 +  /* da_5  5 */
4377 +  {
4378 +    "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4379 +  },
4380 +
4381 +  /* db_4  6 */
4382 +  {
4383 +    "feni(287 only)","fdisi(287 only)","fNclex","fNinit",
4384 +    "fNsetpm(287 only)","(bad)","(bad)","(bad)",
4385 +  },
4386 +
4387 +  /* de_3  7 */
4388 +  {
4389 +    "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4390 +  },
4391 +
4392 +  /* df_4  8 */
4393 +  {
4394 +    "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4395 +  },
4396 +};
4397 +
4398 +static void
4399 +dofloat (int sizeflag)
4400 +{
4401 +  const struct dis386 *dp;
4402 +  unsigned char floatop;
4403 +
4404 +  floatop = codep[-1];
4405 +
4406 +  if (mod != 3)
4407 +    {
4408 +      int fp_indx = (floatop - 0xd8) * 8 + reg;
4409 +
4410 +      putop (float_mem[fp_indx], sizeflag);
4411 +      obufp = op1out;
4412 +      OP_E (float_mem_mode[fp_indx], sizeflag);
4413 +      return;
4414 +    }
4415 +  /* Skip mod/rm byte.  */
4416 +  MODRM_CHECK;
4417 +  codep++;
4418 +
4419 +  dp = &float_reg[floatop - 0xd8][reg];
4420 +  if (dp->name == NULL)
4421 +    {
4422 +      putop (fgrps[dp->bytemode1][rm], sizeflag);
4423 +
4424 +      /* Instruction fnstsw is only one with strange arg.  */
4425 +      if (floatop == 0xdf && codep[-1] == 0xe0)
4426 +       strcpy (op1out, names16[0]);
4427 +    }
4428 +  else
4429 +    {
4430 +      putop (dp->name, sizeflag);
4431 +
4432 +      obufp = op1out;
4433 +      if (dp->op1)
4434 +       (*dp->op1) (dp->bytemode1, sizeflag);
4435 +      obufp = op2out;
4436 +      if (dp->op2)
4437 +       (*dp->op2) (dp->bytemode2, sizeflag);
4438 +    }
4439 +}
4440 +
4441 +static void
4442 +OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4443 +{
4444 +  oappend ("%st");
4445 +}
4446 +
4447 +static void
4448 +OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4449 +{
4450 +  sprintf (scratchbuf, "%%st(%d)", rm);
4451 +  oappend (scratchbuf + intel_syntax);
4452 +}
4453 +
4454 +/* Capital letters in template are macros.  */
4455 +static int
4456 +putop (const char *template, int sizeflag)
4457 +{
4458 +  const char *p;
4459 +  int alt = 0;
4460 +
4461 +  for (p = template; *p; p++)
4462 +    {
4463 +      switch (*p)
4464 +       {
4465 +       default:
4466 +         *obufp++ = *p;
4467 +         break;
4468 +       case '{':
4469 +         alt = 0;
4470 +         if (intel_syntax)
4471 +           alt += 1;
4472 +         if (mode_64bit)
4473 +           alt += 2;
4474 +         while (alt != 0)
4475 +           {
4476 +             while (*++p != '|')
4477 +               {
4478 +                 if (*p == '}')
4479 +                   {
4480 +                     /* Alternative not valid.  */
4481 +                     strcpy (obuf, "(bad)");
4482 +                     obufp = obuf + 5;
4483 +                     return 1;
4484 +                   }
4485 +                 else if (*p == '\0')
4486 +                   abort ();
4487 +               }
4488 +             alt--;
4489 +           }
4490 +         /* Fall through.  */
4491 +       case 'I':
4492 +         alt = 1;
4493 +         continue;
4494 +       case '|':
4495 +         while (*++p != '}')
4496 +           {
4497 +             if (*p == '\0')
4498 +               abort ();
4499 +           }
4500 +         break;
4501 +       case '}':
4502 +         break;
4503 +       case 'A':
4504 +         if (intel_syntax)
4505 +           break;
4506 +         if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
4507 +           *obufp++ = 'b';
4508 +         break;
4509 +       case 'B':
4510 +         if (intel_syntax)
4511 +           break;
4512 +         if (sizeflag & SUFFIX_ALWAYS)
4513 +           *obufp++ = 'b';
4514 +         break;
4515 +       case 'C':
4516 +         if (intel_syntax && !alt)
4517 +           break;
4518 +         if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
4519 +           {
4520 +             if (sizeflag & DFLAG)
4521 +               *obufp++ = intel_syntax ? 'd' : 'l';
4522 +             else
4523 +               *obufp++ = intel_syntax ? 'w' : 's';
4524 +             used_prefixes |= (prefixes & PREFIX_DATA);
4525 +           }
4526 +         break;
4527 +       case 'E':               /* For jcxz/jecxz */
4528 +         if (mode_64bit)
4529 +           {
4530 +             if (sizeflag & AFLAG)
4531 +               *obufp++ = 'r';
4532 +             else
4533 +               *obufp++ = 'e';
4534 +           }
4535 +         else
4536 +           if (sizeflag & AFLAG)
4537 +             *obufp++ = 'e';
4538 +         used_prefixes |= (prefixes & PREFIX_ADDR);
4539 +         break;
4540 +       case 'F':
4541 +         if (intel_syntax)
4542 +           break;
4543 +         if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
4544 +           {
4545 +             if (sizeflag & AFLAG)
4546 +               *obufp++ = mode_64bit ? 'q' : 'l';
4547 +             else
4548 +               *obufp++ = mode_64bit ? 'l' : 'w';
4549 +             used_prefixes |= (prefixes & PREFIX_ADDR);
4550 +           }
4551 +         break;
4552 +       case 'H':
4553 +         if (intel_syntax)
4554 +           break;
4555 +         if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
4556 +             || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
4557 +           {
4558 +             used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
4559 +             *obufp++ = ',';
4560 +             *obufp++ = 'p';
4561 +             if (prefixes & PREFIX_DS)
4562 +               *obufp++ = 't';
4563 +             else
4564 +               *obufp++ = 'n';
4565 +           }
4566 +         break;
4567 +       case 'J':
4568 +         if (intel_syntax)
4569 +           break;
4570 +         *obufp++ = 'l';
4571 +         break;
4572 +       case 'L':
4573 +         if (intel_syntax)
4574 +           break;
4575 +         if (sizeflag & SUFFIX_ALWAYS)
4576 +           *obufp++ = 'l';
4577 +         break;
4578 +       case 'N':
4579 +         if ((prefixes & PREFIX_FWAIT) == 0)
4580 +           *obufp++ = 'n';
4581 +         else
4582 +           used_prefixes |= PREFIX_FWAIT;
4583 +         break;
4584 +       case 'O':
4585 +         USED_REX (REX_MODE64);
4586 +         if (rex & REX_MODE64)
4587 +           *obufp++ = 'o';
4588 +         else
4589 +           *obufp++ = 'd';
4590 +         break;
4591 +       case 'T':
4592 +         if (intel_syntax)
4593 +           break;
4594 +         if (mode_64bit)
4595 +           {
4596 +             *obufp++ = 'q';
4597 +             break;
4598 +           }
4599 +         /* Fall through.  */
4600 +       case 'P':
4601 +         if (intel_syntax)
4602 +           break;
4603 +         if ((prefixes & PREFIX_DATA)
4604 +             || (rex & REX_MODE64)
4605 +             || (sizeflag & SUFFIX_ALWAYS))
4606 +           {
4607 +             USED_REX (REX_MODE64);
4608 +             if (rex & REX_MODE64)
4609 +               *obufp++ = 'q';
4610 +             else
4611 +               {
4612 +                  if (sizeflag & DFLAG)
4613 +                     *obufp++ = 'l';
4614 +                  else
4615 +                    *obufp++ = 'w';
4616 +                  used_prefixes |= (prefixes & PREFIX_DATA);
4617 +               }
4618 +           }
4619 +         break;
4620 +       case 'U':
4621 +         if (intel_syntax)
4622 +           break;
4623 +         if (mode_64bit)
4624 +           {
4625 +             *obufp++ = 'q';
4626 +             break;
4627 +           }
4628 +         /* Fall through.  */
4629 +       case 'Q':
4630 +         if (intel_syntax && !alt)
4631 +           break;
4632 +         USED_REX (REX_MODE64);
4633 +         if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
4634 +           {
4635 +             if (rex & REX_MODE64)
4636 +               *obufp++ = 'q';
4637 +             else
4638 +               {
4639 +                 if (sizeflag & DFLAG)
4640 +                   *obufp++ = intel_syntax ? 'd' : 'l';
4641 +                 else
4642 +                   *obufp++ = 'w';
4643 +                 used_prefixes |= (prefixes & PREFIX_DATA);
4644 +               }
4645 +           }
4646 +         break;
4647 +       case 'R':
4648 +         USED_REX (REX_MODE64);
4649 +         if (intel_syntax)
4650 +           {
4651 +             if (rex & REX_MODE64)
4652 +               {
4653 +                 *obufp++ = 'q';
4654 +                 *obufp++ = 't';
4655 +               }
4656 +             else if (sizeflag & DFLAG)
4657 +               {
4658 +                 *obufp++ = 'd';
4659 +                 *obufp++ = 'q';
4660 +               }
4661 +             else
4662 +               {
4663 +                 *obufp++ = 'w';
4664 +                 *obufp++ = 'd';
4665 +               }
4666 +           }
4667 +         else
4668 +           {
4669 +             if (rex & REX_MODE64)
4670 +               *obufp++ = 'q';
4671 +             else if (sizeflag & DFLAG)
4672 +               *obufp++ = 'l';
4673 +             else
4674 +               *obufp++ = 'w';
4675 +           }
4676 +         if (!(rex & REX_MODE64))
4677 +           used_prefixes |= (prefixes & PREFIX_DATA);
4678 +         break;
4679 +       case 'S':
4680 +         if (intel_syntax)
4681 +           break;
4682 +         if (sizeflag & SUFFIX_ALWAYS)
4683 +           {
4684 +             if (rex & REX_MODE64)
4685 +               *obufp++ = 'q';
4686 +             else
4687 +               {
4688 +                 if (sizeflag & DFLAG)
4689 +                   *obufp++ = 'l';
4690 +                 else
4691 +                   *obufp++ = 'w';
4692 +                 used_prefixes |= (prefixes & PREFIX_DATA);
4693 +               }
4694 +           }
4695 +         break;
4696 +       case 'X':
4697 +         if (prefixes & PREFIX_DATA)
4698 +           *obufp++ = 'd';
4699 +         else
4700 +           *obufp++ = 's';
4701 +         used_prefixes |= (prefixes & PREFIX_DATA);
4702 +         break;
4703 +       case 'Y':
4704 +         if (intel_syntax)
4705 +           break;
4706 +         if (rex & REX_MODE64)
4707 +           {
4708 +             USED_REX (REX_MODE64);
4709 +             *obufp++ = 'q';
4710 +           }
4711 +         break;
4712 +         /* implicit operand size 'l' for i386 or 'q' for x86-64 */
4713 +       case 'W':
4714 +         /* operand size flag for cwtl, cbtw */
4715 +         USED_REX (0);
4716 +         if (rex)
4717 +           *obufp++ = 'l';
4718 +         else if (sizeflag & DFLAG)
4719 +           *obufp++ = 'w';
4720 +         else
4721 +           *obufp++ = 'b';
4722 +         if (intel_syntax)
4723 +           {
4724 +             if (rex)
4725 +               {
4726 +                 *obufp++ = 'q';
4727 +                 *obufp++ = 'e';
4728 +               }
4729 +             if (sizeflag & DFLAG)
4730 +               {
4731 +                 *obufp++ = 'd';
4732 +                 *obufp++ = 'e';
4733 +               }
4734 +             else
4735 +               {
4736 +                 *obufp++ = 'w';
4737 +               }
4738 +           }
4739 +         if (!rex)
4740 +           used_prefixes |= (prefixes & PREFIX_DATA);
4741 +         break;
4742 +       }
4743 +      alt = 0;
4744 +    }
4745 +  *obufp = 0;
4746 +  return 0;
4747 +}
4748 +
4749 +static void
4750 +oappend (const char *s)
4751 +{
4752 +  strcpy (obufp, s);
4753 +  obufp += strlen (s);
4754 +}
4755 +
4756 +static void
4757 +append_seg (void)
4758 +{
4759 +  if (prefixes & PREFIX_CS)
4760 +    {
4761 +      used_prefixes |= PREFIX_CS;
4762 +      oappend ("%cs:" + intel_syntax);
4763 +    }
4764 +  if (prefixes & PREFIX_DS)
4765 +    {
4766 +      used_prefixes |= PREFIX_DS;
4767 +      oappend ("%ds:" + intel_syntax);
4768 +    }
4769 +  if (prefixes & PREFIX_SS)
4770 +    {
4771 +      used_prefixes |= PREFIX_SS;
4772 +      oappend ("%ss:" + intel_syntax);
4773 +    }
4774 +  if (prefixes & PREFIX_ES)
4775 +    {
4776 +      used_prefixes |= PREFIX_ES;
4777 +      oappend ("%es:" + intel_syntax);
4778 +    }
4779 +  if (prefixes & PREFIX_FS)
4780 +    {
4781 +      used_prefixes |= PREFIX_FS;
4782 +      oappend ("%fs:" + intel_syntax);
4783 +    }
4784 +  if (prefixes & PREFIX_GS)
4785 +    {
4786 +      used_prefixes |= PREFIX_GS;
4787 +      oappend ("%gs:" + intel_syntax);
4788 +    }
4789 +}
4790 +
4791 +static void
4792 +OP_indirE (int bytemode, int sizeflag)
4793 +{
4794 +  if (!intel_syntax)
4795 +    oappend ("*");
4796 +  OP_E (bytemode, sizeflag);
4797 +}
4798 +
4799 +static void
4800 +print_operand_value (char *buf, int hex, bfd_vma disp)
4801 +{
4802 +  if (mode_64bit)
4803 +    {
4804 +      if (hex)
4805 +       {
4806 +         char tmp[30];
4807 +         int i;
4808 +         buf[0] = '0';
4809 +         buf[1] = 'x';
4810 +         sprintf_vma (tmp, disp);
4811 +         for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
4812 +         strcpy (buf + 2, tmp + i);
4813 +       }
4814 +      else
4815 +       {
4816 +         bfd_signed_vma v = disp;
4817 +         char tmp[30];
4818 +         int i;
4819 +         if (v < 0)
4820 +           {
4821 +             *(buf++) = '-';
4822 +             v = -disp;
4823 +             /* Check for possible overflow on 0x8000000000000000.  */
4824 +             if (v < 0)
4825 +               {
4826 +                 strcpy (buf, "9223372036854775808");
4827 +                 return;
4828 +               }
4829 +           }
4830 +         if (!v)
4831 +           {
4832 +             strcpy (buf, "0");
4833 +             return;
4834 +           }
4835 +
4836 +         i = 0;
4837 +         tmp[29] = 0;
4838 +         while (v)
4839 +           {
4840 +             tmp[28 - i] = (v % 10) + '0';
4841 +             v /= 10;
4842 +             i++;
4843 +           }
4844 +         strcpy (buf, tmp + 29 - i);
4845 +       }
4846 +    }
4847 +  else
4848 +    {
4849 +      if (hex)
4850 +       sprintf (buf, "0x%x", (unsigned int) disp);
4851 +      else
4852 +       sprintf (buf, "%d", (int) disp);
4853 +    }
4854 +}
4855 +
4856 +static void
4857 +OP_E (int bytemode, int sizeflag)
4858 +{
4859 +  bfd_vma disp;
4860 +  int add = 0;
4861 +  int riprel = 0;
4862 +  USED_REX (REX_EXTZ);
4863 +  if (rex & REX_EXTZ)
4864 +    add += 8;
4865 +
4866 +  /* Skip mod/rm byte.  */
4867 +  MODRM_CHECK;
4868 +  codep++;
4869 +
4870 +  if (mod == 3)
4871 +    {
4872 +      switch (bytemode)
4873 +       {
4874 +       case b_mode:
4875 +         USED_REX (0);
4876 +         if (rex)
4877 +           oappend (names8rex[rm + add]);
4878 +         else
4879 +           oappend (names8[rm + add]);
4880 +         break;
4881 +       case w_mode:
4882 +         oappend (names16[rm + add]);
4883 +         break;
4884 +       case d_mode:
4885 +         oappend (names32[rm + add]);
4886 +         break;
4887 +       case q_mode:
4888 +         oappend (names64[rm + add]);
4889 +         break;
4890 +       case m_mode:
4891 +         if (mode_64bit)
4892 +           oappend (names64[rm + add]);
4893 +         else
4894 +           oappend (names32[rm + add]);
4895 +         break;
4896 +       case branch_v_mode:
4897 +         if (mode_64bit)
4898 +           oappend (names64[rm + add]);
4899 +         else
4900 +           {
4901 +             if ((sizeflag & DFLAG) || bytemode != branch_v_mode)
4902 +               oappend (names32[rm + add]);
4903 +             else
4904 +               oappend (names16[rm + add]);
4905 +             used_prefixes |= (prefixes & PREFIX_DATA);
4906 +           }
4907 +         break;
4908 +       case v_mode:
4909 +       case dq_mode:
4910 +       case dqw_mode:
4911 +         USED_REX (REX_MODE64);
4912 +         if (rex & REX_MODE64)
4913 +           oappend (names64[rm + add]);
4914 +         else if ((sizeflag & DFLAG) || bytemode != v_mode)
4915 +           oappend (names32[rm + add]);
4916 +         else
4917 +           oappend (names16[rm + add]);
4918 +         used_prefixes |= (prefixes & PREFIX_DATA);
4919 +         break;
4920 +       case 0:
4921 +         break;
4922 +       default:
4923 +         oappend (INTERNAL_DISASSEMBLER_ERROR);
4924 +         break;
4925 +       }
4926 +      return;
4927 +    }
4928 +
4929 +  disp = 0;
4930 +  append_seg ();
4931 +
4932 +  if ((sizeflag & AFLAG) || mode_64bit) /* 32 bit address mode */
4933 +    {
4934 +      int havesib;
4935 +      int havebase;
4936 +      int base;
4937 +      int index = 0;
4938 +      int scale = 0;
4939 +
4940 +      havesib = 0;
4941 +      havebase = 1;
4942 +      base = rm;
4943 +
4944 +      if (base == 4)
4945 +       {
4946 +         havesib = 1;
4947 +         FETCH_DATA (the_info, codep + 1);
4948 +         index = (*codep >> 3) & 7;
4949 +         if (mode_64bit || index != 0x4)
4950 +           /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored.  */
4951 +           scale = (*codep >> 6) & 3;
4952 +         base = *codep & 7;
4953 +         USED_REX (REX_EXTY);
4954 +         if (rex & REX_EXTY)
4955 +           index += 8;
4956 +         codep++;
4957 +       }
4958 +      base += add;
4959 +
4960 +      switch (mod)
4961 +       {
4962 +       case 0:
4963 +         if ((base & 7) == 5)
4964 +           {
4965 +             havebase = 0;
4966 +             if (mode_64bit && !havesib)
4967 +               riprel = 1;
4968 +             disp = get32s ();
4969 +           }
4970 +         break;
4971 +       case 1:
4972 +         FETCH_DATA (the_info, codep + 1);
4973 +         disp = *codep++;
4974 +         if ((disp & 0x80) != 0)
4975 +           disp -= 0x100;
4976 +         break;
4977 +       case 2:
4978 +         disp = get32s ();
4979 +         break;
4980 +       }
4981 +
4982 +      if (!intel_syntax)
4983 +       if (mod != 0 || (base & 7) == 5)
4984 +         {
4985 +           print_operand_value (scratchbuf, !riprel, disp);
4986 +           oappend (scratchbuf);
4987 +           if (riprel)
4988 +             {
4989 +               set_op (disp, 1);
4990 +               oappend ("(%rip)");
4991 +             }
4992 +         }
4993 +
4994 +      if (havebase || (havesib && (index != 4 || scale != 0)))
4995 +       {
4996 +         if (intel_syntax)
4997 +           {
4998 +             switch (bytemode)
4999 +               {
5000 +               case b_mode:
5001 +                 oappend ("BYTE PTR ");
5002 +                 break;
5003 +               case w_mode:
5004 +               case dqw_mode:
5005 +                 oappend ("WORD PTR ");
5006 +                 break;
5007 +               case branch_v_mode:
5008 +               case v_mode:
5009 +               case dq_mode:
5010 +                 USED_REX (REX_MODE64);
5011 +                 if (rex & REX_MODE64)
5012 +                   oappend ("QWORD PTR ");
5013 +                 else if ((sizeflag & DFLAG) || bytemode == dq_mode)
5014 +                   oappend ("DWORD PTR ");
5015 +                 else
5016 +                   oappend ("WORD PTR ");
5017 +                 used_prefixes |= (prefixes & PREFIX_DATA);
5018 +                 break;
5019 +               case d_mode:
5020 +                 oappend ("DWORD PTR ");
5021 +                 break;
5022 +               case q_mode:
5023 +                 oappend ("QWORD PTR ");
5024 +                 break;
5025 +               case m_mode:
5026 +                 if (mode_64bit)
5027 +                   oappend ("QWORD PTR ");
5028 +                 else
5029 +                   oappend ("DWORD PTR ");
5030 +                 break;
5031 +               case f_mode:
5032 +                 if (sizeflag & DFLAG)
5033 +                   {
5034 +                     used_prefixes |= (prefixes & PREFIX_DATA);
5035 +                     oappend ("FWORD PTR ");
5036 +                   }
5037 +                 else
5038 +                   oappend ("DWORD PTR ");
5039 +                 break;
5040 +               case t_mode:
5041 +                 oappend ("TBYTE PTR ");
5042 +                 break;
5043 +               case x_mode:
5044 +                 oappend ("XMMWORD PTR ");
5045 +                 break;
5046 +               default:
5047 +                 break;
5048 +               }
5049 +           }
5050 +         *obufp++ = open_char;
5051 +         if (intel_syntax && riprel)
5052 +           oappend ("rip + ");
5053 +         *obufp = '\0';
5054 +         if (havebase)
5055 +           oappend (mode_64bit && (sizeflag & AFLAG)
5056 +                    ? names64[base] : names32[base]);
5057 +         if (havesib)
5058 +           {
5059 +             if (index != 4)
5060 +               {
5061 +                 if (!intel_syntax || havebase)
5062 +                   {
5063 +                     *obufp++ = separator_char;
5064 +                     *obufp = '\0';
5065 +                   }
5066 +                 oappend (mode_64bit && (sizeflag & AFLAG)
5067 +                          ? names64[index] : names32[index]);
5068 +               }
5069 +             if (scale != 0 || (!intel_syntax && index != 4))
5070 +               {
5071 +                 *obufp++ = scale_char;
5072 +                 *obufp = '\0';
5073 +                 sprintf (scratchbuf, "%d", 1 << scale);
5074 +                 oappend (scratchbuf);
5075 +               }
5076 +           }
5077 +         if (intel_syntax && disp)
5078 +           {
5079 +             if ((bfd_signed_vma) disp > 0)
5080 +               {
5081 +                 *obufp++ = '+';
5082 +                 *obufp = '\0';
5083 +               }
5084 +             else if (mod != 1)
5085 +               {
5086 +                 *obufp++ = '-';
5087 +                 *obufp = '\0';
5088 +                 disp = - (bfd_signed_vma) disp;
5089 +               }
5090 +
5091 +             print_operand_value (scratchbuf, mod != 1, disp);
5092 +             oappend (scratchbuf);
5093 +           }
5094 +
5095 +         *obufp++ = close_char;
5096 +         *obufp = '\0';
5097 +       }
5098 +      else if (intel_syntax)
5099 +       {
5100 +         if (mod != 0 || (base & 7) == 5)
5101 +           {
5102 +             if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5103 +                             | PREFIX_ES | PREFIX_FS | PREFIX_GS))
5104 +               ;
5105 +             else
5106 +               {
5107 +                 oappend (names_seg[ds_reg - es_reg]);
5108 +                 oappend (":");
5109 +               }
5110 +             print_operand_value (scratchbuf, 1, disp);
5111 +             oappend (scratchbuf);
5112 +           }
5113 +       }
5114 +    }
5115 +  else
5116 +    { /* 16 bit address mode */
5117 +      switch (mod)
5118 +       {
5119 +       case 0:
5120 +         if (rm == 6)
5121 +           {
5122 +             disp = get16 ();
5123 +             if ((disp & 0x8000) != 0)
5124 +               disp -= 0x10000;
5125 +           }
5126 +         break;
5127 +       case 1:
5128 +         FETCH_DATA (the_info, codep + 1);
5129 +         disp = *codep++;
5130 +         if ((disp & 0x80) != 0)
5131 +           disp -= 0x100;
5132 +         break;
5133 +       case 2:
5134 +         disp = get16 ();
5135 +         if ((disp & 0x8000) != 0)
5136 +           disp -= 0x10000;
5137 +         break;
5138 +       }
5139 +
5140 +      if (!intel_syntax)
5141 +       if (mod != 0 || rm == 6)
5142 +         {
5143 +           print_operand_value (scratchbuf, 0, disp);
5144 +           oappend (scratchbuf);
5145 +         }
5146 +
5147 +      if (mod != 0 || rm != 6)
5148 +       {
5149 +         *obufp++ = open_char;
5150 +         *obufp = '\0';
5151 +         oappend (index16[rm]);
5152 +         if (intel_syntax && disp)
5153 +           {
5154 +             if ((bfd_signed_vma) disp > 0)
5155 +               {
5156 +                 *obufp++ = '+';
5157 +                 *obufp = '\0';
5158 +               }
5159 +             else if (mod != 1)
5160 +               {
5161 +                 *obufp++ = '-';
5162 +                 *obufp = '\0';
5163 +                 disp = - (bfd_signed_vma) disp;
5164 +               }
5165 +
5166 +             print_operand_value (scratchbuf, mod != 1, disp);
5167 +             oappend (scratchbuf);
5168 +           }
5169 +
5170 +         *obufp++ = close_char;
5171 +         *obufp = '\0';
5172 +       }
5173 +      else if (intel_syntax)
5174 +       {
5175 +         if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5176 +                         | PREFIX_ES | PREFIX_FS | PREFIX_GS))
5177 +           ;
5178 +         else
5179 +           {
5180 +             oappend (names_seg[ds_reg - es_reg]);
5181 +             oappend (":");
5182 +           }
5183 +         print_operand_value (scratchbuf, 1, disp & 0xffff);
5184 +         oappend (scratchbuf);
5185 +       }
5186 +    }
5187 +}
5188 +
5189 +static void
5190 +OP_G (int bytemode, int sizeflag)
5191 +{
5192 +  int add = 0;
5193 +  USED_REX (REX_EXTX);
5194 +  if (rex & REX_EXTX)
5195 +    add += 8;
5196 +  switch (bytemode)
5197 +    {
5198 +    case b_mode:
5199 +      USED_REX (0);
5200 +      if (rex)
5201 +       oappend (names8rex[reg + add]);
5202 +      else
5203 +       oappend (names8[reg + add]);
5204 +      break;
5205 +    case w_mode:
5206 +      oappend (names16[reg + add]);
5207 +      break;
5208 +    case d_mode:
5209 +      oappend (names32[reg + add]);
5210 +      break;
5211 +    case q_mode:
5212 +      oappend (names64[reg + add]);
5213 +      break;
5214 +    case v_mode:
5215 +    case dq_mode:
5216 +    case dqw_mode:
5217 +      USED_REX (REX_MODE64);
5218 +      if (rex & REX_MODE64)
5219 +       oappend (names64[reg + add]);
5220 +      else if ((sizeflag & DFLAG) || bytemode != v_mode)
5221 +       oappend (names32[reg + add]);
5222 +      else
5223 +       oappend (names16[reg + add]);
5224 +      used_prefixes |= (prefixes & PREFIX_DATA);
5225 +      break;
5226 +    case m_mode:
5227 +      if (mode_64bit)
5228 +       oappend (names64[reg + add]);
5229 +      else
5230 +       oappend (names32[reg + add]);
5231 +      break;
5232 +    default:
5233 +      oappend (INTERNAL_DISASSEMBLER_ERROR);
5234 +      break;
5235 +    }
5236 +}
5237 +
5238 +static bfd_vma
5239 +get64 (void)
5240 +{
5241 +  bfd_vma x;
5242 +#ifdef BFD64
5243 +  unsigned int a;
5244 +  unsigned int b;
5245 +
5246 +  FETCH_DATA (the_info, codep + 8);
5247 +  a = *codep++ & 0xff;
5248 +  a |= (*codep++ & 0xff) << 8;
5249 +  a |= (*codep++ & 0xff) << 16;
5250 +  a |= (*codep++ & 0xff) << 24;
5251 +  b = *codep++ & 0xff;
5252 +  b |= (*codep++ & 0xff) << 8;
5253 +  b |= (*codep++ & 0xff) << 16;
5254 +  b |= (*codep++ & 0xff) << 24;
5255 +  x = a + ((bfd_vma) b << 32);
5256 +#else
5257 +  abort ();
5258 +  x = 0;
5259 +#endif
5260 +  return x;
5261 +}
5262 +
5263 +static bfd_signed_vma
5264 +get32 (void)
5265 +{
5266 +  bfd_signed_vma x = 0;
5267 +
5268 +  FETCH_DATA (the_info, codep + 4);
5269 +  x = *codep++ & (bfd_signed_vma) 0xff;
5270 +  x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
5271 +  x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
5272 +  x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
5273 +  return x;
5274 +}
5275 +
5276 +static bfd_signed_vma
5277 +get32s (void)
5278 +{
5279 +  bfd_signed_vma x = 0;
5280 +
5281 +  FETCH_DATA (the_info, codep + 4);
5282 +  x = *codep++ & (bfd_signed_vma) 0xff;
5283 +  x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
5284 +  x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
5285 +  x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
5286 +
5287 +  x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
5288 +
5289 +  return x;
5290 +}
5291 +
5292 +static int
5293 +get16 (void)
5294 +{
5295 +  int x = 0;
5296 +
5297 +  FETCH_DATA (the_info, codep + 2);
5298 +  x = *codep++ & 0xff;
5299 +  x |= (*codep++ & 0xff) << 8;
5300 +  return x;
5301 +}
5302 +
5303 +static void
5304 +set_op (bfd_vma op, int riprel)
5305 +{
5306 +  op_index[op_ad] = op_ad;
5307 +  if (mode_64bit)
5308 +    {
5309 +      op_address[op_ad] = op;
5310 +      op_riprel[op_ad] = riprel;
5311 +    }
5312 +  else
5313 +    {
5314 +      /* Mask to get a 32-bit address.  */
5315 +      op_address[op_ad] = op & 0xffffffff;
5316 +      op_riprel[op_ad] = riprel & 0xffffffff;
5317 +    }
5318 +}
5319 +
5320 +static void
5321 +OP_REG (int code, int sizeflag)
5322 +{
5323 +  const char *s;
5324 +  int add = 0;
5325 +  USED_REX (REX_EXTZ);
5326 +  if (rex & REX_EXTZ)
5327 +    add = 8;
5328 +
5329 +  switch (code)
5330 +    {
5331 +    case indir_dx_reg:
5332 +      if (intel_syntax)
5333 +       s = "[dx]";
5334 +      else
5335 +       s = "(%dx)";
5336 +      break;
5337 +    case ax_reg: case cx_reg: case dx_reg: case bx_reg:
5338 +    case sp_reg: case bp_reg: case si_reg: case di_reg:
5339 +      s = names16[code - ax_reg + add];
5340 +      break;
5341 +    case es_reg: case ss_reg: case cs_reg:
5342 +    case ds_reg: case fs_reg: case gs_reg:
5343 +      s = names_seg[code - es_reg + add];
5344 +      break;
5345 +    case al_reg: case ah_reg: case cl_reg: case ch_reg:
5346 +    case dl_reg: case dh_reg: case bl_reg: case bh_reg:
5347 +      USED_REX (0);
5348 +      if (rex)
5349 +       s = names8rex[code - al_reg + add];
5350 +      else
5351 +       s = names8[code - al_reg];
5352 +      break;
5353 +    case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
5354 +    case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
5355 +      if (mode_64bit)
5356 +       {
5357 +         s = names64[code - rAX_reg + add];
5358 +         break;
5359 +       }
5360 +      code += eAX_reg - rAX_reg;
5361 +      /* Fall through.  */
5362 +    case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
5363 +    case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
5364 +      USED_REX (REX_MODE64);
5365 +      if (rex & REX_MODE64)
5366 +       s = names64[code - eAX_reg + add];
5367 +      else if (sizeflag & DFLAG)
5368 +       s = names32[code - eAX_reg + add];
5369 +      else
5370 +       s = names16[code - eAX_reg + add];
5371 +      used_prefixes |= (prefixes & PREFIX_DATA);
5372 +      break;
5373 +    default:
5374 +      s = INTERNAL_DISASSEMBLER_ERROR;
5375 +      break;
5376 +    }
5377 +  oappend (s);
5378 +}
5379 +
5380 +static void
5381 +OP_IMREG (int code, int sizeflag)
5382 +{
5383 +  const char *s;
5384 +
5385 +  switch (code)
5386 +    {
5387 +    case indir_dx_reg:
5388 +      if (intel_syntax)
5389 +       s = "[dx]";
5390 +      else
5391 +       s = "(%dx)";
5392 +      break;
5393 +    case ax_reg: case cx_reg: case dx_reg: case bx_reg:
5394 +    case sp_reg: case bp_reg: case si_reg: case di_reg:
5395 +      s = names16[code - ax_reg];
5396 +      break;
5397 +    case es_reg: case ss_reg: case cs_reg:
5398 +    case ds_reg: case fs_reg: case gs_reg:
5399 +      s = names_seg[code - es_reg];
5400 +      break;
5401 +    case al_reg: case ah_reg: case cl_reg: case ch_reg:
5402 +    case dl_reg: case dh_reg: case bl_reg: case bh_reg:
5403 +      USED_REX (0);
5404 +      if (rex)
5405 +       s = names8rex[code - al_reg];
5406 +      else
5407 +       s = names8[code - al_reg];
5408 +      break;
5409 +    case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
5410 +    case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
5411 +      USED_REX (REX_MODE64);
5412 +      if (rex & REX_MODE64)
5413 +       s = names64[code - eAX_reg];
5414 +      else if (sizeflag & DFLAG)
5415 +       s = names32[code - eAX_reg];
5416 +      else
5417 +       s = names16[code - eAX_reg];
5418 +      used_prefixes |= (prefixes & PREFIX_DATA);
5419 +      break;
5420 +    default:
5421 +      s = INTERNAL_DISASSEMBLER_ERROR;
5422 +      break;
5423 +    }
5424 +  oappend (s);
5425 +}
5426 +
5427 +static void
5428 +OP_I (int bytemode, int sizeflag)
5429 +{
5430 +  bfd_signed_vma op;
5431 +  bfd_signed_vma mask = -1;
5432 +
5433 +  switch (bytemode)
5434 +    {
5435 +    case b_mode:
5436 +      FETCH_DATA (the_info, codep + 1);
5437 +      op = *codep++;
5438 +      mask = 0xff;
5439 +      break;
5440 +    case q_mode:
5441 +      if (mode_64bit)
5442 +       {
5443 +         op = get32s ();
5444 +         break;
5445 +       }
5446 +      /* Fall through.  */
5447 +    case v_mode:
5448 +      USED_REX (REX_MODE64);
5449 +      if (rex & REX_MODE64)
5450 +       op = get32s ();
5451 +      else if (sizeflag & DFLAG)
5452 +       {
5453 +         op = get32 ();
5454 +         mask = 0xffffffff;
5455 +       }
5456 +      else
5457 +       {
5458 +         op = get16 ();
5459 +         mask = 0xfffff;
5460 +       }
5461 +      used_prefixes |= (prefixes & PREFIX_DATA);
5462 +      break;
5463 +    case w_mode:
5464 +      mask = 0xfffff;
5465 +      op = get16 ();
5466 +      break;
5467 +    case const_1_mode:
5468 +      if (intel_syntax)
5469 +        oappend ("1");
5470 +      return;
5471 +    default:
5472 +      oappend (INTERNAL_DISASSEMBLER_ERROR);
5473 +      return;
5474 +    }
5475 +
5476 +  op &= mask;
5477 +  scratchbuf[0] = '$';
5478 +  print_operand_value (scratchbuf + 1, 1, op);
5479 +  oappend (scratchbuf + intel_syntax);
5480 +  scratchbuf[0] = '\0';
5481 +}
5482 +
5483 +static void
5484 +OP_I64 (int bytemode, int sizeflag)
5485 +{
5486 +  bfd_signed_vma op;
5487 +  bfd_signed_vma mask = -1;
5488 +
5489 +  if (!mode_64bit)
5490 +    {
5491 +      OP_I (bytemode, sizeflag);
5492 +      return;
5493 +    }
5494 +
5495 +  switch (bytemode)
5496 +    {
5497 +    case b_mode:
5498 +      FETCH_DATA (the_info, codep + 1);
5499 +      op = *codep++;
5500 +      mask = 0xff;
5501 +      break;
5502 +    case v_mode:
5503 +      USED_REX (REX_MODE64);
5504 +      if (rex & REX_MODE64)
5505 +       op = get64 ();
5506 +      else if (sizeflag & DFLAG)
5507 +       {
5508 +         op = get32 ();
5509 +         mask = 0xffffffff;
5510 +       }
5511 +      else
5512 +       {
5513 +         op = get16 ();
5514 +         mask = 0xfffff;
5515 +       }
5516 +      used_prefixes |= (prefixes & PREFIX_DATA);
5517 +      break;
5518 +    case w_mode:
5519 +      mask = 0xfffff;
5520 +      op = get16 ();
5521 +      break;
5522 +    default:
5523 +      oappend (INTERNAL_DISASSEMBLER_ERROR);
5524 +      return;
5525 +    }
5526 +
5527 +  op &= mask;
5528 +  scratchbuf[0] = '$';
5529 +  print_operand_value (scratchbuf + 1, 1, op);
5530 +  oappend (scratchbuf + intel_syntax);
5531 +  scratchbuf[0] = '\0';
5532 +}
5533 +
5534 +static void
5535 +OP_sI (int bytemode, int sizeflag)
5536 +{
5537 +  bfd_signed_vma op;
5538 +  bfd_signed_vma mask = -1;
5539 +
5540 +  switch (bytemode)
5541 +    {
5542 +    case b_mode:
5543 +      FETCH_DATA (the_info, codep + 1);
5544 +      op = *codep++;
5545 +      if ((op & 0x80) != 0)
5546 +       op -= 0x100;
5547 +      mask = 0xffffffff;
5548 +      break;
5549 +    case v_mode:
5550 +      USED_REX (REX_MODE64);
5551 +      if (rex & REX_MODE64)
5552 +       op = get32s ();
5553 +      else if (sizeflag & DFLAG)
5554 +       {
5555 +         op = get32s ();
5556 +         mask = 0xffffffff;
5557 +       }
5558 +      else
5559 +       {
5560 +         mask = 0xffffffff;
5561 +         op = get16 ();
5562 +         if ((op & 0x8000) != 0)
5563 +           op -= 0x10000;
5564 +       }
5565 +      used_prefixes |= (prefixes & PREFIX_DATA);
5566 +      break;
5567 +    case w_mode:
5568 +      op = get16 ();
5569 +      mask = 0xffffffff;
5570 +      if ((op & 0x8000) != 0)
5571 +       op -= 0x10000;
5572 +      break;
5573 +    default:
5574 +      oappend (INTERNAL_DISASSEMBLER_ERROR);
5575 +      return;
5576 +    }
5577 +
5578 +  scratchbuf[0] = '$';
5579 +  print_operand_value (scratchbuf + 1, 1, op);
5580 +  oappend (scratchbuf + intel_syntax);
5581 +}
5582 +
5583 +static void
5584 +OP_J (int bytemode, int sizeflag)
5585 +{
5586 +  bfd_vma disp;
5587 +  bfd_vma mask = -1;
5588 +
5589 +  switch (bytemode)
5590 +    {
5591 +    case b_mode:
5592 +      FETCH_DATA (the_info, codep + 1);
5593 +      disp = *codep++;
5594 +      if ((disp & 0x80) != 0)
5595 +       disp -= 0x100;
5596 +      break;
5597 +    case v_mode:
5598 +      if (sizeflag & DFLAG)
5599 +       disp = get32s ();
5600 +      else
5601 +       {
5602 +         disp = get16 ();
5603 +         /* For some reason, a data16 prefix on a jump instruction
5604 +            means that the pc is masked to 16 bits after the
5605 +            displacement is added!  */
5606 +         mask = 0xffff;
5607 +       }
5608 +      break;
5609 +    default:
5610 +      oappend (INTERNAL_DISASSEMBLER_ERROR);
5611 +      return;
5612 +    }
5613 +  disp = (start_pc + codep - start_codep + disp) & mask;
5614 +  set_op (disp, 0);
5615 +  print_operand_value (scratchbuf, 1, disp);
5616 +  oappend (scratchbuf);
5617 +}
5618 +
5619 +static void
5620 +OP_SEG (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5621 +{
5622 +  oappend (names_seg[reg]);
5623 +}
5624 +
5625 +static void
5626 +OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
5627 +{
5628 +  int seg, offset;
5629 +
5630 +  if (sizeflag & DFLAG)
5631 +    {
5632 +      offset = get32 ();
5633 +      seg = get16 ();
5634 +    }
5635 +  else
5636 +    {
5637 +      offset = get16 ();
5638 +      seg = get16 ();
5639 +    }
5640 +  used_prefixes |= (prefixes & PREFIX_DATA);
5641 +  if (intel_syntax)
5642 +    sprintf (scratchbuf, "0x%x,0x%x", seg, offset);
5643 +  else
5644 +    sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
5645 +  oappend (scratchbuf);
5646 +}
5647 +
5648 +static void
5649 +OP_OFF (int bytemode ATTRIBUTE_UNUSED, int sizeflag)
5650 +{
5651 +  bfd_vma off;
5652 +
5653 +  append_seg ();
5654 +
5655 +  if ((sizeflag & AFLAG) || mode_64bit)
5656 +    off = get32 ();
5657 +  else
5658 +    off = get16 ();
5659 +
5660 +  if (intel_syntax)
5661 +    {
5662 +      if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5663 +                       | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
5664 +       {
5665 +         oappend (names_seg[ds_reg - es_reg]);
5666 +         oappend (":");
5667 +       }
5668 +    }
5669 +  print_operand_value (scratchbuf, 1, off);
5670 +  oappend (scratchbuf);
5671 +}
5672 +
5673 +static void
5674 +OP_OFF64 (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5675 +{
5676 +  bfd_vma off;
5677 +
5678 +  if (!mode_64bit)
5679 +    {
5680 +      OP_OFF (bytemode, sizeflag);
5681 +      return;
5682 +    }
5683 +
5684 +  append_seg ();
5685 +
5686 +  off = get64 ();
5687 +
5688 +  if (intel_syntax)
5689 +    {
5690 +      if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5691 +                       | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
5692 +       {
5693 +         oappend (names_seg[ds_reg - es_reg]);
5694 +         oappend (":");
5695 +       }
5696 +    }
5697 +  print_operand_value (scratchbuf, 1, off);
5698 +  oappend (scratchbuf);
5699 +}
5700 +
5701 +static void
5702 +ptr_reg (int code, int sizeflag)
5703 +{
5704 +  const char *s;
5705 +
5706 +  *obufp++ = open_char;
5707 +  used_prefixes |= (prefixes & PREFIX_ADDR);
5708 +  if (mode_64bit)
5709 +    {
5710 +      if (!(sizeflag & AFLAG))
5711 +       s = names32[code - eAX_reg];
5712 +      else
5713 +       s = names64[code - eAX_reg];
5714 +    }
5715 +  else if (sizeflag & AFLAG)
5716 +    s = names32[code - eAX_reg];
5717 +  else
5718 +    s = names16[code - eAX_reg];
5719 +  oappend (s);
5720 +  *obufp++ = close_char;
5721 +  *obufp = 0;
5722 +}
5723 +
5724 +static void
5725 +OP_ESreg (int code, int sizeflag)
5726 +{
5727 +  if (intel_syntax)
5728 +    {
5729 +      if (codep[-1] & 1)
5730 +       {
5731 +         USED_REX (REX_MODE64);
5732 +         used_prefixes |= (prefixes & PREFIX_DATA);
5733 +         if (rex & REX_MODE64)
5734 +           oappend ("QWORD PTR ");
5735 +         else if ((sizeflag & DFLAG))
5736 +           oappend ("DWORD PTR ");
5737 +         else
5738 +           oappend ("WORD PTR ");
5739 +       }
5740 +      else
5741 +       oappend ("BYTE PTR ");
5742 +    }
5743 +
5744 +  oappend ("%es:" + intel_syntax);
5745 +  ptr_reg (code, sizeflag);
5746 +}
5747 +
5748 +static void
5749 +OP_DSreg (int code, int sizeflag)
5750 +{
5751 +  if (intel_syntax)
5752 +    {
5753 +      if (codep[-1] != 0xd7 && (codep[-1] & 1))
5754 +       {
5755 +         USED_REX (REX_MODE64);
5756 +         used_prefixes |= (prefixes & PREFIX_DATA);
5757 +         if (rex & REX_MODE64)
5758 +           oappend ("QWORD PTR ");
5759 +         else if ((sizeflag & DFLAG))
5760 +           oappend ("DWORD PTR ");
5761 +         else
5762 +           oappend ("WORD PTR ");
5763 +       }
5764 +      else
5765 +       oappend ("BYTE PTR ");
5766 +    }
5767 +
5768 +  if ((prefixes
5769 +       & (PREFIX_CS
5770 +         | PREFIX_DS
5771 +         | PREFIX_SS
5772 +         | PREFIX_ES
5773 +         | PREFIX_FS
5774 +         | PREFIX_GS)) == 0)
5775 +    prefixes |= PREFIX_DS;
5776 +  append_seg ();
5777 +  ptr_reg (code, sizeflag);
5778 +}
5779 +
5780 +static void
5781 +OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5782 +{
5783 +  int add = 0;
5784 +  if (rex & REX_EXTX)
5785 +    {
5786 +      USED_REX (REX_EXTX);
5787 +      add = 8;
5788 +    }
5789 +  else if (!mode_64bit && (prefixes & PREFIX_LOCK))
5790 +    {
5791 +      used_prefixes |= PREFIX_LOCK;
5792 +      add = 8;
5793 +    }
5794 +  sprintf (scratchbuf, "%%cr%d", reg + add);
5795 +  oappend (scratchbuf + intel_syntax);
5796 +}
5797 +
5798 +static void
5799 +OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5800 +{
5801 +  int add = 0;
5802 +  USED_REX (REX_EXTX);
5803 +  if (rex & REX_EXTX)
5804 +    add = 8;
5805 +  if (intel_syntax)
5806 +    sprintf (scratchbuf, "db%d", reg + add);
5807 +  else
5808 +    sprintf (scratchbuf, "%%db%d", reg + add);
5809 +  oappend (scratchbuf);
5810 +}
5811 +
5812 +static void
5813 +OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5814 +{
5815 +  sprintf (scratchbuf, "%%tr%d", reg);
5816 +  oappend (scratchbuf + intel_syntax);
5817 +}
5818 +
5819 +static void
5820 +OP_Rd (int bytemode, int sizeflag)
5821 +{
5822 +  if (mod == 3)
5823 +    OP_E (bytemode, sizeflag);
5824 +  else
5825 +    BadOp ();
5826 +}
5827 +
5828 +static void
5829 +OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5830 +{
5831 +  used_prefixes |= (prefixes & PREFIX_DATA);
5832 +  if (prefixes & PREFIX_DATA)
5833 +    {
5834 +      int add = 0;
5835 +      USED_REX (REX_EXTX);
5836 +      if (rex & REX_EXTX)
5837 +       add = 8;
5838 +      sprintf (scratchbuf, "%%xmm%d", reg + add);
5839 +    }
5840 +  else
5841 +    sprintf (scratchbuf, "%%mm%d", reg);
5842 +  oappend (scratchbuf + intel_syntax);
5843 +}
5844 +
5845 +static void
5846 +OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5847 +{
5848 +  int add = 0;
5849 +  USED_REX (REX_EXTX);
5850 +  if (rex & REX_EXTX)
5851 +    add = 8;
5852 +  sprintf (scratchbuf, "%%xmm%d", reg + add);
5853 +  oappend (scratchbuf + intel_syntax);
5854 +}
5855 +
5856 +static void
5857 +OP_EM (int bytemode, int sizeflag)
5858 +{
5859 +  if (mod != 3)
5860 +    {
5861 +      if (intel_syntax && bytemode == v_mode)
5862 +       {
5863 +         bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
5864 +         used_prefixes |= (prefixes & PREFIX_DATA);
5865 +       }
5866 +      OP_E (bytemode, sizeflag);
5867 +      return;
5868 +    }
5869 +
5870 +  /* Skip mod/rm byte.  */
5871 +  MODRM_CHECK;
5872 +  codep++;
5873 +  used_prefixes |= (prefixes & PREFIX_DATA);
5874 +  if (prefixes & PREFIX_DATA)
5875 +    {
5876 +      int add = 0;
5877 +
5878 +      USED_REX (REX_EXTZ);
5879 +      if (rex & REX_EXTZ)
5880 +       add = 8;
5881 +      sprintf (scratchbuf, "%%xmm%d", rm + add);
5882 +    }
5883 +  else
5884 +    sprintf (scratchbuf, "%%mm%d", rm);
5885 +  oappend (scratchbuf + intel_syntax);
5886 +}
5887 +
5888 +static void
5889 +OP_EX (int bytemode, int sizeflag)
5890 +{
5891 +  int add = 0;
5892 +  if (mod != 3)
5893 +    {
5894 +      if (intel_syntax && bytemode == v_mode)
5895 +       {
5896 +         switch (prefixes & (PREFIX_DATA|PREFIX_REPZ|PREFIX_REPNZ))
5897 +           {
5898 +           case 0:            bytemode = x_mode; break;
5899 +           case PREFIX_REPZ:  bytemode = d_mode; used_prefixes |= PREFIX_REPZ;  break;
5900 +           case PREFIX_DATA:  bytemode = x_mode; used_prefixes |= PREFIX_DATA;  break;
5901 +           case PREFIX_REPNZ: bytemode = q_mode; used_prefixes |= PREFIX_REPNZ; break;
5902 +           default:           bytemode = 0; break;
5903 +           }
5904 +       }
5905 +      OP_E (bytemode, sizeflag);
5906 +      return;
5907 +    }
5908 +  USED_REX (REX_EXTZ);
5909 +  if (rex & REX_EXTZ)
5910 +    add = 8;
5911 +
5912 +  /* Skip mod/rm byte.  */
5913 +  MODRM_CHECK;
5914 +  codep++;
5915 +  sprintf (scratchbuf, "%%xmm%d", rm + add);
5916 +  oappend (scratchbuf + intel_syntax);
5917 +}
5918 +
5919 +static void
5920 +OP_MS (int bytemode, int sizeflag)
5921 +{
5922 +  if (mod == 3)
5923 +    OP_EM (bytemode, sizeflag);
5924 +  else
5925 +    BadOp ();
5926 +}
5927 +
5928 +static void
5929 +OP_XS (int bytemode, int sizeflag)
5930 +{
5931 +  if (mod == 3)
5932 +    OP_EX (bytemode, sizeflag);
5933 +  else
5934 +    BadOp ();
5935 +}
5936 +
5937 +static void
5938 +OP_M (int bytemode, int sizeflag)
5939 +{
5940 +  if (mod == 3)
5941 +    BadOp ();  /* bad lea,lds,les,lfs,lgs,lss modrm */
5942 +  else
5943 +    OP_E (bytemode, sizeflag);
5944 +}
5945 +
5946 +static void
5947 +OP_0f07 (int bytemode, int sizeflag)
5948 +{
5949 +  if (mod != 3 || rm != 0)
5950 +    BadOp ();
5951 +  else
5952 +    OP_E (bytemode, sizeflag);
5953 +}
5954 +
5955 +static void
5956 +OP_0fae (int bytemode, int sizeflag)
5957 +{
5958 +  if (mod == 3)
5959 +    {
5960 +      if (reg == 7)
5961 +       strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence");
5962 +
5963 +      if (reg < 5 || rm != 0)
5964 +       {
5965 +         BadOp ();     /* bad sfence, mfence, or lfence */
5966 +         return;
5967 +       }
5968 +    }
5969 +  else if (reg != 7)
5970 +    {
5971 +      BadOp ();                /* bad clflush */
5972 +      return;
5973 +    }
5974 +
5975 +  OP_E (bytemode, sizeflag);
5976 +}
5977 +
5978 +static void
5979 +NOP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5980 +{
5981 +  /* NOP with REPZ prefix is called PAUSE.  */
5982 +  if (prefixes == PREFIX_REPZ)
5983 +    strcpy (obuf, "pause");
5984 +}
5985 +
5986 +static const char *const Suffix3DNow[] = {
5987 +/* 00 */       NULL,           NULL,           NULL,           NULL,
5988 +/* 04 */       NULL,           NULL,           NULL,           NULL,
5989 +/* 08 */       NULL,           NULL,           NULL,           NULL,
5990 +/* 0C */       "pi2fw",        "pi2fd",        NULL,           NULL,
5991 +/* 10 */       NULL,           NULL,           NULL,           NULL,
5992 +/* 14 */       NULL,           NULL,           NULL,           NULL,
5993 +/* 18 */       NULL,           NULL,           NULL,           NULL,
5994 +/* 1C */       "pf2iw",        "pf2id",        NULL,           NULL,
5995 +/* 20 */       NULL,           NULL,           NULL,           NULL,
5996 +/* 24 */       NULL,           NULL,           NULL,           NULL,
5997 +/* 28 */       NULL,           NULL,           NULL,           NULL,
5998 +/* 2C */       NULL,           NULL,           NULL,           NULL,
5999 +/* 30 */       NULL,           NULL,           NULL,           NULL,
6000 +/* 34 */       NULL,           NULL,           NULL,           NULL,
6001 +/* 38 */       NULL,           NULL,           NULL,           NULL,
6002 +/* 3C */       NULL,           NULL,           NULL,           NULL,
6003 +/* 40 */       NULL,           NULL,           NULL,           NULL,
6004 +/* 44 */       NULL,           NULL,           NULL,           NULL,
6005 +/* 48 */       NULL,           NULL,           NULL,           NULL,
6006 +/* 4C */       NULL,           NULL,           NULL,           NULL,
6007 +/* 50 */       NULL,           NULL,           NULL,           NULL,
6008 +/* 54 */       NULL,           NULL,           NULL,           NULL,
6009 +/* 58 */       NULL,           NULL,           NULL,           NULL,
6010 +/* 5C */       NULL,           NULL,           NULL,           NULL,
6011 +/* 60 */       NULL,           NULL,           NULL,           NULL,
6012 +/* 64 */       NULL,           NULL,           NULL,           NULL,
6013 +/* 68 */       NULL,           NULL,           NULL,           NULL,
6014 +/* 6C */       NULL,           NULL,           NULL,           NULL,
6015 +/* 70 */       NULL,           NULL,           NULL,           NULL,
6016 +/* 74 */       NULL,           NULL,           NULL,           NULL,
6017 +/* 78 */       NULL,           NULL,           NULL,           NULL,
6018 +/* 7C */       NULL,           NULL,           NULL,           NULL,
6019 +/* 80 */       NULL,           NULL,           NULL,           NULL,
6020 +/* 84 */       NULL,           NULL,           NULL,           NULL,
6021 +/* 88 */       NULL,           NULL,           "pfnacc",       NULL,
6022 +/* 8C */       NULL,           NULL,           "pfpnacc",      NULL,
6023 +/* 90 */       "pfcmpge",      NULL,           NULL,           NULL,
6024 +/* 94 */       "pfmin",        NULL,           "pfrcp",        "pfrsqrt",
6025 +/* 98 */       NULL,           NULL,           "pfsub",        NULL,
6026 +/* 9C */       NULL,           NULL,           "pfadd",        NULL,
6027 +/* A0 */       "pfcmpgt",      NULL,           NULL,           NULL,
6028 +/* A4 */       "pfmax",        NULL,           "pfrcpit1",     "pfrsqit1",
6029 +/* A8 */       NULL,           NULL,           "pfsubr",       NULL,
6030 +/* AC */       NULL,           NULL,           "pfacc",        NULL,
6031 +/* B0 */       "pfcmpeq",      NULL,           NULL,           NULL,
6032 +/* B4 */       "pfmul",        NULL,           "pfrcpit2",     "pfmulhrw",
6033 +/* B8 */       NULL,           NULL,           NULL,           "pswapd",
6034 +/* BC */       NULL,           NULL,           NULL,           "pavgusb",
6035 +/* C0 */       NULL,           NULL,           NULL,           NULL,
6036 +/* C4 */       NULL,           NULL,           NULL,           NULL,
6037 +/* C8 */       NULL,           NULL,           NULL,           NULL,
6038 +/* CC */       NULL,           NULL,           NULL,           NULL,
6039 +/* D0 */       NULL,           NULL,           NULL,           NULL,
6040 +/* D4 */       NULL,           NULL,           NULL,           NULL,
6041 +/* D8 */       NULL,           NULL,           NULL,           NULL,
6042 +/* DC */       NULL,           NULL,           NULL,           NULL,
6043 +/* E0 */       NULL,           NULL,           NULL,           NULL,
6044 +/* E4 */       NULL,           NULL,           NULL,           NULL,
6045 +/* E8 */       NULL,           NULL,           NULL,           NULL,
6046 +/* EC */       NULL,           NULL,           NULL,           NULL,
6047 +/* F0 */       NULL,           NULL,           NULL,           NULL,
6048 +/* F4 */       NULL,           NULL,           NULL,           NULL,
6049 +/* F8 */       NULL,           NULL,           NULL,           NULL,
6050 +/* FC */       NULL,           NULL,           NULL,           NULL,
6051 +};
6052 +
6053 +static void
6054 +OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
6055 +{
6056 +  const char *mnemonic;
6057 +
6058 +  FETCH_DATA (the_info, codep + 1);
6059 +  /* AMD 3DNow! instructions are specified by an opcode suffix in the
6060 +     place where an 8-bit immediate would normally go.  ie. the last
6061 +     byte of the instruction.  */
6062 +  obufp = obuf + strlen (obuf);
6063 +  mnemonic = Suffix3DNow[*codep++ & 0xff];
6064 +  if (mnemonic)
6065 +    oappend (mnemonic);
6066 +  else
6067 +    {
6068 +      /* Since a variable sized modrm/sib chunk is between the start
6069 +        of the opcode (0x0f0f) and the opcode suffix, we need to do
6070 +        all the modrm processing first, and don't know until now that
6071 +        we have a bad opcode.  This necessitates some cleaning up.  */
6072 +      op1out[0] = '\0';
6073 +      op2out[0] = '\0';
6074 +      BadOp ();
6075 +    }
6076 +}
6077 +
6078 +static const char *simd_cmp_op[] = {
6079 +  "eq",
6080 +  "lt",
6081 +  "le",
6082 +  "unord",
6083 +  "neq",
6084 +  "nlt",
6085 +  "nle",
6086 +  "ord"
6087 +};
6088 +
6089 +static void
6090 +OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
6091 +{
6092 +  unsigned int cmp_type;
6093 +
6094 +  FETCH_DATA (the_info, codep + 1);
6095 +  obufp = obuf + strlen (obuf);
6096 +  cmp_type = *codep++ & 0xff;
6097 +  if (cmp_type < 8)
6098 +    {
6099 +      char suffix1 = 'p', suffix2 = 's';
6100 +      used_prefixes |= (prefixes & PREFIX_REPZ);
6101 +      if (prefixes & PREFIX_REPZ)
6102 +       suffix1 = 's';
6103 +      else
6104 +       {
6105 +         used_prefixes |= (prefixes & PREFIX_DATA);
6106 +         if (prefixes & PREFIX_DATA)
6107 +           suffix2 = 'd';
6108 +         else
6109 +           {
6110 +             used_prefixes |= (prefixes & PREFIX_REPNZ);
6111 +             if (prefixes & PREFIX_REPNZ)
6112 +               suffix1 = 's', suffix2 = 'd';
6113 +           }
6114 +       }
6115 +      sprintf (scratchbuf, "cmp%s%c%c",
6116 +              simd_cmp_op[cmp_type], suffix1, suffix2);
6117 +      used_prefixes |= (prefixes & PREFIX_REPZ);
6118 +      oappend (scratchbuf);
6119 +    }
6120 +  else
6121 +    {
6122 +      /* We have a bad extension byte.  Clean up.  */
6123 +      op1out[0] = '\0';
6124 +      op2out[0] = '\0';
6125 +      BadOp ();
6126 +    }
6127 +}
6128 +
6129 +static void
6130 +SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED)
6131 +{
6132 +  /* Change movlps/movhps to movhlps/movlhps for 2 register operand
6133 +     forms of these instructions.  */
6134 +  if (mod == 3)
6135 +    {
6136 +      char *p = obuf + strlen (obuf);
6137 +      *(p + 1) = '\0';
6138 +      *p       = *(p - 1);
6139 +      *(p - 1) = *(p - 2);
6140 +      *(p - 2) = *(p - 3);
6141 +      *(p - 3) = extrachar;
6142 +    }
6143 +}
6144 +
6145 +static void
6146 +PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
6147 +{
6148 +  if (mod == 3 && reg == 1 && rm <= 1)
6149 +    {
6150 +      /* Override "sidt".  */
6151 +      char *p = obuf + strlen (obuf) - 4;
6152 +
6153 +      /* We might have a suffix when disassembling with -Msuffix.  */
6154 +      if (*p == 'i')
6155 +       --p;
6156 +
6157 +      if (rm)
6158 +       {
6159 +         /* mwait %eax,%ecx  */
6160 +         strcpy (p, "mwait");
6161 +         if (!intel_syntax)
6162 +           strcpy (op1out, names32[0]);
6163 +       }
6164 +      else
6165 +       {
6166 +         /* monitor %eax,%ecx,%edx"  */
6167 +         strcpy (p, "monitor");
6168 +         if (!intel_syntax)
6169 +           {
6170 +             if (!mode_64bit)
6171 +               strcpy (op1out, names32[0]);
6172 +             else if (!(prefixes & PREFIX_ADDR))
6173 +               strcpy (op1out, names64[0]);
6174 +             else
6175 +               {
6176 +                 strcpy (op1out, names32[0]);
6177 +                 used_prefixes |= PREFIX_ADDR;
6178 +               }
6179 +             strcpy (op3out, names32[2]);
6180 +           }
6181 +       }
6182 +      if (!intel_syntax)
6183 +       {
6184 +         strcpy (op2out, names32[1]);
6185 +         two_source_ops = 1;
6186 +       }
6187 +
6188 +      codep++;
6189 +    }
6190 +  else
6191 +    OP_M (0, sizeflag);
6192 +}
6193 +
6194 +static void
6195 +SVME_Fixup (int bytemode, int sizeflag)
6196 +{
6197 +  const char *alt;
6198 +  char *p;
6199 +
6200 +  switch (*codep)
6201 +    {
6202 +    case 0xd8:
6203 +      alt = "vmrun";
6204 +      break;
6205 +    case 0xd9:
6206 +      alt = "vmmcall";
6207 +      break;
6208 +    case 0xda:
6209 +      alt = "vmload";
6210 +      break;
6211 +    case 0xdb:
6212 +      alt = "vmsave";
6213 +      break;
6214 +    case 0xdc:
6215 +      alt = "stgi";
6216 +      break;
6217 +    case 0xdd:
6218 +      alt = "clgi";
6219 +      break;
6220 +    case 0xde:
6221 +      alt = "skinit";
6222 +      break;
6223 +    case 0xdf:
6224 +      alt = "invlpga";
6225 +      break;
6226 +    default:
6227 +      OP_M (bytemode, sizeflag);
6228 +      return;
6229 +    }
6230 +  /* Override "lidt".  */
6231 +  p = obuf + strlen (obuf) - 4;
6232 +  /* We might have a suffix.  */
6233 +  if (*p == 'i')
6234 +    --p;
6235 +  strcpy (p, alt);
6236 +  if (!(prefixes & PREFIX_ADDR))
6237 +    {
6238 +      ++codep;
6239 +      return;
6240 +    }
6241 +  used_prefixes |= PREFIX_ADDR;
6242 +  switch (*codep++)
6243 +    {
6244 +    case 0xdf:
6245 +      strcpy (op2out, names32[1]);
6246 +      two_source_ops = 1;
6247 +         /* Fall through.  */
6248 +    case 0xd8:
6249 +    case 0xda:
6250 +    case 0xdb:
6251 +      *obufp++ = open_char;
6252 +      if (mode_64bit || (sizeflag & AFLAG))
6253 +        alt = names32[0];
6254 +      else
6255 +        alt = names16[0];
6256 +      strcpy (obufp, alt);
6257 +      obufp += strlen (alt);
6258 +      *obufp++ = close_char;
6259 +      *obufp = '\0';
6260 +      break;
6261 +    }
6262 +}
6263 +
6264 +static void
6265 +INVLPG_Fixup (int bytemode, int sizeflag)
6266 +{
6267 +  const char *alt;
6268 +
6269 +  switch (*codep)
6270 +    {
6271 +    case 0xf8:
6272 +      alt = "swapgs";
6273 +      break;
6274 +    case 0xf9:
6275 +      alt = "rdtscp";
6276 +      break;
6277 +    default:
6278 +      OP_M (bytemode, sizeflag);
6279 +      return;
6280 +    }
6281 +  /* Override "invlpg".  */
6282 +  strcpy (obuf + strlen (obuf) - 6, alt);
6283 +  codep++;
6284 +}
6285 +
6286 +static void
6287 +BadOp (void)
6288 +{
6289 +  /* Throw away prefixes and 1st. opcode byte.  */
6290 +  codep = insn_codep + 1;
6291 +  oappend ("(bad)");
6292 +}
6293 +
6294 +static void
6295 +SEG_Fixup (int extrachar, int sizeflag)
6296 +{
6297 +  if (mod == 3)
6298 +    {
6299 +      /* We need to add a proper suffix with
6300 +
6301 +               movw %ds,%ax
6302 +               movl %ds,%eax
6303 +               movq %ds,%rax
6304 +               movw %ax,%ds
6305 +               movl %eax,%ds
6306 +               movq %rax,%ds
6307 +       */
6308 +      const char *suffix;
6309 +
6310 +      if (prefixes & PREFIX_DATA)
6311 +       suffix = "w";
6312 +      else
6313 +       {
6314 +         USED_REX (REX_MODE64);
6315 +         if (rex & REX_MODE64)
6316 +           suffix = "q";
6317 +         else
6318 +           suffix = "l";
6319 +       }
6320 +      strcat (obuf, suffix);
6321 +    }
6322 +  else
6323 +    {
6324 +      /* We need to fix the suffix for
6325 +
6326 +               movw %ds,(%eax)
6327 +               movw %ds,(%rax)
6328 +               movw (%eax),%ds
6329 +               movw (%rax),%ds
6330 +
6331 +        Override "mov[l|q]".  */
6332 +      char *p = obuf + strlen (obuf) - 1;
6333 +
6334 +      /* We might not have a suffix.  */
6335 +      if (*p == 'v')
6336 +       ++p;
6337 +      *p = 'w';
6338 +    }
6339 +
6340 +  OP_E (extrachar, sizeflag);
6341 +}
6342 +
6343 +static void
6344 +VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
6345 +{
6346 +  if (mod == 3 && reg == 0 && rm >=1 && rm <= 4)
6347 +    {
6348 +      /* Override "sgdt".  */
6349 +      char *p = obuf + strlen (obuf) - 4;
6350 +
6351 +      /* We might have a suffix when disassembling with -Msuffix.  */
6352 +      if (*p == 'g')
6353 +       --p;
6354 +
6355 +      switch (rm)
6356 +       {
6357 +       case 1:
6358 +         strcpy (p, "vmcall");
6359 +         break;
6360 +       case 2:
6361 +         strcpy (p, "vmlaunch");
6362 +         break;
6363 +       case 3:
6364 +         strcpy (p, "vmresume");
6365 +         break;
6366 +       case 4:
6367 +         strcpy (p, "vmxoff");
6368 +         break;
6369 +       }
6370 +
6371 +      codep++;
6372 +    }
6373 +  else
6374 +    OP_E (0, sizeflag);
6375 +}
6376 +
6377 +static void
6378 +OP_VMX (int bytemode, int sizeflag)
6379 +{
6380 +  used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ));
6381 +  if (prefixes & PREFIX_DATA)
6382 +    strcpy (obuf, "vmclear");
6383 +  else if (prefixes & PREFIX_REPZ)
6384 +    strcpy (obuf, "vmxon");
6385 +  else
6386 +    strcpy (obuf, "vmptrld");
6387 +  OP_E (bytemode, sizeflag);
6388 +}
6389 --- /dev/null
6390 +++ b/arch/x86/kdb/kdba_bp_32.c
6391 @@ -0,0 +1,914 @@
6392 +/*
6393 + * Kernel Debugger Architecture Dependent Breakpoint Handling
6394 + *
6395 + * This file is subject to the terms and conditions of the GNU General Public
6396 + * License.  See the file "COPYING" in the main directory of this archive
6397 + * for more details.
6398 + *
6399 + * Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
6400 + */
6401 +
6402 +#include <linux/string.h>
6403 +#include <linux/kernel.h>
6404 +#include <linux/sched.h>
6405 +#include <linux/smp.h>
6406 +#include <linux/ptrace.h>
6407 +#include <linux/kdb.h>
6408 +#include <linux/kdbprivate.h>
6409 +
6410 +
6411 +static char *kdba_rwtypes[] = { "Instruction(Register)", "Data Write",
6412 +                       "I/O", "Data Access"};
6413 +
6414 +/*
6415 + * Table describing processor architecture hardware
6416 + * breakpoint registers for every CPU.
6417 + */
6418 +
6419 +static kdbhard_bp_t kdb_hardbreaks[NR_CPUS][KDB_MAXHARDBPT];
6420 +
6421 +/*
6422 + * kdba_db_trap
6423 + *
6424 + *     Perform breakpoint processing upon entry to the
6425 + *     processor debugger fault.   Determine and print
6426 + *     the active breakpoint.
6427 + *
6428 + * Parameters:
6429 + *     regs    Exception frame containing machine register state
6430 + *     error   Error number passed to kdb.
6431 + * Outputs:
6432 + *     None.
6433 + * Returns:
6434 + *     KDB_DB_BPT      Standard instruction or data breakpoint encountered
6435 + *     KDB_DB_SS       Single Step fault ('ss' command or end of 'ssb' command)
6436 + *     KDB_DB_SSB      Single Step fault, caller should continue ('ssb' command)
6437 + *     KDB_DB_SSBPT    Single step over breakpoint
6438 + *     KDB_DB_NOBPT    No existing kdb breakpoint matches this debug exception
6439 + * Locking:
6440 + *     None.
6441 + * Remarks:
6442 + *     Yup, there be goto's here.
6443 + *
6444 + *     If multiple processors receive debug exceptions simultaneously,
6445 + *     one may be waiting at the kdb fence in kdb() while the user
6446 + *     issues a 'bc' command to clear the breakpoint the processor
6447 + *     which is waiting has already encountered.  If this is the case,
6448 + *     the debug registers will no longer match any entry in the
6449 + *     breakpoint table, and we'll return the value KDB_DB_NOBPT.
6450 + *     This can cause a panic in die_if_kernel().  It is safer to
6451 + *     disable the breakpoint (bd), go until all processors are past
6452 + *     the breakpoint then clear the breakpoint (bc).  This code
6453 + *     recognises a breakpoint even when disabled but not when it has
6454 + *     been cleared.
6455 + *
6456 + *     WARNING: This routine clears the debug state.  It should be called
6457 + *              once per debug and the result cached.
6458 + */
6459 +
6460 +kdb_dbtrap_t
6461 +kdba_db_trap(struct pt_regs *regs, int error_unused)
6462 +{
6463 +       kdb_machreg_t dr6;
6464 +       kdb_machreg_t dr7;
6465 +       int rw, reg;
6466 +       int i;
6467 +       kdb_dbtrap_t rv = KDB_DB_BPT;
6468 +       kdb_bp_t *bp;
6469 +       int cpu = smp_processor_id();
6470 +
6471 +       if (KDB_NULL_REGS(regs))
6472 +               return KDB_DB_NOBPT;
6473 +
6474 +       dr6 = kdba_getdr6();
6475 +       dr7 = kdba_getdr7();
6476 +
6477 +       if (KDB_DEBUG(BP))
6478 +               kdb_printf("kdb: dr6 0x%lx dr7 0x%lx\n", dr6, dr7);
6479 +       if (dr6 & DR6_BS) {
6480 +               if (KDB_STATE(SSBPT)) {
6481 +                       if (KDB_DEBUG(BP))
6482 +                               kdb_printf("ssbpt\n");
6483 +                       KDB_STATE_CLEAR(SSBPT);
6484 +                       for(i=0,bp=kdb_breakpoints;
6485 +                           i < KDB_MAXBPT;
6486 +                           i++, bp++) {
6487 +                               if (KDB_DEBUG(BP))
6488 +                                       kdb_printf("bp 0x%p enabled %d delayed %d global %d cpu %d\n",
6489 +                                                  bp, bp->bp_enabled, bp->bp_delayed, bp->bp_global, bp->bp_cpu);
6490 +                               if (!bp->bp_enabled)
6491 +                                       continue;
6492 +                               if (!bp->bp_global && bp->bp_cpu != smp_processor_id())
6493 +                                       continue;
6494 +                               if (KDB_DEBUG(BP))
6495 +                                       kdb_printf("bp for this cpu\n");
6496 +                               if (bp->bp_delayed) {
6497 +                                       bp->bp_delayed = 0;
6498 +                                       if (KDB_DEBUG(BP)){
6499 +                                               /* Can't be hw breakpoint */
6500 +                                               if (bp->bp_hardtype)
6501 +                                                       kdb_printf("kdb: Error - hw bp delayed\n");
6502 +                                               kdb_printf("kdba_installbp\n");
6503 +                                       }
6504 +                                       kdba_installbp(regs, bp);
6505 +                                       if (!KDB_STATE(DOING_SS)) {
6506 +                                               regs->flags &= ~EF_TF;
6507 +                                               return(KDB_DB_SSBPT);
6508 +                                       }
6509 +                                       break;
6510 +                               }
6511 +                       }
6512 +                       if (i == KDB_MAXBPT) {
6513 +                               kdb_printf("kdb: Unable to find delayed breakpoint\n");
6514 +                       }
6515 +                       if (!KDB_STATE(DOING_SS)) {
6516 +                               regs->flags &= ~EF_TF;
6517 +                               return(KDB_DB_NOBPT);
6518 +                       }
6519 +                       /* FALLTHROUGH */
6520 +               }
6521 +
6522 +               /*
6523 +                * KDB_STATE_DOING_SS is set when the kernel debugger is using
6524 +                * the processor trap flag to single-step a processor.  If a
6525 +                * single step trap occurs and this flag is clear, the SS trap
6526 +                * will be ignored by KDB and the kernel will be allowed to deal
6527 +                * with it as necessary (e.g. for ptrace).
6528 +                */
6529 +               if (!KDB_STATE(DOING_SS))
6530 +                       goto unknown;
6531 +
6532 +               /* single step */
6533 +               rv = KDB_DB_SS;         /* Indicate single step */
6534 +               if (KDB_STATE(DOING_SSB)) {
6535 +                       unsigned char instruction[2];
6536 +
6537 +                       kdb_id1(regs->ip);
6538 +                       if (kdb_getarea(instruction, regs->ip) ||
6539 +                           (instruction[0]&0xf0) == 0xe0 ||    /* short disp jumps */
6540 +                           (instruction[0]&0xf0) == 0x70 ||    /* Misc. jumps */
6541 +                           instruction[0]        == 0xc2 ||    /* ret */
6542 +                           instruction[0]        == 0x9a ||    /* call */
6543 +                           (instruction[0]&0xf8) == 0xc8 ||    /* enter, leave, iret, int, */
6544 +                           ((instruction[0]      == 0x0f) &&
6545 +                            ((instruction[1]&0xf0)== 0x80))
6546 +                          ) {
6547 +                               /*
6548 +                                * End the ssb command here.
6549 +                                */
6550 +                               KDB_STATE_CLEAR(DOING_SSB);
6551 +                               KDB_STATE_CLEAR(DOING_SS);
6552 +                       } else {
6553 +                               rv = KDB_DB_SSB; /* Indicate ssb - dismiss immediately */
6554 +                       }
6555 +               } else {
6556 +                       /*
6557 +                        * Print current insn
6558 +                        */
6559 +                       kdb_printf("SS trap at ");
6560 +                       kdb_symbol_print(regs->ip, NULL, KDB_SP_DEFAULT|KDB_SP_NEWLINE);
6561 +                       kdb_id1(regs->ip);
6562 +                       KDB_STATE_CLEAR(DOING_SS);
6563 +               }
6564 +
6565 +               if (rv != KDB_DB_SSB)
6566 +                       regs->flags &= ~EF_TF;
6567 +       }
6568 +
6569 +       if (dr6 & DR6_B0) {
6570 +               rw = DR7_RW0(dr7);
6571 +               reg = 0;
6572 +               goto handle;
6573 +       }
6574 +
6575 +       if (dr6 & DR6_B1) {
6576 +               rw = DR7_RW1(dr7);
6577 +               reg = 1;
6578 +               goto handle;
6579 +       }
6580 +
6581 +       if (dr6 & DR6_B2) {
6582 +               rw = DR7_RW2(dr7);
6583 +               reg = 2;
6584 +               goto handle;
6585 +       }
6586 +
6587 +       if (dr6 & DR6_B3) {
6588 +               rw = DR7_RW3(dr7);
6589 +               reg = 3;
6590 +               goto handle;
6591 +       }
6592 +
6593 +       if (rv > 0)
6594 +               goto handled;
6595 +
6596 +       goto unknown;   /* dismiss */
6597 +
6598 +handle:
6599 +       /*
6600 +        * Set Resume Flag
6601 +        */
6602 +       regs->flags |= EF_RF;
6603 +
6604 +       /*
6605 +        * Determine which breakpoint was encountered.
6606 +        */
6607 +       for(i=0, bp=kdb_breakpoints; i<KDB_MAXBPT; i++, bp++) {
6608 +               if (!(bp->bp_free)
6609 +                && (bp->bp_global || bp->bp_cpu == smp_processor_id())
6610 +                && (bp->bp_hard[cpu])
6611 +                && (bp->bp_hard[cpu]->bph_reg == reg)) {
6612 +                       /*
6613 +                        * Hit this breakpoint.
6614 +                        */
6615 +                       kdb_printf("%s breakpoint #%d at " kdb_bfd_vma_fmt "\n",
6616 +                                 kdba_rwtypes[rw],
6617 +                                 i, bp->bp_addr);
6618 +
6619 +                       /*
6620 +                        * For an instruction breakpoint, disassemble
6621 +                        * the current instruction.
6622 +                        */
6623 +                       if (rw == 0) {
6624 +                               kdb_id1(regs->ip);
6625 +                       }
6626 +
6627 +                       goto handled;
6628 +               }
6629 +       }
6630 +
6631 +unknown:
6632 +       regs->flags |= EF_RF;   /* Supress further faults */
6633 +       rv = KDB_DB_NOBPT;      /* Cause kdb() to return */
6634 +
6635 +handled:
6636 +
6637 +       /*
6638 +        * Clear the pending exceptions.
6639 +        */
6640 +       kdba_putdr6(0);
6641 +
6642 +       return rv;
6643 +}
6644 +
6645 +/*
6646 + * kdba_bp_trap
6647 + *
6648 + *     Perform breakpoint processing upon entry to the
6649 + *     processor breakpoint instruction fault.   Determine and print
6650 + *     the active breakpoint.
6651 + *
6652 + * Parameters:
6653 + *     regs    Exception frame containing machine register state
6654 + *     error   Error number passed to kdb.
6655 + * Outputs:
6656 + *     None.
6657 + * Returns:
6658 + *     0       Standard instruction or data breakpoint encountered
6659 + *     1       Single Step fault ('ss' command)
6660 + *     2       Single Step fault, caller should continue ('ssb' command)
6661 + *     3       No existing kdb breakpoint matches this debug exception
6662 + * Locking:
6663 + *     None.
6664 + * Remarks:
6665 + *
6666 + *     If multiple processors receive debug exceptions simultaneously,
6667 + *     one may be waiting at the kdb fence in kdb() while the user
6668 + *     issues a 'bc' command to clear the breakpoint the processor which
6669 + *     is waiting has already encountered.   If this is the case, the
6670 + *     debug registers will no longer match any entry in the breakpoint
6671 + *     table, and we'll return the value '3'.  This can cause a panic
6672 + *     in die_if_kernel().  It is safer to disable the breakpoint (bd),
6673 + *     'go' until all processors are past the breakpoint then clear the
6674 + *     breakpoint (bc).  This code recognises a breakpoint even when
6675 + *     disabled but not when it has been cleared.
6676 + *
6677 + *     WARNING: This routine resets the ip.  It should be called
6678 + *              once per breakpoint and the result cached.
6679 + */
6680 +
6681 +kdb_dbtrap_t
6682 +kdba_bp_trap(struct pt_regs *regs, int error_unused)
6683 +{
6684 +       int i;
6685 +       kdb_dbtrap_t rv;
6686 +       kdb_bp_t *bp;
6687 +
6688 +       if (KDB_NULL_REGS(regs))
6689 +               return KDB_DB_NOBPT;
6690 +
6691 +       /*
6692 +        * Determine which breakpoint was encountered.
6693 +        */
6694 +       if (KDB_DEBUG(BP))
6695 +               kdb_printf("kdba_bp_trap: ip=0x%lx (not adjusted) "
6696 +                          "flags=0x%lx regs=0x%p sp=0x%lx\n",
6697 +                          regs->ip, regs->flags, regs, regs->sp);
6698 +
6699 +       rv = KDB_DB_NOBPT;      /* Cause kdb() to return */
6700 +
6701 +       for(i=0, bp=kdb_breakpoints; i<KDB_MAXBPT; i++, bp++) {
6702 +               if (bp->bp_free)
6703 +                       continue;
6704 +               if (!bp->bp_global && bp->bp_cpu != smp_processor_id())
6705 +                       continue;
6706 +                if ((void *)bp->bp_addr == (void *)(regs->ip - bp->bp_adjust)) {
6707 +                       /* Hit this breakpoint.  */
6708 +                       regs->ip -= bp->bp_adjust;
6709 +                       kdb_printf("Instruction(i) breakpoint #%d at 0x%lx (adjusted)\n",
6710 +                                 i, regs->ip);
6711 +                       kdb_id1(regs->ip);
6712 +                       rv = KDB_DB_BPT;
6713 +                       bp->bp_delay = 1;
6714 +                       /* SSBPT is set when the kernel debugger must single
6715 +                        * step a task in order to re-establish an instruction
6716 +                        * breakpoint which uses the instruction replacement
6717 +                        * mechanism.  It is cleared by any action that removes
6718 +                        * the need to single-step the breakpoint.
6719 +                        */
6720 +                       KDB_STATE_SET(SSBPT);
6721 +                       break;
6722 +               }
6723 +       }
6724 +
6725 +       return rv;
6726 +}
6727 +
6728 +/*
6729 + * kdba_handle_bp
6730 + *
6731 + *     Handle an instruction-breakpoint trap.  Called when re-installing
6732 + *     an enabled breakpoint which has has the bp_delay bit set.
6733 + *
6734 + * Parameters:
6735 + * Returns:
6736 + * Locking:
6737 + * Remarks:
6738 + *
6739 + * Ok, we really need to:
6740 + *     1) Restore the original instruction byte
6741 + *     2) Single Step
6742 + *     3) Restore breakpoint instruction
6743 + *     4) Continue.
6744 + *
6745 + *
6746 + */
6747 +
6748 +static void
6749 +kdba_handle_bp(struct pt_regs *regs, kdb_bp_t *bp)
6750 +{
6751 +       if (KDB_NULL_REGS(regs))
6752 +               return;
6753 +
6754 +       if (KDB_DEBUG(BP))
6755 +               kdb_printf("regs->ip = 0x%lx\n", regs->ip);
6756 +
6757 +       /*
6758 +        * Setup single step
6759 +        */
6760 +       kdba_setsinglestep(regs);
6761 +
6762 +       /*
6763 +        * Reset delay attribute
6764 +        */
6765 +       bp->bp_delay = 0;
6766 +       bp->bp_delayed = 1;
6767 +}
6768 +
6769 +
6770 +/*
6771 + * kdba_bptype
6772 + *
6773 + *     Return a string describing type of breakpoint.
6774 + *
6775 + * Parameters:
6776 + *     bph     Pointer to hardware breakpoint description
6777 + * Outputs:
6778 + *     None.
6779 + * Returns:
6780 + *     Character string.
6781 + * Locking:
6782 + *     None.
6783 + * Remarks:
6784 + */
6785 +
6786 +char *
6787 +kdba_bptype(kdbhard_bp_t *bph)
6788 +{
6789 +       char *mode;
6790 +
6791 +       mode = kdba_rwtypes[bph->bph_mode];
6792 +
6793 +       return mode;
6794 +}
6795 +
6796 +/*
6797 + * kdba_printbpreg
6798 + *
6799 + *     Print register name assigned to breakpoint
6800 + *
6801 + * Parameters:
6802 + *     bph     Pointer hardware breakpoint structure
6803 + * Outputs:
6804 + *     None.
6805 + * Returns:
6806 + *     None.
6807 + * Locking:
6808 + *     None.
6809 + * Remarks:
6810 + */
6811 +
6812 +static void
6813 +kdba_printbpreg(kdbhard_bp_t *bph)
6814 +{
6815 +       kdb_printf(" in dr%ld", bph->bph_reg);
6816 +}
6817 +
6818 +/*
6819 + * kdba_printbp
6820 + *
6821 + *     Print string describing hardware breakpoint.
6822 + *
6823 + * Parameters:
6824 + *     bph     Pointer to hardware breakpoint description
6825 + * Outputs:
6826 + *     None.
6827 + * Returns:
6828 + *     None.
6829 + * Locking:
6830 + *     None.
6831 + * Remarks:
6832 + */
6833 +
6834 +void
6835 +kdba_printbp(kdb_bp_t *bp)
6836 +{
6837 +       int cpu;
6838 +
6839 +       kdb_printf("\n    is enabled");
6840 +       if (bp->bp_hardtype) {
6841 +               if (bp->bp_global)
6842 +                       cpu = smp_processor_id();
6843 +               else
6844 +                       cpu = bp->bp_cpu;
6845 +               kdba_printbpreg(bp->bp_hard[cpu]);
6846 +               if (bp->bp_hard[cpu]->bph_mode != 0) {
6847 +                       kdb_printf(" for %d bytes",
6848 +                                  bp->bp_hard[cpu]->bph_length+1);
6849 +               }
6850 +       }
6851 +}
6852 +
6853 +/*
6854 + * kdba_parsebp
6855 + *
6856 + *     Parse architecture dependent portion of the
6857 + *     breakpoint command.
6858 + *
6859 + * Parameters:
6860 + *     None.
6861 + * Outputs:
6862 + *     None.
6863 + * Returns:
6864 + *     Zero for success, a kdb diagnostic for failure
6865 + * Locking:
6866 + *     None.
6867 + * Remarks:
6868 + *     for Ia32 architure, data access, data write and
6869 + *     I/O breakpoints are supported in addition to instruction
6870 + *     breakpoints.
6871 + *
6872 + *     {datar|dataw|io|inst} [length]
6873 + */
6874 +
6875 +int
6876 +kdba_parsebp(int argc, const char **argv, int *nextargp, kdb_bp_t *bp)
6877 +{
6878 +       int nextarg = *nextargp;
6879 +       int diag;
6880 +       kdbhard_bp_t *bph = &bp->bp_template;
6881 +
6882 +       bph->bph_mode = 0;              /* Default to instruction breakpoint */
6883 +       bph->bph_length = 0;            /* Length must be zero for insn bp */
6884 +       if ((argc + 1) != nextarg) {
6885 +               if (strnicmp(argv[nextarg], "datar", sizeof("datar")) == 0) {
6886 +                       bph->bph_mode = 3;
6887 +               } else if (strnicmp(argv[nextarg], "dataw", sizeof("dataw")) == 0) {
6888 +                       bph->bph_mode = 1;
6889 +               } else if (strnicmp(argv[nextarg], "io", sizeof("io")) == 0) {
6890 +                       bph->bph_mode = 2;
6891 +               } else if (strnicmp(argv[nextarg], "inst", sizeof("inst")) == 0) {
6892 +                       bph->bph_mode = 0;
6893 +               } else {
6894 +                       return KDB_ARGCOUNT;
6895 +               }
6896 +
6897 +               bph->bph_length = 3;    /* Default to 4 byte */
6898 +
6899 +               nextarg++;
6900 +
6901 +               if ((argc + 1) != nextarg) {
6902 +                       unsigned long len;
6903 +
6904 +                       diag = kdbgetularg((char *)argv[nextarg],
6905 +                                          &len);
6906 +                       if (diag)
6907 +                               return diag;
6908 +
6909 +
6910 +                       if ((len > 4) || (len == 3))
6911 +                               return KDB_BADLENGTH;
6912 +
6913 +                       bph->bph_length = len;
6914 +                       bph->bph_length--; /* Normalize for debug register */
6915 +                       nextarg++;
6916 +               }
6917 +
6918 +               if ((argc + 1) != nextarg)
6919 +                       return KDB_ARGCOUNT;
6920 +
6921 +               /*
6922 +                * Indicate to architecture independent level that
6923 +                * a hardware register assignment is required to enable
6924 +                * this breakpoint.
6925 +                */
6926 +
6927 +               bph->bph_free = 0;
6928 +       } else {
6929 +               if (KDB_DEBUG(BP))
6930 +                       kdb_printf("kdba_bp: no args, forcehw is %d\n", bp->bp_forcehw);
6931 +               if (bp->bp_forcehw) {
6932 +                       /*
6933 +                        * We are forced to use a hardware register for this
6934 +                        * breakpoint because either the bph or bpha
6935 +                        * commands were used to establish this breakpoint.
6936 +                        */
6937 +                       bph->bph_free = 0;
6938 +               } else {
6939 +                       /*
6940 +                        * Indicate to architecture dependent level that
6941 +                        * the instruction replacement breakpoint technique
6942 +                        * should be used for this breakpoint.
6943 +                        */
6944 +                       bph->bph_free = 1;
6945 +                       bp->bp_adjust = 1;      /* software, int 3 is one byte */
6946 +               }
6947 +       }
6948 +
6949 +       if (bph->bph_mode != 2 && kdba_verify_rw(bp->bp_addr, bph->bph_length+1)) {
6950 +               kdb_printf("Invalid address for breakpoint, ignoring bp command\n");
6951 +               return KDB_BADADDR;
6952 +       }
6953 +
6954 +       *nextargp = nextarg;
6955 +       return 0;
6956 +}
6957 +
6958 +/*
6959 + * kdba_allocbp
6960 + *
6961 + *     Allocate hw register for bp on specific CPU
6962 + *
6963 + * Parameters:
6964 + *     None.
6965 + * Outputs:
6966 + *     None.
6967 + * Returns:
6968 + *     A pointer to the allocated register kdbhard_bp_t structure for
6969 + *     success, Null and a non-zero diagnostic for failure.
6970 + * Locking:
6971 + *     None.
6972 + * Remarks:
6973 + */
6974 +
6975 +static kdbhard_bp_t *
6976 +kdba_allocbp(kdbhard_bp_t *bph, int *diagp, unsigned int cpu)
6977 +{
6978 +       int i;
6979 +       kdbhard_bp_t *newbph;
6980 +
6981 +       for(i=0; i < KDB_MAXHARDBPT; i++) {
6982 +               newbph=&(kdb_hardbreaks[cpu][i]);
6983 +               if (newbph->bph_free) {
6984 +                       break;
6985 +               }
6986 +       }
6987 +
6988 +       if (i == KDB_MAXHARDBPT) {
6989 +               *diagp = KDB_TOOMANYDBREGS;
6990 +               return NULL;
6991 +       }
6992 +
6993 +       *diagp = 0;
6994 +
6995 +       /*
6996 +        * Copy data from template.  Can't just copy the entire template
6997 +        * here because the register number in kdb_hardbreaks must be
6998 +        * preserved.
6999 +        */
7000 +       newbph->bph_data = bph->bph_data;
7001 +       newbph->bph_write = bph->bph_write;
7002 +       newbph->bph_mode = bph->bph_mode;
7003 +       newbph->bph_length = bph->bph_length;
7004 +
7005 +       /*
7006 +        * Mark entry allocated.
7007 +        */
7008 +       newbph->bph_free = 0;
7009 +
7010 +       return newbph;
7011 +}
7012 +
7013 +/*
7014 + * kdba_alloc_hwbp
7015 + *
7016 + *     Associate a hardware registers with a breakpoint.
7017 + *     If hw bp is global hw registers descriptor will be allocated
7018 + *     on every CPU.
7019 + *
7020 + * Parameters:
7021 + *     bp - hardware bp
7022 + *     diagp - pointer to variable that will store error when
7023 + *     function complete
7024 + * Outputs:
7025 + *     None.
7026 + * Returns:
7027 + *     None
7028 + * Locking:
7029 + *     None.
7030 + * Remarks:
7031 + *     Should be called with correct bp->bp_template
7032 + */
7033 +
7034 +void
7035 +kdba_alloc_hwbp(kdb_bp_t *bp, int *diagp)
7036 +{
7037 +       int i;
7038 +
7039 +       if (bp->bp_global){
7040 +               for (i = 0; i < NR_CPUS; ++i) {
7041 +                       if (!cpu_online(i))
7042 +                               continue;
7043 +                       bp->bp_hard[i] = kdba_allocbp(&bp->bp_template, diagp, i);
7044 +                       if (*diagp)
7045 +                               break;
7046 +               }
7047 +       } else {
7048 +               bp->bp_hard[bp->bp_cpu] = kdba_allocbp(&bp->bp_template, diagp, bp->bp_cpu);
7049 +       }
7050 +       bp->bp_hardtype = 1;
7051 +}
7052 +
7053 +/*
7054 + * kdba_freebp
7055 + *
7056 + *     Deallocate hw registers descriptor for bp on specific CPU
7057 + *
7058 + * Parameters:
7059 + *     None.
7060 + * Outputs:
7061 + *     None.
7062 + * Returns:
7063 + *     Zero for success, a kdb diagnostic for failure
7064 + * Locking:
7065 + *     None.
7066 + * Remarks:
7067 + */
7068 +
7069 +static void
7070 +kdba_freebp(kdbhard_bp_t *bph)
7071 +{
7072 +       bph->bph_free = 1;
7073 +}
7074 +
7075 +/*
7076 + * kdba_free_hwbp
7077 + *
7078 + *     Frees allocated hw registers descriptors for bp.
7079 + *     If hw bp is global, hw registers descriptors will be freed
7080 + *     on every CPU.
7081 + *
7082 + * Parameters:
7083 + *     bp - hardware bp
7084 + * Outputs:
7085 + *     None.
7086 + * Returns:
7087 + *     None
7088 + * Locking:
7089 + *     None.
7090 + * Remarks:
7091 + *     Should be called with correct bp->bp_template
7092 + */
7093 +
7094 +void
7095 +kdba_free_hwbp(kdb_bp_t *bp)
7096 +{
7097 +       int i;
7098 +
7099 +       /* When kernel enters KDB, first, all local bps
7100 +        * are removed, so here we don't need to clear
7101 +        * debug registers.
7102 +        */
7103 +
7104 +       if (bp->bp_global){
7105 +               for (i = 0; i < NR_CPUS; ++i) {
7106 +                       if (!cpu_online(i))
7107 +                               continue;
7108 +                       if (bp->bp_hard[i])
7109 +                               kdba_freebp(bp->bp_hard[i]);
7110 +                       bp->bp_hard[i] = 0;
7111 +               }
7112 +       } else {
7113 +               kdba_freebp(bp->bp_hard[bp->bp_cpu]);
7114 +               bp->bp_hard[bp->bp_cpu] = NULL;
7115 +       }
7116 +       bp->bp_hardtype = 0;
7117 +}
7118 +
7119 +/*
7120 + * kdba_initbp
7121 + *
7122 + *     Initialize the breakpoint table for the hardware breakpoint
7123 + *     register.
7124 + *
7125 + * Parameters:
7126 + *     None.
7127 + * Outputs:
7128 + *     None.
7129 + * Returns:
7130 + *     Zero for success, a kdb diagnostic for failure
7131 + * Locking:
7132 + *     None.
7133 + * Remarks:
7134 + *
7135 + *     There is one entry per register.  On the ia32 architecture
7136 + *     all the registers are interchangeable, so no special allocation
7137 + *     criteria are required.
7138 + */
7139 +
7140 +void
7141 +kdba_initbp(void)
7142 +{
7143 +       int i,j;
7144 +       kdbhard_bp_t *bph;
7145 +
7146 +       /*
7147 +        * Clear the hardware breakpoint table
7148 +        */
7149 +
7150 +       memset(kdb_hardbreaks, '\0', sizeof(kdb_hardbreaks));
7151 +
7152 +       for (i = 0; i < NR_CPUS; ++i) {
7153 +               /* Called early so we don't know actual
7154 +                * ammount of CPUs
7155 +                */
7156 +               for(j=0; j < KDB_MAXHARDBPT; j++) {
7157 +                       bph=&(kdb_hardbreaks[i][j]);
7158 +                       bph->bph_reg = j;
7159 +                       bph->bph_free = 1;
7160 +               }
7161 +       }
7162 +}
7163 +
7164 +/*
7165 + * kdba_installbp
7166 + *
7167 + *     Install a breakpoint
7168 + *
7169 + * Parameters:
7170 + *     regs    Exception frame
7171 + *     bp      Breakpoint structure for the breakpoint to be installed
7172 + * Outputs:
7173 + *     None.
7174 + * Returns:
7175 + *     0 if breakpoint installed.
7176 + * Locking:
7177 + *     None.
7178 + * Remarks:
7179 + *     For hardware breakpoints, a debug register is allocated
7180 + *     and assigned to the breakpoint.  If no debug register is
7181 + *     available, a warning message is printed and the breakpoint
7182 + *     is disabled.
7183 + *
7184 + *     For instruction replacement breakpoints, we must single-step
7185 + *     over the replaced instruction at this point so we can re-install
7186 + *     the breakpoint instruction after the single-step.  SSBPT is set
7187 + *     when the breakpoint is initially hit and is cleared by any action
7188 + *     that removes the need for single-step over the breakpoint.
7189 + */
7190 +
7191 +int
7192 +kdba_installbp(struct pt_regs *regs, kdb_bp_t *bp)
7193 +{
7194 +       int cpu = smp_processor_id();
7195 +
7196 +       /*
7197 +        * Install the breakpoint, if it is not already installed.
7198 +        */
7199 +
7200 +       if (KDB_DEBUG(BP)) {
7201 +               kdb_printf("kdba_installbp bp_installed %d\n", bp->bp_installed);
7202 +       }
7203 +       if (!KDB_STATE(SSBPT))
7204 +               bp->bp_delay = 0;
7205 +
7206 +       if (bp->bp_hardtype) {
7207 +               if (KDB_DEBUG(BP) && !bp->bp_global && cpu != bp->bp_cpu){
7208 +                       kdb_printf("kdba_installbp: cpu != bp->bp_cpu for local hw bp\n");
7209 +               }
7210 +
7211 +               if (KDB_DEBUG(BP) && !bp->bp_hard[cpu]){
7212 +                       kdb_printf("kdba_installbp: Error - bp_hard[smp_processor_id()] is emply\n");
7213 +                       return 1;
7214 +               }
7215 +
7216 +               if (!bp->bp_hard[cpu]->bph_installed){
7217 +                       kdba_installdbreg(bp);
7218 +                       bp->bp_hard[cpu]->bph_installed = 1;
7219 +                       if (KDB_DEBUG(BP)) {
7220 +                               kdb_printf("kdba_installbp hardware reg %ld at " kdb_bfd_vma_fmt "\n",
7221 +                                  bp->bp_hard[cpu]->bph_reg, bp->bp_addr);
7222 +                       }
7223 +               }
7224 +       } else if (!bp->bp_installed) {
7225 +               if (bp->bp_delay) {
7226 +                       if (KDB_DEBUG(BP))
7227 +                               kdb_printf("kdba_installbp delayed bp\n");
7228 +                       kdba_handle_bp(regs, bp);
7229 +               } else {
7230 +                       if (kdb_getarea_size(&(bp->bp_inst), bp->bp_addr, 1) ||
7231 +                           kdb_putword(bp->bp_addr, IA32_BREAKPOINT_INSTRUCTION, 1)) {
7232 +                               kdb_printf("kdba_installbp failed to set software breakpoint at 0x%lx\n", bp->bp_addr);
7233 +                               return(1);
7234 +                       }
7235 +                       bp->bp_installed = 1;
7236 +                       if (KDB_DEBUG(BP))
7237 +                               kdb_printf("kdba_installbp instruction 0x%x at " kdb_bfd_vma_fmt "\n",
7238 +                                          IA32_BREAKPOINT_INSTRUCTION, bp->bp_addr);
7239 +               }
7240 +       }
7241 +       return(0);
7242 +}
7243 +
7244 +/*
7245 + * kdba_removebp
7246 + *
7247 + *     Make a breakpoint ineffective.
7248 + *
7249 + * Parameters:
7250 + *     None.
7251 + * Outputs:
7252 + *     None.
7253 + * Returns:
7254 + *     None.
7255 + * Locking:
7256 + *     None.
7257 + * Remarks:
7258 + */
7259 +
7260 +int
7261 +kdba_removebp(kdb_bp_t *bp)
7262 +{
7263 +       int cpu = smp_processor_id();
7264 +
7265 +       /*
7266 +        * For hardware breakpoints, remove it from the active register,
7267 +        * for software breakpoints, restore the instruction stream.
7268 +        */
7269 +       if (KDB_DEBUG(BP)) {
7270 +               kdb_printf("kdba_removebp bp_installed %d\n", bp->bp_installed);
7271 +       }
7272 +
7273 +       if (bp->bp_hardtype) {
7274 +               if (KDB_DEBUG(BP) && !bp->bp_global && cpu != bp->bp_cpu){
7275 +                       kdb_printf("kdba_removebp: cpu != bp->bp_cpu for local hw bp\n");
7276 +               }
7277 +
7278 +               if (KDB_DEBUG(BP) && !bp->bp_hard[cpu]){
7279 +                       kdb_printf("kdba_removebp: Error - bp_hard[smp_processor_id()] is emply\n");
7280 +                       return 1;
7281 +               }
7282 +
7283 +               if (KDB_DEBUG(BP)) {
7284 +                       kdb_printf("kdb: removing hardware reg %ld at " kdb_bfd_vma_fmt "\n",
7285 +                                  bp->bp_hard[cpu]->bph_reg, bp->bp_addr);
7286 +               }
7287 +
7288 +               if (bp->bp_hard[cpu]->bph_installed){
7289 +                       if (KDB_DEBUG(BP)) {
7290 +                               kdb_printf("kdba_installbp hardware reg %ld at " kdb_bfd_vma_fmt "\n",
7291 +                                  bp->bp_hard[cpu]->bph_reg, bp->bp_addr);
7292 +                       }
7293 +                       kdba_removedbreg(bp);
7294 +                       bp->bp_hard[cpu]->bph_installed = 0;
7295 +               }
7296 +       } else if (bp->bp_installed) {
7297 +               if (KDB_DEBUG(BP))
7298 +                       kdb_printf("kdb: restoring instruction 0x%x at " kdb_bfd_vma_fmt "\n",
7299 +                                  bp->bp_inst, bp->bp_addr);
7300 +               if (kdb_putword(bp->bp_addr, bp->bp_inst, 1))
7301 +                       return(1);
7302 +               bp->bp_installed = 0;
7303 +       }
7304 +       return(0);
7305 +}
7306 --- /dev/null
7307 +++ b/arch/x86/kdb/kdba_bp_64.c
7308 @@ -0,0 +1,912 @@
7309 +/*
7310 + * Kernel Debugger Architecture Dependent Breakpoint Handling
7311 + *
7312 + * This file is subject to the terms and conditions of the GNU General Public
7313 + * License.  See the file "COPYING" in the main directory of this archive
7314 + * for more details.
7315 + *
7316 + * Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
7317 + */
7318 +
7319 +#include <linux/string.h>
7320 +#include <linux/kernel.h>
7321 +#include <linux/sched.h>
7322 +#include <linux/smp.h>
7323 +#include <linux/ptrace.h>
7324 +#include <linux/kdb.h>
7325 +#include <linux/kdbprivate.h>
7326 +
7327 +
7328 +static char *kdba_rwtypes[] = { "Instruction(Register)", "Data Write",
7329 +                       "I/O", "Data Access"};
7330 +
7331 +/*
7332 + * Table describing processor architecture hardware
7333 + * breakpoint registers for every CPU.
7334 + */
7335 +
7336 +static kdbhard_bp_t kdb_hardbreaks[NR_CPUS][KDB_MAXHARDBPT];
7337 +
7338 +/*
7339 + * kdba_db_trap
7340 + *
7341 + *     Perform breakpoint processing upon entry to the
7342 + *     processor debugger fault.   Determine and print
7343 + *     the active breakpoint.
7344 + *
7345 + * Parameters:
7346 + *     regs    Exception frame containing machine register state
7347 + *     error   Error number passed to kdb.
7348 + * Outputs:
7349 + *     None.
7350 + * Returns:
7351 + *     KDB_DB_BPT      Standard instruction or data breakpoint encountered
7352 + *     KDB_DB_SS       Single Step fault ('ss' command or end of 'ssb' command)
7353 + *     KDB_DB_SSB      Single Step fault, caller should continue ('ssb' command)
7354 + *     KDB_DB_SSBPT    Single step over breakpoint
7355 + *     KDB_DB_NOBPT    No existing kdb breakpoint matches this debug exception
7356 + * Locking:
7357 + *     None.
7358 + * Remarks:
7359 + *     Yup, there be goto's here.
7360 + *
7361 + *     If multiple processors receive debug exceptions simultaneously,
7362 + *     one may be waiting at the kdb fence in kdb() while the user
7363 + *     issues a 'bc' command to clear the breakpoint the processor
7364 + *     which is waiting has already encountered.  If this is the case,
7365 + *     the debug registers will no longer match any entry in the
7366 + *     breakpoint table, and we'll return the value KDB_DB_NOBPT.
7367 + *     This can cause a panic in die_if_kernel().  It is safer to
7368 + *     disable the breakpoint (bd), go until all processors are past
7369 + *     the breakpoint then clear the breakpoint (bc).  This code
7370 + *     recognises a breakpoint even when disabled but not when it has
7371 + *     been cleared.
7372 + *
7373 + *     WARNING: This routine clears the debug state.  It should be called
7374 + *              once per debug and the result cached.
7375 + */
7376 +
7377 +kdb_dbtrap_t
7378 +kdba_db_trap(struct pt_regs *regs, int error_unused)
7379 +{
7380 +       kdb_machreg_t dr6;
7381 +       kdb_machreg_t dr7;
7382 +       int rw, reg;
7383 +       int i;
7384 +       kdb_dbtrap_t rv = KDB_DB_BPT;
7385 +       kdb_bp_t *bp;
7386 +       int cpu = smp_processor_id();
7387 +
7388 +       if (KDB_NULL_REGS(regs))
7389 +               return KDB_DB_NOBPT;
7390 +
7391 +       dr6 = kdba_getdr6();
7392 +       dr7 = kdba_getdr7();
7393 +
7394 +       if (KDB_DEBUG(BP))
7395 +               kdb_printf("kdb: dr6 0x%lx dr7 0x%lx\n", dr6, dr7);
7396 +       if (dr6 & DR6_BS) {
7397 +               if (KDB_STATE(SSBPT)) {
7398 +                       if (KDB_DEBUG(BP))
7399 +                               kdb_printf("ssbpt\n");
7400 +                       KDB_STATE_CLEAR(SSBPT);
7401 +                       for(i=0,bp=kdb_breakpoints;
7402 +                           i < KDB_MAXBPT;
7403 +                           i++, bp++) {
7404 +                               if (KDB_DEBUG(BP))
7405 +                                       kdb_printf("bp 0x%p enabled %d delayed %d global %d cpu %d\n",
7406 +                                                  bp, bp->bp_enabled, bp->bp_delayed, bp->bp_global, bp->bp_cpu);
7407 +                               if (!bp->bp_enabled)
7408 +                                       continue;
7409 +                               if (!bp->bp_global && bp->bp_cpu != smp_processor_id())
7410 +                                       continue;
7411 +                               if (KDB_DEBUG(BP))
7412 +                                       kdb_printf("bp for this cpu\n");
7413 +                               if (bp->bp_delayed) {
7414 +                                       bp->bp_delayed = 0;
7415 +                                       if (KDB_DEBUG(BP)){
7416 +                                               /* Can't be hw breakpoint */
7417 +                                               if (bp->bp_hardtype)
7418 +                                                       kdb_printf("kdb: Error - hw bp delayed\n");
7419 +                                               kdb_printf("kdba_installbp\n");
7420 +                                       }
7421 +                                       kdba_installbp(regs, bp);
7422 +                                       if (!KDB_STATE(DOING_SS)) {
7423 +                                               regs->flags &= ~X86_EFLAGS_TF;
7424 +                                               return(KDB_DB_SSBPT);
7425 +                                       }
7426 +                                       break;
7427 +                               }
7428 +                       }
7429 +                       if (i == KDB_MAXBPT) {
7430 +                               kdb_printf("kdb: Unable to find delayed breakpoint\n");
7431 +                       }
7432 +                       if (!KDB_STATE(DOING_SS)) {
7433 +                               regs->flags &= ~X86_EFLAGS_TF;
7434 +                               return(KDB_DB_NOBPT);
7435 +                       }
7436 +                       /* FALLTHROUGH */
7437 +               }
7438 +
7439 +               /*
7440 +                * KDB_STATE_DOING_SS is set when the kernel debugger is using
7441 +                * the processor trap flag to single-step a processor.  If a
7442 +                * single step trap occurs and this flag is clear, the SS trap
7443 +                * will be ignored by KDB and the kernel will be allowed to deal
7444 +                * with it as necessary (e.g. for ptrace).
7445 +                */
7446 +               if (!KDB_STATE(DOING_SS))
7447 +                       goto unknown;
7448 +
7449 +               /* single step */
7450 +               rv = KDB_DB_SS;         /* Indicate single step */
7451 +               if (KDB_STATE(DOING_SSB)) {
7452 +                       unsigned char instruction[2];
7453 +
7454 +                       kdb_id1(regs->ip);
7455 +                       if (kdb_getarea(instruction, regs->ip) ||
7456 +                           (instruction[0]&0xf0) == 0xe0 ||    /* short disp jumps */
7457 +                           (instruction[0]&0xf0) == 0x70 ||    /* Misc. jumps */
7458 +                           instruction[0]        == 0xc2 ||    /* ret */
7459 +                           instruction[0]        == 0x9a ||    /* call */
7460 +                           (instruction[0]&0xf8) == 0xc8 ||    /* enter, leave, iret, int, */
7461 +                           ((instruction[0]      == 0x0f) &&
7462 +                            ((instruction[1]&0xf0)== 0x80))
7463 +                          ) {
7464 +                               /*
7465 +                                * End the ssb command here.
7466 +                                */
7467 +                               KDB_STATE_CLEAR(DOING_SSB);
7468 +                               KDB_STATE_CLEAR(DOING_SS);
7469 +                       } else {
7470 +                               rv = KDB_DB_SSB; /* Indicate ssb - dismiss immediately */
7471 +                       }
7472 +               } else {
7473 +                       /*
7474 +                        * Print current insn
7475 +                        */
7476 +                       kdb_printf("SS trap at ");
7477 +                       kdb_symbol_print(regs->ip, NULL, KDB_SP_DEFAULT|KDB_SP_NEWLINE);
7478 +                       kdb_id1(regs->ip);
7479 +                       KDB_STATE_CLEAR(DOING_SS);
7480 +               }
7481 +
7482 +               if (rv != KDB_DB_SSB)
7483 +                       regs->flags &= ~X86_EFLAGS_TF;
7484 +       }
7485 +
7486 +       if (dr6 & DR6_B0) {
7487 +               rw = DR7_RW0(dr7);
7488 +               reg = 0;
7489 +               goto handle;
7490 +       }
7491 +
7492 +       if (dr6 & DR6_B1) {
7493 +               rw = DR7_RW1(dr7);
7494 +               reg = 1;
7495 +               goto handle;
7496 +       }
7497 +
7498 +       if (dr6 & DR6_B2) {
7499 +               rw = DR7_RW2(dr7);
7500 +               reg = 2;
7501 +               goto handle;
7502 +       }
7503 +
7504 +       if (dr6 & DR6_B3) {
7505 +               rw = DR7_RW3(dr7);
7506 +               reg = 3;
7507 +               goto handle;
7508 +       }
7509 +
7510 +       if (rv > 0)
7511 +               goto handled;
7512 +
7513 +       goto unknown;   /* dismiss */
7514 +
7515 +handle:
7516 +       /*
7517 +        * Set Resume Flag
7518 +        */
7519 +       regs->flags |= X86_EFLAGS_RF;
7520 +
7521 +       /*
7522 +        * Determine which breakpoint was encountered.
7523 +        */
7524 +       for(i=0, bp=kdb_breakpoints; i<KDB_MAXBPT; i++, bp++) {
7525 +               if (!(bp->bp_free)
7526 +                && (bp->bp_global || bp->bp_cpu == smp_processor_id())
7527 +                && (bp->bp_hard[cpu])
7528 +                && (bp->bp_hard[cpu]->bph_reg == reg)) {
7529 +                       /*
7530 +                        * Hit this breakpoint.
7531 +                        */
7532 +                       kdb_printf("%s breakpoint #%d at " kdb_bfd_vma_fmt "\n",
7533 +                                 kdba_rwtypes[rw],
7534 +                                 i, bp->bp_addr);
7535 +
7536 +                       /*
7537 +                        * For an instruction breakpoint, disassemble
7538 +                        * the current instruction.
7539 +                        */
7540 +                       if (rw == 0) {
7541 +                               kdb_id1(regs->ip);
7542 +                       }
7543 +
7544 +                       goto handled;
7545 +               }
7546 +       }
7547 +
7548 +unknown:
7549 +       regs->flags |= X86_EFLAGS_RF;   /* Supress further faults */
7550 +       rv = KDB_DB_NOBPT;      /* Cause kdb() to return */
7551 +
7552 +handled:
7553 +
7554 +       /*
7555 +        * Clear the pending exceptions.
7556 +        */
7557 +       kdba_putdr6(0);
7558 +
7559 +       return rv;
7560 +}
7561 +
7562 +/*
7563 + * kdba_bp_trap
7564 + *
7565 + *     Perform breakpoint processing upon entry to the
7566 + *     processor breakpoint instruction fault.   Determine and print
7567 + *     the active breakpoint.
7568 + *
7569 + * Parameters:
7570 + *     regs    Exception frame containing machine register state
7571 + *     error   Error number passed to kdb.
7572 + * Outputs:
7573 + *     None.
7574 + * Returns:
7575 + *     0       Standard instruction or data breakpoint encountered
7576 + *     1       Single Step fault ('ss' command)
7577 + *     2       Single Step fault, caller should continue ('ssb' command)
7578 + *     3       No existing kdb breakpoint matches this debug exception
7579 + * Locking:
7580 + *     None.
7581 + * Remarks:
7582 + *
7583 + *     If multiple processors receive debug exceptions simultaneously,
7584 + *     one may be waiting at the kdb fence in kdb() while the user
7585 + *     issues a 'bc' command to clear the breakpoint the processor which
7586 + *     is waiting has already encountered.   If this is the case, the
7587 + *     debug registers will no longer match any entry in the breakpoint
7588 + *     table, and we'll return the value '3'.  This can cause a panic
7589 + *     in die_if_kernel().  It is safer to disable the breakpoint (bd),
7590 + *     'go' until all processors are past the breakpoint then clear the
7591 + *     breakpoint (bc).  This code recognises a breakpoint even when
7592 + *     disabled but not when it has been cleared.
7593 + *
7594 + *     WARNING: This routine resets the ip.  It should be called
7595 + *              once per breakpoint and the result cached.
7596 + */
7597 +
7598 +kdb_dbtrap_t
7599 +kdba_bp_trap(struct pt_regs *regs, int error_unused)
7600 +{
7601 +       int i;
7602 +       kdb_dbtrap_t rv;
7603 +       kdb_bp_t *bp;
7604 +
7605 +       if (KDB_NULL_REGS(regs))
7606 +               return KDB_DB_NOBPT;
7607 +
7608 +       /*
7609 +        * Determine which breakpoint was encountered.
7610 +        */
7611 +       if (KDB_DEBUG(BP))
7612 +               kdb_printf("kdba_bp_trap: ip=0x%lx (not adjusted) "
7613 +                          "flags=0x%lx ef=0x%p sp=0x%lx\n",
7614 +                          regs->ip, regs->flags, regs, regs->sp);
7615 +
7616 +       rv = KDB_DB_NOBPT;      /* Cause kdb() to return */
7617 +
7618 +       for(i=0, bp=kdb_breakpoints; i<KDB_MAXBPT; i++, bp++) {
7619 +               if (bp->bp_free)
7620 +                       continue;
7621 +               if (!bp->bp_global && bp->bp_cpu != smp_processor_id())
7622 +                       continue;
7623 +                if ((void *)bp->bp_addr == (void *)(regs->ip - bp->bp_adjust)) {
7624 +                       /* Hit this breakpoint.  */
7625 +                       regs->ip -= bp->bp_adjust;
7626 +                       kdb_printf("Instruction(i) breakpoint #%d at 0x%lx (adjusted)\n",
7627 +                                 i, regs->ip);
7628 +                       kdb_id1(regs->ip);
7629 +                       rv = KDB_DB_BPT;
7630 +                       bp->bp_delay = 1;
7631 +                       /* SSBPT is set when the kernel debugger must single
7632 +                        * step a task in order to re-establish an instruction
7633 +                        * breakpoint which uses the instruction replacement
7634 +                        * mechanism.  It is cleared by any action that removes
7635 +                        * the need to single-step the breakpoint.
7636 +                        */
7637 +                       KDB_STATE_SET(SSBPT);
7638 +                       break;
7639 +               }
7640 +       }
7641 +
7642 +       return rv;
7643 +}
7644 +
7645 +/*
7646 + * kdba_handle_bp
7647 + *
7648 + *     Handle an instruction-breakpoint trap.  Called when re-installing
7649 + *     an enabled breakpoint which has has the bp_delay bit set.
7650 + *
7651 + * Parameters:
7652 + * Returns:
7653 + * Locking:
7654 + * Remarks:
7655 + *
7656 + * Ok, we really need to:
7657 + *     1) Restore the original instruction byte
7658 + *     2) Single Step
7659 + *     3) Restore breakpoint instruction
7660 + *     4) Continue.
7661 + *
7662 + *
7663 + */
7664 +
7665 +static void
7666 +kdba_handle_bp(struct pt_regs *regs, kdb_bp_t *bp)
7667 +{
7668 +       if (KDB_NULL_REGS(regs))
7669 +               return;
7670 +
7671 +       if (KDB_DEBUG(BP))
7672 +               kdb_printf("regs->ip = 0x%lx\n", regs->ip);
7673 +
7674 +       /*
7675 +        * Setup single step
7676 +        */
7677 +       kdba_setsinglestep(regs);
7678 +
7679 +       /*
7680 +        * Reset delay attribute
7681 +        */
7682 +       bp->bp_delay = 0;
7683 +       bp->bp_delayed = 1;
7684 +}
7685 +
7686 +
7687 +/*
7688 + * kdba_bptype
7689 + *
7690 + *     Return a string describing type of breakpoint.
7691 + *
7692 + * Parameters:
7693 + *     bph     Pointer to hardware breakpoint description
7694 + * Outputs:
7695 + *     None.
7696 + * Returns:
7697 + *     Character string.
7698 + * Locking:
7699 + *     None.
7700 + * Remarks:
7701 + */
7702 +
7703 +char *
7704 +kdba_bptype(kdbhard_bp_t *bph)
7705 +{
7706 +       char *mode;
7707 +
7708 +       mode = kdba_rwtypes[bph->bph_mode];
7709 +
7710 +       return mode;
7711 +}
7712 +
7713 +/*
7714 + * kdba_printbpreg
7715 + *
7716 + *     Print register name assigned to breakpoint
7717 + *
7718 + * Parameters:
7719 + *     bph     Pointer hardware breakpoint structure
7720 + * Outputs:
7721 + *     None.
7722 + * Returns:
7723 + *     None.
7724 + * Locking:
7725 + *     None.
7726 + * Remarks:
7727 + */
7728 +
7729 +static void
7730 +kdba_printbpreg(kdbhard_bp_t *bph)
7731 +{
7732 +       kdb_printf(" in dr%ld", bph->bph_reg);
7733 +}
7734 +
7735 +/*
7736 + * kdba_printbp
7737 + *
7738 + *     Print string describing hardware breakpoint.
7739 + *
7740 + * Parameters:
7741 + *     bph     Pointer to hardware breakpoint description
7742 + * Outputs:
7743 + *     None.
7744 + * Returns:
7745 + *     None.
7746 + * Locking:
7747 + *     None.
7748 + * Remarks:
7749 + */
7750 +
7751 +void
7752 +kdba_printbp(kdb_bp_t *bp)
7753 +{
7754 +       int cpu;
7755 +
7756 +       kdb_printf("\n    is enabled");
7757 +       if (bp->bp_hardtype) {
7758 +               if (bp->bp_global)
7759 +                       cpu = smp_processor_id();
7760 +               else
7761 +                       cpu = bp->bp_cpu;
7762 +               kdba_printbpreg(bp->bp_hard[cpu]);
7763 +               if (bp->bp_hard[cpu]->bph_mode != 0) {
7764 +                       kdb_printf(" for %d bytes",
7765 +                                  bp->bp_hard[cpu]->bph_length+1);
7766 +               }
7767 +       }
7768 +}
7769 +
7770 +/*
7771 + * kdba_parsebp
7772 + *
7773 + *     Parse architecture dependent portion of the
7774 + *     breakpoint command.
7775 + *
7776 + * Parameters:
7777 + *     None.
7778 + * Outputs:
7779 + *     None.
7780 + * Returns:
7781 + *     Zero for success, a kdb diagnostic for failure
7782 + * Locking:
7783 + *     None.
7784 + * Remarks:
7785 + *     for Ia32 architure, data access, data write and
7786 + *     I/O breakpoints are supported in addition to instruction
7787 + *     breakpoints.
7788 + *
7789 + *     {datar|dataw|io|inst} [length]
7790 + */
7791 +
7792 +int
7793 +kdba_parsebp(int argc, const char **argv, int *nextargp, kdb_bp_t *bp)
7794 +{
7795 +       int nextarg = *nextargp;
7796 +       int diag;
7797 +       kdbhard_bp_t *bph = &bp->bp_template;
7798 +
7799 +       bph->bph_mode = 0;              /* Default to instruction breakpoint */
7800 +       bph->bph_length = 0;            /* Length must be zero for insn bp */
7801 +       if ((argc + 1) != nextarg) {
7802 +               if (strnicmp(argv[nextarg], "datar", sizeof("datar")) == 0) {
7803 +                       bph->bph_mode = 3;
7804 +               } else if (strnicmp(argv[nextarg], "dataw", sizeof("dataw")) == 0) {
7805 +                       bph->bph_mode = 1;
7806 +               } else if (strnicmp(argv[nextarg], "io", sizeof("io")) == 0) {
7807 +                       bph->bph_mode = 2;
7808 +               } else if (strnicmp(argv[nextarg], "inst", sizeof("inst")) == 0) {
7809 +                       bph->bph_mode = 0;
7810 +               } else {
7811 +                       return KDB_ARGCOUNT;
7812 +               }
7813 +
7814 +               bph->bph_length = 3;    /* Default to 4 byte */
7815 +
7816 +               nextarg++;
7817 +
7818 +               if ((argc + 1) != nextarg) {
7819 +                       unsigned long len;
7820 +
7821 +                       diag = kdbgetularg((char *)argv[nextarg],
7822 +                                          &len);
7823 +                       if (diag)
7824 +                               return diag;
7825 +
7826 +
7827 +                       if ((len > 4) || (len == 3))
7828 +                               return KDB_BADLENGTH;
7829 +
7830 +                       bph->bph_length = len;
7831 +                       bph->bph_length--; /* Normalize for debug register */
7832 +                       nextarg++;
7833 +               }
7834 +
7835 +               if ((argc + 1) != nextarg)
7836 +                       return KDB_ARGCOUNT;
7837 +
7838 +               /*
7839 +                * Indicate to architecture independent level that
7840 +                * a hardware register assignment is required to enable
7841 +                * this breakpoint.
7842 +                */
7843 +
7844 +               bph->bph_free = 0;
7845 +       } else {
7846 +               if (KDB_DEBUG(BP))
7847 +                       kdb_printf("kdba_bp: no args, forcehw is %d\n", bp->bp_forcehw);
7848 +               if (bp->bp_forcehw) {
7849 +                       /*
7850 +                        * We are forced to use a hardware register for this
7851 +                        * breakpoint because either the bph or bpha
7852 +                        * commands were used to establish this breakpoint.
7853 +                        */
7854 +                       bph->bph_free = 0;
7855 +               } else {
7856 +                       /*
7857 +                        * Indicate to architecture dependent level that
7858 +                        * the instruction replacement breakpoint technique
7859 +                        * should be used for this breakpoint.
7860 +                        */
7861 +                       bph->bph_free = 1;
7862 +                       bp->bp_adjust = 1;      /* software, int 3 is one byte */
7863 +               }
7864 +       }
7865 +
7866 +       if (bph->bph_mode != 2 && kdba_verify_rw(bp->bp_addr, bph->bph_length+1)) {
7867 +               kdb_printf("Invalid address for breakpoint, ignoring bp command\n");
7868 +               return KDB_BADADDR;
7869 +       }
7870 +
7871 +       *nextargp = nextarg;
7872 +       return 0;
7873 +}
7874 +
7875 +/*
7876 + * kdba_allocbp
7877 + *
7878 + *     Allocate hw register for bp on specific CPU
7879 + *
7880 + * Parameters:
7881 + *     None.
7882 + * Outputs:
7883 + *     None.
7884 + * Returns:
7885 + *     A pointer to the allocated register kdbhard_bp_t structure for
7886 + *     success, Null and a non-zero diagnostic for failure.
7887 + * Locking:
7888 + *     None.
7889 + * Remarks:
7890 + */
7891 +
7892 +static kdbhard_bp_t *
7893 +kdba_allocbp(kdbhard_bp_t *bph, int *diagp, unsigned int cpu)
7894 +{
7895 +       int i;
7896 +       kdbhard_bp_t *newbph;
7897 +
7898 +       for(i=0; i < KDB_MAXHARDBPT; i++) {
7899 +               newbph=&(kdb_hardbreaks[cpu][i]);
7900 +               if (newbph->bph_free) {
7901 +                       break;
7902 +               }
7903 +       }
7904 +
7905 +       if (i == KDB_MAXHARDBPT) {
7906 +               *diagp = KDB_TOOMANYDBREGS;
7907 +               return NULL;
7908 +       }
7909 +
7910 +       *diagp = 0;
7911 +
7912 +       /*
7913 +        * Copy data from template.  Can't just copy the entire template
7914 +        * here because the register number in kdb_hardbreaks must be
7915 +        * preserved.
7916 +        */
7917 +       newbph->bph_data = bph->bph_data;
7918 +       newbph->bph_write = bph->bph_write;
7919 +       newbph->bph_mode = bph->bph_mode;
7920 +       newbph->bph_length = bph->bph_length;
7921 +
7922 +       /*
7923 +        * Mark entry allocated.
7924 +        */
7925 +       newbph->bph_free = 0;
7926 +
7927 +       return newbph;
7928 +}
7929 +
7930 +/*
7931 + * kdba_alloc_hwbp
7932 + *
7933 + *     Associate a hardware registers with a breakpoint.
7934 + *     If hw bp is global hw registers descriptor will be allocated
7935 + *     on every CPU.
7936 + *
7937 + * Parameters:
7938 + *     bp - hardware bp
7939 + *     diagp - pointer to variable that will store error when
7940 + *     function complete
7941 + * Outputs:
7942 + *     None.
7943 + * Returns:
7944 + *     None
7945 + * Locking:
7946 + *     None.
7947 + * Remarks:
7948 + *     Should be called with correct bp->bp_template
7949 + */
7950 +
7951 +void
7952 +kdba_alloc_hwbp(kdb_bp_t *bp, int *diagp)
7953 +{
7954 +       int i;
7955 +
7956 +       if (bp->bp_global){
7957 +               for (i = 0; i < NR_CPUS; ++i) {
7958 +                       if (!cpu_online(i))
7959 +                               continue;
7960 +                       bp->bp_hard[i] = kdba_allocbp(&bp->bp_template, diagp, i);
7961 +                       if (*diagp)
7962 +                               break;
7963 +               }
7964 +       } else {
7965 +               bp->bp_hard[bp->bp_cpu] = kdba_allocbp(&bp->bp_template, diagp, bp->bp_cpu);
7966 +       }
7967 +       bp->bp_hardtype = 1;
7968 +}
7969 +
7970 +/*
7971 + * kdba_freebp
7972 + *
7973 + *     Deallocate hw registers descriptor for bp on specific CPU
7974 + *
7975 + * Parameters:
7976 + *     None.
7977 + * Outputs:
7978 + *     None.
7979 + * Returns:
7980 + *     Zero for success, a kdb diagnostic for failure
7981 + * Locking:
7982 + *     None.
7983 + * Remarks:
7984 + */
7985 +
7986 +static void
7987 +kdba_freebp(kdbhard_bp_t *bph)
7988 +{
7989 +       bph->bph_free = 1;
7990 +}
7991 +
7992 +/*
7993 + * kdba_free_hwbp
7994 + *
7995 + *     Frees allocated hw registers descriptors for bp.
7996 + *     If hw bp is global, hw registers descriptors will be freed
7997 + *     on every CPU.
7998 + *
7999 + * Parameters:
8000 + *     bp - hardware bp
8001 + * Outputs:
8002 + *     None.
8003 + * Returns:
8004 + *     None
8005 + * Locking:
8006 + *     None.
8007 + * Remarks:
8008 + *     Should be called with correct bp->bp_template
8009 + */
8010 +
8011 +void
8012 +kdba_free_hwbp(kdb_bp_t *bp)
8013 +{
8014 +       int i;
8015 +
8016 +       /* When kernel enters KDB, first, all local bps
8017 +        * are removed, so here we don't need to clear
8018 +        * debug registers.
8019 +        */
8020 +
8021 +       if (bp->bp_global){
8022 +               for (i = 0; i < NR_CPUS; ++i) {
8023 +                       if (!cpu_online(i))
8024 +                               continue;
8025 +                       if (bp->bp_hard[i])
8026 +                               kdba_freebp(bp->bp_hard[i]);
8027 +                       bp->bp_hard[i] = 0;
8028 +               }
8029 +       } else {
8030 +               kdba_freebp(bp->bp_hard[bp->bp_cpu]);
8031 +               bp->bp_hard[bp->bp_cpu] = NULL;
8032 +       }
8033 +       bp->bp_hardtype = 0;
8034 +}
8035 +
8036 +/*
8037 + * kdba_initbp
8038 + *
8039 + *     Initialize the breakpoint table for the hardware breakpoint
8040 + *     register.
8041 + *
8042 + * Parameters:
8043 + *     None.
8044 + * Outputs:
8045 + *     None.
8046 + * Returns:
8047 + *     Zero for success, a kdb diagnostic for failure
8048 + * Locking:
8049 + *     None.
8050 + * Remarks:
8051 + *
8052 + *     There is one entry per register.  On the ia32 architecture
8053 + *     all the registers are interchangeable, so no special allocation
8054 + *     criteria are required.
8055 + */
8056 +
8057 +void
8058 +kdba_initbp(void)
8059 +{
8060 +       int i,j;
8061 +       kdbhard_bp_t *bph;
8062 +
8063 +       /*
8064 +        * Clear the hardware breakpoint table
8065 +        */
8066 +
8067 +       memset(kdb_hardbreaks, '\0', sizeof(kdb_hardbreaks));
8068 +
8069 +       for (i = 0; i < NR_CPUS; ++i) {
8070 +               /* Called early so we don't know actual
8071 +                * ammount of CPUs
8072 +                */
8073 +               for(j=0; j < KDB_MAXHARDBPT; j++) {
8074 +                       bph=&(kdb_hardbreaks[i][j]);
8075 +                       bph->bph_reg = j;
8076 +                       bph->bph_free = 1;
8077 +               }
8078 +       }
8079 +}
8080 +
8081 +/*
8082 + * kdba_installbp
8083 + *
8084 + *     Install a breakpoint
8085 + *
8086 + * Parameters:
8087 + *     regs    Exception frame
8088 + *     bp      Breakpoint structure for the breakpoint to be installed
8089 + * Outputs:
8090 + *     None.
8091 + * Returns:
8092 + *     0 if breakpoint installed.
8093 + * Locking:
8094 + *     None.
8095 + * Remarks:
8096 + *     For hardware breakpoints, a debug register is allocated
8097 + *     and assigned to the breakpoint.  If no debug register is
8098 + *     available, a warning message is printed and the breakpoint
8099 + *     is disabled.
8100 + *
8101 + *     For instruction replacement breakpoints, we must single-step
8102 + *     over the replaced instruction at this point so we can re-install
8103 + *     the breakpoint instruction after the single-step.
8104 + */
8105 +
8106 +int
8107 +kdba_installbp(struct pt_regs *regs, kdb_bp_t *bp)
8108 +{
8109 +       int cpu = smp_processor_id();
8110 +
8111 +       /*
8112 +        * Install the breakpoint, if it is not already installed.
8113 +        */
8114 +
8115 +       if (KDB_DEBUG(BP)) {
8116 +               kdb_printf("kdba_installbp bp_installed %d\n", bp->bp_installed);
8117 +       }
8118 +       if (!KDB_STATE(SSBPT))
8119 +               bp->bp_delay = 0;
8120 +
8121 +       if (bp->bp_hardtype) {
8122 +               if (KDB_DEBUG(BP) && !bp->bp_global && cpu != bp->bp_cpu){
8123 +                       kdb_printf("kdba_removebp: cpu != bp->bp_cpu for local hw bp\n");
8124 +               }
8125 +
8126 +               if (KDB_DEBUG(BP) && !bp->bp_hard[cpu]){
8127 +                       kdb_printf("kdba_removebp: Error - bp_hard[smp_processor_id()] is emply\n");
8128 +                       return 1;
8129 +               }
8130 +
8131 +               if (!bp->bp_hard[cpu]->bph_installed){
8132 +                       kdba_installdbreg(bp);
8133 +                       bp->bp_hard[cpu]->bph_installed = 1;
8134 +                       if (KDB_DEBUG(BP)) {
8135 +                               kdb_printf("kdba_installbp hardware reg %ld at " kdb_bfd_vma_fmt "\n",
8136 +                                  bp->bp_hard[cpu]->bph_reg, bp->bp_addr);
8137 +                       }
8138 +               }
8139 +       } else if (!bp->bp_installed) {
8140 +               if (bp->bp_delay) {
8141 +                       if (KDB_DEBUG(BP))
8142 +                               kdb_printf("kdba_installbp delayed bp\n");
8143 +                       kdba_handle_bp(regs, bp);
8144 +               } else {
8145 +                       if (kdb_getarea_size(&(bp->bp_inst), bp->bp_addr, 1) ||
8146 +                           kdb_putword(bp->bp_addr, IA32_BREAKPOINT_INSTRUCTION, 1)) {
8147 +                               kdb_printf("kdba_installbp failed to set software breakpoint at " kdb_bfd_vma_fmt "\n", bp->bp_addr);
8148 +                               return(1);
8149 +                       }
8150 +                       bp->bp_installed = 1;
8151 +                       if (KDB_DEBUG(BP))
8152 +                               kdb_printf("kdba_installbp instruction 0x%x at " kdb_bfd_vma_fmt "\n",
8153 +                                          IA32_BREAKPOINT_INSTRUCTION, bp->bp_addr);
8154 +               }
8155 +       }
8156 +       return(0);
8157 +}
8158 +
8159 +/*
8160 + * kdba_removebp
8161 + *
8162 + *     Make a breakpoint ineffective.
8163 + *
8164 + * Parameters:
8165 + *     None.
8166 + * Outputs:
8167 + *     None.
8168 + * Returns:
8169 + *     None.
8170 + * Locking:
8171 + *     None.
8172 + * Remarks:
8173 + */
8174 +
8175 +int
8176 +kdba_removebp(kdb_bp_t *bp)
8177 +{
8178 +       int cpu = smp_processor_id();
8179 +
8180 +       /*
8181 +        * For hardware breakpoints, remove it from the active register,
8182 +        * for software breakpoints, restore the instruction stream.
8183 +        */
8184 +       if (KDB_DEBUG(BP)) {
8185 +               kdb_printf("kdba_removebp bp_installed %d\n", bp->bp_installed);
8186 +       }
8187 +
8188 +       if (bp->bp_hardtype) {
8189 +               if (KDB_DEBUG(BP) && !bp->bp_global && cpu != bp->bp_cpu){
8190 +                       kdb_printf("kdba_removebp: cpu != bp->bp_cpu for local hw bp\n");
8191 +               }
8192 +
8193 +               if (KDB_DEBUG(BP) && !bp->bp_hard[cpu]){
8194 +                       kdb_printf("kdba_removebp: Error - bp_hard[smp_processor_id()] is emply\n");
8195 +                       return 1;
8196 +               }
8197 +
8198 +               if (KDB_DEBUG(BP)) {
8199 +                       kdb_printf("kdb: removing hardware reg %ld at " kdb_bfd_vma_fmt "\n",
8200 +                                  bp->bp_hard[cpu]->bph_reg, bp->bp_addr);
8201 +               }
8202 +
8203 +               if (bp->bp_hard[cpu]->bph_installed){
8204 +                       if (KDB_DEBUG(BP)) {
8205 +                               kdb_printf("kdba_installbp hardware reg %ld at " kdb_bfd_vma_fmt "\n",
8206 +                                  bp->bp_hard[cpu]->bph_reg, bp->bp_addr);
8207 +                       }
8208 +                       kdba_removedbreg(bp);
8209 +                       bp->bp_hard[cpu]->bph_installed = 0;
8210 +               }
8211 +       } else if (bp->bp_installed) {
8212 +               if (KDB_DEBUG(BP))
8213 +                       kdb_printf("kdb: restoring instruction 0x%x at " kdb_bfd_vma_fmt "\n",
8214 +                                  bp->bp_inst, bp->bp_addr);
8215 +               if (kdb_putword(bp->bp_addr, bp->bp_inst, 1))
8216 +                       return(1);
8217 +               bp->bp_installed = 0;
8218 +       }
8219 +       return(0);
8220 +}
8221 --- /dev/null
8222 +++ b/arch/x86/kdb/kdba_bt.c
8223 @@ -0,0 +1,5597 @@
8224 +/*
8225 + * This file is subject to the terms and conditions of the GNU General Public
8226 + * License.  See the file "COPYING" in the main directory of this archive
8227 + * for more details.
8228 + *
8229 + * Copyright (c) 2006, 2007-2008 Silicon Graphics, Inc.  All Rights Reserved.
8230 + *
8231 + * Common code for doing accurate backtraces on i386 and x86_64, including
8232 + * printing the values of arguments.
8233 + */
8234 +
8235 +#include <linux/init.h>
8236 +#include <linux/kallsyms.h>
8237 +#include <linux/kdb.h>
8238 +#include <linux/kdbprivate.h>
8239 +#include <linux/ctype.h>
8240 +#include <linux/string.h>
8241 +#include <linux/stringify.h>
8242 +#include <linux/kernel.h>
8243 +#include <linux/sched.h>
8244 +#include <linux/nmi.h>
8245 +#include <asm/asm-offsets.h>
8246 +#include <asm/system.h>
8247 +
8248 +#define KDB_DEBUG_BB(fmt, ...)                                                 \
8249 +       {if (KDB_DEBUG(BB)) kdb_printf(fmt, ## __VA_ARGS__);}
8250 +#define KDB_DEBUG_BB_OFFSET_PRINTF(offset, prefix, suffix)                     \
8251 +       kdb_printf(prefix "%c0x%x" suffix,                                      \
8252 +                  offset >= 0 ? '+' : '-',                                     \
8253 +                  offset >= 0 ? offset : -offset)
8254 +#define KDB_DEBUG_BB_OFFSET(offset, prefix, suffix)                            \
8255 +       {if (KDB_DEBUG(BB)) KDB_DEBUG_BB_OFFSET_PRINTF(offset, prefix, suffix);}
8256 +
8257 +#define        BB_CHECK(expr, val, ret)                                                \
8258 +({                                                                             \
8259 +       if (unlikely(expr)) {                                                   \
8260 +               kdb_printf("%s, line %d: BB_CHECK(" #expr ") failed "           \
8261 +                       #val "=%lx\n",                                          \
8262 +                       __FUNCTION__, __LINE__, (long)val);                     \
8263 +               bb_giveup = 1;                                                  \
8264 +               return ret;                                                     \
8265 +       }                                                                       \
8266 +})
8267 +
8268 +static int bb_giveup;
8269 +
8270 +/* Use BBRG_Rxx for both i386 and x86_64.  RAX through R15 must be at the end,
8271 + * starting with RAX.  Some of these codes do not reflect actual registers,
8272 + * such codes are special cases when parsing the record of register changes.
8273 + * When updating BBRG_ entries, update bbrg_name as well.
8274 + */
8275 +
8276 +enum bb_reg_code
8277 +{
8278 +       BBRG_UNDEFINED = 0,     /* Register contents are undefined */
8279 +       BBRG_OSP,               /* original stack pointer on entry to function */
8280 +       BBRG_RAX,
8281 +       BBRG_RBX,
8282 +       BBRG_RCX,
8283 +       BBRG_RDX,
8284 +       BBRG_RDI,
8285 +       BBRG_RSI,
8286 +       BBRG_RBP,
8287 +       BBRG_RSP,
8288 +       BBRG_R8,
8289 +       BBRG_R9,
8290 +       BBRG_R10,
8291 +       BBRG_R11,
8292 +       BBRG_R12,
8293 +       BBRG_R13,
8294 +       BBRG_R14,
8295 +       BBRG_R15,
8296 +};
8297 +
8298 +const static char *bbrg_name[] = {
8299 +       [BBRG_UNDEFINED]   = "undefined",
8300 +       [BBRG_OSP]         = "osp",
8301 +       [BBRG_RAX]         = "rax",
8302 +       [BBRG_RBX]         = "rbx",
8303 +       [BBRG_RCX]         = "rcx",
8304 +       [BBRG_RDX]         = "rdx",
8305 +       [BBRG_RDI]         = "rdi",
8306 +       [BBRG_RSI]         = "rsi",
8307 +       [BBRG_RBP]         = "rbp",
8308 +       [BBRG_RSP]         = "rsp",
8309 +       [BBRG_R8]          = "r8",
8310 +       [BBRG_R9]          = "r9",
8311 +       [BBRG_R10]         = "r10",
8312 +       [BBRG_R11]         = "r11",
8313 +       [BBRG_R12]         = "r12",
8314 +       [BBRG_R13]         = "r13",
8315 +       [BBRG_R14]         = "r14",
8316 +       [BBRG_R15]         = "r15",
8317 +};
8318 +
8319 +/* Map a register name to its register code.  This includes the sub-register
8320 + * addressable fields, e.g. parts of rax can be addressed as ax, al, ah, eax.
8321 + * The list is sorted so it can be binary chopped, sort command is:
8322 + *   LANG=C sort -t '"' -k2
8323 + */
8324 +
8325 +struct bb_reg_code_map {
8326 +       enum bb_reg_code reg;
8327 +       const char *name;
8328 +};
8329 +
8330 +const static struct bb_reg_code_map
8331 +bb_reg_code_map[] = {
8332 +       { BBRG_RAX, "ah" },
8333 +       { BBRG_RAX, "al" },
8334 +       { BBRG_RAX, "ax" },
8335 +       { BBRG_RBX, "bh" },
8336 +       { BBRG_RBX, "bl" },
8337 +       { BBRG_RBP, "bp" },
8338 +       { BBRG_RBP, "bpl" },
8339 +       { BBRG_RBX, "bx" },
8340 +       { BBRG_RCX, "ch" },
8341 +       { BBRG_RCX, "cl" },
8342 +       { BBRG_RCX, "cx" },
8343 +       { BBRG_RDX, "dh" },
8344 +       { BBRG_RDI, "di" },
8345 +       { BBRG_RDI, "dil" },
8346 +       { BBRG_RDX, "dl" },
8347 +       { BBRG_RDX, "dx" },
8348 +       { BBRG_RAX, "eax" },
8349 +       { BBRG_RBP, "ebp" },
8350 +       { BBRG_RBX, "ebx" },
8351 +       { BBRG_RCX, "ecx" },
8352 +       { BBRG_RDI, "edi" },
8353 +       { BBRG_RDX, "edx" },
8354 +       { BBRG_RSI, "esi" },
8355 +       { BBRG_RSP, "esp" },
8356 +       { BBRG_R10, "r10" },
8357 +       { BBRG_R10, "r10d" },
8358 +       { BBRG_R10, "r10l" },
8359 +       { BBRG_R10, "r10w" },
8360 +       { BBRG_R11, "r11" },
8361 +       { BBRG_R11, "r11d" },
8362 +       { BBRG_R11, "r11l" },
8363 +       { BBRG_R11, "r11w" },
8364 +       { BBRG_R12, "r12" },
8365 +       { BBRG_R12, "r12d" },
8366 +       { BBRG_R12, "r12l" },
8367 +       { BBRG_R12, "r12w" },
8368 +       { BBRG_R13, "r13" },
8369 +       { BBRG_R13, "r13d" },
8370 +       { BBRG_R13, "r13l" },
8371 +       { BBRG_R13, "r13w" },
8372 +       { BBRG_R14, "r14" },
8373 +       { BBRG_R14, "r14d" },
8374 +       { BBRG_R14, "r14l" },
8375 +       { BBRG_R14, "r14w" },
8376 +       { BBRG_R15, "r15" },
8377 +       { BBRG_R15, "r15d" },
8378 +       { BBRG_R15, "r15l" },
8379 +       { BBRG_R15, "r15w" },
8380 +       { BBRG_R8,  "r8" },
8381 +       { BBRG_R8,  "r8d" },
8382 +       { BBRG_R8,  "r8l" },
8383 +       { BBRG_R8,  "r8w" },
8384 +       { BBRG_R9,  "r9" },
8385 +       { BBRG_R9,  "r9d" },
8386 +       { BBRG_R9,  "r9l" },
8387 +       { BBRG_R9,  "r9w" },
8388 +       { BBRG_RAX, "rax" },
8389 +       { BBRG_RBP, "rbp" },
8390 +       { BBRG_RBX, "rbx" },
8391 +       { BBRG_RCX, "rcx" },
8392 +       { BBRG_RDI, "rdi" },
8393 +       { BBRG_RDX, "rdx" },
8394 +       { BBRG_RSI, "rsi" },
8395 +       { BBRG_RSP, "rsp" },
8396 +       { BBRG_RSI, "si" },
8397 +       { BBRG_RSI, "sil" },
8398 +       { BBRG_RSP, "sp" },
8399 +       { BBRG_RSP, "spl" },
8400 +};
8401 +
8402 +/* Record register contents in terms of the values that were passed to this
8403 + * function, IOW track which registers contain an input value.  A register's
8404 + * contents can be undefined, it can contain an input register value or it can
8405 + * contain an offset from the original stack pointer.
8406 + *
8407 + * This structure is used to represent the current contents of the integer
8408 + * registers, it is held in an array that is indexed by BBRG_xxx.  The element
8409 + * for BBRG_xxx indicates what input value is currently in BBRG_xxx.  When
8410 + * 'value' is BBRG_OSP then register BBRG_xxx contains a stack pointer,
8411 + * pointing at 'offset' from the original stack pointer on entry to the
8412 + * function.  When 'value' is not BBRG_OSP then element BBRG_xxx contains the
8413 + * original contents of an input register and offset is ignored.
8414 + *
8415 + * An input register 'value' can be stored in more than one register and/or in
8416 + * more than one memory location.
8417 + */
8418 +
8419 +struct bb_reg_contains
8420 +{
8421 +       enum bb_reg_code value: 8;
8422 +       short offset;
8423 +};
8424 +
8425 +/* Note: the offsets in struct bb_mem_contains in this code are _NOT_ offsets
8426 + * from OSP, they are offsets from current RSP.  It fits better with the way
8427 + * that struct pt_regs is built, some code pushes extra data before pt_regs so
8428 + * working with OSP relative offsets gets messy.  struct bb_mem_contains
8429 + * entries must be in descending order of RSP offset.
8430 + */
8431 +
8432 +typedef struct { DECLARE_BITMAP(bits, BBRG_R15+1); } bbrgmask_t;
8433 +#define BB_SKIP(reg) (1 << (BBRG_ ## reg))
8434 +struct bb_mem_contains {
8435 +       short offset_address;
8436 +       enum bb_reg_code value: 8;
8437 +};
8438 +
8439 +/* Transfer of control to a label outside the current function.  If the
8440 + * transfer is to a known common restore path that expects known registers
8441 + * and/or a known memory state (e.g. struct pt_regs) then do a sanity check on
8442 + * the state at this point.
8443 + */
8444 +
8445 +struct bb_name_state {
8446 +       const char *name;                       /* target function */
8447 +       bfd_vma address;                        /* Address of target function */
8448 +       const char *fname;                      /* optional from function name */
8449 +       const struct bb_mem_contains *mem;      /* expected memory state */
8450 +       const struct bb_reg_contains *regs;     /* expected register state */
8451 +       const unsigned short mem_size;          /* ARRAY_SIZE(mem) */
8452 +       const unsigned short regs_size;         /* ARRAY_SIZE(regs) */
8453 +       const short osp_offset;                 /* RSP in regs == OSP+osp_offset */
8454 +       const bbrgmask_t skip_mem;              /* Some slots in mem may be undefined */
8455 +       const bbrgmask_t skip_regs;             /* Some slots in regs may be undefined */
8456 +};
8457 +
8458 +/* NS (NAME_STATE) macros define the register and memory state when we transfer
8459 + * control to or start decoding a special case name.  Use NS when the target
8460 + * label always has the same state.  Use NS_FROM and specify the source label
8461 + * if the target state is slightly different depending on where it is branched
8462 + * from.  This gives better state checking, by isolating the special cases.
8463 + *
8464 + * Note: for the same target label, NS_FROM entries must be followed by a
8465 + * single NS entry.
8466 + */
8467 +
8468 +#define        NS_FROM(iname, ifname, imem, iregs, iskip_mem, iskip_regs, iosp_offset) \
8469 +       { \
8470 +               .name = iname, \
8471 +               .fname = ifname, \
8472 +               .mem = imem, \
8473 +               .regs = iregs, \
8474 +               .mem_size = ARRAY_SIZE(imem), \
8475 +               .regs_size = ARRAY_SIZE(iregs), \
8476 +               .skip_mem.bits[0] = iskip_mem, \
8477 +               .skip_regs.bits[0] = iskip_regs, \
8478 +               .osp_offset = iosp_offset, \
8479 +                       .address = 0 \
8480 +       }
8481 +
8482 +/* Shorter forms for the common cases */
8483 +#define        NS(iname, imem, iregs, iskip_mem, iskip_regs, iosp_offset) \
8484 +         NS_FROM(iname, NULL, imem, iregs, iskip_mem, iskip_regs, iosp_offset)
8485 +#define        NS_MEM(iname, imem, iskip_mem) \
8486 +         NS_FROM(iname, NULL, imem, no_regs, iskip_mem, 0, 0)
8487 +#define        NS_MEM_FROM(iname, ifname, imem, iskip_mem) \
8488 +         NS_FROM(iname, ifname, imem, no_regs, iskip_mem, 0, 0)
8489 +#define        NS_REG(iname, iregs, iskip_regs) \
8490 +         NS_FROM(iname, NULL, no_memory, iregs, 0, iskip_regs, 0)
8491 +#define        NS_REG_FROM(iname, ifname, iregs, iskip_regs) \
8492 +         NS_FROM(iname, ifname, no_memory, iregs, 0, iskip_regs, 0)
8493 +
8494 +static void
8495 +bb_reg_code_set_value(enum bb_reg_code dst, enum bb_reg_code src);
8496 +
8497 +static const char *bb_mod_name, *bb_func_name;
8498 +
8499 +static int
8500 +bb_noret(const char *name)
8501 +{
8502 +       if (strcmp(name, "panic") == 0 ||
8503 +           strcmp(name, "do_exit") == 0 ||
8504 +           strcmp(name, "do_group_exit") == 0 ||
8505 +           strcmp(name, "complete_and_exit") == 0)
8506 +               return 1;
8507 +       return 0;
8508 +}
8509 +
8510 +/*============================================================================*/
8511 +/*                                                                            */
8512 +/* Most of the basic block code and data is common to x86_64 and i386.  This  */
8513 +/* large ifdef  contains almost all of the differences between the two        */
8514 +/* architectures.                                                             */
8515 +/*                                                                            */
8516 +/* Make sure you update the correct section of this ifdef.                    */
8517 +/*                                                                            */
8518 +/*============================================================================*/
8519 +
8520 +#ifdef CONFIG_X86_64
8521 +
8522 +/* Registers that can be used to pass parameters, in the order that parameters
8523 + * are passed.
8524 + */
8525 +
8526 +const static enum bb_reg_code
8527 +bb_param_reg[] = {
8528 +       BBRG_RDI,
8529 +       BBRG_RSI,
8530 +       BBRG_RDX,
8531 +       BBRG_RCX,
8532 +       BBRG_R8,
8533 +       BBRG_R9,
8534 +};
8535 +
8536 +const static enum bb_reg_code
8537 +bb_preserved_reg[] = {
8538 +       BBRG_RBX,
8539 +       BBRG_RBP,
8540 +       BBRG_RSP,
8541 +       BBRG_R12,
8542 +       BBRG_R13,
8543 +       BBRG_R14,
8544 +       BBRG_R15,
8545 +};
8546 +
8547 +static const struct bb_mem_contains full_pt_regs[] = {
8548 +       { 0x70, BBRG_RDI },
8549 +       { 0x68, BBRG_RSI },
8550 +       { 0x60, BBRG_RDX },
8551 +       { 0x58, BBRG_RCX },
8552 +       { 0x50, BBRG_RAX },
8553 +       { 0x48, BBRG_R8  },
8554 +       { 0x40, BBRG_R9  },
8555 +       { 0x38, BBRG_R10 },
8556 +       { 0x30, BBRG_R11 },
8557 +       { 0x28, BBRG_RBX },
8558 +       { 0x20, BBRG_RBP },
8559 +       { 0x18, BBRG_R12 },
8560 +       { 0x10, BBRG_R13 },
8561 +       { 0x08, BBRG_R14 },
8562 +       { 0x00, BBRG_R15 },
8563 +};
8564 +static const struct bb_mem_contains partial_pt_regs[] = {
8565 +       { 0x40, BBRG_RDI },
8566 +       { 0x38, BBRG_RSI },
8567 +       { 0x30, BBRG_RDX },
8568 +       { 0x28, BBRG_RCX },
8569 +       { 0x20, BBRG_RAX },
8570 +       { 0x18, BBRG_R8  },
8571 +       { 0x10, BBRG_R9  },
8572 +       { 0x08, BBRG_R10 },
8573 +       { 0x00, BBRG_R11 },
8574 +};
8575 +static const struct bb_mem_contains partial_pt_regs_plus_1[] = {
8576 +       { 0x48, BBRG_RDI },
8577 +       { 0x40, BBRG_RSI },
8578 +       { 0x38, BBRG_RDX },
8579 +       { 0x30, BBRG_RCX },
8580 +       { 0x28, BBRG_RAX },
8581 +       { 0x20, BBRG_R8  },
8582 +       { 0x18, BBRG_R9  },
8583 +       { 0x10, BBRG_R10 },
8584 +       { 0x08, BBRG_R11 },
8585 +};
8586 +static const struct bb_mem_contains partial_pt_regs_plus_2[] = {
8587 +       { 0x50, BBRG_RDI },
8588 +       { 0x48, BBRG_RSI },
8589 +       { 0x40, BBRG_RDX },
8590 +       { 0x38, BBRG_RCX },
8591 +       { 0x30, BBRG_RAX },
8592 +       { 0x28, BBRG_R8  },
8593 +       { 0x20, BBRG_R9  },
8594 +       { 0x18, BBRG_R10 },
8595 +       { 0x10, BBRG_R11 },
8596 +};
8597 +static const struct bb_mem_contains no_memory[] = {
8598 +};
8599 +/* Hardware has already pushed an error_code on the stack.  Use undefined just
8600 + * to set the initial stack offset.
8601 + */
8602 +static const struct bb_mem_contains error_code[] = {
8603 +       { 0x0, BBRG_UNDEFINED },
8604 +};
8605 +/* error_code plus original rax */
8606 +static const struct bb_mem_contains error_code_rax[] = {
8607 +       { 0x8, BBRG_UNDEFINED },
8608 +       { 0x0, BBRG_RAX },
8609 +};
8610 +
8611 +static const struct bb_reg_contains all_regs[] = {
8612 +       [BBRG_RAX] = { BBRG_RAX, 0 },
8613 +       [BBRG_RBX] = { BBRG_RBX, 0 },
8614 +       [BBRG_RCX] = { BBRG_RCX, 0 },
8615 +       [BBRG_RDX] = { BBRG_RDX, 0 },
8616 +       [BBRG_RDI] = { BBRG_RDI, 0 },
8617 +       [BBRG_RSI] = { BBRG_RSI, 0 },
8618 +       [BBRG_RBP] = { BBRG_RBP, 0 },
8619 +       [BBRG_RSP] = { BBRG_OSP, 0 },
8620 +       [BBRG_R8 ] = { BBRG_R8,  0 },
8621 +       [BBRG_R9 ] = { BBRG_R9,  0 },
8622 +       [BBRG_R10] = { BBRG_R10, 0 },
8623 +       [BBRG_R11] = { BBRG_R11, 0 },
8624 +       [BBRG_R12] = { BBRG_R12, 0 },
8625 +       [BBRG_R13] = { BBRG_R13, 0 },
8626 +       [BBRG_R14] = { BBRG_R14, 0 },
8627 +       [BBRG_R15] = { BBRG_R15, 0 },
8628 +};
8629 +static const struct bb_reg_contains no_regs[] = {
8630 +};
8631 +
8632 +static struct bb_name_state bb_special_cases[] = {
8633 +
8634 +       /* First the cases that pass data only in memory.  We do not check any
8635 +        * register state for these cases.
8636 +        */
8637 +
8638 +       /* Simple cases, no exceptions */
8639 +       NS_MEM("ia32_ptregs_common", partial_pt_regs_plus_1, 0),
8640 +       NS_MEM("ia32_sysret", partial_pt_regs, 0),
8641 +       NS_MEM("int_careful", partial_pt_regs, 0),
8642 +       NS_MEM("int_restore_rest", full_pt_regs, 0),
8643 +       NS_MEM("int_signal", full_pt_regs, 0),
8644 +       NS_MEM("int_very_careful", partial_pt_regs, 0),
8645 +       NS_MEM("int_with_check", partial_pt_regs, 0),
8646 +#ifdef CONFIG_TRACE_IRQFLAGS
8647 +       NS_MEM("paranoid_exit0", full_pt_regs, 0),
8648 +#endif /* CONFIG_TRACE_IRQFLAGS */
8649 +       NS_MEM("paranoid_exit1", full_pt_regs, 0),
8650 +       NS_MEM("ptregscall_common", partial_pt_regs_plus_1, 0),
8651 +       NS_MEM("restore_norax", partial_pt_regs, 0),
8652 +       NS_MEM("restore", partial_pt_regs, 0),
8653 +       NS_MEM("ret_from_intr", partial_pt_regs_plus_2, 0),
8654 +       NS_MEM("stub32_clone", partial_pt_regs_plus_1, 0),
8655 +       NS_MEM("stub32_execve", partial_pt_regs_plus_1, 0),
8656 +       NS_MEM("stub32_fork", partial_pt_regs_plus_1, 0),
8657 +       NS_MEM("stub32_iopl", partial_pt_regs_plus_1, 0),
8658 +       NS_MEM("stub32_rt_sigreturn", partial_pt_regs_plus_1, 0),
8659 +       NS_MEM("stub32_rt_sigsuspend", partial_pt_regs_plus_1, 0),
8660 +       NS_MEM("stub32_sigaltstack", partial_pt_regs_plus_1, 0),
8661 +       NS_MEM("stub32_sigreturn", partial_pt_regs_plus_1, 0),
8662 +       NS_MEM("stub32_sigsuspend", partial_pt_regs_plus_1, 0),
8663 +       NS_MEM("stub32_vfork", partial_pt_regs_plus_1, 0),
8664 +       NS_MEM("stub_clone", partial_pt_regs_plus_1, 0),
8665 +       NS_MEM("stub_execve", partial_pt_regs_plus_1, 0),
8666 +       NS_MEM("stub_fork", partial_pt_regs_plus_1, 0),
8667 +       NS_MEM("stub_iopl", partial_pt_regs_plus_1, 0),
8668 +       NS_MEM("stub_rt_sigreturn", partial_pt_regs_plus_1, 0),
8669 +       NS_MEM("stub_rt_sigsuspend", partial_pt_regs_plus_1, 0),
8670 +       NS_MEM("stub_sigaltstack", partial_pt_regs_plus_1, 0),
8671 +       NS_MEM("stub_vfork", partial_pt_regs_plus_1, 0),
8672 +
8673 +       NS_MEM_FROM("ia32_badsys", "ia32_sysenter_target",
8674 +               partial_pt_regs,
8675 +               /* ia32_sysenter_target uses CLEAR_RREGS to clear R8-R11 on
8676 +                * some paths.  It also stomps on RAX.
8677 +                */
8678 +               BB_SKIP(R8) | BB_SKIP(R9) | BB_SKIP(R10) | BB_SKIP(R11) |
8679 +               BB_SKIP(RAX)),
8680 +       NS_MEM_FROM("ia32_badsys", "ia32_cstar_target",
8681 +               partial_pt_regs,
8682 +               /* ia32_cstar_target uses CLEAR_RREGS to clear R8-R11 on some
8683 +                * paths.  It also stomps on RAX.  Even more confusing, instead
8684 +                * of storing RCX it stores RBP.  WTF?
8685 +                */
8686 +               BB_SKIP(R8) | BB_SKIP(R9) | BB_SKIP(R10) | BB_SKIP(R11) |
8687 +               BB_SKIP(RAX) | BB_SKIP(RCX)),
8688 +       NS_MEM("ia32_badsys", partial_pt_regs, 0),
8689 +
8690 +       /* Various bits of code branch to int_ret_from_sys_call, with slightly
8691 +        * different missing values in pt_regs.
8692 +        */
8693 +       NS_MEM_FROM("int_ret_from_sys_call", "ret_from_fork",
8694 +               partial_pt_regs,
8695 +               BB_SKIP(R11)),
8696 +       NS_MEM_FROM("int_ret_from_sys_call", "stub_execve",
8697 +               partial_pt_regs,
8698 +               BB_SKIP(RAX) | BB_SKIP(RCX)),
8699 +       NS_MEM_FROM("int_ret_from_sys_call", "stub_rt_sigreturn",
8700 +               partial_pt_regs,
8701 +               BB_SKIP(RAX) | BB_SKIP(RCX)),
8702 +       NS_MEM_FROM("int_ret_from_sys_call", "kernel_execve",
8703 +               partial_pt_regs,
8704 +               BB_SKIP(RAX)),
8705 +       NS_MEM_FROM("int_ret_from_sys_call", "ia32_syscall",
8706 +               partial_pt_regs,
8707 +               /* ia32_syscall only saves RDI through RCX. */
8708 +               BB_SKIP(R8) | BB_SKIP(R9) | BB_SKIP(R10) | BB_SKIP(R11) |
8709 +               BB_SKIP(RAX)),
8710 +       NS_MEM_FROM("int_ret_from_sys_call", "ia32_sysenter_target",
8711 +               partial_pt_regs,
8712 +               /* ia32_sysenter_target uses CLEAR_RREGS to clear R8-R11 on
8713 +               * some paths.  It also stomps on RAX.
8714 +               */
8715 +               BB_SKIP(R8) | BB_SKIP(R9) | BB_SKIP(R10) | BB_SKIP(R11) |
8716 +               BB_SKIP(RAX)),
8717 +       NS_MEM_FROM("int_ret_from_sys_call", "ia32_cstar_target",
8718 +               partial_pt_regs,
8719 +               /* ia32_cstar_target uses CLEAR_RREGS to clear R8-R11 on some
8720 +                * paths.  It also stomps on RAX.  Even more confusing, instead
8721 +                * of storing RCX it stores RBP.  WTF?
8722 +                */
8723 +               BB_SKIP(R8) | BB_SKIP(R9) | BB_SKIP(R10) | BB_SKIP(R11) |
8724 +               BB_SKIP(RAX) | BB_SKIP(RCX)),
8725 +       NS_MEM("int_ret_from_sys_call", partial_pt_regs, 0),
8726 +
8727 +#ifdef CONFIG_PREEMPT
8728 +       NS_MEM("retint_kernel", partial_pt_regs, BB_SKIP(RAX)),
8729 +#endif /* CONFIG_PREEMPT */
8730 +
8731 +       NS_MEM("retint_careful", partial_pt_regs, BB_SKIP(RAX)),
8732 +
8733 +       /* Horrible hack: For a brand new x86_64 task, switch_to() branches to
8734 +        * ret_from_fork with a totally different stack state from all the
8735 +        * other tasks that come out of switch_to().  This non-standard state
8736 +        * cannot be represented so just ignore the branch from switch_to() to
8737 +        * ret_from_fork.  Due to inlining and linker labels, switch_to() can
8738 +        * appear as several different function labels, including schedule,
8739 +        * context_switch and __sched_text_start.
8740 +        */
8741 +       NS_MEM_FROM("ret_from_fork", "schedule", no_memory, 0),
8742 +       NS_MEM_FROM("ret_from_fork", "__sched_text_start", no_memory, 0),
8743 +       NS_MEM_FROM("ret_from_fork", "context_switch", no_memory, 0),
8744 +       NS_MEM("ret_from_fork", full_pt_regs, 0),
8745 +
8746 +
8747 +       NS_MEM_FROM("ret_from_sys_call", "ret_from_fork",
8748 +               partial_pt_regs,
8749 +               BB_SKIP(R11)),
8750 +       NS_MEM("ret_from_sys_call", partial_pt_regs, 0),
8751 +
8752 +       NS_MEM("retint_restore_args",
8753 +               partial_pt_regs,
8754 +               BB_SKIP(RAX) | BB_SKIP(RCX)),
8755 +
8756 +       NS_MEM("retint_swapgs",
8757 +               partial_pt_regs,
8758 +               BB_SKIP(RAX) | BB_SKIP(RCX)),
8759 +
8760 +       /* Now the cases that pass data in registers.  We do not check any
8761 +        * memory state for these cases.
8762 +        */
8763 +
8764 +       NS_REG("bad_put_user",
8765 +               all_regs,
8766 +               BB_SKIP(RAX) | BB_SKIP(RCX) | BB_SKIP(R8)),
8767 +
8768 +       NS_REG("bad_get_user",
8769 +               all_regs,
8770 +               BB_SKIP(RAX) | BB_SKIP(RCX) | BB_SKIP(R8)),
8771 +
8772 +       NS_REG("bad_to_user",
8773 +               all_regs,
8774 +               BB_SKIP(RAX) | BB_SKIP(RCX)),
8775 +
8776 +       NS_REG("ia32_ptregs_common",
8777 +               all_regs,
8778 +               0),
8779 +
8780 +       NS_REG("copy_user_generic_unrolled",
8781 +               all_regs,
8782 +               BB_SKIP(RAX) | BB_SKIP(RCX)),
8783 +
8784 +       NS_REG("copy_user_generic_string",
8785 +               all_regs,
8786 +               BB_SKIP(RAX) | BB_SKIP(RCX)),
8787 +
8788 +       NS_REG("irq_return",
8789 +               all_regs,
8790 +               0),
8791 +
8792 +       /* Finally the cases that pass data in both registers and memory.
8793 +        */
8794 +
8795 +       NS("invalid_TSS", error_code, all_regs, 0, 0, 0),
8796 +       NS("segment_not_present", error_code, all_regs, 0, 0, 0),
8797 +       NS("alignment_check", error_code, all_regs, 0, 0, 0),
8798 +       NS("page_fault", error_code, all_regs, 0, 0, 0),
8799 +       NS("general_protection", error_code, all_regs, 0, 0, 0),
8800 +       NS("error_entry", error_code_rax, all_regs, 0, BB_SKIP(RAX), -0x10),
8801 +       NS("common_interrupt", error_code, all_regs, 0, 0, -0x8),
8802 +};
8803 +
8804 +static const char *bb_spurious[] = {
8805 +                               /* schedule */
8806 +       "thread_return",
8807 +                               /* ret_from_fork */
8808 +       "rff_action",
8809 +       "rff_trace",
8810 +                               /* system_call */
8811 +       "ret_from_sys_call",
8812 +       "sysret_check",
8813 +       "sysret_careful",
8814 +       "sysret_signal",
8815 +       "badsys",
8816 +       "tracesys",
8817 +       "int_ret_from_sys_call",
8818 +       "int_with_check",
8819 +       "int_careful",
8820 +       "int_very_careful",
8821 +       "int_signal",
8822 +       "int_restore_rest",
8823 +                               /* common_interrupt */
8824 +       "ret_from_intr",
8825 +       "exit_intr",
8826 +       "retint_with_reschedule",
8827 +       "retint_check",
8828 +       "retint_swapgs",
8829 +       "retint_restore_args",
8830 +       "restore_args",
8831 +       "irq_return",
8832 +       "bad_iret",
8833 +       "retint_careful",
8834 +       "retint_signal",
8835 +#ifdef CONFIG_PREEMPT
8836 +       "retint_kernel",
8837 +#endif /* CONFIG_PREEMPT */
8838 +                               /* .macro paranoidexit */
8839 +#ifdef CONFIG_TRACE_IRQFLAGS
8840 +       "paranoid_exit0",
8841 +       "paranoid_userspace0",
8842 +       "paranoid_restore0",
8843 +       "paranoid_swapgs0",
8844 +       "paranoid_schedule0",
8845 +#endif /* CONFIG_TRACE_IRQFLAGS */
8846 +       "paranoid_exit1",
8847 +       "paranoid_swapgs1",
8848 +       "paranoid_restore1",
8849 +       "paranoid_userspace1",
8850 +       "paranoid_schedule1",
8851 +                               /* error_entry */
8852 +       "error_swapgs",
8853 +       "error_sti",
8854 +       "error_exit",
8855 +       "error_kernelspace",
8856 +                               /* load_gs_index */
8857 +       "gs_change",
8858 +       "bad_gs",
8859 +                               /* ia32_sysenter_target */
8860 +       "sysenter_do_call",
8861 +       "sysenter_tracesys",
8862 +                               /* ia32_cstar_target */
8863 +       "cstar_do_call",
8864 +       "cstar_tracesys",
8865 +       "ia32_badarg",
8866 +                               /* ia32_syscall */
8867 +       "ia32_do_syscall",
8868 +       "ia32_sysret",
8869 +       "ia32_tracesys",
8870 +       "ia32_badsys",
8871 +#ifdef CONFIG_HIBERNATION
8872 +                               /* restore_image */
8873 +       "loop",
8874 +       "done",
8875 +#endif /* CONFIG_HIBERNATION */
8876 +#ifdef CONFIG_KPROBES
8877 +                               /* jprobe_return */
8878 +       "jprobe_return_end",
8879 +                               /* kretprobe_trampoline_holder */
8880 +       "kretprobe_trampoline",
8881 +#endif /* CONFIG_KPROBES */
8882 +#ifdef CONFIG_KEXEC
8883 +                               /* relocate_kernel */
8884 +       "relocate_new_kernel",
8885 +#endif /* CONFIG_KEXEC */
8886 +#ifdef CONFIG_XEN
8887 +                               /* arch/i386/xen/xen-asm.S */
8888 +       "xen_irq_enable_direct_end",
8889 +       "xen_irq_disable_direct_end",
8890 +       "xen_save_fl_direct_end",
8891 +       "xen_restore_fl_direct_end",
8892 +       "xen_iret_start_crit",
8893 +       "iret_restore_end",
8894 +       "xen_iret_end_crit",
8895 +       "hyper_iret",
8896 +#endif /* CONFIG_XEN */
8897 +};
8898 +
8899 +static const char *bb_hardware_handlers[] = {
8900 +       "system_call",
8901 +       "common_interrupt",
8902 +       "error_entry",
8903 +       "debug",
8904 +       "nmi",
8905 +       "int3",
8906 +       "double_fault",
8907 +       "stack_segment",
8908 +       "machine_check",
8909 +       "kdb_call",
8910 +};
8911 +
8912 +static int
8913 +bb_hardware_pushed_arch(kdb_machreg_t rsp,
8914 +                       const struct kdb_activation_record *ar)
8915 +{
8916 +       /* x86_64 interrupt stacks are 16 byte aligned and you must get the
8917 +        * next rsp from stack, it cannot be statically calculated.  Do not
8918 +        * include the word at rsp, it is pushed by hardware but is treated as
8919 +        * a normal software return value.
8920 +        *
8921 +        * When an IST switch occurs (e.g. NMI) then the saved rsp points to
8922 +        * another stack entirely.  Assume that the IST stack is 16 byte
8923 +        * aligned and just return the size of the hardware data on this stack.
8924 +        * The stack unwind code will take care of the stack switch.
8925 +        */
8926 +       kdb_machreg_t saved_rsp = *((kdb_machreg_t *)rsp + 3);
8927 +       int hardware_pushed = saved_rsp - rsp - KDB_WORD_SIZE;
8928 +       if (hardware_pushed < 4 * KDB_WORD_SIZE ||
8929 +           saved_rsp < ar->stack.logical_start ||
8930 +           saved_rsp >= ar->stack.logical_end)
8931 +               return 4 * KDB_WORD_SIZE;
8932 +       else
8933 +               return hardware_pushed;
8934 +}
8935 +
8936 +static void
8937 +bb_start_block0(void)
8938 +{
8939 +       bb_reg_code_set_value(BBRG_RAX, BBRG_RAX);
8940 +       bb_reg_code_set_value(BBRG_RBX, BBRG_RBX);
8941 +       bb_reg_code_set_value(BBRG_RCX, BBRG_RCX);
8942 +       bb_reg_code_set_value(BBRG_RDX, BBRG_RDX);
8943 +       bb_reg_code_set_value(BBRG_RDI, BBRG_RDI);
8944 +       bb_reg_code_set_value(BBRG_RSI, BBRG_RSI);
8945 +       bb_reg_code_set_value(BBRG_RBP, BBRG_RBP);
8946 +       bb_reg_code_set_value(BBRG_RSP, BBRG_OSP);
8947 +       bb_reg_code_set_value(BBRG_R8, BBRG_R8);
8948 +       bb_reg_code_set_value(BBRG_R9, BBRG_R9);
8949 +       bb_reg_code_set_value(BBRG_R10, BBRG_R10);
8950 +       bb_reg_code_set_value(BBRG_R11, BBRG_R11);
8951 +       bb_reg_code_set_value(BBRG_R12, BBRG_R12);
8952 +       bb_reg_code_set_value(BBRG_R13, BBRG_R13);
8953 +       bb_reg_code_set_value(BBRG_R14, BBRG_R14);
8954 +       bb_reg_code_set_value(BBRG_R15, BBRG_R15);
8955 +}
8956 +
8957 +/* x86_64 does not have a special case for __switch_to */
8958 +
8959 +static void
8960 +bb_fixup_switch_to(char *p)
8961 +{
8962 +}
8963 +
8964 +static int
8965 +bb_asmlinkage_arch(void)
8966 +{
8967 +       return strncmp(bb_func_name, "__down", 6) == 0 ||
8968 +              strncmp(bb_func_name, "__up", 4) == 0 ||
8969 +              strncmp(bb_func_name, "stub_", 5) == 0 ||
8970 +              strcmp(bb_func_name, "ret_from_fork") == 0 ||
8971 +              strcmp(bb_func_name, "ptregscall_common") == 0;
8972 +}
8973 +
8974 +#else  /* !CONFIG_X86_64 */
8975 +
8976 +/* Registers that can be used to pass parameters, in the order that parameters
8977 + * are passed.
8978 + */
8979 +
8980 +const static enum bb_reg_code
8981 +bb_param_reg[] = {
8982 +       BBRG_RAX,
8983 +       BBRG_RDX,
8984 +       BBRG_RCX,
8985 +};
8986 +
8987 +const static enum bb_reg_code
8988 +bb_preserved_reg[] = {
8989 +       BBRG_RBX,
8990 +       BBRG_RBP,
8991 +       BBRG_RSP,
8992 +       BBRG_RSI,
8993 +       BBRG_RDI,
8994 +};
8995 +
8996 +static const struct bb_mem_contains full_pt_regs[] = {
8997 +       { 0x18, BBRG_RAX },
8998 +       { 0x14, BBRG_RBP },
8999 +       { 0x10, BBRG_RDI },
9000 +       { 0x0c, BBRG_RSI },
9001 +       { 0x08, BBRG_RDX },
9002 +       { 0x04, BBRG_RCX },
9003 +       { 0x00, BBRG_RBX },
9004 +};
9005 +static const struct bb_mem_contains no_memory[] = {
9006 +};
9007 +/* Hardware has already pushed an error_code on the stack.  Use undefined just
9008 + * to set the initial stack offset.
9009 + */
9010 +static const struct bb_mem_contains error_code[] = {
9011 +       { 0x0, BBRG_UNDEFINED },
9012 +};
9013 +/* rbx already pushed */
9014 +static const struct bb_mem_contains rbx_pushed[] = {
9015 +       { 0x0, BBRG_RBX },
9016 +};
9017 +#ifdef CONFIG_MATH_EMULATION
9018 +static const struct bb_mem_contains mem_fpu_reg_round[] = {
9019 +       { 0xc, BBRG_RBP },
9020 +       { 0x8, BBRG_RSI },
9021 +       { 0x4, BBRG_RDI },
9022 +       { 0x0, BBRG_RBX },
9023 +};
9024 +#endif /* CONFIG_MATH_EMULATION */
9025 +
9026 +static const struct bb_reg_contains all_regs[] = {
9027 +       [BBRG_RAX] = { BBRG_RAX, 0 },
9028 +       [BBRG_RBX] = { BBRG_RBX, 0 },
9029 +       [BBRG_RCX] = { BBRG_RCX, 0 },
9030 +       [BBRG_RDX] = { BBRG_RDX, 0 },
9031 +       [BBRG_RDI] = { BBRG_RDI, 0 },
9032 +       [BBRG_RSI] = { BBRG_RSI, 0 },
9033 +       [BBRG_RBP] = { BBRG_RBP, 0 },
9034 +       [BBRG_RSP] = { BBRG_OSP, 0 },
9035 +};
9036 +static const struct bb_reg_contains no_regs[] = {
9037 +};
9038 +#ifdef CONFIG_MATH_EMULATION
9039 +static const struct bb_reg_contains reg_fpu_reg_round[] = {
9040 +       [BBRG_RBP] = { BBRG_OSP, -0x4 },
9041 +       [BBRG_RSP] = { BBRG_OSP, -0x10 },
9042 +};
9043 +#endif /* CONFIG_MATH_EMULATION */
9044 +
9045 +static struct bb_name_state bb_special_cases[] = {
9046 +
9047 +       /* First the cases that pass data only in memory.  We do not check any
9048 +        * register state for these cases.
9049 +        */
9050 +
9051 +       /* Simple cases, no exceptions */
9052 +       NS_MEM("check_userspace", full_pt_regs, 0),
9053 +       NS_MEM("device_not_available_emulate", full_pt_regs, 0),
9054 +       NS_MEM("ldt_ss", full_pt_regs, 0),
9055 +       NS_MEM("no_singlestep", full_pt_regs, 0),
9056 +       NS_MEM("restore_all", full_pt_regs, 0),
9057 +       NS_MEM("restore_nocheck", full_pt_regs, 0),
9058 +       NS_MEM("restore_nocheck_notrace", full_pt_regs, 0),
9059 +       NS_MEM("ret_from_exception", full_pt_regs, 0),
9060 +       NS_MEM("ret_from_fork", full_pt_regs, 0),
9061 +       NS_MEM("ret_from_intr", full_pt_regs, 0),
9062 +       NS_MEM("work_notifysig", full_pt_regs, 0),
9063 +       NS_MEM("work_pending", full_pt_regs, 0),
9064 +
9065 +#ifdef CONFIG_PREEMPT
9066 +       NS_MEM("resume_kernel", full_pt_regs, 0),
9067 +#endif /* CONFIG_PREEMPT */
9068 +
9069 +       NS_MEM("common_interrupt", error_code, 0),
9070 +       NS_MEM("error_code", error_code, 0),
9071 +
9072 +       NS_MEM("bad_put_user", rbx_pushed, 0),
9073 +
9074 +       NS_MEM_FROM("resume_userspace", "syscall_badsys",
9075 +               full_pt_regs, BB_SKIP(RAX)),
9076 +       NS_MEM_FROM("resume_userspace", "syscall_fault",
9077 +               full_pt_regs, BB_SKIP(RAX)),
9078 +       NS_MEM_FROM("resume_userspace", "syscall_trace_entry",
9079 +               full_pt_regs, BB_SKIP(RAX)),
9080 +       /* Too difficult to trace through the various vm86 functions for now.
9081 +        * They are C functions that start off with some memory state, fiddle
9082 +        * the registers then jmp directly to resume_userspace.  For the
9083 +        * moment, just assume that they are valid and do no checks.
9084 +        */
9085 +       NS_FROM("resume_userspace", "do_int",
9086 +               no_memory, no_regs, 0, 0, 0),
9087 +       NS_FROM("resume_userspace", "do_sys_vm86",
9088 +               no_memory, no_regs, 0, 0, 0),
9089 +       NS_FROM("resume_userspace", "handle_vm86_fault",
9090 +               no_memory, no_regs, 0, 0, 0),
9091 +       NS_FROM("resume_userspace", "handle_vm86_trap",
9092 +               no_memory, no_regs, 0, 0, 0),
9093 +       NS_MEM("resume_userspace", full_pt_regs, 0),
9094 +
9095 +       NS_MEM_FROM("syscall_badsys", "ia32_sysenter_target",
9096 +               full_pt_regs, BB_SKIP(RBP)),
9097 +       NS_MEM("syscall_badsys", full_pt_regs, 0),
9098 +
9099 +       NS_MEM_FROM("syscall_call", "syscall_trace_entry",
9100 +               full_pt_regs, BB_SKIP(RAX)),
9101 +       NS_MEM("syscall_call", full_pt_regs, 0),
9102 +
9103 +       NS_MEM_FROM("syscall_exit", "syscall_trace_entry",
9104 +               full_pt_regs, BB_SKIP(RAX)),
9105 +       NS_MEM("syscall_exit", full_pt_regs, 0),
9106 +
9107 +       NS_MEM_FROM("syscall_exit_work", "ia32_sysenter_target",
9108 +               full_pt_regs, BB_SKIP(RAX) | BB_SKIP(RBP)),
9109 +       NS_MEM_FROM("syscall_exit_work", "system_call",
9110 +               full_pt_regs, BB_SKIP(RAX)),
9111 +       NS_MEM("syscall_exit_work", full_pt_regs, 0),
9112 +
9113 +       NS_MEM_FROM("syscall_trace_entry", "ia32_sysenter_target",
9114 +               full_pt_regs, BB_SKIP(RBP)),
9115 +       NS_MEM_FROM("syscall_trace_entry", "system_call",
9116 +               full_pt_regs, BB_SKIP(RAX)),
9117 +       NS_MEM("syscall_trace_entry", full_pt_regs, 0),
9118 +
9119 +       /* Now the cases that pass data in registers.  We do not check any
9120 +        * memory state for these cases.
9121 +        */
9122 +
9123 +       NS_REG("syscall_fault", all_regs, 0),
9124 +
9125 +       NS_REG("bad_get_user", all_regs,
9126 +               BB_SKIP(RAX) | BB_SKIP(RDX)),
9127 +
9128 +       /* Finally the cases that pass data in both registers and memory.
9129 +       */
9130 +
9131 +       /* This entry is redundant now because bb_fixup_switch_to() hides the
9132 +        * jmp __switch_to case, however the entry is left here as
9133 +        * documentation.
9134 +        *
9135 +        * NS("__switch_to", no_memory, no_regs, 0, 0, 0),
9136 +        */
9137 +
9138 +       NS("iret_exc", no_memory, all_regs, 0, 0, 0x20),
9139 +
9140 +#ifdef CONFIG_MATH_EMULATION
9141 +       NS("fpu_reg_round", mem_fpu_reg_round, reg_fpu_reg_round, 0, 0, 0),
9142 +#endif /* CONFIG_MATH_EMULATION */
9143 +};
9144 +
9145 +static const char *bb_spurious[] = {
9146 +                               /* ret_from_exception */
9147 +       "ret_from_intr",
9148 +       "check_userspace",
9149 +       "resume_userspace",
9150 +                               /* resume_kernel */
9151 +#ifdef CONFIG_PREEMPT
9152 +       "need_resched",
9153 +#endif /* CONFIG_PREEMPT */
9154 +                               /* ia32_sysenter_target */
9155 +       "sysenter_past_esp",
9156 +                               /* system_call */
9157 +       "no_singlestep",
9158 +       "syscall_call",
9159 +       "syscall_exit",
9160 +       "restore_all",
9161 +       "restore_nocheck",
9162 +       "restore_nocheck_notrace",
9163 +       "ldt_ss",
9164 +       /* do not include iret_exc, it is in a .fixup section */
9165 +                               /* work_pending */
9166 +       "work_resched",
9167 +       "work_notifysig",
9168 +#ifdef CONFIG_VM86
9169 +       "work_notifysig_v86",
9170 +#endif /* CONFIG_VM86 */
9171 +                               /* page_fault */
9172 +       "error_code",
9173 +                               /* device_not_available */
9174 +       "device_not_available_emulate",
9175 +                               /* debug */
9176 +       "debug_esp_fix_insn",
9177 +       "debug_stack_correct",
9178 +                               /* nmi */
9179 +       "nmi_stack_correct",
9180 +       "nmi_stack_fixup",
9181 +       "nmi_debug_stack_check",
9182 +       "nmi_espfix_stack",
9183 +#ifdef CONFIG_HIBERNATION
9184 +                               /* restore_image */
9185 +       "copy_loop",
9186 +       "done",
9187 +#endif /* CONFIG_HIBERNATION */
9188 +#ifdef CONFIG_KPROBES
9189 +                               /* jprobe_return */
9190 +       "jprobe_return_end",
9191 +#endif /* CONFIG_KPROBES */
9192 +#ifdef CONFIG_KEXEC
9193 +                               /* relocate_kernel */
9194 +       "relocate_new_kernel",
9195 +#endif /* CONFIG_KEXEC */
9196 +#ifdef CONFIG_MATH_EMULATION
9197 +                               /* assorted *.S files in arch/i386/math_emu */
9198 +       "Denorm_done",
9199 +       "Denorm_shift_more_than_32",
9200 +       "Denorm_shift_more_than_63",
9201 +       "Denorm_shift_more_than_64",
9202 +       "Do_unmasked_underflow",
9203 +       "Exp_not_underflow",
9204 +       "fpu_Arith_exit",
9205 +       "fpu_reg_round",
9206 +       "fpu_reg_round_signed_special_exit",
9207 +       "fpu_reg_round_special_exit",
9208 +       "L_accum_done",
9209 +       "L_accum_loaded",
9210 +       "L_accum_loop",
9211 +       "L_arg1_larger",
9212 +       "L_bugged",
9213 +       "L_bugged_1",
9214 +       "L_bugged_2",
9215 +       "L_bugged_3",
9216 +       "L_bugged_4",
9217 +       "L_bugged_denorm_486",
9218 +       "L_bugged_round24",
9219 +       "L_bugged_round53",
9220 +       "L_bugged_round64",
9221 +       "LCheck_24_round_up",
9222 +       "LCheck_53_round_up",
9223 +       "LCheck_Round_Overflow",
9224 +       "LCheck_truncate_24",
9225 +       "LCheck_truncate_53",
9226 +       "LCheck_truncate_64",
9227 +       "LDenormal_adj_exponent",
9228 +       "L_deNormalised",
9229 +       "LDo_24_round_up",
9230 +       "LDo_2nd_32_bits",
9231 +       "LDo_2nd_div",
9232 +       "LDo_3rd_32_bits",
9233 +       "LDo_3rd_div",
9234 +       "LDo_53_round_up",
9235 +       "LDo_64_round_up",
9236 +       "L_done",
9237 +       "LDo_truncate_24",
9238 +       "LDown_24",
9239 +       "LDown_53",
9240 +       "LDown_64",
9241 +       "L_entry_bugged",
9242 +       "L_error_exit",
9243 +       "L_exactly_32",
9244 +       "L_exception_exit",
9245 +       "L_exit",
9246 +       "L_exit_nuo_valid",
9247 +       "L_exit_nuo_zero",
9248 +       "L_exit_valid",
9249 +       "L_extent_zero",
9250 +       "LFirst_div_done",
9251 +       "LFirst_div_not_1",
9252 +       "L_Full_Division",
9253 +       "LGreater_Half_24",
9254 +       "LGreater_Half_53",
9255 +       "LGreater_than_1",
9256 +       "LLess_than_1",
9257 +       "L_Make_denorm",
9258 +       "L_more_31_no_low",
9259 +       "L_more_63_no_low",
9260 +       "L_more_than_31",
9261 +       "L_more_than_63",
9262 +       "L_more_than_64",
9263 +       "L_more_than_65",
9264 +       "L_more_than_95",
9265 +       "L_must_be_zero",
9266 +       "L_n_exit",
9267 +       "L_no_adjust",
9268 +       "L_no_bit_lost",
9269 +       "L_no_overflow",
9270 +       "L_no_precision_loss",
9271 +       "L_Normalised",
9272 +       "L_norm_bugged",
9273 +       "L_n_shift_1",
9274 +       "L_nuo_shift_1",
9275 +       "L_overflow",
9276 +       "L_precision_lost_down",
9277 +       "L_precision_lost_up",
9278 +       "LPrevent_2nd_overflow",
9279 +       "LPrevent_3rd_overflow",
9280 +       "LPseudoDenormal",
9281 +       "L_Re_normalise",
9282 +       "LResult_Normalised",
9283 +       "L_round",
9284 +       "LRound_large",
9285 +       "LRound_nearest_24",
9286 +       "LRound_nearest_53",
9287 +       "LRound_nearest_64",
9288 +       "LRound_not_small",
9289 +       "LRound_ovfl",
9290 +       "LRound_precision",
9291 +       "LRound_prep",
9292 +       "L_round_the_result",
9293 +       "LRound_To_24",
9294 +       "LRound_To_53",
9295 +       "LRound_To_64",
9296 +       "LSecond_div_done",
9297 +       "LSecond_div_not_1",
9298 +       "L_shift_1",
9299 +       "L_shift_32",
9300 +       "L_shift_65_nc",
9301 +       "L_shift_done",
9302 +       "Ls_less_than_32",
9303 +       "Ls_more_than_63",
9304 +       "Ls_more_than_95",
9305 +       "L_Store_significand",
9306 +       "L_subtr",
9307 +       "LTest_over",
9308 +       "LTruncate_53",
9309 +       "LTruncate_64",
9310 +       "L_underflow",
9311 +       "L_underflow_to_zero",
9312 +       "LUp_24",
9313 +       "LUp_53",
9314 +       "LUp_64",
9315 +       "L_zero",
9316 +       "Normalise_result",
9317 +       "Signal_underflow",
9318 +       "sqrt_arg_ge_2",
9319 +       "sqrt_get_more_precision",
9320 +       "sqrt_more_prec_large",
9321 +       "sqrt_more_prec_ok",
9322 +       "sqrt_more_prec_small",
9323 +       "sqrt_near_exact",
9324 +       "sqrt_near_exact_large",
9325 +       "sqrt_near_exact_ok",
9326 +       "sqrt_near_exact_small",
9327 +       "sqrt_near_exact_x",
9328 +       "sqrt_prelim_no_adjust",
9329 +       "sqrt_round_result",
9330 +       "sqrt_stage_2_done",
9331 +       "sqrt_stage_2_error",
9332 +       "sqrt_stage_2_finish",
9333 +       "sqrt_stage_2_positive",
9334 +       "sqrt_stage_3_error",
9335 +       "sqrt_stage_3_finished",
9336 +       "sqrt_stage_3_no_error",
9337 +       "sqrt_stage_3_positive",
9338 +       "Unmasked_underflow",
9339 +       "xExp_not_underflow",
9340 +#endif /* CONFIG_MATH_EMULATION */
9341 +};
9342 +
9343 +static const char *bb_hardware_handlers[] = {
9344 +       "ret_from_exception",
9345 +       "system_call",
9346 +       "work_pending",
9347 +       "syscall_fault",
9348 +       "page_fault",
9349 +       "coprocessor_error",
9350 +       "simd_coprocessor_error",
9351 +       "device_not_available",
9352 +       "debug",
9353 +       "nmi",
9354 +       "int3",
9355 +       "overflow",
9356 +       "bounds",
9357 +       "invalid_op",
9358 +       "coprocessor_segment_overrun",
9359 +       "invalid_TSS",
9360 +       "segment_not_present",
9361 +       "stack_segment",
9362 +       "general_protection",
9363 +       "alignment_check",
9364 +       "kdb_call",
9365 +       "divide_error",
9366 +       "machine_check",
9367 +       "spurious_interrupt_bug",
9368 +};
9369 +
9370 +static int
9371 +bb_hardware_pushed_arch(kdb_machreg_t rsp,
9372 +                       const struct kdb_activation_record *ar)
9373 +{
9374 +       return (2 * KDB_WORD_SIZE);
9375 +}
9376 +
9377 +static void
9378 +bb_start_block0(void)
9379 +{
9380 +       bb_reg_code_set_value(BBRG_RAX, BBRG_RAX);
9381 +       bb_reg_code_set_value(BBRG_RBX, BBRG_RBX);
9382 +       bb_reg_code_set_value(BBRG_RCX, BBRG_RCX);
9383 +       bb_reg_code_set_value(BBRG_RDX, BBRG_RDX);
9384 +       bb_reg_code_set_value(BBRG_RDI, BBRG_RDI);
9385 +       bb_reg_code_set_value(BBRG_RSI, BBRG_RSI);
9386 +       bb_reg_code_set_value(BBRG_RBP, BBRG_RBP);
9387 +       bb_reg_code_set_value(BBRG_RSP, BBRG_OSP);
9388 +}
9389 +
9390 +/* The i386 code that switches stack in a context switch is an extremely
9391 + * special case.  It saves the rip pointing to a label that is not otherwise
9392 + * referenced, saves the current rsp then pushes a word.  The magic code that
9393 + * resumes the new task picks up the saved rip and rsp, effectively referencing
9394 + * a label that otherwise is not used and ignoring the pushed word.
9395 + *
9396 + * The simplest way to handle this very strange case is to recognise jmp
9397 + * address <__switch_to> and treat it as a popfl instruction.  This avoids
9398 + * terminating the block on this jmp and removes one word from the stack state,
9399 + * which is the end effect of all the magic code.
9400 + *
9401 + * Called with the instruction line, starting after the first ':'.
9402 + */
9403 +
9404 +static void
9405 +bb_fixup_switch_to(char *p)
9406 +{
9407 +       char *p1 = p;
9408 +       p += strspn(p, " \t");          /* start of instruction */
9409 +       if (strncmp(p, "jmp", 3))
9410 +               return;
9411 +       p += strcspn(p, " \t");         /* end of instruction */
9412 +       p += strspn(p, " \t");          /* start of address */
9413 +       p += strcspn(p, " \t");         /* end of address */
9414 +       p += strspn(p, " \t");          /* start of comment */
9415 +       if (strcmp(p, "<__switch_to>") == 0)
9416 +               strcpy(p1, "popfl");
9417 +}
9418 +
9419 +static int
9420 +bb_asmlinkage_arch(void)
9421 +{
9422 +       return strcmp(bb_func_name, "ret_from_exception") == 0 ||
9423 +              strcmp(bb_func_name, "syscall_trace_entry") == 0;
9424 +}
9425 +
9426 +#endif /* CONFIG_X86_64 */
9427 +
9428 +
9429 +/*============================================================================*/
9430 +/*                                                                            */
9431 +/* Common code and data.                                                      */
9432 +/*                                                                            */
9433 +/*============================================================================*/
9434 +
9435 +
9436 +/* Tracking registers by decoding the instructions is quite a bit harder than
9437 + * doing the same tracking using compiler generated information.  Register
9438 + * contents can remain in the same register, they can be copied to other
9439 + * registers, they can be stored on stack or they can be modified/overwritten.
9440 + * At any one time, there are 0 or more copies of the original value that was
9441 + * supplied in each register on input to the current function.  If a register
9442 + * exists in multiple places, one copy of that register is the master version,
9443 + * the others are temporary copies which may or may not be destroyed before the
9444 + * end of the function.
9445 + *
9446 + * The compiler knows which copy of a register is the master and which are
9447 + * temporary copies, which makes it relatively easy to track register contents
9448 + * as they are saved and restored.  Without that compiler based knowledge, this
9449 + * code has to track _every_ possible copy of each register, simply because we
9450 + * do not know which is the master copy and which are temporary copies which
9451 + * may be destroyed later.
9452 + *
9453 + * It gets worse: registers that contain parameters can be copied to other
9454 + * registers which are then saved on stack in a lower level function.  Also the
9455 + * stack pointer may be held in multiple registers (typically RSP and RBP)
9456 + * which contain different offsets from the base of the stack on entry to this
9457 + * function.  All of which means that we have to track _all_ register
9458 + * movements, or at least as much as possible.
9459 + *
9460 + * Start with the basic block that contains the start of the function, by
9461 + * definition all registers contain their initial value.  Track each
9462 + * instruction's effect on register contents, this includes reading from a
9463 + * parameter register before any write to that register, IOW the register
9464 + * really does contain a parameter.  The register state is represented by a
9465 + * dynamically sized array with each entry containing :-
9466 + *
9467 + *   Register name
9468 + *   Location it is copied to (another register or stack + offset)
9469 + *
9470 + * Besides the register tracking array, we track which parameter registers are
9471 + * read before being written, to determine how many parameters are passed in
9472 + * registers.  We also track which registers contain stack pointers, including
9473 + * their offset from the original stack pointer on entry to the function.
9474 + *
9475 + * At each exit from the current basic block (via JMP instruction or drop
9476 + * through), the register state is cloned to form the state on input to the
9477 + * target basic block and the target is marked for processing using this state.
9478 + * When there are multiple ways to enter a basic block (e.g. several JMP
9479 + * instructions referencing the same target) then there will be multiple sets
9480 + * of register state to form the "input" for that basic block, there is no
9481 + * guarantee that all paths to that block will have the same register state.
9482 + *
9483 + * As each target block is processed, all the known sets of register state are
9484 + * merged to form a suitable subset of the state which agrees with all the
9485 + * inputs.  The most common case is where one path to this block copies a
9486 + * register to another register but another path does not, therefore the copy
9487 + * is only a temporary and should not be propogated into this block.
9488 + *
9489 + * If the target block already has an input state from the current transfer
9490 + * point and the new input state is identical to the previous input state then
9491 + * we have reached a steady state for the arc from the current location to the
9492 + * target block.  Therefore there is no need to process the target block again.
9493 + *
9494 + * The steps of "process a block, create state for target block(s), pick a new
9495 + * target block, merge state for target block, process target block" will
9496 + * continue until all the state changes have propogated all the way down the
9497 + * basic block tree, including round any cycles in the tree.  The merge step
9498 + * only deletes tracking entries from the input state(s), it never adds a
9499 + * tracking entry.  Therefore the overall algorithm is guaranteed to converge
9500 + * to a steady state, the worst possible case is that every tracking entry into
9501 + * a block is deleted, which will result in an empty output state.
9502 + *
9503 + * As each instruction is decoded, it is checked to see if this is the point at
9504 + * which execution left this function.  This can be a call to another function
9505 + * (actually the return address to this function) or is the instruction which
9506 + * was about to be executed when an interrupt occurred (including an oops).
9507 + * Save the register state at this point.
9508 + *
9509 + * We always know what the registers contain when execution left this function.
9510 + * For an interrupt, the registers are in struct pt_regs.  For a call to
9511 + * another function, we have already deduced the register state on entry to the
9512 + * other function by unwinding to the start of that function.  Given the
9513 + * register state on exit from this function plus the known register contents
9514 + * on entry to the next function, we can determine the stack pointer value on
9515 + * input to this function.  That in turn lets us calculate the address of input
9516 + * registers that have been stored on stack, giving us the input parameters.
9517 + * Finally the stack pointer gives us the return address which is the exit
9518 + * point from the calling function, repeat the unwind process on that function.
9519 + *
9520 + * The data that tracks which registers contain input parameters is function
9521 + * global, not local to any basic block.  To determine which input registers
9522 + * contain parameters, we have to decode the entire function.  Otherwise an
9523 + * exit early in the function might not have read any parameters yet.
9524 + */
9525 +
9526 +/* Record memory contents in terms of the values that were passed to this
9527 + * function, IOW track which memory locations contain an input value.  A memory
9528 + * location's contents can be undefined, it can contain an input register value
9529 + * or it can contain an offset from the original stack pointer.
9530 + *
9531 + * This structure is used to record register contents that have been stored in
9532 + * memory.  Location (BBRG_OSP + 'offset_address') contains the input value
9533 + * from register 'value'.  When 'value' is BBRG_OSP then offset_value contains
9534 + * the offset from the original stack pointer that was stored in this memory
9535 + * location.  When 'value' is not BBRG_OSP then the memory location contains
9536 + * the original contents of an input register and offset_value is ignored.
9537 + *
9538 + * An input register 'value' can be stored in more than one register and/or in
9539 + * more than one memory location.
9540 + */
9541 +
9542 +struct bb_memory_contains
9543 +{
9544 +       short offset_address;
9545 +       enum bb_reg_code value: 8;
9546 +       short offset_value;
9547 +};
9548 +
9549 +/* Track the register state in each basic block. */
9550 +
9551 +struct bb_reg_state
9552 +{
9553 +       /* Indexed by register value 'reg - BBRG_RAX' */
9554 +       struct bb_reg_contains contains[KDB_INT_REGISTERS];
9555 +       int ref_count;
9556 +       int mem_count;
9557 +       /* dynamic size for memory locations, see mem_count */
9558 +       struct bb_memory_contains memory[0];
9559 +};
9560 +
9561 +static struct bb_reg_state *bb_reg_state, *bb_exit_state;
9562 +static int bb_reg_state_max, bb_reg_params, bb_memory_params;
9563 +
9564 +struct bb_actual
9565 +{
9566 +       bfd_vma value;
9567 +       int valid;
9568 +};
9569 +
9570 +/* Contains the actual hex value of a register, plus a valid bit.  Indexed by
9571 + * register value 'reg - BBRG_RAX'
9572 + */
9573 +static struct bb_actual bb_actual[KDB_INT_REGISTERS];
9574 +
9575 +static bfd_vma bb_func_start, bb_func_end;
9576 +static bfd_vma bb_common_interrupt, bb_error_entry, bb_ret_from_intr,
9577 +              bb_thread_return, bb_sync_regs, bb_save_v86_state,
9578 +              bb__sched_text_start, bb__sched_text_end;
9579 +
9580 +/* Record jmp instructions, both conditional and unconditional.  These form the
9581 + * arcs between the basic blocks.  This is also used to record the state when
9582 + * one block drops through into the next.
9583 + *
9584 + * A bb can have multiple associated bb_jmp entries, one for each jcc
9585 + * instruction plus at most one bb_jmp for the drop through case.  If a bb
9586 + * drops through to the next bb then the drop through bb_jmp entry will be the
9587 + * last entry in the set of bb_jmp's that are associated with the bb.  This is
9588 + * enforced by the fact that jcc entries are added during the disassembly phase
9589 + * of pass 1, the drop through entries are added near the end of pass 1.
9590 + *
9591 + * At address 'from' in this block, we have a jump to address 'to'.  The
9592 + * register state at 'from' is copied to the target block.
9593 + */
9594 +
9595 +struct bb_jmp
9596 +{
9597 +       bfd_vma from;
9598 +       bfd_vma to;
9599 +       struct bb_reg_state *state;
9600 +       unsigned int drop_through: 1;
9601 +};
9602 +
9603 +struct bb
9604 +{
9605 +       bfd_vma start;
9606 +       /* The end address of a basic block is sloppy.  It can be the first
9607 +        * byte of the last instruction in the block or it can be the last byte
9608 +        * of the block.
9609 +        */
9610 +       bfd_vma end;
9611 +       unsigned int changed: 1;
9612 +       unsigned int drop_through: 1;
9613 +};
9614 +
9615 +static struct bb **bb_list, *bb_curr;
9616 +static int bb_max, bb_count;
9617 +
9618 +static struct bb_jmp *bb_jmp_list;
9619 +static int bb_jmp_max, bb_jmp_count;
9620 +
9621 +/* Add a new bb entry to the list.  This does an insert sort. */
9622 +
9623 +static struct bb *
9624 +bb_new(bfd_vma order)
9625 +{
9626 +       int i, j;
9627 +       struct bb *bb, *p;
9628 +       if (bb_giveup)
9629 +               return NULL;
9630 +       if (bb_count == bb_max) {
9631 +               struct bb **bb_list_new;
9632 +               bb_max += 10;
9633 +               bb_list_new = debug_kmalloc(bb_max*sizeof(*bb_list_new),
9634 +                                           GFP_ATOMIC);
9635 +               if (!bb_list_new) {
9636 +                       kdb_printf("\n\n%s: out of debug_kmalloc\n", __FUNCTION__);
9637 +                       bb_giveup = 1;
9638 +                       return NULL;
9639 +               }
9640 +               memcpy(bb_list_new, bb_list, bb_count*sizeof(*bb_list));
9641 +               debug_kfree(bb_list);
9642 +               bb_list = bb_list_new;
9643 +       }
9644 +       bb = debug_kmalloc(sizeof(*bb), GFP_ATOMIC);
9645 +       if (!bb) {
9646 +               kdb_printf("\n\n%s: out of debug_kmalloc\n", __FUNCTION__);
9647 +               bb_giveup = 1;
9648 +               return NULL;
9649 +       }
9650 +       memset(bb, 0, sizeof(*bb));
9651 +       for (i = 0; i < bb_count; ++i) {
9652 +               p = bb_list[i];
9653 +               if ((p->start && p->start > order) ||
9654 +                   (p->end && p->end > order))
9655 +                       break;
9656 +       }
9657 +       for (j = bb_count-1; j >= i; --j)
9658 +               bb_list[j+1] = bb_list[j];
9659 +       bb_list[i] = bb;
9660 +       ++bb_count;
9661 +       return bb;
9662 +}
9663 +
9664 +/* Add a new bb_jmp entry to the list.  This list is not sorted. */
9665 +
9666 +static struct bb_jmp *
9667 +bb_jmp_new(bfd_vma from, bfd_vma to, unsigned int drop_through)
9668 +{
9669 +       struct bb_jmp *bb_jmp;
9670 +       if (bb_giveup)
9671 +               return NULL;
9672 +       if (bb_jmp_count == bb_jmp_max) {
9673 +               struct bb_jmp *bb_jmp_list_new;
9674 +               bb_jmp_max += 10;
9675 +               bb_jmp_list_new =
9676 +                       debug_kmalloc(bb_jmp_max*sizeof(*bb_jmp_list_new),
9677 +                                     GFP_ATOMIC);
9678 +               if (!bb_jmp_list_new) {
9679 +                       kdb_printf("\n\n%s: out of debug_kmalloc\n",
9680 +                                  __FUNCTION__);
9681 +                       bb_giveup = 1;
9682 +                       return NULL;
9683 +               }
9684 +               memcpy(bb_jmp_list_new, bb_jmp_list,
9685 +                      bb_jmp_count*sizeof(*bb_jmp_list));
9686 +               debug_kfree(bb_jmp_list);
9687 +               bb_jmp_list = bb_jmp_list_new;
9688 +       }
9689 +       bb_jmp = bb_jmp_list + bb_jmp_count++;
9690 +       bb_jmp->from = from;
9691 +       bb_jmp->to = to;
9692 +       bb_jmp->drop_through = drop_through;
9693 +       bb_jmp->state = NULL;
9694 +       return bb_jmp;
9695 +}
9696 +
9697 +static void
9698 +bb_delete(int i)
9699 +{
9700 +       struct bb *bb = bb_list[i];
9701 +       memcpy(bb_list+i, bb_list+i+1, (bb_count-i-1)*sizeof(*bb_list));
9702 +       bb_list[--bb_count] = NULL;
9703 +       debug_kfree(bb);
9704 +}
9705 +
9706 +static struct bb *
9707 +bb_add(bfd_vma start, bfd_vma end)
9708 +{
9709 +       int i;
9710 +       struct bb *bb;
9711 +       /* Ignore basic blocks whose start address is outside the current
9712 +        * function.  These occur for call instructions and for tail recursion.
9713 +        */
9714 +       if (start &&
9715 +           (start < bb_func_start || start >= bb_func_end))
9716 +                      return NULL;
9717 +       for (i = 0; i < bb_count; ++i) {
9718 +               bb = bb_list[i];
9719 +               if ((start && bb->start == start) ||
9720 +                   (end && bb->end == end))
9721 +                       return bb;
9722 +       }
9723 +       bb = bb_new(start ? start : end);
9724 +       if (bb) {
9725 +               bb->start = start;
9726 +               bb->end = end;
9727 +       }
9728 +       return bb;
9729 +}
9730 +
9731 +static struct bb_jmp *
9732 +bb_jmp_add(bfd_vma from, bfd_vma to, unsigned int drop_through)
9733 +{
9734 +       int i;
9735 +       struct bb_jmp *bb_jmp;
9736 +       for (i = 0, bb_jmp = bb_jmp_list; i < bb_jmp_count; ++i, ++bb_jmp) {
9737 +               if (bb_jmp->from == from &&
9738 +                   bb_jmp->to == to &&
9739 +                   bb_jmp->drop_through == drop_through)
9740 +                       return bb_jmp;
9741 +       }
9742 +       bb_jmp = bb_jmp_new(from, to, drop_through);
9743 +       return bb_jmp;
9744 +}
9745 +
9746 +static unsigned long bb_curr_addr, bb_exit_addr;
9747 +static char bb_buffer[256];    /* A bit too big to go on stack */
9748 +
9749 +/* Computed jmp uses 'jmp *addr(,%reg,[48])' where 'addr' is the start of a
9750 + * table of addresses that point into the current function.  Run the table and
9751 + * generate bb starts for each target address plus a bb_jmp from this address
9752 + * to the target address.
9753 + *
9754 + * Only called for 'jmp' instructions, with the pointer starting at 'jmp'.
9755 + */
9756 +
9757 +static void
9758 +bb_pass1_computed_jmp(char *p)
9759 +{
9760 +       unsigned long table, scale;
9761 +       kdb_machreg_t addr;
9762 +       struct bb* bb;
9763 +       p += strcspn(p, " \t");         /* end of instruction */
9764 +       p += strspn(p, " \t");          /* start of address */
9765 +       if (*p++ != '*')
9766 +               return;
9767 +       table = simple_strtoul(p, &p, 0);
9768 +       if (strncmp(p, "(,%", 3) != 0)
9769 +               return;
9770 +       p += 3;
9771 +       p += strcspn(p, ",");           /* end of reg */
9772 +       if (*p++ != ',')
9773 +               return;
9774 +       scale = simple_strtoul(p, &p, 0);
9775 +       if (scale != KDB_WORD_SIZE || strcmp(p, ")"))
9776 +               return;
9777 +       while (!bb_giveup) {
9778 +               if (kdb_getword(&addr, table, sizeof(addr)))
9779 +                       return;
9780 +               if (addr < bb_func_start || addr >= bb_func_end)
9781 +                       return;
9782 +               bb = bb_add(addr, 0);
9783 +               if (bb)
9784 +                       bb_jmp_add(bb_curr_addr, addr, 0);
9785 +               table += KDB_WORD_SIZE;
9786 +       }
9787 +}
9788 +
9789 +/* Pass 1, identify the start and end of each basic block */
9790 +
9791 +static int
9792 +bb_dis_pass1(PTR file, const char *fmt, ...)
9793 +{
9794 +       int l = strlen(bb_buffer);
9795 +       char *p;
9796 +       va_list ap;
9797 +       va_start(ap, fmt);
9798 +       vsnprintf(bb_buffer + l, sizeof(bb_buffer) - l, fmt, ap);
9799 +       va_end(ap);
9800 +       if ((p = strchr(bb_buffer, '\n'))) {
9801 +               *p = '\0';
9802 +               /* ret[q], iret[q], sysexit, sysret, ud2a or jmp[q] end a
9803 +                * block.  As does a call to a function marked noret.
9804 +                */
9805 +               p = bb_buffer;
9806 +               p += strcspn(p, ":");
9807 +               if (*p++ == ':') {
9808 +                       bb_fixup_switch_to(p);
9809 +                       p += strspn(p, " \t");  /* start of instruction */
9810 +                       if (strncmp(p, "ret", 3) == 0 ||
9811 +                           strncmp(p, "iret", 4) == 0 ||
9812 +                           strncmp(p, "sysexit", 7) == 0 ||
9813 +                           strncmp(p, "sysret", 6) == 0 ||
9814 +                           strncmp(p, "ud2a", 4) == 0 ||
9815 +                           strncmp(p, "jmp", 3) == 0) {
9816 +                               if (strncmp(p, "jmp", 3) == 0)
9817 +                                       bb_pass1_computed_jmp(p);
9818 +                               bb_add(0, bb_curr_addr);
9819 +                       };
9820 +                       if (strncmp(p, "call", 4) == 0) {
9821 +                               strsep(&p, " \t");      /* end of opcode */
9822 +                               if (p)
9823 +                                       p += strspn(p, " \t");  /* operand(s) */
9824 +                               if (p && strchr(p, '<')) {
9825 +                                       p = strchr(p, '<') + 1;
9826 +                                       *strchr(p, '>') = '\0';
9827 +                                       if (bb_noret(p))
9828 +                                               bb_add(0, bb_curr_addr);
9829 +                               }
9830 +                       };
9831 +               }
9832 +               bb_buffer[0] = '\0';
9833 +       }
9834 +       return 0;
9835 +}
9836 +
9837 +static void
9838 +bb_printaddr_pass1(bfd_vma addr, disassemble_info *dip)
9839 +{
9840 +       kdb_symtab_t symtab;
9841 +       unsigned int offset;
9842 +       struct bb* bb;
9843 +       /* disasm only calls the printaddr routine for the target of jmp, loop
9844 +        * or call instructions, i.e. the start of a basic block.  call is
9845 +        * ignored by bb_add because the target address is outside the current
9846 +        * function.
9847 +        */
9848 +       dip->fprintf_func(dip->stream, "0x%lx", addr);
9849 +       kdbnearsym(addr, &symtab);
9850 +       if (symtab.sym_name) {
9851 +               dip->fprintf_func(dip->stream, " <%s", symtab.sym_name);
9852 +               if ((offset = addr - symtab.sym_start))
9853 +                       dip->fprintf_func(dip->stream, "+0x%x", offset);
9854 +               dip->fprintf_func(dip->stream, ">");
9855 +       }
9856 +       bb = bb_add(addr, 0);
9857 +       if (bb)
9858 +               bb_jmp_add(bb_curr_addr, addr, 0);
9859 +}
9860 +
9861 +static void
9862 +bb_pass1(void)
9863 +{
9864 +       int i;
9865 +       unsigned long addr;
9866 +       struct bb *bb;
9867 +       struct bb_jmp *bb_jmp;
9868 +
9869 +       if (KDB_DEBUG(BB) | KDB_DEBUG(BB_SUMM))
9870 +               kdb_printf("%s: func_name %s func_start " kdb_bfd_vma_fmt0
9871 +                          " func_end " kdb_bfd_vma_fmt0 "\n",
9872 +                          __FUNCTION__,
9873 +                          bb_func_name,
9874 +                          bb_func_start,
9875 +                          bb_func_end);
9876 +       kdb_di.fprintf_func = bb_dis_pass1;
9877 +       kdb_di.print_address_func = bb_printaddr_pass1;
9878 +
9879 +       bb_add(bb_func_start, 0);
9880 +       for (bb_curr_addr = bb_func_start;
9881 +            bb_curr_addr < bb_func_end;
9882 +            ++bb_curr_addr) {
9883 +               unsigned char c;
9884 +               if (kdb_getarea(c, bb_curr_addr)) {
9885 +                       kdb_printf("%s: unreadable function code at ",
9886 +                                  __FUNCTION__);
9887 +                       kdb_symbol_print(bb_curr_addr, NULL, KDB_SP_DEFAULT);
9888 +                       kdb_printf(", giving up\n");
9889 +                       bb_giveup = 1;
9890 +                       return;
9891 +               }
9892 +       }
9893 +       for (addr = bb_func_start; addr < bb_func_end; ) {
9894 +               bb_curr_addr = addr;
9895 +               addr += kdba_id_printinsn(addr, &kdb_di);
9896 +               kdb_di.fprintf_func(NULL, "\n");
9897 +       }
9898 +       if (bb_giveup)
9899 +               goto out;
9900 +
9901 +       /* Special case: a block consisting of a single instruction which is
9902 +        * both the target of a jmp and is also an ending instruction, so we
9903 +        * add two blocks using the same address, one as a start and one as an
9904 +        * end, in no guaranteed order.  The end must be ordered after the
9905 +        * start.
9906 +        */
9907 +       for (i = 0; i < bb_count-1; ++i) {
9908 +               struct bb *bb1 = bb_list[i], *bb2 = bb_list[i+1];
9909 +               if (bb1->end && bb1->end == bb2->start) {
9910 +                       bb = bb_list[i+1];
9911 +                       bb_list[i+1] = bb_list[i];
9912 +                       bb_list[i] = bb;
9913 +               }
9914 +       }
9915 +
9916 +       /* Some bb have a start address, some have an end address.  Collapse
9917 +        * them into entries that have both start and end addresses.  The first
9918 +        * entry is guaranteed to have a start address.
9919 +        */
9920 +       for (i = 0; i < bb_count-1; ++i) {
9921 +               struct bb *bb1 = bb_list[i], *bb2 = bb_list[i+1];
9922 +               if (bb1->end)
9923 +                       continue;
9924 +               if (bb2->start) {
9925 +                       bb1->end = bb2->start - 1;
9926 +                       bb1->drop_through = 1;
9927 +                       bb_jmp_add(bb1->end, bb2->start, 1);
9928 +               } else {
9929 +                       bb1->end = bb2->end;
9930 +                       bb_delete(i+1);
9931 +               }
9932 +       }
9933 +       bb = bb_list[bb_count-1];
9934 +       if (!bb->end)
9935 +               bb->end = bb_func_end - 1;
9936 +
9937 +       /* It would be nice to check that all bb have a valid start and end
9938 +        * address but there is just too much garbage code in the kernel to do
9939 +        * that check.  Aligned functions in assembler code mean that there is
9940 +        * space between the end of one function and the start of the next and
9941 +        * that space contains previous code from the assembler's buffers.  It
9942 +        * looks like dead code with nothing that branches to it, so no start
9943 +        * address.  do_sys_vm86() ends with 'jmp resume_userspace' which the C
9944 +        * compiler does not know about so gcc appends the normal exit code,
9945 +        * again nothing branches to this dangling code.
9946 +        *
9947 +        * The best we can do is delete bb entries with no start address.
9948 +        */
9949 +       for (i = 0; i < bb_count; ++i) {
9950 +               struct bb *bb = bb_list[i];
9951 +               if (!bb->start)
9952 +                       bb_delete(i--);
9953 +       }
9954 +       for (i = 0; i < bb_count; ++i) {
9955 +               struct bb *bb = bb_list[i];
9956 +               if (!bb->end) {
9957 +                       kdb_printf("%s: incomplete bb state\n", __FUNCTION__);
9958 +                       bb_giveup = 1;
9959 +                       goto debug;
9960 +               }
9961 +       }
9962 +
9963 +out:
9964 +       if (!KDB_DEBUG(BB))
9965 +               return;
9966 +debug:
9967 +       kdb_printf("%s: end\n", __FUNCTION__);
9968 +       for (i = 0; i < bb_count; ++i) {
9969 +               bb = bb_list[i];
9970 +               kdb_printf("  bb[%d] start "
9971 +                          kdb_bfd_vma_fmt0
9972 +                          " end " kdb_bfd_vma_fmt0
9973 +                          " drop_through %d",
9974 +                          i, bb->start, bb->end, bb->drop_through);
9975 +               kdb_printf("\n");
9976 +       }
9977 +       for (i = 0; i < bb_jmp_count; ++i) {
9978 +               bb_jmp = bb_jmp_list + i;
9979 +               kdb_printf("  bb_jmp[%d] from "
9980 +                          kdb_bfd_vma_fmt0
9981 +                          " to " kdb_bfd_vma_fmt0
9982 +                          " drop_through %d\n",
9983 +                          i, bb_jmp->from, bb_jmp->to, bb_jmp->drop_through);
9984 +       }
9985 +}
9986 +
9987 +/* Pass 2, record register changes in each basic block */
9988 +
9989 +/* For each opcode that we care about, indicate how it uses its operands.  Most
9990 + * opcodes can be handled generically because they completely specify their
9991 + * operands in the instruction, however many opcodes have side effects such as
9992 + * reading or writing rax or updating rsp.  Instructions that change registers
9993 + * that are not listed in the operands must be handled as special cases.  In
9994 + * addition, instructions that copy registers while preserving their contents
9995 + * (push, pop, mov) or change the contents in a well defined way (add with an
9996 + * immediate, lea) must be handled as special cases in order to track the
9997 + * register contents.
9998 + *
9999 + * The tables below only list opcodes that are actually used in the Linux
10000 + * kernel, so they omit most of the floating point and all of the SSE type
10001 + * instructions.  The operand usage entries only cater for accesses to memory
10002 + * and to the integer registers, accesses to floating point registers and flags
10003 + * are not relevant for kernel backtraces.
10004 + */
10005 +
10006 +enum bb_operand_usage {
10007 +       BBOU_UNKNOWN = 0,
10008 +               /* generic entries.  because xchg can do any combinations of
10009 +                * read src, write src, read dst and  write dst we need to
10010 +                * define all 16 possibilities.  These are ordered by rs = 1,
10011 +                * rd = 2, ws = 4, wd = 8, bb_usage_x*() functions rely on this
10012 +                * order.
10013 +                */
10014 +       BBOU_RS = 1,    /* read src */          /*  1 */
10015 +       BBOU_RD,        /* read dst */          /*  2 */
10016 +       BBOU_RSRD,                              /*  3 */
10017 +       BBOU_WS,        /* write src */         /*  4 */
10018 +       BBOU_RSWS,                              /*  5 */
10019 +       BBOU_RDWS,                              /*  6 */
10020 +       BBOU_RSRDWS,                            /*  7 */
10021 +       BBOU_WD,        /* write dst */         /*  8 */
10022 +       BBOU_RSWD,                              /*  9 */
10023 +       BBOU_RDWD,                              /* 10 */
10024 +       BBOU_RSRDWD,                            /* 11 */
10025 +       BBOU_WSWD,                              /* 12 */
10026 +       BBOU_RSWSWD,                            /* 13 */
10027 +       BBOU_RDWSWD,                            /* 14 */
10028 +       BBOU_RSRDWSWD,                          /* 15 */
10029 +               /* opcode specific entries */
10030 +       BBOU_ADD,
10031 +       BBOU_CALL,
10032 +       BBOU_CBW,
10033 +       BBOU_CMOV,
10034 +       BBOU_CMPXCHG,
10035 +       BBOU_CMPXCHGD,
10036 +       BBOU_CPUID,
10037 +       BBOU_CWD,
10038 +       BBOU_DIV,
10039 +       BBOU_IDIV,
10040 +       BBOU_IMUL,
10041 +       BBOU_IRET,
10042 +       BBOU_JMP,
10043 +       BBOU_LAHF,
10044 +       BBOU_LEA,
10045 +       BBOU_LEAVE,
10046 +       BBOU_LODS,
10047 +       BBOU_LOOP,
10048 +       BBOU_LSS,
10049 +       BBOU_MONITOR,
10050 +       BBOU_MOV,
10051 +       BBOU_MOVS,
10052 +       BBOU_MUL,
10053 +       BBOU_MWAIT,
10054 +       BBOU_NOP,
10055 +       BBOU_OUTS,
10056 +       BBOU_POP,
10057 +       BBOU_POPF,
10058 +       BBOU_PUSH,
10059 +       BBOU_PUSHF,
10060 +       BBOU_RDMSR,
10061 +       BBOU_RDTSC,
10062 +       BBOU_RET,
10063 +       BBOU_SAHF,
10064 +       BBOU_SCAS,
10065 +       BBOU_SUB,
10066 +       BBOU_SYSEXIT,
10067 +       BBOU_SYSRET,
10068 +       BBOU_WRMSR,
10069 +       BBOU_XADD,
10070 +       BBOU_XCHG,
10071 +       BBOU_XOR,
10072 +};
10073 +
10074 +struct bb_opcode_usage {
10075 +       int length;
10076 +       enum bb_operand_usage usage;
10077 +       const char *opcode;
10078 +};
10079 +
10080 +/* This table is sorted in alphabetical order of opcode, except that the
10081 + * trailing '"' is treated as a high value.  For example, 'in' sorts after
10082 + * 'inc', 'bt' after 'btc'.  This modified sort order ensures that shorter
10083 + * opcodes come after long ones.  A normal sort would put 'in' first, so 'in'
10084 + * would match both 'inc' and 'in'.  When adding any new entries to this table,
10085 + * be careful to put shorter entries last in their group.
10086 + *
10087 + * To automatically sort the table (in vi)
10088 + *   Mark the first and last opcode line with 'a and 'b
10089 + *   'a
10090 + *   !'bsed -e 's/"}/}}/' | LANG=C sort -t '"' -k2 | sed -e 's/}}/"}/'
10091 + *
10092 + * If a new instruction has to be added, first consider if it affects registers
10093 + * other than those listed in the operands.  Also consider if you want to track
10094 + * the results of issuing the instruction, IOW can you extract useful
10095 + * information by looking in detail at the modified registers or memory.  If
10096 + * either test is true then you need a special case to handle the instruction.
10097 + *
10098 + * The generic entries at the start of enum bb_operand_usage all have one thing
10099 + * in common, if a register or memory location is updated then that location
10100 + * becomes undefined, i.e. we lose track of anything that was previously saved
10101 + * in that location.  So only use a generic BBOU_* value when the result of the
10102 + * instruction cannot be calculated exactly _and_ when all the affected
10103 + * registers are listed in the operands.
10104 + *
10105 + * Examples:
10106 + *
10107 + * 'call' does not generate a known result, but as a side effect of call,
10108 + * several scratch registers become undefined, so it needs a special BBOU_CALL
10109 + * entry.
10110 + *
10111 + * 'adc' generates a variable result, it depends on the carry flag, so 'adc'
10112 + * gets a generic entry.  'add' can generate an exact result (add with
10113 + * immediate on a register that points to the stack) or it can generate an
10114 + * unknown result (add a variable, or add immediate to a register that does not
10115 + * contain a stack pointer) so 'add' has its own BBOU_ADD entry.
10116 + */
10117 +
10118 +static const struct bb_opcode_usage
10119 +bb_opcode_usage_all[] = {
10120 +       {3, BBOU_RSRDWD,  "adc"},
10121 +       {3, BBOU_ADD,     "add"},
10122 +       {3, BBOU_RSRDWD,  "and"},
10123 +       {3, BBOU_RSWD,    "bsf"},
10124 +       {3, BBOU_RSWD,    "bsr"},
10125 +       {5, BBOU_RSWS,    "bswap"},
10126 +       {3, BBOU_RSRDWD,  "btc"},
10127 +       {3, BBOU_RSRDWD,  "btr"},
10128 +       {3, BBOU_RSRDWD,  "bts"},
10129 +       {2, BBOU_RSRD,    "bt"},
10130 +       {4, BBOU_CALL,    "call"},
10131 +       {4, BBOU_CBW,     "cbtw"},      /* Intel cbw */
10132 +       {3, BBOU_NOP,     "clc"},
10133 +       {3, BBOU_NOP,     "cld"},
10134 +       {7, BBOU_RS,      "clflush"},
10135 +       {4, BBOU_NOP,     "clgi"},
10136 +       {3, BBOU_NOP,     "cli"},
10137 +       {4, BBOU_CWD,     "cltd"},      /* Intel cdq */
10138 +       {4, BBOU_CBW,     "cltq"},      /* Intel cdqe */
10139 +       {4, BBOU_NOP,     "clts"},
10140 +       {4, BBOU_CMOV,    "cmov"},
10141 +       {9, BBOU_CMPXCHGD,"cmpxchg16"},
10142 +       {8, BBOU_CMPXCHGD,"cmpxchg8"},
10143 +       {7, BBOU_CMPXCHG, "cmpxchg"},
10144 +       {3, BBOU_RSRD,    "cmp"},
10145 +       {5, BBOU_CPUID,   "cpuid"},
10146 +       {4, BBOU_CWD,     "cqto"},      /* Intel cdo */
10147 +       {4, BBOU_CWD,     "cwtd"},      /* Intel cwd */
10148 +       {4, BBOU_CBW,     "cwtl"},      /* Intel cwde */
10149 +       {4, BBOU_NOP,     "data"},      /* alternative ASM_NOP<n> generates data16 on x86_64 */
10150 +       {3, BBOU_RSWS,    "dec"},
10151 +       {3, BBOU_DIV,     "div"},
10152 +       {5, BBOU_RS,      "fdivl"},
10153 +       {5, BBOU_NOP,     "finit"},
10154 +       {6, BBOU_RS,      "fistpl"},
10155 +       {4, BBOU_RS,      "fldl"},
10156 +       {4, BBOU_RS,      "fmul"},
10157 +       {6, BBOU_NOP,     "fnclex"},
10158 +       {6, BBOU_NOP,     "fninit"},
10159 +       {6, BBOU_RS,      "fnsave"},
10160 +       {7, BBOU_NOP,     "fnsetpm"},
10161 +       {6, BBOU_RS,      "frstor"},
10162 +       {5, BBOU_WS,      "fstsw"},
10163 +       {5, BBOU_RS,      "fsubp"},
10164 +       {5, BBOU_NOP,     "fwait"},
10165 +       {7, BBOU_RS,      "fxrstor"},
10166 +       {6, BBOU_RS,      "fxsave"},
10167 +       {3, BBOU_NOP,     "hlt"},
10168 +       {4, BBOU_IDIV,    "idiv"},
10169 +       {4, BBOU_IMUL,    "imul"},
10170 +       {3, BBOU_RSWS,    "inc"},
10171 +       {3, BBOU_NOP,     "int"},
10172 +       {7, BBOU_RSRD,    "invlpga"},
10173 +       {6, BBOU_RS,      "invlpg"},
10174 +       {2, BBOU_RSWD,    "in"},
10175 +       {4, BBOU_IRET,    "iret"},
10176 +       {1, BBOU_JMP,     "j"},
10177 +       {4, BBOU_LAHF,    "lahf"},
10178 +       {3, BBOU_RSWD,    "lar"},
10179 +       {5, BBOU_RS,      "lcall"},
10180 +       {5, BBOU_LEAVE,   "leave"},
10181 +       {3, BBOU_LEA,     "lea"},
10182 +       {6, BBOU_NOP,     "lfence"},
10183 +       {4, BBOU_RS,      "lgdt"},
10184 +       {4, BBOU_RS,      "lidt"},
10185 +       {4, BBOU_RS,      "ljmp"},
10186 +       {4, BBOU_RS,      "lldt"},
10187 +       {4, BBOU_RS,      "lmsw"},
10188 +       {4, BBOU_LODS,    "lods"},
10189 +       {4, BBOU_LOOP,    "loop"},
10190 +       {4, BBOU_NOP,     "lret"},
10191 +       {3, BBOU_RSWD,    "lsl"},
10192 +       {3, BBOU_LSS,     "lss"},
10193 +       {3, BBOU_RS,      "ltr"},
10194 +       {6, BBOU_NOP,     "mfence"},
10195 +       {7, BBOU_MONITOR, "monitor"},
10196 +       {4, BBOU_MOVS,    "movs"},
10197 +       {3, BBOU_MOV,     "mov"},
10198 +       {3, BBOU_MUL,     "mul"},
10199 +       {5, BBOU_MWAIT,   "mwait"},
10200 +       {3, BBOU_RSWS,    "neg"},
10201 +       {3, BBOU_NOP,     "nop"},
10202 +       {3, BBOU_RSWS,    "not"},
10203 +       {2, BBOU_RSRDWD,  "or"},
10204 +       {4, BBOU_OUTS,    "outs"},
10205 +       {3, BBOU_RSRD,    "out"},
10206 +       {5, BBOU_NOP,     "pause"},
10207 +       {4, BBOU_POPF,    "popf"},
10208 +       {3, BBOU_POP,     "pop"},
10209 +       {8, BBOU_RS,      "prefetch"},
10210 +       {5, BBOU_PUSHF,   "pushf"},
10211 +       {4, BBOU_PUSH,    "push"},
10212 +       {3, BBOU_RSRDWD,  "rcl"},
10213 +       {3, BBOU_RSRDWD,  "rcr"},
10214 +       {5, BBOU_RDMSR,   "rdmsr"},
10215 +       {5, BBOU_RDMSR,   "rdpmc"},     /* same side effects as rdmsr */
10216 +       {5, BBOU_RDTSC,   "rdtsc"},
10217 +       {3, BBOU_RET,     "ret"},
10218 +       {3, BBOU_RSRDWD,  "rol"},
10219 +       {3, BBOU_RSRDWD,  "ror"},
10220 +       {4, BBOU_SAHF,    "sahf"},
10221 +       {3, BBOU_RSRDWD,  "sar"},
10222 +       {3, BBOU_RSRDWD,  "sbb"},
10223 +       {4, BBOU_SCAS,    "scas"},
10224 +       {3, BBOU_WS,      "set"},
10225 +       {6, BBOU_NOP,     "sfence"},
10226 +       {4, BBOU_WS,      "sgdt"},
10227 +       {3, BBOU_RSRDWD,  "shl"},
10228 +       {3, BBOU_RSRDWD,  "shr"},
10229 +       {4, BBOU_WS,      "sidt"},
10230 +       {4, BBOU_WS,      "sldt"},
10231 +       {3, BBOU_NOP,     "stc"},
10232 +       {3, BBOU_NOP,     "std"},
10233 +       {4, BBOU_NOP,     "stgi"},
10234 +       {3, BBOU_NOP,     "sti"},
10235 +       {4, BBOU_SCAS,    "stos"},
10236 +       {4, BBOU_WS,      "strl"},
10237 +       {3, BBOU_WS,      "str"},
10238 +       {3, BBOU_SUB,     "sub"},
10239 +       {6, BBOU_NOP,     "swapgs"},
10240 +       {7, BBOU_SYSEXIT, "sysexit"},
10241 +       {6, BBOU_SYSRET,  "sysret"},
10242 +       {4, BBOU_NOP,     "test"},
10243 +       {4, BBOU_NOP,     "ud2a"},
10244 +       {7, BBOU_RS,      "vmclear"},
10245 +       {8, BBOU_NOP,     "vmlaunch"},
10246 +       {6, BBOU_RS,      "vmload"},
10247 +       {7, BBOU_RS,      "vmptrld"},
10248 +       {6, BBOU_WD,      "vmread"},    /* vmread src is an encoding, not a register */
10249 +       {8, BBOU_NOP,     "vmresume"},
10250 +       {5, BBOU_RS,      "vmrun"},
10251 +       {6, BBOU_RS,      "vmsave"},
10252 +       {7, BBOU_WD,      "vmwrite"},   /* vmwrite src is an encoding, not a register */
10253 +       {6, BBOU_NOP,     "wbinvd"},
10254 +       {5, BBOU_WRMSR,   "wrmsr"},
10255 +       {4, BBOU_XADD,    "xadd"},
10256 +       {4, BBOU_XCHG,    "xchg"},
10257 +       {3, BBOU_XOR,     "xor"},
10258 +       {10, BBOU_WS,      "xstore-rng"},
10259 +};
10260 +
10261 +/* To speed up searching, index bb_opcode_usage_all by the first letter of each
10262 + * opcode.
10263 + */
10264 +static struct {
10265 +       const struct bb_opcode_usage *opcode;
10266 +       int size;
10267 +} bb_opcode_usage[26];
10268 +
10269 +struct bb_operand {
10270 +       char *base;
10271 +       char *index;
10272 +       char *segment;
10273 +       long disp;
10274 +       unsigned int scale;
10275 +       enum bb_reg_code base_rc;               /* UNDEFINED or RAX through R15 */
10276 +       enum bb_reg_code index_rc;              /* UNDEFINED or RAX through R15 */
10277 +       unsigned int present            :1;
10278 +       unsigned int disp_present       :1;
10279 +       unsigned int indirect           :1;     /* must be combined with reg or memory */
10280 +       unsigned int immediate          :1;     /* exactly one of these 3 must be set */
10281 +       unsigned int reg                :1;
10282 +       unsigned int memory             :1;
10283 +};
10284 +
10285 +struct bb_decode {
10286 +       char *prefix;
10287 +       char *opcode;
10288 +       const struct bb_opcode_usage *match;
10289 +       struct bb_operand src;
10290 +       struct bb_operand dst;
10291 +       struct bb_operand dst2;
10292 +};
10293 +
10294 +static struct bb_decode bb_decode;
10295 +
10296 +static enum bb_reg_code
10297 +bb_reg_map(const char *reg)
10298 +{
10299 +       int lo, hi, c;
10300 +       const struct bb_reg_code_map *p;
10301 +       lo = 0;
10302 +       hi = ARRAY_SIZE(bb_reg_code_map) - 1;
10303 +       while (lo <= hi) {
10304 +               int mid = (hi + lo) / 2;
10305 +               p = bb_reg_code_map + mid;
10306 +               c = strcmp(p->name, reg+1);
10307 +               if (c == 0)
10308 +                       return p->reg;
10309 +               else if (c > 0)
10310 +                       hi = mid - 1;
10311 +               else
10312 +                       lo = mid + 1;
10313 +       }
10314 +       return BBRG_UNDEFINED;
10315 +}
10316 +
10317 +static void
10318 +bb_parse_operand(char *str, struct bb_operand *operand)
10319 +{
10320 +       char *p = str;
10321 +       int sign = 1;
10322 +       operand->present = 1;
10323 +       /* extract any segment prefix */
10324 +       if (p[0] == '%' && p[1] && p[2] == 's' && p[3] == ':') {
10325 +               operand->memory = 1;
10326 +               operand->segment = p;
10327 +               p[3] = '\0';
10328 +               p += 4;
10329 +       }
10330 +       /* extract displacement, base, index, scale */
10331 +       if (*p == '*') {
10332 +               /* jmp/call *disp(%reg), *%reg or *0xnnn */
10333 +               operand->indirect = 1;
10334 +               ++p;
10335 +       }
10336 +       if (*p == '-') {
10337 +               sign = -1;
10338 +               ++p;
10339 +       }
10340 +       if (*p == '$') {
10341 +               operand->immediate = 1;
10342 +               operand->disp_present = 1;
10343 +               operand->disp = simple_strtoul(p+1, &p, 0);
10344 +       } else if (isdigit(*p)) {
10345 +               operand->memory = 1;
10346 +               operand->disp_present = 1;
10347 +               operand->disp = simple_strtoul(p, &p, 0) * sign;
10348 +       }
10349 +       if (*p == '%') {
10350 +               operand->reg = 1;
10351 +               operand->base = p;
10352 +       } else if (*p == '(') {
10353 +               operand->memory = 1;
10354 +               operand->base = ++p;
10355 +               p += strcspn(p, ",)");
10356 +               if (p == operand->base)
10357 +                       operand->base = NULL;
10358 +               if (*p == ',') {
10359 +                       *p = '\0';
10360 +                       operand->index = ++p;
10361 +                       p += strcspn(p, ",)");
10362 +                       if (p == operand->index)
10363 +                               operand->index = NULL;
10364 +               }
10365 +               if (*p == ',') {
10366 +                       *p = '\0';
10367 +                       operand->scale = simple_strtoul(p+1, &p, 0);
10368 +               }
10369 +               *p = '\0';
10370 +       } else if (*p) {
10371 +               kdb_printf("%s: unexpected token '%c' after disp '%s'\n",
10372 +                          __FUNCTION__, *p, str);
10373 +               bb_giveup = 1;
10374 +       }
10375 +       if ((operand->immediate + operand->reg + operand->memory != 1) ||
10376 +           (operand->indirect && operand->immediate)) {
10377 +               kdb_printf("%s: incorrect decode '%s' N %d I %d R %d M %d\n",
10378 +                          __FUNCTION__, str,
10379 +                          operand->indirect, operand->immediate, operand->reg,
10380 +                          operand->memory);
10381 +               bb_giveup = 1;
10382 +       }
10383 +       if (operand->base)
10384 +               operand->base_rc = bb_reg_map(operand->base);
10385 +       if (operand->index)
10386 +               operand->index_rc = bb_reg_map(operand->index);
10387 +}
10388 +
10389 +static void
10390 +bb_print_operand(const char *type, const struct bb_operand *operand)
10391 +{
10392 +       if (!operand->present)
10393 +               return;
10394 +       kdb_printf("  %s %c%c: ",
10395 +                  type,
10396 +                  operand->indirect ? 'N' : ' ',
10397 +                  operand->immediate ? 'I' :
10398 +                    operand->reg ? 'R' :
10399 +                    operand->memory ? 'M' :
10400 +                    '?'
10401 +                  );
10402 +       if (operand->segment)
10403 +               kdb_printf("%s:", operand->segment);
10404 +       if (operand->immediate) {
10405 +               kdb_printf("$0x%lx", operand->disp);
10406 +       } else if (operand->reg) {
10407 +               if (operand->indirect)
10408 +                       kdb_printf("*");
10409 +               kdb_printf("%s", operand->base);
10410 +       } else if (operand->memory) {
10411 +               if (operand->indirect && (operand->base || operand->index))
10412 +                       kdb_printf("*");
10413 +               if (operand->disp_present) {
10414 +                       kdb_printf("0x%lx", operand->disp);
10415 +               }
10416 +               if (operand->base || operand->index || operand->scale) {
10417 +                       kdb_printf("(");
10418 +                       if (operand->base)
10419 +                               kdb_printf("%s", operand->base);
10420 +                       if (operand->index || operand->scale)
10421 +                               kdb_printf(",");
10422 +                       if (operand->index)
10423 +                               kdb_printf("%s", operand->index);
10424 +                       if (operand->scale)
10425 +                               kdb_printf(",%d", operand->scale);
10426 +                       kdb_printf(")");
10427 +               }
10428 +       }
10429 +       if (operand->base_rc)
10430 +               kdb_printf(" base_rc %d (%s)",
10431 +                          operand->base_rc, bbrg_name[operand->base_rc]);
10432 +       if (operand->index_rc)
10433 +               kdb_printf(" index_rc %d (%s)",
10434 +                          operand->index_rc,
10435 +                          bbrg_name[operand->index_rc]);
10436 +       kdb_printf("\n");
10437 +}
10438 +
10439 +static void
10440 +bb_print_opcode(void)
10441 +{
10442 +       const struct bb_opcode_usage *o = bb_decode.match;
10443 +       kdb_printf("  ");
10444 +       if (bb_decode.prefix)
10445 +               kdb_printf("%s ", bb_decode.prefix);
10446 +       kdb_printf("opcode '%s' matched by '%s', usage %d\n",
10447 +                  bb_decode.opcode, o->opcode, o->usage);
10448 +}
10449 +
10450 +static int
10451 +bb_parse_opcode(void)
10452 +{
10453 +       int c, i;
10454 +       const struct bb_opcode_usage *o;
10455 +       static int bb_parse_opcode_error_limit = 5;
10456 +       c = bb_decode.opcode[0] - 'a';
10457 +       if (c < 0 || c >= ARRAY_SIZE(bb_opcode_usage))
10458 +               goto nomatch;
10459 +       o = bb_opcode_usage[c].opcode;
10460 +       if (!o)
10461 +               goto nomatch;
10462 +       for (i = 0; i < bb_opcode_usage[c].size; ++i, ++o) {
10463 +               if (strncmp(bb_decode.opcode, o->opcode, o->length) == 0) {
10464 +                       bb_decode.match = o;
10465 +                       if (KDB_DEBUG(BB))
10466 +                               bb_print_opcode();
10467 +                       return 0;
10468 +               }
10469 +       }
10470 +nomatch:
10471 +       if (!bb_parse_opcode_error_limit)
10472 +               return 1;
10473 +       --bb_parse_opcode_error_limit;
10474 +       kdb_printf("%s: no match at [%s]%s " kdb_bfd_vma_fmt0 " - '%s'\n",
10475 +                  __FUNCTION__,
10476 +                  bb_mod_name, bb_func_name, bb_curr_addr,
10477 +                  bb_decode.opcode);
10478 +       return 1;
10479 +}
10480 +
10481 +static bool
10482 +bb_is_int_reg(enum bb_reg_code reg)
10483 +{
10484 +       return reg >= BBRG_RAX && reg < (BBRG_RAX + KDB_INT_REGISTERS);
10485 +}
10486 +
10487 +static bool
10488 +bb_is_simple_memory(const struct bb_operand *operand)
10489 +{
10490 +       return operand->memory &&
10491 +              bb_is_int_reg(operand->base_rc) &&
10492 +              !operand->index_rc &&
10493 +              operand->scale == 0 &&
10494 +              !operand->segment;
10495 +}
10496 +
10497 +static bool
10498 +bb_is_static_disp(const struct bb_operand *operand)
10499 +{
10500 +       return operand->memory &&
10501 +              !operand->base_rc &&
10502 +              !operand->index_rc &&
10503 +              operand->scale == 0 &&
10504 +              !operand->segment &&
10505 +              !operand->indirect;
10506 +}
10507 +
10508 +static enum bb_reg_code
10509 +bb_reg_code_value(enum bb_reg_code reg)
10510 +{
10511 +       BB_CHECK(!bb_is_int_reg(reg), reg, 0);
10512 +       return bb_reg_state->contains[reg - BBRG_RAX].value;
10513 +}
10514 +
10515 +static short
10516 +bb_reg_code_offset(enum bb_reg_code reg)
10517 +{
10518 +       BB_CHECK(!bb_is_int_reg(reg), reg, 0);
10519 +       return bb_reg_state->contains[reg - BBRG_RAX].offset;
10520 +}
10521 +
10522 +static void
10523 +bb_reg_code_set_value(enum bb_reg_code dst, enum bb_reg_code src)
10524 +{
10525 +       BB_CHECK(!bb_is_int_reg(dst), dst, );
10526 +       bb_reg_state->contains[dst - BBRG_RAX].value = src;
10527 +}
10528 +
10529 +static void
10530 +bb_reg_code_set_offset(enum bb_reg_code dst, short offset)
10531 +{
10532 +       BB_CHECK(!bb_is_int_reg(dst), dst, );
10533 +       bb_reg_state->contains[dst - BBRG_RAX].offset = offset;
10534 +}
10535 +
10536 +static bool
10537 +bb_is_osp_defined(enum bb_reg_code reg)
10538 +{
10539 +       if (bb_is_int_reg(reg))
10540 +               return bb_reg_code_value(reg) == BBRG_OSP;
10541 +       else
10542 +               return 0;
10543 +}
10544 +
10545 +static bfd_vma
10546 +bb_actual_value(enum bb_reg_code reg)
10547 +{
10548 +       BB_CHECK(!bb_is_int_reg(reg), reg, 0);
10549 +       return bb_actual[reg - BBRG_RAX].value;
10550 +}
10551 +
10552 +static int
10553 +bb_actual_valid(enum bb_reg_code reg)
10554 +{
10555 +       BB_CHECK(!bb_is_int_reg(reg), reg, 0);
10556 +       return bb_actual[reg - BBRG_RAX].valid;
10557 +}
10558 +
10559 +static void
10560 +bb_actual_set_value(enum bb_reg_code reg, bfd_vma value)
10561 +{
10562 +       BB_CHECK(!bb_is_int_reg(reg), reg, );
10563 +       bb_actual[reg - BBRG_RAX].value = value;
10564 +}
10565 +
10566 +static void
10567 +bb_actual_set_valid(enum bb_reg_code reg, int valid)
10568 +{
10569 +       BB_CHECK(!bb_is_int_reg(reg), reg, );
10570 +       bb_actual[reg - BBRG_RAX].valid = valid;
10571 +}
10572 +
10573 +/* The scheduler code switches RSP then does PUSH, it is not an error for RSP
10574 + * to be undefined in this area of the code.
10575 + */
10576 +static bool
10577 +bb_is_scheduler_address(void)
10578 +{
10579 +       return bb_curr_addr >= bb__sched_text_start &&
10580 +              bb_curr_addr < bb__sched_text_end;
10581 +}
10582 +
10583 +static void
10584 +bb_reg_read(enum bb_reg_code reg)
10585 +{
10586 +       int i, r = 0;
10587 +       if (!bb_is_int_reg(reg) ||
10588 +           bb_reg_code_value(reg) != reg)
10589 +               return;
10590 +       for (i = 0;
10591 +            i < min_t(unsigned int, REGPARM, ARRAY_SIZE(bb_param_reg));
10592 +            ++i) {
10593 +               if (reg == bb_param_reg[i]) {
10594 +                       r = i + 1;
10595 +                       break;
10596 +               }
10597 +       }
10598 +       bb_reg_params = max(bb_reg_params, r);
10599 +}
10600 +
10601 +static void
10602 +bb_do_reg_state_print(const struct bb_reg_state *s)
10603 +{
10604 +       int i, offset_address, offset_value;
10605 +       const struct bb_memory_contains *c;
10606 +       enum bb_reg_code value;
10607 +       kdb_printf("  bb_reg_state %p\n", s);
10608 +       for (i = 0; i < ARRAY_SIZE(s->contains); ++i) {
10609 +               value = s->contains[i].value;
10610 +               offset_value = s->contains[i].offset;
10611 +               kdb_printf("    %s = %s",
10612 +                          bbrg_name[i + BBRG_RAX], bbrg_name[value]);
10613 +               if (value == BBRG_OSP)
10614 +                       KDB_DEBUG_BB_OFFSET_PRINTF(offset_value, "", "");
10615 +               kdb_printf("\n");
10616 +       }
10617 +       for (i = 0, c = s->memory; i < s->mem_count; ++i, ++c) {
10618 +               offset_address = c->offset_address;
10619 +               value = c->value;
10620 +               offset_value = c->offset_value;
10621 +               kdb_printf("    slot %d offset_address %c0x%x %s",
10622 +                          i,
10623 +                          offset_address >= 0 ? '+' : '-',
10624 +                          offset_address >= 0 ? offset_address : -offset_address,
10625 +                          bbrg_name[value]);
10626 +               if (value == BBRG_OSP)
10627 +                       KDB_DEBUG_BB_OFFSET_PRINTF(offset_value, "", "");
10628 +               kdb_printf("\n");
10629 +       }
10630 +}
10631 +
10632 +static void
10633 +bb_reg_state_print(const struct bb_reg_state *s)
10634 +{
10635 +       if (KDB_DEBUG(BB))
10636 +               bb_do_reg_state_print(s);
10637 +}
10638 +
10639 +/* Set register 'dst' to contain the value from 'src'.  This includes reading
10640 + * from 'src' and writing to 'dst'.  The offset value is copied iff 'src'
10641 + * contains a stack pointer.
10642 + *
10643 + * Be very careful about the context here.  'dst' and 'src' reflect integer
10644 + * registers by name, _not_ by the value of their contents.  "mov %rax,%rsi"
10645 + * will call this function as bb_reg_set_reg(BBRG_RSI, BBRG_RAX), which
10646 + * reflects what the assembler code is doing.  However we need to track the
10647 + * _values_ in the registers, not their names.  IOW, we really care about "what
10648 + * value does rax contain when it is copied into rsi?", so we can record the
10649 + * fact that we now have two copies of that value, one in rax and one in rsi.
10650 + */
10651 +
10652 +static void
10653 +bb_reg_set_reg(enum bb_reg_code dst, enum bb_reg_code src)
10654 +{
10655 +       enum bb_reg_code src_value = BBRG_UNDEFINED;
10656 +       short offset_value = 0;
10657 +       KDB_DEBUG_BB("  %s = %s", bbrg_name[dst], bbrg_name[src]);
10658 +       if (bb_is_int_reg(src)) {
10659 +               bb_reg_read(src);
10660 +               src_value = bb_reg_code_value(src);
10661 +               KDB_DEBUG_BB(" (%s", bbrg_name[src_value]);
10662 +               if (bb_is_osp_defined(src)) {
10663 +                       offset_value = bb_reg_code_offset(src);
10664 +                       KDB_DEBUG_BB_OFFSET(offset_value, "", "");
10665 +               }
10666 +               KDB_DEBUG_BB(")");
10667 +       }
10668 +       if (bb_is_int_reg(dst)) {
10669 +               bb_reg_code_set_value(dst, src_value);
10670 +               bb_reg_code_set_offset(dst, offset_value);
10671 +       }
10672 +       KDB_DEBUG_BB("\n");
10673 +}
10674 +
10675 +static void
10676 +bb_reg_set_undef(enum bb_reg_code dst)
10677 +{
10678 +       bb_reg_set_reg(dst, BBRG_UNDEFINED);
10679 +}
10680 +
10681 +/* Delete any record of a stored register held in osp + 'offset' */
10682 +
10683 +static void
10684 +bb_delete_memory(short offset)
10685 +{
10686 +       int i;
10687 +       struct bb_memory_contains *c;
10688 +       for (i = 0, c = bb_reg_state->memory;
10689 +            i < bb_reg_state->mem_count;
10690 +            ++i, ++c) {
10691 +               if (c->offset_address == offset &&
10692 +                   c->value != BBRG_UNDEFINED) {
10693 +                       KDB_DEBUG_BB("  delete %s from ",
10694 +                                    bbrg_name[c->value]);
10695 +                       KDB_DEBUG_BB_OFFSET(offset, "osp", "");
10696 +                       KDB_DEBUG_BB(" slot %d\n",
10697 +                                    (int)(c - bb_reg_state->memory));
10698 +                       memset(c, BBRG_UNDEFINED, sizeof(*c));
10699 +                       if (i == bb_reg_state->mem_count - 1)
10700 +                               --bb_reg_state->mem_count;
10701 +               }
10702 +       }
10703 +}
10704 +
10705 +/* Set memory location *('dst' + 'offset_address') to contain the supplied
10706 + * value and offset.  'dst' is assumed to be a register that contains a stack
10707 + * pointer.
10708 + */
10709 +
10710 +static void
10711 +bb_memory_set_reg_value(enum bb_reg_code dst, short offset_address,
10712 +                       enum bb_reg_code value, short offset_value)
10713 +{
10714 +       int i;
10715 +       struct bb_memory_contains *c, *free = NULL;
10716 +       BB_CHECK(!bb_is_osp_defined(dst), dst, );
10717 +       KDB_DEBUG_BB("  *(%s", bbrg_name[dst]);
10718 +       KDB_DEBUG_BB_OFFSET(offset_address, "", "");
10719 +       offset_address += bb_reg_code_offset(dst);
10720 +       KDB_DEBUG_BB_OFFSET(offset_address, " osp", ") = ");
10721 +       KDB_DEBUG_BB("%s", bbrg_name[value]);
10722 +       if (value == BBRG_OSP)
10723 +               KDB_DEBUG_BB_OFFSET(offset_value, "", "");
10724 +       for (i = 0, c = bb_reg_state->memory;
10725 +            i < bb_reg_state_max;
10726 +            ++i, ++c) {
10727 +               if (c->offset_address == offset_address)
10728 +                       free = c;
10729 +               else if (c->value == BBRG_UNDEFINED && !free)
10730 +                       free = c;
10731 +       }
10732 +       if (!free) {
10733 +               struct bb_reg_state *new, *old = bb_reg_state;
10734 +               size_t old_size, new_size;
10735 +               int slot;
10736 +               old_size = sizeof(*old) + bb_reg_state_max *
10737 +                                 sizeof(old->memory[0]);
10738 +               slot = bb_reg_state_max;
10739 +               bb_reg_state_max += 5;
10740 +               new_size = sizeof(*new) + bb_reg_state_max *
10741 +                                 sizeof(new->memory[0]);
10742 +               new = debug_kmalloc(new_size, GFP_ATOMIC);
10743 +               if (!new) {
10744 +                       kdb_printf("\n\n%s: out of debug_kmalloc\n", __FUNCTION__);
10745 +                       bb_giveup = 1;
10746 +               } else {
10747 +                       memcpy(new, old, old_size);
10748 +                       memset((char *)new + old_size, BBRG_UNDEFINED,
10749 +                              new_size - old_size);
10750 +                       bb_reg_state = new;
10751 +                       debug_kfree(old);
10752 +                       free = bb_reg_state->memory + slot;
10753 +               }
10754 +       }
10755 +       if (free) {
10756 +               int slot = free - bb_reg_state->memory;
10757 +               free->offset_address = offset_address;
10758 +               free->value = value;
10759 +               free->offset_value = offset_value;
10760 +               KDB_DEBUG_BB(" slot %d", slot);
10761 +               bb_reg_state->mem_count = max(bb_reg_state->mem_count, slot+1);
10762 +       }
10763 +       KDB_DEBUG_BB("\n");
10764 +}
10765 +
10766 +/* Set memory location *('dst' + 'offset') to contain the value from register
10767 + * 'src'.  'dst' is assumed to be a register that contains a stack pointer.
10768 + * This differs from bb_memory_set_reg_value because it takes a src register
10769 + * which contains a value and possibly an offset, bb_memory_set_reg_value is
10770 + * passed the value and offset directly.
10771 + */
10772 +
10773 +static void
10774 +bb_memory_set_reg(enum bb_reg_code dst, enum bb_reg_code src,
10775 +                 short offset_address)
10776 +{
10777 +       int offset_value;
10778 +       enum bb_reg_code value;
10779 +       BB_CHECK(!bb_is_osp_defined(dst), dst, );
10780 +       if (!bb_is_int_reg(src))
10781 +               return;
10782 +       value = bb_reg_code_value(src);
10783 +       if (value == BBRG_UNDEFINED) {
10784 +               bb_delete_memory(offset_address + bb_reg_code_offset(dst));
10785 +               return;
10786 +       }
10787 +       offset_value = bb_reg_code_offset(src);
10788 +       bb_reg_read(src);
10789 +       bb_memory_set_reg_value(dst, offset_address, value, offset_value);
10790 +}
10791 +
10792 +/* Set register 'dst' to contain the value from memory *('src' + offset_address).
10793 + * 'src' is assumed to be a register that contains a stack pointer.
10794 + */
10795 +
10796 +static void
10797 +bb_reg_set_memory(enum bb_reg_code dst, enum bb_reg_code src, short offset_address)
10798 +{
10799 +       int i, defined = 0;
10800 +       struct bb_memory_contains *s;
10801 +       BB_CHECK(!bb_is_osp_defined(src), src, );
10802 +       KDB_DEBUG_BB("  %s = *(%s",
10803 +                    bbrg_name[dst], bbrg_name[src]);
10804 +       KDB_DEBUG_BB_OFFSET(offset_address, "", ")");
10805 +       offset_address += bb_reg_code_offset(src);
10806 +       KDB_DEBUG_BB_OFFSET(offset_address, " (osp", ")");
10807 +       for (i = 0, s = bb_reg_state->memory;
10808 +            i < bb_reg_state->mem_count;
10809 +            ++i, ++s) {
10810 +               if (s->offset_address == offset_address && bb_is_int_reg(dst)) {
10811 +                       bb_reg_code_set_value(dst, s->value);
10812 +                       KDB_DEBUG_BB(" value %s", bbrg_name[s->value]);
10813 +                       if (s->value == BBRG_OSP) {
10814 +                               bb_reg_code_set_offset(dst, s->offset_value);
10815 +                               KDB_DEBUG_BB_OFFSET(s->offset_value, "", "");
10816 +                       } else {
10817 +                               bb_reg_code_set_offset(dst, 0);
10818 +                       }
10819 +                       defined = 1;
10820 +               }
10821 +       }
10822 +       if (!defined)
10823 +               bb_reg_set_reg(dst, BBRG_UNDEFINED);
10824 +       else
10825 +               KDB_DEBUG_BB("\n");
10826 +}
10827 +
10828 +/* A generic read from an operand. */
10829 +
10830 +static void
10831 +bb_read_operand(const struct bb_operand *operand)
10832 +{
10833 +       int m = 0;
10834 +       if (operand->base_rc)
10835 +               bb_reg_read(operand->base_rc);
10836 +       if (operand->index_rc)
10837 +               bb_reg_read(operand->index_rc);
10838 +       if (bb_is_simple_memory(operand) &&
10839 +           bb_is_osp_defined(operand->base_rc) &&
10840 +           bb_decode.match->usage != BBOU_LEA) {
10841 +               m = (bb_reg_code_offset(operand->base_rc) + operand->disp +
10842 +                    KDB_WORD_SIZE - 1) / KDB_WORD_SIZE;
10843 +               bb_memory_params = max(bb_memory_params, m);
10844 +       }
10845 +}
10846 +
10847 +/* A generic write to an operand, resulting in an undefined value in that
10848 + * location.  All well defined operands are handled separately, this function
10849 + * only handles the opcodes where the result is undefined.
10850 + */
10851 +
10852 +static void
10853 +bb_write_operand(const struct bb_operand *operand)
10854 +{
10855 +       enum bb_reg_code base_rc = operand->base_rc;
10856 +       if (operand->memory) {
10857 +               if (base_rc)
10858 +                       bb_reg_read(base_rc);
10859 +               if (operand->index_rc)
10860 +                       bb_reg_read(operand->index_rc);
10861 +       } else if (operand->reg && base_rc) {
10862 +               bb_reg_set_undef(base_rc);
10863 +       }
10864 +       if (bb_is_simple_memory(operand) && bb_is_osp_defined(base_rc)) {
10865 +               int offset;
10866 +               offset = bb_reg_code_offset(base_rc) + operand->disp;
10867 +               offset = ALIGN(offset - KDB_WORD_SIZE + 1, KDB_WORD_SIZE);
10868 +               bb_delete_memory(offset);
10869 +       }
10870 +}
10871 +
10872 +/* Adjust a register that contains a stack pointer */
10873 +
10874 +static void
10875 +bb_adjust_osp(enum bb_reg_code reg, int adjust)
10876 +{
10877 +       int offset = bb_reg_code_offset(reg), old_offset = offset;
10878 +       KDB_DEBUG_BB("  %s osp offset ", bbrg_name[reg]);
10879 +       KDB_DEBUG_BB_OFFSET(bb_reg_code_offset(reg), "", " -> ");
10880 +       offset += adjust;
10881 +       bb_reg_code_set_offset(reg, offset);
10882 +       KDB_DEBUG_BB_OFFSET(bb_reg_code_offset(reg), "", "\n");
10883 +       /* When RSP is adjusted upwards, it invalidates any memory
10884 +        * stored between the old and current stack offsets.
10885 +        */
10886 +       if (reg == BBRG_RSP) {
10887 +               while (old_offset < bb_reg_code_offset(reg)) {
10888 +                       bb_delete_memory(old_offset);
10889 +                       old_offset += KDB_WORD_SIZE;
10890 +               }
10891 +       }
10892 +}
10893 +
10894 +/* The current instruction adjusts a register that contains a stack pointer.
10895 + * Direction is 1 or -1, depending on whether the instruction is add/lea or
10896 + * sub.
10897 + */
10898 +
10899 +static void
10900 +bb_adjust_osp_instruction(int direction)
10901 +{
10902 +       enum bb_reg_code dst_reg = bb_decode.dst.base_rc;
10903 +       if (bb_decode.src.immediate ||
10904 +           bb_decode.match->usage == BBOU_LEA /* lea has its own checks */) {
10905 +               int adjust = direction * bb_decode.src.disp;
10906 +               bb_adjust_osp(dst_reg, adjust);
10907 +       } else {
10908 +               /* variable stack adjustment, osp offset is not well defined */
10909 +               KDB_DEBUG_BB("  %s osp offset ", bbrg_name[dst_reg]);
10910 +               KDB_DEBUG_BB_OFFSET(bb_reg_code_offset(dst_reg), "", " -> undefined\n");
10911 +               bb_reg_code_set_value(dst_reg, BBRG_UNDEFINED);
10912 +               bb_reg_code_set_offset(dst_reg, 0);
10913 +       }
10914 +}
10915 +
10916 +/* Some instructions using memory have an explicit length suffix (b, w, l, q).
10917 + * The equivalent instructions using a register imply the length from the
10918 + * register name.  Deduce the operand length.
10919 + */
10920 +
10921 +static int
10922 +bb_operand_length(const struct bb_operand *operand, char opcode_suffix)
10923 +{
10924 +       int l = 0;
10925 +       switch (opcode_suffix) {
10926 +       case 'b':
10927 +               l = 8;
10928 +               break;
10929 +       case 'w':
10930 +               l = 16;
10931 +               break;
10932 +       case 'l':
10933 +               l = 32;
10934 +               break;
10935 +       case 'q':
10936 +               l = 64;
10937 +               break;
10938 +       }
10939 +       if (l == 0 && operand->reg) {
10940 +               switch (strlen(operand->base)) {
10941 +               case 3:
10942 +                       switch (operand->base[2]) {
10943 +                       case 'h':
10944 +                       case 'l':
10945 +                               l = 8;
10946 +                               break;
10947 +                       default:
10948 +                               l = 16;
10949 +                               break;
10950 +                       }
10951 +               case 4:
10952 +                       if (operand->base[1] == 'r')
10953 +                               l = 64;
10954 +                       else
10955 +                               l = 32;
10956 +                       break;
10957 +               }
10958 +       }
10959 +       return l;
10960 +}
10961 +
10962 +static int
10963 +bb_reg_state_size(const struct bb_reg_state *state)
10964 +{
10965 +       return sizeof(*state) +
10966 +              state->mem_count * sizeof(state->memory[0]);
10967 +}
10968 +
10969 +/* Canonicalize the current bb_reg_state so it can be compared against
10970 + * previously created states.  Sort the memory entries in descending order of
10971 + * offset_address (stack grows down).  Empty slots are moved to the end of the
10972 + * list and trimmed.
10973 + */
10974 +
10975 +static void
10976 +bb_reg_state_canonicalize(void)
10977 +{
10978 +       int i, order, changed;
10979 +       struct bb_memory_contains *p1, *p2, temp;
10980 +       do {
10981 +               changed = 0;
10982 +               for (i = 0, p1 = bb_reg_state->memory;
10983 +                    i < bb_reg_state->mem_count-1;
10984 +                    ++i, ++p1) {
10985 +                       p2 = p1 + 1;
10986 +                       if (p2->value == BBRG_UNDEFINED) {
10987 +                               order = 0;
10988 +                       } else if (p1->value == BBRG_UNDEFINED) {
10989 +                               order = 1;
10990 +                       } else if (p1->offset_address < p2->offset_address) {
10991 +                               order = 1;
10992 +                       } else if (p1->offset_address > p2->offset_address) {
10993 +                               order = -1;
10994 +                       } else {
10995 +                               order = 0;
10996 +                       }
10997 +                       if (order > 0) {
10998 +                               temp = *p2;
10999 +                               *p2 = *p1;
11000 +                               *p1 = temp;
11001 +                               changed = 1;
11002 +                       }
11003 +               }
11004 +       } while(changed);
11005 +       for (i = 0, p1 = bb_reg_state->memory;
11006 +            i < bb_reg_state_max;
11007 +            ++i, ++p1) {
11008 +               if (p1->value != BBRG_UNDEFINED)
11009 +                       bb_reg_state->mem_count = i + 1;
11010 +       }
11011 +       bb_reg_state_print(bb_reg_state);
11012 +}
11013 +
11014 +static int
11015 +bb_special_case(bfd_vma to)
11016 +{
11017 +       int i, j, rsp_offset, expect_offset, offset, errors = 0, max_errors = 40;
11018 +       enum bb_reg_code reg, expect_value, value;
11019 +       struct bb_name_state *r;
11020 +
11021 +       for (i = 0, r = bb_special_cases;
11022 +            i < ARRAY_SIZE(bb_special_cases);
11023 +            ++i, ++r) {
11024 +               if (to == r->address &&
11025 +                   (r->fname == NULL || strcmp(bb_func_name, r->fname) == 0))
11026 +                       goto match;
11027 +       }
11028 +       /* Some inline assembler code has jumps to .fixup sections which result
11029 +        * in out of line transfers with undefined state, ignore them.
11030 +        */
11031 +       if (strcmp(bb_func_name, "strnlen_user") == 0 ||
11032 +           strcmp(bb_func_name, "copy_from_user") == 0)
11033 +               return 1;
11034 +       return 0;
11035 +
11036 +match:
11037 +       /* Check the running registers match */
11038 +       for (reg = BBRG_RAX; reg < r->regs_size; ++reg) {
11039 +               expect_value = r->regs[reg].value;
11040 +               if (test_bit(expect_value, r->skip_regs.bits)) {
11041 +                       /* this regs entry is not defined for this label */
11042 +                       continue;
11043 +               }
11044 +               if (expect_value == BBRG_UNDEFINED)
11045 +                       continue;
11046 +               expect_offset = r->regs[reg].offset;
11047 +               value = bb_reg_code_value(reg);
11048 +               offset = bb_reg_code_offset(reg);
11049 +               if (expect_value == value &&
11050 +                   (value != BBRG_OSP || r->osp_offset == offset))
11051 +                       continue;
11052 +               kdb_printf("%s: Expected %s to contain %s",
11053 +                          __FUNCTION__,
11054 +                          bbrg_name[reg],
11055 +                          bbrg_name[expect_value]);
11056 +               if (r->osp_offset)
11057 +                       KDB_DEBUG_BB_OFFSET_PRINTF(r->osp_offset, "", "");
11058 +               kdb_printf(".  It actually contains %s", bbrg_name[value]);
11059 +               if (offset)
11060 +                       KDB_DEBUG_BB_OFFSET_PRINTF(offset, "", "");
11061 +               kdb_printf("\n");
11062 +               ++errors;
11063 +               if (max_errors-- == 0)
11064 +                       goto fail;
11065 +       }
11066 +       /* Check that any memory data on stack matches */
11067 +       i = j = 0;
11068 +       while (i < bb_reg_state->mem_count &&
11069 +              j < r->mem_size) {
11070 +               expect_value = r->mem[j].value;
11071 +               if (test_bit(expect_value, r->skip_mem.bits) ||
11072 +                   expect_value == BBRG_UNDEFINED) {
11073 +                       /* this memory slot is not defined for this label */
11074 +                       ++j;
11075 +                       continue;
11076 +               }
11077 +               rsp_offset = bb_reg_state->memory[i].offset_address -
11078 +                       bb_reg_code_offset(BBRG_RSP);
11079 +               if (rsp_offset >
11080 +                   r->mem[j].offset_address) {
11081 +                       /* extra slots in memory are OK */
11082 +                       ++i;
11083 +               } else if (rsp_offset <
11084 +                          r->mem[j].offset_address) {
11085 +                       /* Required memory slot is missing */
11086 +                       kdb_printf("%s: Invalid bb_reg_state.memory, "
11087 +                                  "missing memory entry[%d] %s\n",
11088 +                          __FUNCTION__, j, bbrg_name[expect_value]);
11089 +                       ++errors;
11090 +                       if (max_errors-- == 0)
11091 +                               goto fail;
11092 +                       ++j;
11093 +               } else {
11094 +                       if (bb_reg_state->memory[i].offset_value ||
11095 +                           bb_reg_state->memory[i].value != expect_value) {
11096 +                               /* memory slot is present but contains wrong
11097 +                                * value.
11098 +                                */
11099 +                               kdb_printf("%s: Invalid bb_reg_state.memory, "
11100 +                                           "wrong value in slot %d, "
11101 +                                           "should be %s, it is %s\n",
11102 +                                  __FUNCTION__, i,
11103 +                                  bbrg_name[expect_value],
11104 +                                  bbrg_name[bb_reg_state->memory[i].value]);
11105 +                               ++errors;
11106 +                               if (max_errors-- == 0)
11107 +                                       goto fail;
11108 +                       }
11109 +                       ++i;
11110 +                       ++j;
11111 +               }
11112 +       }
11113 +       while (j < r->mem_size) {
11114 +               expect_value = r->mem[j].value;
11115 +               if (test_bit(expect_value, r->skip_mem.bits) ||
11116 +                   expect_value == BBRG_UNDEFINED)
11117 +                       ++j;
11118 +               else
11119 +                       break;
11120 +       }
11121 +       if (j != r->mem_size) {
11122 +               /* Hit end of memory before testing all the pt_reg slots */
11123 +               kdb_printf("%s: Invalid bb_reg_state.memory, "
11124 +                           "missing trailing entries\n",
11125 +                  __FUNCTION__);
11126 +               ++errors;
11127 +               if (max_errors-- == 0)
11128 +                       goto fail;
11129 +       }
11130 +       if (errors)
11131 +               goto fail;
11132 +       return 1;
11133 +fail:
11134 +       kdb_printf("%s: on transfer to %s\n", __FUNCTION__, r->name);
11135 +       bb_giveup = 1;
11136 +       return 1;
11137 +}
11138 +
11139 +/* Transfer of control to a label outside the current function.  If the
11140 + * transfer is to a known common code path then do a sanity check on the state
11141 + * at this point.
11142 + */
11143 +
11144 +static void
11145 +bb_sanity_check(int type)
11146 +{
11147 +       enum bb_reg_code expect, actual;
11148 +       int i, offset, error = 0;
11149 +
11150 +       for (i = 0; i < ARRAY_SIZE(bb_preserved_reg); ++i) {
11151 +               expect = bb_preserved_reg[i];
11152 +               actual = bb_reg_code_value(expect);
11153 +               offset = bb_reg_code_offset(expect);
11154 +               if (expect == actual)
11155 +                       continue;
11156 +               /* type == 1 is sysret/sysexit, ignore RSP */
11157 +               if (type && expect == BBRG_RSP)
11158 +                       continue;
11159 +               /* type == 1 is sysret/sysexit, ignore RBP for i386 */
11160 +               /* We used to have "#ifndef CONFIG_X86_64" for the type=1 RBP
11161 +                * test; however, x86_64 can run ia32 compatible mode and
11162 +                * hit this problem. Perform the following test anyway!
11163 +                */
11164 +               if (type && expect == BBRG_RBP)
11165 +                       continue;
11166 +               /* RSP should contain OSP+0.  Except for ptregscall_common and
11167 +                * ia32_ptregs_common, they get a partial pt_regs, fudge the
11168 +                * stack to make it a full pt_regs then reverse the effect on
11169 +                * exit, so the offset is -0x50 on exit.
11170 +                */
11171 +               if (expect == BBRG_RSP &&
11172 +                   bb_is_osp_defined(expect) &&
11173 +                   (offset == 0 ||
11174 +                    (offset == -0x50 &&
11175 +                     (strcmp(bb_func_name, "ptregscall_common") == 0 ||
11176 +                      strcmp(bb_func_name, "ia32_ptregs_common") == 0))))
11177 +                       continue;
11178 +               kdb_printf("%s: Expected %s, got %s",
11179 +                          __FUNCTION__,
11180 +                          bbrg_name[expect], bbrg_name[actual]);
11181 +               if (offset)
11182 +                       KDB_DEBUG_BB_OFFSET_PRINTF(offset, "", "");
11183 +               kdb_printf("\n");
11184 +               error = 1;
11185 +       }
11186 +       BB_CHECK(error, error, );
11187 +}
11188 +
11189 +/* Transfer of control.  Follow the arc and save the current state as input to
11190 + * another basic block.
11191 + */
11192 +
11193 +static void
11194 +bb_transfer(bfd_vma from, bfd_vma to, unsigned int drop_through)
11195 +{
11196 +       int i, found;
11197 +       size_t size;
11198 +       struct bb* bb = NULL;   /*stupid gcc */
11199 +       struct bb_jmp *bb_jmp;
11200 +       struct bb_reg_state *state;
11201 +       bb_reg_state_canonicalize();
11202 +       found = 0;
11203 +       for (i = 0; i < bb_jmp_count; ++i) {
11204 +               bb_jmp = bb_jmp_list + i;
11205 +               if (bb_jmp->from == from &&
11206 +                   bb_jmp->to == to &&
11207 +                   bb_jmp->drop_through == drop_through) {
11208 +                       found = 1;
11209 +                       break;
11210 +               }
11211 +       }
11212 +       if (!found) {
11213 +               /* Transfer outside the current function.  Check the special
11214 +                * cases (mainly in entry.S) first.  If it is not a known
11215 +                * special case then check if the target address is the start
11216 +                * of a function or not.  If it is the start of a function then
11217 +                * assume tail recursion and require that the state be the same
11218 +                * as on entry.  Otherwise assume out of line code (e.g.
11219 +                * spinlock contention path) and ignore it, the state can be
11220 +                * anything.
11221 +                */
11222 +               kdb_symtab_t symtab;
11223 +               if (bb_special_case(to))
11224 +                       return;
11225 +               kdbnearsym(to, &symtab);
11226 +               if (symtab.sym_start != to)
11227 +                       return;
11228 +               bb_sanity_check(0);
11229 +               if (bb_giveup)
11230 +                       return;
11231 +#ifdef NO_SIBLINGS
11232 +               /* Only print this message when the kernel is compiled with
11233 +                * -fno-optimize-sibling-calls.  Otherwise it would print a
11234 +                * message for every tail recursion call.  If you see the
11235 +                * message below then you probably have an assembler label that
11236 +                * is not listed in the special cases.
11237 +                */
11238 +               kdb_printf("  not matched: from "
11239 +                          kdb_bfd_vma_fmt0
11240 +                          " to " kdb_bfd_vma_fmt0
11241 +                          " drop_through %d bb_jmp[%d]\n",
11242 +                          from, to, drop_through, i);
11243 +#endif /* NO_SIBLINGS */
11244 +               return;
11245 +       }
11246 +       KDB_DEBUG_BB("  matched: from " kdb_bfd_vma_fmt0
11247 +                    " to " kdb_bfd_vma_fmt0
11248 +                    " drop_through %d bb_jmp[%d]\n",
11249 +                    from, to, drop_through, i);
11250 +       found = 0;
11251 +       for (i = 0; i < bb_count; ++i) {
11252 +               bb = bb_list[i];
11253 +               if (bb->start == to) {
11254 +                       found = 1;
11255 +                       break;
11256 +               }
11257 +       }
11258 +       BB_CHECK(!found, to, );
11259 +       /* If the register state for this arc has already been set (we are
11260 +        * rescanning the block that originates the arc) and the state is the
11261 +        * same as the previous state for this arc then this input to the
11262 +        * target block is the same as last time, so there is no need to rescan
11263 +        * the target block.
11264 +        */
11265 +       state = bb_jmp->state;
11266 +       size = bb_reg_state_size(bb_reg_state);
11267 +       if (state) {
11268 +               bb_reg_state->ref_count = state->ref_count;
11269 +               if (memcmp(state, bb_reg_state, size) == 0) {
11270 +                       KDB_DEBUG_BB("  no state change\n");
11271 +                       return;
11272 +               }
11273 +               if (--state->ref_count == 0)
11274 +                       debug_kfree(state);
11275 +               bb_jmp->state = NULL;
11276 +       }
11277 +       /* New input state is required.  To save space, check if any other arcs
11278 +        * have the same state and reuse them where possible.  The overall set
11279 +        * of inputs to the target block is now different so the target block
11280 +        * must be rescanned.
11281 +        */
11282 +       bb->changed = 1;
11283 +       for (i = 0; i < bb_jmp_count; ++i) {
11284 +               state = bb_jmp_list[i].state;
11285 +               if (!state)
11286 +                       continue;
11287 +               bb_reg_state->ref_count = state->ref_count;
11288 +               if (memcmp(state, bb_reg_state, size) == 0) {
11289 +                       KDB_DEBUG_BB("  reuse bb_jmp[%d]\n", i);
11290 +                       bb_jmp->state = state;
11291 +                       ++state->ref_count;
11292 +                       return;
11293 +               }
11294 +       }
11295 +       state = debug_kmalloc(size, GFP_ATOMIC);
11296 +       if (!state) {
11297 +               kdb_printf("\n\n%s: out of debug_kmalloc\n", __FUNCTION__);
11298 +               bb_giveup = 1;
11299 +               return;
11300 +       }
11301 +       memcpy(state, bb_reg_state, size);
11302 +       state->ref_count = 1;
11303 +       bb_jmp->state = state;
11304 +       KDB_DEBUG_BB("  new state %p\n", state);
11305 +}
11306 +
11307 +/* Isolate the processing for 'mov' so it can be used for 'xadd'/'xchg' as
11308 + * well.
11309 + *
11310 + * xadd/xchg expect this function to return BBOU_NOP for special cases,
11311 + * otherwise it returns BBOU_RSWD.  All special cases must be handled entirely
11312 + * within this function, including doing bb_read_operand or bb_write_operand
11313 + * where necessary.
11314 + */
11315 +
11316 +static enum bb_operand_usage
11317 +bb_usage_mov(const struct bb_operand *src, const struct bb_operand *dst, int l)
11318 +{
11319 +       int full_register_src, full_register_dst;
11320 +       full_register_src = bb_operand_length(src, bb_decode.opcode[l])
11321 +                           == KDB_WORD_SIZE * 8;
11322 +       full_register_dst = bb_operand_length(dst, bb_decode.opcode[l])
11323 +                           == KDB_WORD_SIZE * 8;
11324 +       /* If both src and dst are full integer registers then record the
11325 +        * register change.
11326 +        */
11327 +       if (src->reg &&
11328 +           bb_is_int_reg(src->base_rc) &&
11329 +           dst->reg &&
11330 +           bb_is_int_reg(dst->base_rc) &&
11331 +           full_register_src &&
11332 +           full_register_dst) {
11333 +               /* Special case for the code that switches stacks in
11334 +                * jprobe_return.  That code must modify RSP but it does it in
11335 +                * a well defined manner.  Do not invalidate RSP.
11336 +                */
11337 +               if (src->base_rc == BBRG_RBX &&
11338 +                   dst->base_rc == BBRG_RSP &&
11339 +                   strcmp(bb_func_name, "jprobe_return") == 0) {
11340 +                       bb_read_operand(src);
11341 +                       return BBOU_NOP;
11342 +               }
11343 +               /* math_abort takes the equivalent of a longjmp structure and
11344 +                * resets the stack.  Ignore this, it leaves RSP well defined.
11345 +                */
11346 +               if (dst->base_rc == BBRG_RSP &&
11347 +                   strcmp(bb_func_name, "math_abort") == 0) {
11348 +                       bb_read_operand(src);
11349 +                       return BBOU_NOP;
11350 +               }
11351 +               bb_reg_set_reg(dst->base_rc, src->base_rc);
11352 +               return BBOU_NOP;
11353 +       }
11354 +       /* If the move is from a full integer register to stack then record it.
11355 +        */
11356 +       if (src->reg &&
11357 +           bb_is_simple_memory(dst) &&
11358 +           bb_is_osp_defined(dst->base_rc) &&
11359 +           full_register_src) {
11360 +               /* Ugly special case.  Initializing list heads on stack causes
11361 +                * false references to stack variables when the list head is
11362 +                * used.  Static code analysis cannot detect that the list head
11363 +                * has been changed by a previous execution loop and that a
11364 +                * basic block is only executed after the list head has been
11365 +                * changed.
11366 +                *
11367 +                * These false references can result in valid stack variables
11368 +                * being incorrectly cleared on some logic paths.  Ignore
11369 +                * stores to stack variables which point to themselves or to
11370 +                * the previous word so the list head initialization is not
11371 +                * recorded.
11372 +                */
11373 +               if (bb_is_osp_defined(src->base_rc)) {
11374 +                       int stack1 = bb_reg_code_offset(src->base_rc);
11375 +                       int stack2 = bb_reg_code_offset(dst->base_rc) +
11376 +                                    dst->disp;
11377 +                       if (stack1 == stack2 ||
11378 +                           stack1 == stack2 - KDB_WORD_SIZE)
11379 +                               return BBOU_NOP;
11380 +               }
11381 +               bb_memory_set_reg(dst->base_rc, src->base_rc, dst->disp);
11382 +               return BBOU_NOP;
11383 +       }
11384 +       /* If the move is from stack to a full integer register then record it.
11385 +        */
11386 +       if (bb_is_simple_memory(src) &&
11387 +           bb_is_osp_defined(src->base_rc) &&
11388 +           dst->reg &&
11389 +           bb_is_int_reg(dst->base_rc) &&
11390 +           full_register_dst) {
11391 +#ifdef CONFIG_X86_32
11392 +               /* mov from TSS_sysenter_sp0+offset to esp to fix up the
11393 +                * sysenter stack, it leaves esp well defined.  mov
11394 +                * TSS_ysenter_sp0+offset(%esp),%esp is followed by up to 5
11395 +                * push instructions to mimic the hardware stack push.  If
11396 +                * TSS_sysenter_sp0 is offset then only 3 words will be
11397 +                * pushed.
11398 +                */
11399 +               if (dst->base_rc == BBRG_RSP &&
11400 +                   src->disp >= TSS_sysenter_sp0 &&
11401 +                   bb_is_osp_defined(BBRG_RSP)) {
11402 +                       int pushes;
11403 +                       pushes = src->disp == TSS_sysenter_sp0 ? 5 : 3;
11404 +                       bb_reg_code_set_offset(BBRG_RSP,
11405 +                               bb_reg_code_offset(BBRG_RSP) +
11406 +                                       pushes * KDB_WORD_SIZE);
11407 +                       KDB_DEBUG_BB_OFFSET(
11408 +                               bb_reg_code_offset(BBRG_RSP),
11409 +                               "  sysenter fixup, RSP",
11410 +                              "\n");
11411 +                       return BBOU_NOP;
11412 +               }
11413 +#endif /* CONFIG_X86_32 */
11414 +               bb_read_operand(src);
11415 +               bb_reg_set_memory(dst->base_rc, src->base_rc, src->disp);
11416 +               return BBOU_NOP;
11417 +       }
11418 +       /* move %gs:0x<nn>,%rsp is used to unconditionally switch to another
11419 +        * stack.  Ignore this special case, it is handled by the stack
11420 +        * unwinding code.
11421 +        */
11422 +       if (src->segment &&
11423 +           strcmp(src->segment, "%gs") == 0 &&
11424 +           dst->reg &&
11425 +           dst->base_rc == BBRG_RSP)
11426 +               return BBOU_NOP;
11427 +       /* move %reg,%reg is a nop */
11428 +       if (src->reg &&
11429 +           dst->reg &&
11430 +           !src->segment &&
11431 +           !dst->segment &&
11432 +           strcmp(src->base, dst->base) == 0)
11433 +               return BBOU_NOP;
11434 +       /* Special case for the code that switches stacks in the scheduler
11435 +        * (switch_to()).  That code must modify RSP but it does it in a well
11436 +        * defined manner.  Do not invalidate RSP.
11437 +        */
11438 +       if (dst->reg &&
11439 +           dst->base_rc == BBRG_RSP &&
11440 +           full_register_dst &&
11441 +           bb_is_scheduler_address()) {
11442 +               bb_read_operand(src);
11443 +               return BBOU_NOP;
11444 +       }
11445 +       /* Special case for the code that switches stacks in resume from
11446 +        * hibernation code.  That code must modify RSP but it does it in a
11447 +        * well defined manner.  Do not invalidate RSP.
11448 +        */
11449 +       if (src->memory &&
11450 +           dst->reg &&
11451 +           dst->base_rc == BBRG_RSP &&
11452 +           full_register_dst &&
11453 +           strcmp(bb_func_name, "restore_image") == 0) {
11454 +               bb_read_operand(src);
11455 +               return BBOU_NOP;
11456 +       }
11457 +       return BBOU_RSWD;
11458 +}
11459 +
11460 +static enum bb_operand_usage
11461 +bb_usage_xadd(const struct bb_operand *src, const struct bb_operand *dst)
11462 +{
11463 +       /* Simulate xadd as a series of instructions including mov, that way we
11464 +        * get the benefit of all the special cases already handled by
11465 +        * BBOU_MOV.
11466 +        *
11467 +        * tmp = src + dst, src = dst, dst = tmp.
11468 +        *
11469 +        * For tmp, pick a register that is undefined.  If all registers are
11470 +        * defined then pick one that is not being used by xadd.
11471 +        */
11472 +       enum bb_reg_code reg = BBRG_UNDEFINED;
11473 +       struct bb_operand tmp;
11474 +       struct bb_reg_contains save_tmp;
11475 +       enum bb_operand_usage usage;
11476 +       int undefined = 0;
11477 +       for (reg = BBRG_RAX; reg < BBRG_RAX + KDB_INT_REGISTERS; ++reg) {
11478 +               if (bb_reg_code_value(reg) == BBRG_UNDEFINED) {
11479 +                       undefined = 1;
11480 +                       break;
11481 +               }
11482 +       }
11483 +       if (!undefined) {
11484 +               for (reg = BBRG_RAX; reg < BBRG_RAX + KDB_INT_REGISTERS; ++reg) {
11485 +                       if (reg != src->base_rc &&
11486 +                           reg != src->index_rc &&
11487 +                           reg != dst->base_rc &&
11488 +                           reg != dst->index_rc &&
11489 +                           reg != BBRG_RSP)
11490 +                               break;
11491 +               }
11492 +       }
11493 +       KDB_DEBUG_BB("  %s saving tmp %s\n", __FUNCTION__, bbrg_name[reg]);
11494 +       save_tmp = bb_reg_state->contains[reg - BBRG_RAX];
11495 +       bb_reg_set_undef(reg);
11496 +       memset(&tmp, 0, sizeof(tmp));
11497 +       tmp.present = 1;
11498 +       tmp.reg = 1;
11499 +       tmp.base = debug_kmalloc(strlen(bbrg_name[reg]) + 2, GFP_ATOMIC);
11500 +       if (tmp.base) {
11501 +               tmp.base[0] = '%';
11502 +               strcpy(tmp.base + 1, bbrg_name[reg]);
11503 +       }
11504 +       tmp.base_rc = reg;
11505 +       bb_read_operand(src);
11506 +       bb_read_operand(dst);
11507 +       if (bb_usage_mov(src, dst, sizeof("xadd")-1) == BBOU_NOP)
11508 +               usage = BBOU_RSRD;
11509 +       else
11510 +               usage = BBOU_RSRDWS;
11511 +       bb_usage_mov(&tmp, dst, sizeof("xadd")-1);
11512 +       KDB_DEBUG_BB("  %s restoring tmp %s\n", __FUNCTION__, bbrg_name[reg]);
11513 +       bb_reg_state->contains[reg - BBRG_RAX] = save_tmp;
11514 +       debug_kfree(tmp.base);
11515 +       return usage;
11516 +}
11517 +
11518 +static enum bb_operand_usage
11519 +bb_usage_xchg(const struct bb_operand *src, const struct bb_operand *dst)
11520 +{
11521 +       /* Simulate xchg as a series of mov instructions, that way we get the
11522 +        * benefit of all the special cases already handled by BBOU_MOV.
11523 +        *
11524 +        * mov dst,tmp; mov src,dst; mov tmp,src;
11525 +        *
11526 +        * For tmp, pick a register that is undefined.  If all registers are
11527 +        * defined then pick one that is not being used by xchg.
11528 +        */
11529 +       enum bb_reg_code reg = BBRG_UNDEFINED;
11530 +       int rs = BBOU_RS, rd = BBOU_RD, ws = BBOU_WS, wd = BBOU_WD;
11531 +       struct bb_operand tmp;
11532 +       struct bb_reg_contains save_tmp;
11533 +       int undefined = 0;
11534 +       for (reg = BBRG_RAX; reg < BBRG_RAX + KDB_INT_REGISTERS; ++reg) {
11535 +               if (bb_reg_code_value(reg) == BBRG_UNDEFINED) {
11536 +                       undefined = 1;
11537 +                       break;
11538 +               }
11539 +       }
11540 +       if (!undefined) {
11541 +               for (reg = BBRG_RAX; reg < BBRG_RAX + KDB_INT_REGISTERS; ++reg) {
11542 +                       if (reg != src->base_rc &&
11543 +                           reg != src->index_rc &&
11544 +                           reg != dst->base_rc &&
11545 +                           reg != dst->index_rc &&
11546 +                           reg != BBRG_RSP)
11547 +                               break;
11548 +               }
11549 +       }
11550 +       KDB_DEBUG_BB("  %s saving tmp %s\n", __FUNCTION__, bbrg_name[reg]);
11551 +       save_tmp = bb_reg_state->contains[reg - BBRG_RAX];
11552 +       memset(&tmp, 0, sizeof(tmp));
11553 +       tmp.present = 1;
11554 +       tmp.reg = 1;
11555 +       tmp.base = debug_kmalloc(strlen(bbrg_name[reg]) + 2, GFP_ATOMIC);
11556 +       if (tmp.base) {
11557 +               tmp.base[0] = '%';
11558 +               strcpy(tmp.base + 1, bbrg_name[reg]);
11559 +       }
11560 +       tmp.base_rc = reg;
11561 +       if (bb_usage_mov(dst, &tmp, sizeof("xchg")-1) == BBOU_NOP)
11562 +               rd = 0;
11563 +       if (bb_usage_mov(src, dst, sizeof("xchg")-1) == BBOU_NOP) {
11564 +               rs = 0;
11565 +               wd = 0;
11566 +       }
11567 +       if (bb_usage_mov(&tmp, src, sizeof("xchg")-1) == BBOU_NOP)
11568 +               ws = 0;
11569 +       KDB_DEBUG_BB("  %s restoring tmp %s\n", __FUNCTION__, bbrg_name[reg]);
11570 +       bb_reg_state->contains[reg - BBRG_RAX] = save_tmp;
11571 +       debug_kfree(tmp.base);
11572 +       return rs | rd | ws | wd;
11573 +}
11574 +
11575 +/* Invalidate all the scratch registers */
11576 +
11577 +static void
11578 +bb_invalidate_scratch_reg(void)
11579 +{
11580 +       int i, j;
11581 +       for (i = BBRG_RAX; i < BBRG_RAX + KDB_INT_REGISTERS; ++i) {
11582 +               for (j = 0; j < ARRAY_SIZE(bb_preserved_reg); ++j) {
11583 +                       if (i == bb_preserved_reg[j])
11584 +                               goto preserved;
11585 +               }
11586 +               bb_reg_set_undef(i);
11587 +preserved:
11588 +               continue;
11589 +       }
11590 +}
11591 +
11592 +static void
11593 +bb_pass2_computed_jmp(const struct bb_operand *src)
11594 +{
11595 +       unsigned long table = src->disp;
11596 +       kdb_machreg_t addr;
11597 +       while (!bb_giveup) {
11598 +               if (kdb_getword(&addr, table, sizeof(addr)))
11599 +                       return;
11600 +               if (addr < bb_func_start || addr >= bb_func_end)
11601 +                       return;
11602 +               bb_transfer(bb_curr_addr, addr, 0);
11603 +               table += KDB_WORD_SIZE;
11604 +       }
11605 +}
11606 +
11607 +/* The current instruction has been decoded and all the information is in
11608 + * bb_decode.  Based on the opcode, track any operand usage that we care about.
11609 + */
11610 +
11611 +static void
11612 +bb_usage(void)
11613 +{
11614 +       enum bb_operand_usage usage = bb_decode.match->usage;
11615 +       struct bb_operand *src = &bb_decode.src;
11616 +       struct bb_operand *dst = &bb_decode.dst;
11617 +       struct bb_operand *dst2 = &bb_decode.dst2;
11618 +       int opcode_suffix, operand_length;
11619 +
11620 +       /* First handle all the special usage cases, and map them to a generic
11621 +        * case after catering for the side effects.
11622 +        */
11623 +
11624 +       if (usage == BBOU_IMUL &&
11625 +           src->present && !dst->present && !dst2->present) {
11626 +               /* single operand imul, same effects as mul */
11627 +               usage = BBOU_MUL;
11628 +       }
11629 +
11630 +       /* AT&T syntax uses movs<l1><l2> for move with sign extension, instead
11631 +        * of the Intel movsx.  The AT&T syntax causes problems for the opcode
11632 +        * mapping; movs with sign extension needs to be treated as a generic
11633 +        * read src, write dst, but instead it falls under the movs I/O
11634 +        * instruction.  Fix it.
11635 +        */
11636 +       if (usage == BBOU_MOVS && strlen(bb_decode.opcode) > 5)
11637 +               usage = BBOU_RSWD;
11638 +
11639 +       /* This switch statement deliberately does not use 'default' at the top
11640 +        * level.  That way the compiler will complain if a new BBOU_ enum is
11641 +        * added above and not explicitly handled here.
11642 +        */
11643 +       switch (usage) {
11644 +       case BBOU_UNKNOWN:      /* drop through */
11645 +       case BBOU_RS:           /* drop through */
11646 +       case BBOU_RD:           /* drop through */
11647 +       case BBOU_RSRD:         /* drop through */
11648 +       case BBOU_WS:           /* drop through */
11649 +       case BBOU_RSWS:         /* drop through */
11650 +       case BBOU_RDWS:         /* drop through */
11651 +       case BBOU_RSRDWS:       /* drop through */
11652 +       case BBOU_WD:           /* drop through */
11653 +       case BBOU_RSWD:         /* drop through */
11654 +       case BBOU_RDWD:         /* drop through */
11655 +       case BBOU_RSRDWD:       /* drop through */
11656 +       case BBOU_WSWD:         /* drop through */
11657 +       case BBOU_RSWSWD:       /* drop through */
11658 +       case BBOU_RDWSWD:       /* drop through */
11659 +       case BBOU_RSRDWSWD:
11660 +               break;          /* ignore generic usage for now */
11661 +       case BBOU_ADD:
11662 +               /* Special case for add instructions that adjust registers
11663 +                * which are mapping the stack.
11664 +                */
11665 +               if (dst->reg && bb_is_osp_defined(dst->base_rc)) {
11666 +                       bb_adjust_osp_instruction(1);
11667 +                       usage = BBOU_RS;
11668 +               } else {
11669 +                       usage = BBOU_RSRDWD;
11670 +               }
11671 +               break;
11672 +       case BBOU_CALL:
11673 +               /* Invalidate the scratch registers.  Functions sync_regs and
11674 +                * save_v86_state are special, their return value is the new
11675 +                * stack pointer.
11676 +                */
11677 +               bb_reg_state_print(bb_reg_state);
11678 +               bb_invalidate_scratch_reg();
11679 +               if (bb_is_static_disp(src)) {
11680 +                       if (src->disp == bb_sync_regs) {
11681 +                               bb_reg_set_reg(BBRG_RAX, BBRG_RSP);
11682 +                       } else if (src->disp == bb_save_v86_state) {
11683 +                               bb_reg_set_reg(BBRG_RAX, BBRG_RSP);
11684 +                               bb_adjust_osp(BBRG_RAX, +KDB_WORD_SIZE);
11685 +                       }
11686 +               }
11687 +               usage = BBOU_NOP;
11688 +               break;
11689 +       case BBOU_CBW:
11690 +               /* Convert word in RAX.  Read RAX, write RAX */
11691 +               bb_reg_read(BBRG_RAX);
11692 +               bb_reg_set_undef(BBRG_RAX);
11693 +               usage = BBOU_NOP;
11694 +               break;
11695 +       case BBOU_CMOV:
11696 +               /* cmove %gs:0x<nn>,%rsp is used to conditionally switch to
11697 +                * another stack.  Ignore this special case, it is handled by
11698 +                * the stack unwinding code.
11699 +                */
11700 +               if (src->segment &&
11701 +                   strcmp(src->segment, "%gs") == 0 &&
11702 +                   dst->reg &&
11703 +                   dst->base_rc == BBRG_RSP)
11704 +                       usage = BBOU_NOP;
11705 +               else
11706 +                       usage = BBOU_RSWD;
11707 +               break;
11708 +       case BBOU_CMPXCHG:
11709 +               /* Read RAX, write RAX plus src read, dst write */
11710 +               bb_reg_read(BBRG_RAX);
11711 +               bb_reg_set_undef(BBRG_RAX);
11712 +               usage = BBOU_RSWD;
11713 +               break;
11714 +       case BBOU_CMPXCHGD:
11715 +               /* Read RAX, RBX, RCX, RDX, write RAX, RDX plus src read/write */
11716 +               bb_reg_read(BBRG_RAX);
11717 +               bb_reg_read(BBRG_RBX);
11718 +               bb_reg_read(BBRG_RCX);
11719 +               bb_reg_read(BBRG_RDX);
11720 +               bb_reg_set_undef(BBRG_RAX);
11721 +               bb_reg_set_undef(BBRG_RDX);
11722 +               usage = BBOU_RSWS;
11723 +               break;
11724 +       case BBOU_CPUID:
11725 +               /* Read RAX, write RAX, RBX, RCX, RDX */
11726 +               bb_reg_read(BBRG_RAX);
11727 +               bb_reg_set_undef(BBRG_RAX);
11728 +               bb_reg_set_undef(BBRG_RBX);
11729 +               bb_reg_set_undef(BBRG_RCX);
11730 +               bb_reg_set_undef(BBRG_RDX);
11731 +               usage = BBOU_NOP;
11732 +               break;
11733 +       case BBOU_CWD:
11734 +               /* Convert word in RAX, RDX.  Read RAX, write RDX */
11735 +               bb_reg_read(BBRG_RAX);
11736 +               bb_reg_set_undef(BBRG_RDX);
11737 +               usage = BBOU_NOP;
11738 +               break;
11739 +       case BBOU_DIV:  /* drop through */
11740 +       case BBOU_IDIV:
11741 +               /* The 8 bit variants only affect RAX, the 16, 32 and 64 bit
11742 +                * variants affect RDX as well.
11743 +                */
11744 +               switch (usage) {
11745 +               case BBOU_DIV:
11746 +                       opcode_suffix = bb_decode.opcode[3];
11747 +                       break;
11748 +               case BBOU_IDIV:
11749 +                       opcode_suffix = bb_decode.opcode[4];
11750 +                       break;
11751 +               default:
11752 +                       opcode_suffix = 'q';
11753 +                       break;
11754 +               }
11755 +               operand_length = bb_operand_length(src, opcode_suffix);
11756 +               bb_reg_read(BBRG_RAX);
11757 +               bb_reg_set_undef(BBRG_RAX);
11758 +               if (operand_length != 8) {
11759 +                       bb_reg_read(BBRG_RDX);
11760 +                       bb_reg_set_undef(BBRG_RDX);
11761 +               }
11762 +               usage = BBOU_RS;
11763 +               break;
11764 +       case BBOU_IMUL:
11765 +               /* Only the two and three operand forms get here.  The one
11766 +                * operand form is treated as mul.
11767 +                */
11768 +               if (dst2->present) {
11769 +                       /* The three operand form is a special case, read the first two
11770 +                        * operands, write the third.
11771 +                        */
11772 +                       bb_read_operand(src);
11773 +                       bb_read_operand(dst);
11774 +                       bb_write_operand(dst2);
11775 +                       usage = BBOU_NOP;
11776 +               } else {
11777 +                       usage = BBOU_RSRDWD;
11778 +               }
11779 +               break;
11780 +       case BBOU_IRET:
11781 +               bb_sanity_check(0);
11782 +               usage = BBOU_NOP;
11783 +               break;
11784 +       case BBOU_JMP:
11785 +               if (bb_is_static_disp(src))
11786 +                       bb_transfer(bb_curr_addr, src->disp, 0);
11787 +               else if (src->indirect &&
11788 +                        src->disp &&
11789 +                        src->base == NULL &&
11790 +                        src->index &&
11791 +                        src->scale == KDB_WORD_SIZE)
11792 +                       bb_pass2_computed_jmp(src);
11793 +               usage = BBOU_RS;
11794 +               break;
11795 +       case BBOU_LAHF:
11796 +               /* Write RAX */
11797 +               bb_reg_set_undef(BBRG_RAX);
11798 +               usage = BBOU_NOP;
11799 +               break;
11800 +       case BBOU_LEA:
11801 +               /* dst = src + disp.  Often used to calculate offsets into the
11802 +                * stack, so check if it uses a stack pointer.
11803 +                */
11804 +               usage = BBOU_RSWD;
11805 +               if (bb_is_simple_memory(src)) {
11806 +                      if (bb_is_osp_defined(src->base_rc)) {
11807 +                               bb_reg_set_reg(dst->base_rc, src->base_rc);
11808 +                               bb_adjust_osp_instruction(1);
11809 +                               usage = BBOU_RS;
11810 +                       } else if (src->disp == 0 &&
11811 +                                  src->base_rc == dst->base_rc) {
11812 +                               /* lea 0(%reg),%reg is generated by i386
11813 +                                * GENERIC_NOP7.
11814 +                                */
11815 +                               usage = BBOU_NOP;
11816 +                       } else if (src->disp == 4096 &&
11817 +                                  (src->base_rc == BBRG_R8 ||
11818 +                                   src->base_rc == BBRG_RDI) &&
11819 +                                  strcmp(bb_func_name, "relocate_kernel") == 0) {
11820 +                               /* relocate_kernel: setup a new stack at the
11821 +                                * end of the physical control page, using
11822 +                                * (x86_64) lea 4096(%r8),%rsp or (i386) lea
11823 +                                * 4096(%edi),%esp
11824 +                                */
11825 +                               usage = BBOU_NOP;
11826 +                       }
11827 +               }
11828 +               break;
11829 +       case BBOU_LEAVE:
11830 +               /* RSP = RBP; RBP = *(RSP); RSP += KDB_WORD_SIZE; */
11831 +               bb_reg_set_reg(BBRG_RSP, BBRG_RBP);
11832 +               if (bb_is_osp_defined(BBRG_RSP))
11833 +                       bb_reg_set_memory(BBRG_RBP, BBRG_RSP, 0);
11834 +               else
11835 +                       bb_reg_set_undef(BBRG_RBP);
11836 +               if (bb_is_osp_defined(BBRG_RSP))
11837 +                       bb_adjust_osp(BBRG_RSP, KDB_WORD_SIZE);
11838 +               /* common_interrupt uses leave in a non-standard manner */
11839 +               if (strcmp(bb_func_name, "common_interrupt") != 0)
11840 +                       bb_sanity_check(0);
11841 +               usage = BBOU_NOP;
11842 +               break;
11843 +       case BBOU_LODS:
11844 +               /* Read RSI, write RAX, RSI */
11845 +               bb_reg_read(BBRG_RSI);
11846 +               bb_reg_set_undef(BBRG_RAX);
11847 +               bb_reg_set_undef(BBRG_RSI);
11848 +               usage = BBOU_NOP;
11849 +               break;
11850 +       case BBOU_LOOP:
11851 +               /* Read and write RCX */
11852 +               bb_reg_read(BBRG_RCX);
11853 +               bb_reg_set_undef(BBRG_RCX);
11854 +               if (bb_is_static_disp(src))
11855 +                       bb_transfer(bb_curr_addr, src->disp, 0);
11856 +               usage = BBOU_NOP;
11857 +               break;
11858 +       case BBOU_LSS:
11859 +               /* lss offset(%esp),%esp leaves esp well defined */
11860 +               if (dst->reg &&
11861 +                   dst->base_rc == BBRG_RSP &&
11862 +                   bb_is_simple_memory(src) &&
11863 +                   src->base_rc == BBRG_RSP) {
11864 +                       bb_adjust_osp(BBRG_RSP, 2*KDB_WORD_SIZE + src->disp);
11865 +                       usage = BBOU_NOP;
11866 +               } else {
11867 +                       usage = BBOU_RSWD;
11868 +               }
11869 +               break;
11870 +       case BBOU_MONITOR:
11871 +               /* Read RAX, RCX, RDX */
11872 +               bb_reg_set_undef(BBRG_RAX);
11873 +               bb_reg_set_undef(BBRG_RCX);
11874 +               bb_reg_set_undef(BBRG_RDX);
11875 +               usage = BBOU_NOP;
11876 +               break;
11877 +       case BBOU_MOV:
11878 +               usage = bb_usage_mov(src, dst, sizeof("mov")-1);
11879 +               break;
11880 +       case BBOU_MOVS:
11881 +               /* Read RSI, RDI, write RSI, RDI */
11882 +               bb_reg_read(BBRG_RSI);
11883 +               bb_reg_read(BBRG_RDI);
11884 +               bb_reg_set_undef(BBRG_RSI);
11885 +               bb_reg_set_undef(BBRG_RDI);
11886 +               usage = BBOU_NOP;
11887 +               break;
11888 +       case BBOU_MUL:
11889 +               /* imul (one operand form only) or mul.  Read RAX.  If the
11890 +                * operand length is not 8 then write RDX.
11891 +                */
11892 +               if (bb_decode.opcode[0] == 'i')
11893 +                       opcode_suffix = bb_decode.opcode[4];
11894 +               else
11895 +                       opcode_suffix = bb_decode.opcode[3];
11896 +               operand_length = bb_operand_length(src, opcode_suffix);
11897 +               bb_reg_read(BBRG_RAX);
11898 +               if (operand_length != 8)
11899 +                       bb_reg_set_undef(BBRG_RDX);
11900 +               usage = BBOU_NOP;
11901 +               break;
11902 +       case BBOU_MWAIT:
11903 +               /* Read RAX, RCX */
11904 +               bb_reg_read(BBRG_RAX);
11905 +               bb_reg_read(BBRG_RCX);
11906 +               usage = BBOU_NOP;
11907 +               break;
11908 +       case BBOU_NOP:
11909 +               break;
11910 +       case BBOU_OUTS:
11911 +               /* Read RSI, RDX, write RSI */
11912 +               bb_reg_read(BBRG_RSI);
11913 +               bb_reg_read(BBRG_RDX);
11914 +               bb_reg_set_undef(BBRG_RSI);
11915 +               usage = BBOU_NOP;
11916 +               break;
11917 +       case BBOU_POP:
11918 +               /* Complicated by the fact that you can pop from top of stack
11919 +                * to a stack location, for this case the destination location
11920 +                * is calculated after adjusting RSP.  Analysis of the kernel
11921 +                * code shows that gcc only uses this strange format to get the
11922 +                * flags into a local variable, e.g. pushf; popl 0x10(%esp); so
11923 +                * I am going to ignore this special case.
11924 +                */
11925 +               usage = BBOU_WS;
11926 +               if (!bb_is_osp_defined(BBRG_RSP)) {
11927 +                       if (!bb_is_scheduler_address()) {
11928 +                               kdb_printf("pop when BBRG_RSP is undefined?\n");
11929 +                               bb_giveup = 1;
11930 +                       }
11931 +               } else {
11932 +                       if (src->reg) {
11933 +                               bb_reg_set_memory(src->base_rc, BBRG_RSP, 0);
11934 +                               usage = BBOU_NOP;
11935 +                       }
11936 +                       /* pop %rsp does not adjust rsp */
11937 +                       if (!src->reg ||
11938 +                           src->base_rc != BBRG_RSP)
11939 +                               bb_adjust_osp(BBRG_RSP, KDB_WORD_SIZE);
11940 +               }
11941 +               break;
11942 +       case BBOU_POPF:
11943 +               /* Do not care about flags, just adjust RSP */
11944 +               if (!bb_is_osp_defined(BBRG_RSP)) {
11945 +                       if (!bb_is_scheduler_address()) {
11946 +                               kdb_printf("popf when BBRG_RSP is undefined?\n");
11947 +                               bb_giveup = 1;
11948 +                       }
11949 +               } else {
11950 +                       bb_adjust_osp(BBRG_RSP, KDB_WORD_SIZE);
11951 +               }
11952 +               usage = BBOU_WS;
11953 +               break;
11954 +       case BBOU_PUSH:
11955 +               /* Complicated by the fact that you can push from a stack
11956 +                * location to top of stack, the source location is calculated
11957 +                * before adjusting RSP.  Analysis of the kernel code shows
11958 +                * that gcc only uses this strange format to restore the flags
11959 +                * from a local variable, e.g. pushl 0x10(%esp); popf; so I am
11960 +                * going to ignore this special case.
11961 +                */
11962 +               usage = BBOU_RS;
11963 +               if (!bb_is_osp_defined(BBRG_RSP)) {
11964 +                       if (!bb_is_scheduler_address()) {
11965 +                               kdb_printf("push when BBRG_RSP is undefined?\n");
11966 +                               bb_giveup = 1;
11967 +                       }
11968 +               } else {
11969 +                       bb_adjust_osp(BBRG_RSP, -KDB_WORD_SIZE);
11970 +                       if (src->reg &&
11971 +                           bb_reg_code_offset(BBRG_RSP) <= 0)
11972 +                               bb_memory_set_reg(BBRG_RSP, src->base_rc, 0);
11973 +               }
11974 +               break;
11975 +       case BBOU_PUSHF:
11976 +               /* Do not care about flags, just adjust RSP */
11977 +               if (!bb_is_osp_defined(BBRG_RSP)) {
11978 +                       if (!bb_is_scheduler_address()) {
11979 +                               kdb_printf("pushf when BBRG_RSP is undefined?\n");
11980 +                               bb_giveup = 1;
11981 +                       }
11982 +               } else {
11983 +                       bb_adjust_osp(BBRG_RSP, -KDB_WORD_SIZE);
11984 +               }
11985 +               usage = BBOU_WS;
11986 +               break;
11987 +       case BBOU_RDMSR:
11988 +               /* Read RCX, write RAX, RDX */
11989 +               bb_reg_read(BBRG_RCX);
11990 +               bb_reg_set_undef(BBRG_RAX);
11991 +               bb_reg_set_undef(BBRG_RDX);
11992 +               usage = BBOU_NOP;
11993 +               break;
11994 +       case BBOU_RDTSC:
11995 +               /* Write RAX, RDX */
11996 +               bb_reg_set_undef(BBRG_RAX);
11997 +               bb_reg_set_undef(BBRG_RDX);
11998 +               usage = BBOU_NOP;
11999 +               break;
12000 +       case BBOU_RET:
12001 +               usage = BBOU_NOP;
12002 +               /* Functions that restore state which was saved by another
12003 +                * function or build new kernel stacks.  We cannot verify what
12004 +                * is being restored so skip the sanity check.
12005 +                */
12006 +               if (strcmp(bb_func_name, "restore_image") == 0 ||
12007 +                   strcmp(bb_func_name, "relocate_kernel") == 0 ||
12008 +                   strcmp(bb_func_name, "identity_mapped") == 0 ||
12009 +                   strcmp(bb_func_name, "xen_iret_crit_fixup") == 0 ||
12010 +                   strcmp(bb_func_name, "math_abort") == 0)
12011 +                       break;
12012 +               bb_sanity_check(0);
12013 +               break;
12014 +       case BBOU_SAHF:
12015 +               /* Read RAX */
12016 +               bb_reg_read(BBRG_RAX);
12017 +               usage = BBOU_NOP;
12018 +               break;
12019 +       case BBOU_SCAS:
12020 +               /* Read RAX, RDI, write RDI */
12021 +               bb_reg_read(BBRG_RAX);
12022 +               bb_reg_read(BBRG_RDI);
12023 +               bb_reg_set_undef(BBRG_RDI);
12024 +               usage = BBOU_NOP;
12025 +               break;
12026 +       case BBOU_SUB:
12027 +               /* Special case for sub instructions that adjust registers
12028 +                * which are mapping the stack.
12029 +                */
12030 +               if (dst->reg && bb_is_osp_defined(dst->base_rc)) {
12031 +                       bb_adjust_osp_instruction(-1);
12032 +                       usage = BBOU_RS;
12033 +               } else {
12034 +                       usage = BBOU_RSRDWD;
12035 +               }
12036 +               break;
12037 +       case BBOU_SYSEXIT:
12038 +               bb_sanity_check(1);
12039 +               usage = BBOU_NOP;
12040 +               break;
12041 +       case BBOU_SYSRET:
12042 +               bb_sanity_check(1);
12043 +               usage = BBOU_NOP;
12044 +               break;
12045 +       case BBOU_WRMSR:
12046 +               /* Read RCX, RAX, RDX */
12047 +               bb_reg_read(BBRG_RCX);
12048 +               bb_reg_read(BBRG_RAX);
12049 +               bb_reg_read(BBRG_RDX);
12050 +               usage = BBOU_NOP;
12051 +               break;
12052 +       case BBOU_XADD:
12053 +               usage = bb_usage_xadd(src, dst);
12054 +               break;
12055 +       case BBOU_XCHG:
12056 +               /* i386 do_IRQ with 4K stacks does xchg %ebx,%esp; call
12057 +                * irq_handler; mov %ebx,%esp; to switch stacks.  Ignore this
12058 +                * stack switch when tracking registers, it is handled by
12059 +                * higher level backtrace code.  Convert xchg %ebx,%esp to mov
12060 +                * %esp,%ebx so the later mov %ebx,%esp becomes a NOP and the
12061 +                * stack remains defined so we can backtrace through do_IRQ's
12062 +                * stack switch.
12063 +                *
12064 +                * Ditto for do_softirq.
12065 +                */
12066 +               if (src->reg &&
12067 +                   dst->reg &&
12068 +                   src->base_rc == BBRG_RBX &&
12069 +                   dst->base_rc == BBRG_RSP &&
12070 +                   (strcmp(bb_func_name, "do_IRQ") == 0 ||
12071 +                    strcmp(bb_func_name, "do_softirq") == 0)) {
12072 +                       strcpy(bb_decode.opcode, "mov");
12073 +                       usage = bb_usage_mov(dst, src, sizeof("mov")-1);
12074 +               } else {
12075 +                       usage = bb_usage_xchg(src, dst);
12076 +               }
12077 +               break;
12078 +       case BBOU_XOR:
12079 +               /* xor %reg,%reg only counts as a register write, the original
12080 +                * contents of reg are irrelevant.
12081 +                */
12082 +               if (src->reg && dst->reg && src->base_rc == dst->base_rc)
12083 +                       usage = BBOU_WS;
12084 +               else
12085 +                       usage = BBOU_RSRDWD;
12086 +               break;
12087 +       }
12088 +
12089 +       /* The switch statement above handled all the special cases.  Every
12090 +        * opcode should now have a usage of NOP or one of the generic cases.
12091 +        */
12092 +       if (usage == BBOU_UNKNOWN || usage == BBOU_NOP) {
12093 +               /* nothing to do */
12094 +       } else if (usage >= BBOU_RS && usage <= BBOU_RSRDWSWD) {
12095 +               if (usage & BBOU_RS)
12096 +                       bb_read_operand(src);
12097 +               if (usage & BBOU_RD)
12098 +                       bb_read_operand(dst);
12099 +               if (usage & BBOU_WS)
12100 +                       bb_write_operand(src);
12101 +               if (usage & BBOU_WD)
12102 +                       bb_write_operand(dst);
12103 +       } else {
12104 +               kdb_printf("%s: opcode not fully handled\n", __FUNCTION__);
12105 +               if (!KDB_DEBUG(BB)) {
12106 +                       bb_print_opcode();
12107 +                       if (bb_decode.src.present)
12108 +                               bb_print_operand("src", &bb_decode.src);
12109 +                       if (bb_decode.dst.present)
12110 +                               bb_print_operand("dst", &bb_decode.dst);
12111 +                       if (bb_decode.dst2.present)
12112 +                               bb_print_operand("dst2", &bb_decode.dst2);
12113 +               }
12114 +               bb_giveup = 1;
12115 +       }
12116 +}
12117 +
12118 +static void
12119 +bb_parse_buffer(void)
12120 +{
12121 +       char *p, *src, *dst = NULL, *dst2 = NULL;
12122 +       int paren = 0;
12123 +       p = bb_buffer;
12124 +       memset(&bb_decode, 0, sizeof(bb_decode));
12125 +       KDB_DEBUG_BB(" '%s'\n", p);
12126 +       p += strcspn(p, ":");   /* skip address and function name+offset: */
12127 +       if (*p++ != ':') {
12128 +               kdb_printf("%s: cannot find ':' in buffer '%s'\n",
12129 +                          __FUNCTION__, bb_buffer);
12130 +               bb_giveup = 1;
12131 +               return;
12132 +       }
12133 +       p += strspn(p, " \t");  /* step to opcode */
12134 +       if (strncmp(p, "(bad)", 5) == 0)
12135 +               strcpy(p, "nop");
12136 +       /* separate any opcode prefix */
12137 +       if (strncmp(p, "lock", 4) == 0 ||
12138 +           strncmp(p, "rep", 3) == 0 ||
12139 +           strncmp(p, "rex", 3) == 0 ||
12140 +           strncmp(p, "addr", 4) == 0) {
12141 +               bb_decode.prefix = p;
12142 +               p += strcspn(p, " \t");
12143 +               *p++ = '\0';
12144 +               p += strspn(p, " \t");
12145 +       }
12146 +       bb_decode.opcode = p;
12147 +       strsep(&p, " \t");      /* step to end of opcode */
12148 +       if (bb_parse_opcode())
12149 +               return;
12150 +       if (!p)
12151 +               goto no_operands;
12152 +       p += strspn(p, " \t");  /* step to operand(s) */
12153 +       if (!*p)
12154 +               goto no_operands;
12155 +       src = p;
12156 +       p = strsep(&p, " \t");  /* strip comments after operands */
12157 +       /* split 'src','dst' but ignore ',' inside '(' ')' */
12158 +       while (*p) {
12159 +               if (*p == '(') {
12160 +                       ++paren;
12161 +               } else if (*p == ')') {
12162 +                       --paren;
12163 +               } else if (*p == ',' && paren == 0) {
12164 +                       *p = '\0';
12165 +                       if (dst)
12166 +                               dst2 = p+1;
12167 +                       else
12168 +                               dst = p+1;
12169 +               }
12170 +               ++p;
12171 +       }
12172 +       bb_parse_operand(src, &bb_decode.src);
12173 +       if (KDB_DEBUG(BB))
12174 +               bb_print_operand("src", &bb_decode.src);
12175 +       if (dst && !bb_giveup) {
12176 +               bb_parse_operand(dst, &bb_decode.dst);
12177 +               if (KDB_DEBUG(BB))
12178 +                       bb_print_operand("dst", &bb_decode.dst);
12179 +       }
12180 +       if (dst2 && !bb_giveup) {
12181 +               bb_parse_operand(dst2, &bb_decode.dst2);
12182 +               if (KDB_DEBUG(BB))
12183 +                       bb_print_operand("dst2", &bb_decode.dst2);
12184 +       }
12185 +no_operands:
12186 +       if (!bb_giveup)
12187 +               bb_usage();
12188 +}
12189 +
12190 +static int
12191 +bb_dis_pass2(PTR file, const char *fmt, ...)
12192 +{
12193 +       char *p;
12194 +       int l = strlen(bb_buffer);
12195 +       va_list ap;
12196 +       va_start(ap, fmt);
12197 +       vsnprintf(bb_buffer + l, sizeof(bb_buffer) - l, fmt, ap);
12198 +       va_end(ap);
12199 +       if ((p = strchr(bb_buffer, '\n'))) {
12200 +               *p = '\0';
12201 +               p = bb_buffer;
12202 +               p += strcspn(p, ":");
12203 +               if (*p++ == ':')
12204 +                       bb_fixup_switch_to(p);
12205 +               bb_parse_buffer();
12206 +               bb_buffer[0] = '\0';
12207 +       }
12208 +       return 0;
12209 +}
12210 +
12211 +static void
12212 +bb_printaddr_pass2(bfd_vma addr, disassemble_info *dip)
12213 +{
12214 +       kdb_symtab_t symtab;
12215 +       unsigned int offset;
12216 +       dip->fprintf_func(dip->stream, "0x%lx", addr);
12217 +       kdbnearsym(addr, &symtab);
12218 +       if (symtab.sym_name) {
12219 +               dip->fprintf_func(dip->stream, " <%s", symtab.sym_name);
12220 +               if ((offset = addr - symtab.sym_start))
12221 +                       dip->fprintf_func(dip->stream, "+0x%x", offset);
12222 +               dip->fprintf_func(dip->stream, ">");
12223 +       }
12224 +}
12225 +
12226 +/* Set the starting register and memory state for the current bb */
12227 +
12228 +static void
12229 +bb_start_block0_special(void)
12230 +{
12231 +       int i;
12232 +       short offset_address;
12233 +       enum bb_reg_code reg, value;
12234 +       struct bb_name_state *r;
12235 +       for (i = 0, r = bb_special_cases;
12236 +            i < ARRAY_SIZE(bb_special_cases);
12237 +            ++i, ++r) {
12238 +               if (bb_func_start == r->address && r->fname == NULL)
12239 +                       goto match;
12240 +       }
12241 +       return;
12242 +match:
12243 +       /* Set the running registers */
12244 +       for (reg = BBRG_RAX; reg < r->regs_size; ++reg) {
12245 +               value = r->regs[reg].value;
12246 +               if (test_bit(value, r->skip_regs.bits)) {
12247 +                       /* this regs entry is not defined for this label */
12248 +                       continue;
12249 +               }
12250 +               bb_reg_code_set_value(reg, value);
12251 +               bb_reg_code_set_offset(reg, r->regs[reg].offset);
12252 +       }
12253 +       /* Set any memory contents, e.g. pt_regs.  Adjust RSP as required. */
12254 +       offset_address = 0;
12255 +       for (i = 0; i < r->mem_size; ++i) {
12256 +               offset_address = max_t(int,
12257 +                               r->mem[i].offset_address + KDB_WORD_SIZE,
12258 +                               offset_address);
12259 +       }
12260 +       if (bb_reg_code_offset(BBRG_RSP) > -offset_address)
12261 +               bb_adjust_osp(BBRG_RSP, -offset_address - bb_reg_code_offset(BBRG_RSP));
12262 +       for (i = 0; i < r->mem_size; ++i) {
12263 +               value = r->mem[i].value;
12264 +               if (test_bit(value, r->skip_mem.bits)) {
12265 +                       /* this memory entry is not defined for this label */
12266 +                       continue;
12267 +               }
12268 +               bb_memory_set_reg_value(BBRG_RSP, r->mem[i].offset_address,
12269 +                                       value, 0);
12270 +               bb_reg_set_undef(value);
12271 +       }
12272 +       return;
12273 +}
12274 +
12275 +static void
12276 +bb_pass2_start_block(int number)
12277 +{
12278 +       int i, j, k, first, changed;
12279 +       size_t size;
12280 +       struct bb_jmp *bb_jmp;
12281 +       struct bb_reg_state *state;
12282 +       struct bb_memory_contains *c1, *c2;
12283 +       bb_reg_state->mem_count = bb_reg_state_max;
12284 +       size = bb_reg_state_size(bb_reg_state);
12285 +       memset(bb_reg_state, 0, size);
12286 +
12287 +       if (number == 0) {
12288 +               /* The first block is assumed to have well defined inputs */
12289 +               bb_start_block0();
12290 +               /* Some assembler labels have non-standard entry
12291 +                * states.
12292 +                */
12293 +               bb_start_block0_special();
12294 +               bb_reg_state_print(bb_reg_state);
12295 +               return;
12296 +       }
12297 +
12298 +       /* Merge all the input states for the current bb together */
12299 +       first = 1;
12300 +       changed = 0;
12301 +       for (i = 0; i < bb_jmp_count; ++i) {
12302 +               bb_jmp = bb_jmp_list + i;
12303 +               if (bb_jmp->to != bb_curr->start)
12304 +                       continue;
12305 +               state = bb_jmp->state;
12306 +               if (!state)
12307 +                       continue;
12308 +               if (first) {
12309 +                       size = bb_reg_state_size(state);
12310 +                       memcpy(bb_reg_state, state, size);
12311 +                       KDB_DEBUG_BB("  first state %p\n", state);
12312 +                       bb_reg_state_print(bb_reg_state);
12313 +                       first = 0;
12314 +                       continue;
12315 +               }
12316 +
12317 +               KDB_DEBUG_BB("  merging state %p\n", state);
12318 +               /* Merge the register states */
12319 +               for (j = 0; j < ARRAY_SIZE(state->contains); ++j) {
12320 +                       if (memcmp(bb_reg_state->contains + j,
12321 +                                  state->contains + j,
12322 +                                  sizeof(bb_reg_state->contains[0]))) {
12323 +                               /* Different states for this register from two
12324 +                                * or more inputs, make it undefined.
12325 +                                */
12326 +                               if (bb_reg_state->contains[j].value ==
12327 +                                   BBRG_UNDEFINED) {
12328 +                                       KDB_DEBUG_BB("  ignoring %s\n",
12329 +                                                   bbrg_name[j + BBRG_RAX]);
12330 +                               } else {
12331 +                                       bb_reg_set_undef(BBRG_RAX + j);
12332 +                                       changed = 1;
12333 +                               }
12334 +                       }
12335 +               }
12336 +
12337 +               /* Merge the memory states.  This relies on both
12338 +                * bb_reg_state->memory and state->memory being sorted in
12339 +                * descending order, with undefined entries at the end.
12340 +                */
12341 +               c1 = bb_reg_state->memory;
12342 +               c2 = state->memory;
12343 +               j = k = 0;
12344 +               while (j < bb_reg_state->mem_count &&
12345 +                      k < state->mem_count) {
12346 +                       if (c1->offset_address < c2->offset_address) {
12347 +                               KDB_DEBUG_BB_OFFSET(c2->offset_address,
12348 +                                                   "  ignoring c2->offset_address ",
12349 +                                                   "\n");
12350 +                               ++c2;
12351 +                               ++k;
12352 +                               continue;
12353 +                       }
12354 +                       if (c1->offset_address > c2->offset_address) {
12355 +                               /* Memory location is not in all input states,
12356 +                                * delete the memory location.
12357 +                                */
12358 +                               bb_delete_memory(c1->offset_address);
12359 +                               changed = 1;
12360 +                               ++c1;
12361 +                               ++j;
12362 +                               continue;
12363 +                       }
12364 +                       if (memcmp(c1, c2, sizeof(*c1))) {
12365 +                               /* Same location, different contents, delete
12366 +                                * the memory location.
12367 +                                */
12368 +                               bb_delete_memory(c1->offset_address);
12369 +                               KDB_DEBUG_BB_OFFSET(c2->offset_address,
12370 +                                                   "  ignoring c2->offset_address ",
12371 +                                                   "\n");
12372 +                               changed = 1;
12373 +                       }
12374 +                       ++c1;
12375 +                       ++c2;
12376 +                       ++j;
12377 +                       ++k;
12378 +               }
12379 +               while (j < bb_reg_state->mem_count) {
12380 +                       bb_delete_memory(c1->offset_address);
12381 +                       changed = 1;
12382 +                       ++c1;
12383 +                       ++j;
12384 +               }
12385 +       }
12386 +       if (changed) {
12387 +               KDB_DEBUG_BB("  final state\n");
12388 +               bb_reg_state_print(bb_reg_state);
12389 +       }
12390 +}
12391 +
12392 +/* We have reached the exit point from the current function, either a call to
12393 + * the next function or the instruction that was about to executed when an
12394 + * interrupt occurred.  Save the current register state in bb_exit_state.
12395 + */
12396 +
12397 +static void
12398 +bb_save_exit_state(void)
12399 +{
12400 +       size_t size;
12401 +       debug_kfree(bb_exit_state);
12402 +       bb_exit_state = NULL;
12403 +       bb_reg_state_canonicalize();
12404 +       size = bb_reg_state_size(bb_reg_state);
12405 +       bb_exit_state = debug_kmalloc(size, GFP_ATOMIC);
12406 +       if (!bb_exit_state) {
12407 +               kdb_printf("\n\n%s: out of debug_kmalloc\n", __FUNCTION__);
12408 +               bb_giveup = 1;
12409 +               return;
12410 +       }
12411 +       memcpy(bb_exit_state, bb_reg_state, size);
12412 +}
12413 +
12414 +static int
12415 +bb_pass2_do_changed_blocks(int allow_missing)
12416 +{
12417 +       int i, j, missing, changed, maxloops;
12418 +       unsigned long addr;
12419 +       struct bb_jmp *bb_jmp;
12420 +       KDB_DEBUG_BB("\n  %s: allow_missing %d\n", __FUNCTION__, allow_missing);
12421 +       /* Absolute worst case is we have to iterate over all the basic blocks
12422 +        * in an "out of order" state, each iteration losing one register or
12423 +        * memory state.  Any more loops than that is a bug.  "out of order"
12424 +        * means that the layout of blocks in memory does not match the logic
12425 +        * flow through those blocks so (for example) block 27 comes before
12426 +        * block 2.  To allow for out of order blocks, multiply maxloops by the
12427 +        * number of blocks.
12428 +        */
12429 +       maxloops = (KDB_INT_REGISTERS + bb_reg_state_max) * bb_count;
12430 +       changed = 1;
12431 +       do {
12432 +               changed = 0;
12433 +               for (i = 0; i < bb_count; ++i) {
12434 +                       bb_curr = bb_list[i];
12435 +                       if (!bb_curr->changed)
12436 +                               continue;
12437 +                       missing = 0;
12438 +                       for (j = 0, bb_jmp = bb_jmp_list;
12439 +                            j < bb_jmp_count;
12440 +                            ++j, ++bb_jmp) {
12441 +                               if (bb_jmp->to == bb_curr->start &&
12442 +                                   !bb_jmp->state)
12443 +                                       ++missing;
12444 +                       }
12445 +                       if (missing > allow_missing)
12446 +                               continue;
12447 +                       bb_curr->changed = 0;
12448 +                       changed = 1;
12449 +                       KDB_DEBUG_BB("\n  bb[%d]\n", i);
12450 +                       bb_pass2_start_block(i);
12451 +                       for (addr = bb_curr->start;
12452 +                            addr <= bb_curr->end; ) {
12453 +                               bb_curr_addr = addr;
12454 +                               if (addr == bb_exit_addr)
12455 +                                       bb_save_exit_state();
12456 +                               addr += kdba_id_printinsn(addr, &kdb_di);
12457 +                               kdb_di.fprintf_func(NULL, "\n");
12458 +                               if (bb_giveup)
12459 +                                       goto done;
12460 +                       }
12461 +                       if (!bb_exit_state) {
12462 +                               /* ATTRIB_NORET functions are a problem with
12463 +                                * the current gcc.  Allow the trailing address
12464 +                                * a bit of leaway.
12465 +                                */
12466 +                               if (addr == bb_exit_addr ||
12467 +                                   addr == bb_exit_addr + 1)
12468 +                                       bb_save_exit_state();
12469 +                       }
12470 +                       if (bb_curr->drop_through)
12471 +                               bb_transfer(bb_curr->end,
12472 +                                           bb_list[i+1]->start, 1);
12473 +               }
12474 +               if (maxloops-- == 0) {
12475 +                       kdb_printf("\n\n%s maxloops reached\n",
12476 +                                  __FUNCTION__);
12477 +                       bb_giveup = 1;
12478 +                       goto done;
12479 +               }
12480 +       } while(changed);
12481 +done:
12482 +       for (i = 0; i < bb_count; ++i) {
12483 +               bb_curr = bb_list[i];
12484 +               if (bb_curr->changed)
12485 +                       return 1;       /* more to do, increase allow_missing */
12486 +       }
12487 +       return 0;       /* all blocks done */
12488 +}
12489 +
12490 +/* Assume that the current function is a pass through function that does not
12491 + * refer to its register parameters.  Exclude known asmlinkage functions and
12492 + * assume the other functions actually use their registers.
12493 + */
12494 +
12495 +static void
12496 +bb_assume_pass_through(void)
12497 +{
12498 +       static int first_time = 1;
12499 +       if (strncmp(bb_func_name, "sys_", 4) == 0 ||
12500 +           strncmp(bb_func_name, "compat_sys_", 11) == 0 ||
12501 +           strcmp(bb_func_name, "schedule") == 0 ||
12502 +           strcmp(bb_func_name, "do_softirq") == 0 ||
12503 +           strcmp(bb_func_name, "printk") == 0 ||
12504 +           strcmp(bb_func_name, "vprintk") == 0 ||
12505 +           strcmp(bb_func_name, "preempt_schedule") == 0 ||
12506 +           strcmp(bb_func_name, "start_kernel") == 0 ||
12507 +           strcmp(bb_func_name, "csum_partial") == 0 ||
12508 +           strcmp(bb_func_name, "csum_partial_copy_generic") == 0 ||
12509 +           strcmp(bb_func_name, "math_state_restore") == 0 ||
12510 +           strcmp(bb_func_name, "panic") == 0 ||
12511 +           strcmp(bb_func_name, "kdb_printf") == 0 ||
12512 +           strcmp(bb_func_name, "kdb_interrupt") == 0)
12513 +               return;
12514 +       if (bb_asmlinkage_arch())
12515 +               return;
12516 +       bb_reg_params = REGPARM;
12517 +       if (first_time) {
12518 +               kdb_printf("  %s has memory parameters but no register "
12519 +                          "parameters.\n  Assuming it is a 'pass "
12520 +                          "through' function that does not refer to "
12521 +                          "its register\n  parameters and setting %d "
12522 +                          "register parameters\n",
12523 +                          bb_func_name, REGPARM);
12524 +               first_time = 0;
12525 +               return;
12526 +       }
12527 +       kdb_printf("  Assuming %s is 'pass through' with %d register "
12528 +                  "parameters\n",
12529 +                  bb_func_name, REGPARM);
12530 +}
12531 +
12532 +static void
12533 +bb_pass2(void)
12534 +{
12535 +       int allow_missing;
12536 +       if (KDB_DEBUG(BB) | KDB_DEBUG(BB_SUMM))
12537 +               kdb_printf("%s: start\n", __FUNCTION__);
12538 +
12539 +       kdb_di.fprintf_func = bb_dis_pass2;
12540 +       kdb_di.print_address_func = bb_printaddr_pass2;
12541 +
12542 +       bb_reg_state = debug_kmalloc(sizeof(*bb_reg_state), GFP_ATOMIC);
12543 +       if (!bb_reg_state) {
12544 +               kdb_printf("\n\n%s: out of debug_kmalloc\n", __FUNCTION__);
12545 +               bb_giveup = 1;
12546 +               return;
12547 +       }
12548 +       bb_list[0]->changed = 1;
12549 +
12550 +       /* If a block does not have all its input states available then it is
12551 +        * possible for a register to initially appear to hold a known value,
12552 +        * but when other inputs are available then it becomes a variable
12553 +        * value.  The initial false state of "known" can generate false values
12554 +        * for other registers and can even make it look like stack locations
12555 +        * are being changed.
12556 +        *
12557 +        * To avoid these false positives, only process blocks which have all
12558 +        * their inputs defined.  That gives a clean depth first traversal of
12559 +        * the tree, except for loops.  If there are any loops, then start
12560 +        * processing blocks with one missing input, then two missing inputs
12561 +        * etc.
12562 +        *
12563 +        * Absolute worst case is we have to iterate over all the jmp entries,
12564 +        * each iteration allowing one more missing input.  Any more loops than
12565 +        * that is a bug.  Watch out for the corner case of 0 jmp entries.
12566 +        */
12567 +       for (allow_missing = 0; allow_missing <= bb_jmp_count; ++allow_missing) {
12568 +               if (!bb_pass2_do_changed_blocks(allow_missing))
12569 +                       break;
12570 +               if (bb_giveup)
12571 +                       break;
12572 +       }
12573 +       if (allow_missing > bb_jmp_count) {
12574 +               kdb_printf("\n\n%s maxloops reached\n",
12575 +                          __FUNCTION__);
12576 +               bb_giveup = 1;
12577 +               return;
12578 +       }
12579 +
12580 +       if (bb_memory_params && bb_reg_params)
12581 +               bb_reg_params = REGPARM;
12582 +       if (REGPARM &&
12583 +           bb_memory_params &&
12584 +           !bb_reg_params)
12585 +               bb_assume_pass_through();
12586 +       if (KDB_DEBUG(BB) | KDB_DEBUG(BB_SUMM)) {
12587 +               kdb_printf("%s: end bb_reg_params %d bb_memory_params %d\n",
12588 +                          __FUNCTION__, bb_reg_params, bb_memory_params);
12589 +               if (bb_exit_state) {
12590 +                       kdb_printf("%s: bb_exit_state at " kdb_bfd_vma_fmt0 "\n",
12591 +                                  __FUNCTION__, bb_exit_addr);
12592 +                       bb_do_reg_state_print(bb_exit_state);
12593 +               }
12594 +       }
12595 +}
12596 +
12597 +static void
12598 +bb_cleanup(void)
12599 +{
12600 +       int i;
12601 +       struct bb* bb;
12602 +       struct bb_reg_state *state;
12603 +       while (bb_count) {
12604 +               bb = bb_list[0];
12605 +               bb_delete(0);
12606 +       }
12607 +       debug_kfree(bb_list);
12608 +       bb_list = NULL;
12609 +       bb_count = bb_max = 0;
12610 +       for (i = 0; i < bb_jmp_count; ++i) {
12611 +               state = bb_jmp_list[i].state;
12612 +               if (state && --state->ref_count == 0)
12613 +                       debug_kfree(state);
12614 +       }
12615 +       debug_kfree(bb_jmp_list);
12616 +       bb_jmp_list = NULL;
12617 +       bb_jmp_count = bb_jmp_max = 0;
12618 +       debug_kfree(bb_reg_state);
12619 +       bb_reg_state = NULL;
12620 +       bb_reg_state_max = 0;
12621 +       debug_kfree(bb_exit_state);
12622 +       bb_exit_state = NULL;
12623 +       bb_reg_params = bb_memory_params = 0;
12624 +       bb_giveup = 0;
12625 +}
12626 +
12627 +static int
12628 +bb_spurious_global_label(const char *func_name)
12629 +{
12630 +       int i;
12631 +       for (i = 0; i < ARRAY_SIZE(bb_spurious); ++i) {
12632 +               if (strcmp(bb_spurious[i], func_name) == 0)
12633 +                       return 1;
12634 +       }
12635 +       return 0;
12636 +}
12637 +
12638 +/* Given the current actual register contents plus the exit state deduced from
12639 + * a basic block analysis of the current function, rollback the actual register
12640 + * contents to the values they had on entry to this function.
12641 + */
12642 +
12643 +static void
12644 +bb_actual_rollback(const struct kdb_activation_record *ar)
12645 +{
12646 +       int i, offset_address;
12647 +       struct bb_memory_contains *c;
12648 +       enum bb_reg_code reg;
12649 +       unsigned long address, osp = 0;
12650 +       struct bb_actual new[ARRAY_SIZE(bb_actual)];
12651 +
12652 +
12653 +       if (!bb_exit_state) {
12654 +               kdb_printf("%s: no bb_exit_state, cannot rollback\n",
12655 +                          __FUNCTION__);
12656 +               bb_giveup = 1;
12657 +               return;
12658 +       }
12659 +       memcpy(bb_reg_state, bb_exit_state, bb_reg_state_size(bb_exit_state));
12660 +       memset(new, 0, sizeof(new));
12661 +
12662 +       /* The most important register for obtaining saved state is rsp so get
12663 +        * its new value first.  Prefer rsp if it is valid, then other
12664 +        * registers.  Saved values of rsp in memory are unusable without a
12665 +        * register that points to memory.
12666 +        */
12667 +       if (!bb_actual_valid(BBRG_RSP)) {
12668 +               kdb_printf("%s: no starting value for RSP, cannot rollback\n",
12669 +                          __FUNCTION__);
12670 +               bb_giveup = 1;
12671 +               return;
12672 +       }
12673 +       if (KDB_DEBUG(BB) | KDB_DEBUG(BB_SUMM))
12674 +               kdb_printf("%s: rsp " kdb_bfd_vma_fmt0,
12675 +                          __FUNCTION__, bb_actual_value(BBRG_RSP));
12676 +       i = BBRG_RSP;
12677 +       if (!bb_is_osp_defined(i)) {
12678 +               for (i = BBRG_RAX; i < BBRG_RAX + KDB_INT_REGISTERS; ++i) {
12679 +                       if (bb_is_osp_defined(i) && bb_actual_valid(i))
12680 +                               break;
12681 +               }
12682 +       }
12683 +       if (bb_is_osp_defined(i) && bb_actual_valid(i)) {
12684 +               osp = new[BBRG_RSP - BBRG_RAX].value =
12685 +                     bb_actual_value(i) - bb_reg_code_offset(i);
12686 +               new[BBRG_RSP - BBRG_RAX].valid = 1;
12687 +               if (KDB_DEBUG(BB) | KDB_DEBUG(BB_SUMM))
12688 +                       kdb_printf(" -> osp " kdb_bfd_vma_fmt0 "\n", osp);
12689 +       } else {
12690 +               bb_actual_set_valid(BBRG_RSP, 0);
12691 +               if (KDB_DEBUG(BB) | KDB_DEBUG(BB_SUMM))
12692 +                       kdb_printf(" -> undefined\n");
12693 +               kdb_printf("%s: no ending value for RSP, cannot rollback\n",
12694 +                          __FUNCTION__);
12695 +               bb_giveup = 1;
12696 +               return;
12697 +       }
12698 +
12699 +       /* Now the other registers.  First look at register values that have
12700 +        * been copied to other registers.
12701 +        */
12702 +       for (i = BBRG_RAX; i < BBRG_RAX + KDB_INT_REGISTERS; ++i) {
12703 +               reg = bb_reg_code_value(i);
12704 +               if (bb_is_int_reg(reg)) {
12705 +                       new[reg - BBRG_RAX] = bb_actual[i - BBRG_RAX];
12706 +                       if (KDB_DEBUG(BB) | KDB_DEBUG(BB_SUMM)) {
12707 +                               kdb_printf("%s: %s is in %s ",
12708 +                                           __FUNCTION__,
12709 +                                           bbrg_name[reg],
12710 +                                           bbrg_name[i]);
12711 +                               if (bb_actual_valid(i))
12712 +                                       kdb_printf(" -> " kdb_bfd_vma_fmt0 "\n",
12713 +                                                   bb_actual_value(i));
12714 +                               else
12715 +                                       kdb_printf("(invalid)\n");
12716 +                       }
12717 +               }
12718 +       }
12719 +
12720 +       /* Finally register values that have been saved on stack */
12721 +       for (i = 0, c = bb_reg_state->memory;
12722 +            i < bb_reg_state->mem_count;
12723 +            ++i, ++c) {
12724 +               offset_address = c->offset_address;
12725 +               reg = c->value;
12726 +               if (!bb_is_int_reg(reg))
12727 +                       continue;
12728 +               address = osp + offset_address;
12729 +               if (address < ar->stack.logical_start ||
12730 +                   address >= ar->stack.logical_end) {
12731 +                       new[reg - BBRG_RAX].value = 0;
12732 +                       new[reg - BBRG_RAX].valid = 0;
12733 +                       if (KDB_DEBUG(BB) | KDB_DEBUG(BB_SUMM))
12734 +                               kdb_printf("%s: %s -> undefined\n",
12735 +                                          __FUNCTION__,
12736 +                                          bbrg_name[reg]);
12737 +               } else {
12738 +                       if (KDB_DEBUG(BB) | KDB_DEBUG(BB_SUMM)) {
12739 +                               kdb_printf("%s: %s -> *(osp",
12740 +                                          __FUNCTION__,
12741 +                                          bbrg_name[reg]);
12742 +                               KDB_DEBUG_BB_OFFSET_PRINTF(offset_address, "", " ");
12743 +                               kdb_printf(kdb_bfd_vma_fmt0, address);
12744 +                       }
12745 +                       new[reg - BBRG_RAX].value = *(bfd_vma *)address;
12746 +                       new[reg - BBRG_RAX].valid = 1;
12747 +                       if (KDB_DEBUG(BB) | KDB_DEBUG(BB_SUMM))
12748 +                               kdb_printf(") = " kdb_bfd_vma_fmt0 "\n",
12749 +                                          new[reg - BBRG_RAX].value);
12750 +               }
12751 +       }
12752 +
12753 +       memcpy(bb_actual, new, sizeof(bb_actual));
12754 +}
12755 +
12756 +/* Return true if the current function is an interrupt handler */
12757 +
12758 +static bool
12759 +bb_interrupt_handler(kdb_machreg_t rip)
12760 +{
12761 +       unsigned long disp8, disp32, target, addr = (unsigned long)rip;
12762 +       unsigned char code[5];
12763 +       int i;
12764 +
12765 +       for (i = 0; i < ARRAY_SIZE(bb_hardware_handlers); ++i)
12766 +               if (strcmp(bb_func_name, bb_hardware_handlers[i]) == 0)
12767 +                       return 1;
12768 +
12769 +       /* Given the large number of interrupt handlers, it is easiest to look
12770 +        * at the next instruction and see if it is a jmp to the common exit
12771 +        * routines.
12772 +        */
12773 +       if (kdb_getarea(code, addr) ||
12774 +           kdb_getword(&disp32, addr+1, 4) ||
12775 +           kdb_getword(&disp8, addr+1, 1))
12776 +               return 0;       /* not a valid code address */
12777 +       if (code[0] == 0xe9) {
12778 +               target = addr + (s32) disp32 + 5;       /* jmp disp32 */
12779 +               if (target == bb_ret_from_intr ||
12780 +                   target == bb_common_interrupt ||
12781 +                   target == bb_error_entry)
12782 +                       return 1;
12783 +       }
12784 +       if (code[0] == 0xeb) {
12785 +               target = addr + (s8) disp8 + 2;         /* jmp disp8 */
12786 +               if (target == bb_ret_from_intr ||
12787 +                   target == bb_common_interrupt ||
12788 +                   target == bb_error_entry)
12789 +                       return 1;
12790 +       }
12791 +
12792 +       return 0;
12793 +}
12794 +
12795 +/* Copy argument information that was deduced by the basic block analysis and
12796 + * rollback into the kdb stack activation record.
12797 + */
12798 +
12799 +static void
12800 +bb_arguments(struct kdb_activation_record *ar)
12801 +{
12802 +       int i;
12803 +       enum bb_reg_code reg;
12804 +       kdb_machreg_t rsp;
12805 +       ar->args = bb_reg_params + bb_memory_params;
12806 +       bitmap_zero(ar->valid.bits, KDBA_MAXARGS);
12807 +       for (i = 0; i < bb_reg_params; ++i) {
12808 +               reg = bb_param_reg[i];
12809 +               if (bb_actual_valid(reg)) {
12810 +                       ar->arg[i] = bb_actual_value(reg);
12811 +                       set_bit(i, ar->valid.bits);
12812 +               }
12813 +       }
12814 +       if (!bb_actual_valid(BBRG_RSP))
12815 +               return;
12816 +       rsp = bb_actual_value(BBRG_RSP);
12817 +       for (i = bb_reg_params; i < ar->args; ++i) {
12818 +               rsp += KDB_WORD_SIZE;
12819 +               if (kdb_getarea(ar->arg[i], rsp) == 0)
12820 +                       set_bit(i, ar->valid.bits);
12821 +       }
12822 +}
12823 +
12824 +/* Given an exit address from a function, decompose the entire function into
12825 + * basic blocks and determine the register state at the exit point.
12826 + */
12827 +
12828 +static void
12829 +kdb_bb(unsigned long exit)
12830 +{
12831 +       kdb_symtab_t symtab;
12832 +       if (!kdbnearsym(exit, &symtab)) {
12833 +               kdb_printf("%s: address " kdb_bfd_vma_fmt0 " not recognised\n",
12834 +                          __FUNCTION__, exit);
12835 +               bb_giveup = 1;
12836 +               return;
12837 +       }
12838 +       bb_exit_addr = exit;
12839 +       bb_mod_name = symtab.mod_name;
12840 +       bb_func_name = symtab.sym_name;
12841 +       bb_func_start = symtab.sym_start;
12842 +       bb_func_end = symtab.sym_end;
12843 +       /* Various global labels exist in the middle of assembler code and have
12844 +        * a non-standard state.  Ignore these labels and use the start of the
12845 +        * previous label instead.
12846 +        */
12847 +       while (bb_spurious_global_label(symtab.sym_name)) {
12848 +               if (!kdbnearsym(symtab.sym_start - 1, &symtab))
12849 +                       break;
12850 +               bb_func_start = symtab.sym_start;
12851 +       }
12852 +       bb_mod_name = symtab.mod_name;
12853 +       bb_func_name = symtab.sym_name;
12854 +       bb_func_start = symtab.sym_start;
12855 +       /* Ignore spurious labels past this point and use the next non-spurious
12856 +        * label as the end point.
12857 +        */
12858 +       if (kdbnearsym(bb_func_end, &symtab)) {
12859 +               while (bb_spurious_global_label(symtab.sym_name)) {
12860 +                       bb_func_end = symtab.sym_end;
12861 +                       if (!kdbnearsym(symtab.sym_end + 1, &symtab))
12862 +                               break;
12863 +               }
12864 +       }
12865 +       bb_pass1();
12866 +       if (!bb_giveup)
12867 +               bb_pass2();
12868 +       if (bb_giveup)
12869 +               kdb_printf("%s: " kdb_bfd_vma_fmt0
12870 +                          " [%s]%s failed at " kdb_bfd_vma_fmt0 "\n\n",
12871 +                          __FUNCTION__, exit,
12872 +                          bb_mod_name, bb_func_name, bb_curr_addr);
12873 +}
12874 +
12875 +static int
12876 +kdb_bb1(int argc, const char **argv)
12877 +{
12878 +       int diag;
12879 +       unsigned long addr;
12880 +       bb_cleanup();   /* in case previous command was interrupted */
12881 +       kdba_id_init(&kdb_di);
12882 +       if (argc != 1)
12883 +               return KDB_ARGCOUNT;
12884 +       if ((diag = kdbgetularg((char *)argv[1], &addr)))
12885 +               return diag;
12886 +       kdb_save_flags();
12887 +       kdb_flags |= KDB_DEBUG_FLAG_BB << KDB_DEBUG_FLAG_SHIFT;
12888 +       kdb_bb(addr);
12889 +       bb_cleanup();
12890 +       kdb_restore_flags();
12891 +       kdbnearsym_cleanup();
12892 +       return 0;
12893 +}
12894 +
12895 +/* Run a basic block analysis on every function in the base kernel.  Used as a
12896 + * global sanity check to find errors in the basic block code.
12897 + */
12898 +
12899 +static int
12900 +kdb_bb_all(int argc, const char **argv)
12901 +{
12902 +       loff_t pos = 0;
12903 +       const char *symname;
12904 +       unsigned long addr;
12905 +       int i, max_errors = 20;
12906 +       struct bb_name_state *r;
12907 +       kdb_printf("%s: build variables:"
12908 +                  " CCVERSION \"" __stringify(CCVERSION) "\""
12909 +#ifdef CONFIG_X86_64
12910 +                  " CONFIG_X86_64"
12911 +#endif
12912 +#ifdef CONFIG_4KSTACKS
12913 +                  " CONFIG_4KSTACKS"
12914 +#endif
12915 +#ifdef CONFIG_PREEMPT
12916 +                  " CONFIG_PREEMPT"
12917 +#endif
12918 +#ifdef CONFIG_VM86
12919 +                  " CONFIG_VM86"
12920 +#endif
12921 +#ifdef CONFIG_FRAME_POINTER
12922 +                  " CONFIG_FRAME_POINTER"
12923 +#endif
12924 +#ifdef CONFIG_TRACE_IRQFLAGS
12925 +                  " CONFIG_TRACE_IRQFLAGS"
12926 +#endif
12927 +#ifdef CONFIG_HIBERNATION
12928 +                  " CONFIG_HIBERNATION"
12929 +#endif
12930 +#ifdef CONFIG_KPROBES
12931 +                  " CONFIG_KPROBES"
12932 +#endif
12933 +#ifdef CONFIG_KEXEC
12934 +                  " CONFIG_KEXEC"
12935 +#endif
12936 +#ifdef CONFIG_MATH_EMULATION
12937 +                  " CONFIG_MATH_EMULATION"
12938 +#endif
12939 +#ifdef CONFIG_XEN
12940 +                  " CONFIG_XEN"
12941 +#endif
12942 +#ifdef CONFIG_DEBUG_INFO
12943 +                  " CONFIG_DEBUG_INFO"
12944 +#endif
12945 +#ifdef NO_SIBLINGS
12946 +                  " NO_SIBLINGS"
12947 +#endif
12948 +                  " REGPARM=" __stringify(REGPARM)
12949 +                  "\n\n", __FUNCTION__);
12950 +       for (i = 0, r = bb_special_cases;
12951 +            i < ARRAY_SIZE(bb_special_cases);
12952 +            ++i, ++r) {
12953 +               if (!r->address)
12954 +                       kdb_printf("%s: cannot find special_case name %s\n",
12955 +                                  __FUNCTION__, r->name);
12956 +       }
12957 +       for (i = 0; i < ARRAY_SIZE(bb_spurious); ++i) {
12958 +               if (!kallsyms_lookup_name(bb_spurious[i]))
12959 +                       kdb_printf("%s: cannot find spurious label %s\n",
12960 +                                  __FUNCTION__, bb_spurious[i]);
12961 +       }
12962 +       while ((symname = kdb_walk_kallsyms(&pos))) {
12963 +               if (strcmp(symname, "_stext") == 0 ||
12964 +                   strcmp(symname, "stext") == 0)
12965 +                       break;
12966 +       }
12967 +       if (!symname) {
12968 +               kdb_printf("%s: cannot find _stext\n", __FUNCTION__);
12969 +               return 0;
12970 +       }
12971 +       kdba_id_init(&kdb_di);
12972 +       i = 0;
12973 +       while ((symname = kdb_walk_kallsyms(&pos))) {
12974 +               if (strcmp(symname, "_etext") == 0)
12975 +                       break;
12976 +               if (i++ % 100 == 0)
12977 +                       kdb_printf(".");
12978 +               /* x86_64 has some 16 bit functions that appear between stext
12979 +                * and _etext.  Skip them.
12980 +                */
12981 +               if (strcmp(symname, "verify_cpu") == 0 ||
12982 +                   strcmp(symname, "verify_cpu_noamd") == 0 ||
12983 +                   strcmp(symname, "verify_cpu_sse_test") == 0 ||
12984 +                   strcmp(symname, "verify_cpu_no_longmode") == 0 ||
12985 +                   strcmp(symname, "verify_cpu_sse_ok") == 0 ||
12986 +                   strcmp(symname, "mode_seta") == 0 ||
12987 +                   strcmp(symname, "bad_address") == 0 ||
12988 +                   strcmp(symname, "wakeup_code") == 0 ||
12989 +                   strcmp(symname, "wakeup_code_start") == 0 ||
12990 +                   strcmp(symname, "wakeup_start") == 0 ||
12991 +                   strcmp(symname, "wakeup_32_vector") == 0 ||
12992 +                   strcmp(symname, "wakeup_32") == 0 ||
12993 +                   strcmp(symname, "wakeup_long64_vector") == 0 ||
12994 +                   strcmp(symname, "wakeup_long64") == 0 ||
12995 +                   strcmp(symname, "gdta") == 0 ||
12996 +                   strcmp(symname, "idt_48a") == 0 ||
12997 +                   strcmp(symname, "gdt_48a") == 0 ||
12998 +                   strcmp(symname, "bogus_real_magic") == 0 ||
12999 +                   strcmp(symname, "bogus_64_magic") == 0 ||
13000 +                   strcmp(symname, "no_longmode") == 0 ||
13001 +                   strcmp(symname, "mode_set") == 0 ||
13002 +                   strcmp(symname, "mode_seta") == 0 ||
13003 +                   strcmp(symname, "setbada") == 0 ||
13004 +                   strcmp(symname, "check_vesa") == 0 ||
13005 +                   strcmp(symname, "check_vesaa") == 0 ||
13006 +                   strcmp(symname, "_setbada") == 0 ||
13007 +                   strcmp(symname, "wakeup_stack_begin") == 0 ||
13008 +                   strcmp(symname, "wakeup_stack") == 0 ||
13009 +                   strcmp(symname, "wakeup_level4_pgt") == 0 ||
13010 +                   strcmp(symname, "acpi_copy_wakeup_routine") == 0 ||
13011 +                   strcmp(symname, "wakeup_end") == 0 ||
13012 +                   strcmp(symname, "do_suspend_lowlevel_s4bios") == 0 ||
13013 +                   strcmp(symname, "do_suspend_lowlevel") == 0 ||
13014 +                   strcmp(symname, "wakeup_pmode_return") == 0 ||
13015 +                   strcmp(symname, "restore_registers") == 0)
13016 +                       continue;
13017 +               /* __kprobes_text_end contains branches to the middle of code,
13018 +                * with undefined states.
13019 +                */
13020 +               if (strcmp(symname, "__kprobes_text_end") == 0)
13021 +                       continue;
13022 +               /* Data in the middle of the text segment :( */
13023 +               if (strcmp(symname, "level2_kernel_pgt") == 0 ||
13024 +                   strcmp(symname, "level3_kernel_pgt") == 0)
13025 +                       continue;
13026 +               if (bb_spurious_global_label(symname))
13027 +                       continue;
13028 +               if ((addr = kallsyms_lookup_name(symname)) == 0)
13029 +                       continue;
13030 +               // kdb_printf("BB " kdb_bfd_vma_fmt0 " %s\n", addr, symname);
13031 +               bb_cleanup();   /* in case previous command was interrupted */
13032 +               kdbnearsym_cleanup();
13033 +               kdb_bb(addr);
13034 +               touch_nmi_watchdog();
13035 +               if (bb_giveup) {
13036 +                       if (max_errors-- == 0) {
13037 +                               kdb_printf("%s: max_errors reached, giving up\n",
13038 +                                          __FUNCTION__);
13039 +                               break;
13040 +                       } else {
13041 +                               bb_giveup = 0;
13042 +                       }
13043 +               }
13044 +       }
13045 +       kdb_printf("\n");
13046 +       bb_cleanup();
13047 +       kdbnearsym_cleanup();
13048 +       return 0;
13049 +}
13050 +
13051 +/*
13052 + *=============================================================================
13053 + *
13054 + * Everything above this line is doing basic block analysis, function by
13055 + * function.  Everything below this line uses the basic block data to do a
13056 + * complete backtrace over all functions that are used by a process.
13057 + *
13058 + *=============================================================================
13059 + */
13060 +
13061 +
13062 +/*============================================================================*/
13063 +/*                                                                            */
13064 +/* Most of the backtrace code and data is common to x86_64 and i386.  This    */
13065 +/* large ifdef contains all of the differences between the two architectures. */
13066 +/*                                                                            */
13067 +/* Make sure you update the correct section of this ifdef.                    */
13068 +/*                                                                            */
13069 +/*============================================================================*/
13070 +#define XCS "cs"
13071 +#define RSP "sp"
13072 +#define RIP "ip"
13073 +#define ARCH_RSP sp
13074 +#define ARCH_RIP ip
13075 +
13076 +#ifdef CONFIG_X86_64
13077 +
13078 +#define ARCH_NORMAL_PADDING (16 * 8)
13079 +
13080 +/* x86_64 has multiple alternate stacks, with different sizes and different
13081 + * offsets to get the link from one stack to the next.  Some of the stacks are
13082 + * referenced via cpu_pda, some via per_cpu orig_ist.  Debug events can even
13083 + * have multiple nested stacks within the single physical stack, each nested
13084 + * stack has its own link and some of those links are wrong.
13085 + *
13086 + * Consistent it's not!
13087 + *
13088 + * Do not assume that these stacks are aligned on their size.
13089 + */
13090 +#define INTERRUPT_STACK (N_EXCEPTION_STACKS + 1)
13091 +void
13092 +kdba_get_stack_info_alternate(kdb_machreg_t addr, int cpu,
13093 +                             struct kdb_activation_record *ar)
13094 +{
13095 +       static struct {
13096 +               const char *id;
13097 +               unsigned int total_size;
13098 +               unsigned int nested_size;
13099 +               unsigned int next;
13100 +       } *sdp, stack_data[] = {
13101 +               [STACKFAULT_STACK - 1] =  { "stackfault",    EXCEPTION_STKSZ, EXCEPTION_STKSZ, EXCEPTION_STKSZ - 2*sizeof(void *) },
13102 +               [DOUBLEFAULT_STACK - 1] = { "doublefault",   EXCEPTION_STKSZ, EXCEPTION_STKSZ, EXCEPTION_STKSZ - 2*sizeof(void *) },
13103 +               [NMI_STACK - 1] =         { "nmi",           EXCEPTION_STKSZ, EXCEPTION_STKSZ, EXCEPTION_STKSZ - 2*sizeof(void *) },
13104 +               [DEBUG_STACK - 1] =       { "debug",         DEBUG_STKSZ,     EXCEPTION_STKSZ, EXCEPTION_STKSZ - 2*sizeof(void *) },
13105 +               [MCE_STACK - 1] =         { "machine check", EXCEPTION_STKSZ, EXCEPTION_STKSZ, EXCEPTION_STKSZ - 2*sizeof(void *) },
13106 +               [INTERRUPT_STACK - 1] =   { "interrupt",     IRQSTACKSIZE,    IRQSTACKSIZE,    IRQSTACKSIZE    -   sizeof(void *) },
13107 +       };
13108 +       unsigned long total_start = 0, total_size, total_end;
13109 +       int sd, found = 0;
13110 +       extern unsigned long kdba_orig_ist(int, int);
13111 +
13112 +       for (sd = 0, sdp = stack_data;
13113 +            sd < ARRAY_SIZE(stack_data);
13114 +            ++sd, ++sdp) {
13115 +               total_size = sdp->total_size;
13116 +               if (!total_size)
13117 +                       continue;       /* in case stack_data[] has any holes */
13118 +               if (cpu < 0) {
13119 +                       /* Arbitrary address which can be on any cpu, see if it
13120 +                        * falls within any of the alternate stacks
13121 +                        */
13122 +                       int c;
13123 +                       for_each_online_cpu(c) {
13124 +                               if (sd == INTERRUPT_STACK - 1)
13125 +                                       total_end = (unsigned long)cpu_pda(c)->irqstackptr;
13126 +                               else
13127 +                                       total_end = per_cpu(orig_ist, c).ist[sd];
13128 +                               total_start = total_end - total_size;
13129 +                               if (addr >= total_start && addr < total_end) {
13130 +                                       found = 1;
13131 +                                       cpu = c;
13132 +                                       break;
13133 +                               }
13134 +                       }
13135 +                       if (!found)
13136 +                               continue;
13137 +               }
13138 +               /* Only check the supplied or found cpu */
13139 +               if (sd == INTERRUPT_STACK - 1)
13140 +                       total_end = (unsigned long)cpu_pda(cpu)->irqstackptr;
13141 +               else
13142 +                       total_end = per_cpu(orig_ist, cpu).ist[sd];
13143 +               total_start = total_end - total_size;
13144 +               if (addr >= total_start && addr < total_end) {
13145 +                       found = 1;
13146 +                       break;
13147 +               }
13148 +       }
13149 +       if (!found)
13150 +               return;
13151 +       /* find which nested stack the address is in */
13152 +       while (addr > total_start + sdp->nested_size)
13153 +               total_start += sdp->nested_size;
13154 +       ar->stack.physical_start = total_start;
13155 +       ar->stack.physical_end = total_start + sdp->nested_size;
13156 +       ar->stack.logical_start = total_start;
13157 +       ar->stack.logical_end = total_start + sdp->next;
13158 +       ar->stack.next = *(unsigned long *)ar->stack.logical_end;
13159 +       ar->stack.id = sdp->id;
13160 +
13161 +       /* Nasty: when switching to the interrupt stack, the stack state of the
13162 +        * caller is split over two stacks, the original stack and the
13163 +        * interrupt stack.  One word (the previous frame pointer) is stored on
13164 +        * the interrupt stack, the rest of the interrupt data is in the old
13165 +        * frame.  To make the interrupted stack state look as though it is
13166 +        * contiguous, copy the missing word from the interrupt stack to the
13167 +        * original stack and adjust the new stack pointer accordingly.
13168 +        */
13169 +
13170 +       if (sd == INTERRUPT_STACK - 1) {
13171 +               *(unsigned long *)(ar->stack.next - KDB_WORD_SIZE) =
13172 +                       ar->stack.next;
13173 +               ar->stack.next -= KDB_WORD_SIZE;
13174 +       }
13175 +}
13176 +
13177 +/* rip is not in the thread struct for x86_64.  We know that the stack value
13178 + * was saved in schedule near the label thread_return.  Setting rip to
13179 + * thread_return lets the stack trace find that we are in schedule and
13180 + * correctly decode its prologue.
13181 + */
13182 +
13183 +static kdb_machreg_t
13184 +kdba_bt_stack_rip(const struct task_struct *p)
13185 +{
13186 +       return bb_thread_return;
13187 +}
13188 +
13189 +#else  /* !CONFIG_X86_64 */
13190 +
13191 +#define ARCH_NORMAL_PADDING (19 * 4)
13192 +
13193 +#ifdef CONFIG_4KSTACKS
13194 +static struct thread_info **kdba_hardirq_ctx, **kdba_softirq_ctx;
13195 +#endif /* CONFIG_4KSTACKS */
13196 +
13197 +/* On a 4K stack kernel, hardirq_ctx and softirq_ctx are [NR_CPUS] arrays.  The
13198 + * first element of each per-cpu stack is a struct thread_info.
13199 + */
13200 +void
13201 +kdba_get_stack_info_alternate(kdb_machreg_t addr, int cpu,
13202 +                             struct kdb_activation_record *ar)
13203 +{
13204 +#ifdef CONFIG_4KSTACKS
13205 +       struct thread_info *tinfo;
13206 +       tinfo = (struct thread_info *)(addr & -THREAD_SIZE);
13207 +       if (cpu < 0) {
13208 +               /* Arbitrary address, see if it falls within any of the irq
13209 +                * stacks
13210 +                */
13211 +               int found = 0;
13212 +               for_each_online_cpu(cpu) {
13213 +                       if (tinfo == kdba_hardirq_ctx[cpu] ||
13214 +                           tinfo == kdba_softirq_ctx[cpu]) {
13215 +                               found = 1;
13216 +                               break;
13217 +                       }
13218 +               }
13219 +               if (!found)
13220 +                       return;
13221 +       }
13222 +       if (tinfo == kdba_hardirq_ctx[cpu] ||
13223 +           tinfo == kdba_softirq_ctx[cpu]) {
13224 +               ar->stack.physical_start = (kdb_machreg_t)tinfo;
13225 +               ar->stack.physical_end = ar->stack.physical_start + THREAD_SIZE;
13226 +               ar->stack.logical_start = ar->stack.physical_start +
13227 +                                         sizeof(struct thread_info);
13228 +               ar->stack.logical_end = ar->stack.physical_end;
13229 +               ar->stack.next = tinfo->previous_esp;
13230 +               if (tinfo == kdba_hardirq_ctx[cpu])
13231 +                       ar->stack.id = "hardirq_ctx";
13232 +               else
13233 +                       ar->stack.id = "softirq_ctx";
13234 +       }
13235 +#endif /* CONFIG_4KSTACKS */
13236 +}
13237 +
13238 +/* rip is in the thread struct for i386 */
13239 +
13240 +static kdb_machreg_t
13241 +kdba_bt_stack_rip(const struct task_struct *p)
13242 +{
13243 +       return p->thread.ip;
13244 +}
13245 +
13246 +#endif /* CONFIG_X86_64 */
13247 +
13248 +/* Given an address which claims to be on a stack, an optional cpu number and
13249 + * an optional task address, get information about the stack.
13250 + *
13251 + * t == NULL, cpu < 0 indicates an arbitrary stack address with no associated
13252 + * struct task, the address can be in an alternate stack or any task's normal
13253 + * stack.
13254 + *
13255 + * t != NULL, cpu >= 0 indicates a running task, the address can be in an
13256 + * alternate stack or that task's normal stack.
13257 + *
13258 + * t != NULL, cpu < 0 indicates a blocked task, the address can only be in that
13259 + * task's normal stack.
13260 + *
13261 + * t == NULL, cpu >= 0 is not a valid combination.
13262 + */
13263 +
13264 +static void
13265 +kdba_get_stack_info(kdb_machreg_t rsp, int cpu,
13266 +                   struct kdb_activation_record *ar,
13267 +                   const struct task_struct *t)
13268 +{
13269 +       struct thread_info *tinfo;
13270 +       struct task_struct *g, *p;
13271 +       memset(&ar->stack, 0, sizeof(ar->stack));
13272 +       if (KDB_DEBUG(ARA))
13273 +               kdb_printf("%s: " RSP "=0x%lx cpu=%d task=%p\n",
13274 +                          __FUNCTION__, rsp, cpu, t);
13275 +       if (t == NULL || cpu >= 0) {
13276 +               kdba_get_stack_info_alternate(rsp, cpu, ar);
13277 +               if (ar->stack.logical_start)
13278 +                       goto out;
13279 +       }
13280 +       rsp &= -THREAD_SIZE;
13281 +       tinfo = (struct thread_info *)rsp;
13282 +       if (t == NULL) {
13283 +               /* Arbitrary stack address without an associated task, see if
13284 +                * it falls within any normal process stack, including the idle
13285 +                * tasks.
13286 +                */
13287 +               kdb_do_each_thread(g, p) {
13288 +                       if (tinfo == task_thread_info(p)) {
13289 +                               t = p;
13290 +                               goto found;
13291 +                       }
13292 +               } kdb_while_each_thread(g, p);
13293 +               for_each_online_cpu(cpu) {
13294 +                       p = idle_task(cpu);
13295 +                       if (tinfo == task_thread_info(p)) {
13296 +                               t = p;
13297 +                               goto found;
13298 +                       }
13299 +               }
13300 +       found:
13301 +               if (KDB_DEBUG(ARA))
13302 +                       kdb_printf("%s: found task %p\n", __FUNCTION__, t);
13303 +       } else if (cpu >= 0) {
13304 +               /* running task */
13305 +               struct kdb_running_process *krp = kdb_running_process + cpu;
13306 +               if (krp->p != t || tinfo != task_thread_info(t))
13307 +                       t = NULL;
13308 +               if (KDB_DEBUG(ARA))
13309 +                       kdb_printf("%s: running task %p\n", __FUNCTION__, t);
13310 +       } else {
13311 +               /* blocked task */
13312 +               if (tinfo != task_thread_info(t))
13313 +                       t = NULL;
13314 +               if (KDB_DEBUG(ARA))
13315 +                       kdb_printf("%s: blocked task %p\n", __FUNCTION__, t);
13316 +       }
13317 +       if (t) {
13318 +               ar->stack.physical_start = rsp;
13319 +               ar->stack.physical_end = rsp + THREAD_SIZE;
13320 +               ar->stack.logical_start = rsp + sizeof(struct thread_info);
13321 +               ar->stack.logical_end = ar->stack.physical_end - ARCH_NORMAL_PADDING;
13322 +               ar->stack.next = 0;
13323 +               ar->stack.id = "normal";
13324 +       }
13325 +out:
13326 +       if (ar->stack.physical_start && KDB_DEBUG(ARA)) {
13327 +               kdb_printf("%s: ar->stack\n", __FUNCTION__);
13328 +               kdb_printf("    physical_start=0x%lx\n", ar->stack.physical_start);
13329 +               kdb_printf("    physical_end=0x%lx\n", ar->stack.physical_end);
13330 +               kdb_printf("    logical_start=0x%lx\n", ar->stack.logical_start);
13331 +               kdb_printf("    logical_end=0x%lx\n", ar->stack.logical_end);
13332 +               kdb_printf("    next=0x%lx\n", ar->stack.next);
13333 +               kdb_printf("    id=%s\n", ar->stack.id);
13334 +               kdb_printf("    set MDCOUNT %ld\n",
13335 +                          (ar->stack.physical_end - ar->stack.physical_start) /
13336 +                          KDB_WORD_SIZE);
13337 +               kdb_printf("    mds " kdb_machreg_fmt0 "\n",
13338 +                          ar->stack.physical_start);
13339 +       }
13340 +}
13341 +
13342 +static void
13343 +bt_print_one(kdb_machreg_t rip, kdb_machreg_t rsp,
13344 +             const struct kdb_activation_record *ar,
13345 +             const kdb_symtab_t *symtab, int argcount)
13346 +{
13347 +       int btsymarg = 0;
13348 +       int nosect = 0;
13349 +
13350 +       kdbgetintenv("BTSYMARG", &btsymarg);
13351 +       kdbgetintenv("NOSECT", &nosect);
13352 +
13353 +       kdb_printf(kdb_machreg_fmt0, rsp);
13354 +       kdb_symbol_print(rip, symtab,
13355 +                        KDB_SP_SPACEB|KDB_SP_VALUE);
13356 +       if (argcount && ar->args) {
13357 +               int i, argc = ar->args;
13358 +               kdb_printf(" (");
13359 +               if (argc > argcount)
13360 +                       argc = argcount;
13361 +               for (i = 0; i < argc; i++) {
13362 +                       if (i)
13363 +                               kdb_printf(", ");
13364 +                       if (test_bit(i, ar->valid.bits))
13365 +                               kdb_printf("0x%lx", ar->arg[i]);
13366 +                       else
13367 +                               kdb_printf("invalid");
13368 +               }
13369 +               kdb_printf(")");
13370 +       }
13371 +       kdb_printf("\n");
13372 +       if (symtab->sym_name) {
13373 +               if (!nosect) {
13374 +                       kdb_printf("                               %s",
13375 +                                  symtab->mod_name);
13376 +                       if (symtab->sec_name && symtab->sec_start)
13377 +                               kdb_printf(" 0x%lx 0x%lx",
13378 +                                          symtab->sec_start, symtab->sec_end);
13379 +                       kdb_printf(" 0x%lx 0x%lx\n",
13380 +                                  symtab->sym_start, symtab->sym_end);
13381 +               }
13382 +       }
13383 +       if (argcount && ar->args && btsymarg) {
13384 +               int i, argc = ar->args;
13385 +               kdb_symtab_t arg_symtab;
13386 +               for (i = 0; i < argc; i++) {
13387 +                       kdb_machreg_t arg = ar->arg[i];
13388 +                       if (test_bit(i, ar->valid.bits) &&
13389 +                           kdbnearsym(arg, &arg_symtab)) {
13390 +                               kdb_printf("                       ARG %2d ", i);
13391 +                               kdb_symbol_print(arg, &arg_symtab,
13392 +                                                KDB_SP_DEFAULT|KDB_SP_NEWLINE);
13393 +                       }
13394 +               }
13395 +       }
13396 +}
13397 +
13398 +static void
13399 +kdba_bt_new_stack(struct kdb_activation_record *ar, kdb_machreg_t *rsp,
13400 +                  int *count, int *suppress)
13401 +{
13402 +       /* Nasty: common_interrupt builds a partial pt_regs, with r15 through
13403 +        * rbx not being filled in.  It passes struct pt_regs* to do_IRQ (in
13404 +        * rdi) but the stack pointer is not adjusted to account for r15
13405 +        * through rbx.  This has two effects :-
13406 +        *
13407 +        * (1) struct pt_regs on an external interrupt actually overlaps with
13408 +        *     the local stack area used by do_IRQ.  Not only are r15-rbx
13409 +        *     undefined, the area that claims to hold their values can even
13410 +        *     change as the irq is processed.
13411 +        *
13412 +        * (2) The back stack pointer saved for the new frame is not pointing
13413 +        *     at pt_regs, it is pointing at rbx within the pt_regs passed to
13414 +        *     do_IRQ.
13415 +        *
13416 +        * There is nothing that I can do about (1) but I have to fix (2)
13417 +        * because kdb backtrace looks for the "start" address of pt_regs as it
13418 +        * walks back through the stacks.  When switching from the interrupt
13419 +        * stack to another stack, we have to assume that pt_regs has been
13420 +        * seen and turn off backtrace supression.
13421 +        */
13422 +       int probable_pt_regs = strcmp(ar->stack.id, "interrupt") == 0;
13423 +       *rsp = ar->stack.next;
13424 +       if (KDB_DEBUG(ARA))
13425 +               kdb_printf("new " RSP "=" kdb_machreg_fmt0 "\n", *rsp);
13426 +       bb_actual_set_value(BBRG_RSP, *rsp);
13427 +       kdba_get_stack_info(*rsp, -1, ar, NULL);
13428 +       if (!ar->stack.physical_start) {
13429 +               kdb_printf("+++ Cannot resolve next stack\n");
13430 +       } else if (!*suppress) {
13431 +               kdb_printf(" ======================= <%s>\n",
13432 +                          ar->stack.id);
13433 +               ++*count;
13434 +       }
13435 +       if (probable_pt_regs)
13436 +               *suppress = 0;
13437 +}
13438 +
13439 +/*
13440 + * kdba_bt_stack
13441 + *
13442 + * Inputs:
13443 + *     addr    Address provided to 'bt' command, if any.
13444 + *     argcount
13445 + *     p       Pointer to task for 'btp' command.
13446 + * Outputs:
13447 + *     None.
13448 + * Returns:
13449 + *     zero for success, a kdb diagnostic if error
13450 + * Locking:
13451 + *     none.
13452 + * Remarks:
13453 + *     Ultimately all the bt* commands come through this routine.  If
13454 + *     old_style is 0 then it uses the basic block analysis to get an accurate
13455 + *     backtrace with arguments, otherwise it falls back to the old method of
13456 + *     printing anything on stack that looks like a kernel address.
13457 + *
13458 + *     Allowing for the stack data pushed by the hardware is tricky.  We
13459 + *     deduce the presence of hardware pushed data by looking for interrupt
13460 + *     handlers, either by name or by the code that they contain.  This
13461 + *     information must be applied to the next function up the stack, because
13462 + *     the hardware data is above the saved rip for the interrupted (next)
13463 + *     function.
13464 + *
13465 + *     To make things worse, the amount of data pushed is arch specific and
13466 + *     may depend on the rsp for the next function, not the current function.
13467 + *     The number of bytes pushed by hardware cannot be calculated until we
13468 + *     are actually processing the stack for the interrupted function and have
13469 + *     its rsp.
13470 + *
13471 + *     It is also possible for an interrupt to occur in user space and for the
13472 + *     interrupt handler to also be interrupted.  Check the code selector
13473 + *     whenever the previous function is an interrupt handler and stop
13474 + *     backtracing if the interrupt was not in kernel space.
13475 + */
13476 +
13477 +static int
13478 +kdba_bt_stack(kdb_machreg_t addr, int argcount, const struct task_struct *p,
13479 +              int old_style)
13480 +{
13481 +       struct kdb_activation_record ar;
13482 +       kdb_machreg_t rip = 0, rsp = 0, prev_rsp, cs;
13483 +       kdb_symtab_t symtab;
13484 +       int rip_at_rsp = 0, count = 0, btsp = 0, suppress,
13485 +           interrupt_handler = 0, prev_interrupt_handler = 0, hardware_pushed,
13486 +           prev_noret = 0;
13487 +       struct pt_regs *regs = NULL;
13488 +
13489 +       kdbgetintenv("BTSP", &btsp);
13490 +       suppress = !btsp;
13491 +       memset(&ar, 0, sizeof(ar));
13492 +       if (old_style)
13493 +               kdb_printf("Using old style backtrace, unreliable with no arguments\n");
13494 +
13495 +       /*
13496 +        * The caller may have supplied an address at which the stack traceback
13497 +        * operation should begin.  This address is assumed by this code to
13498 +        * point to a return address on the stack to be traced back.
13499 +        *
13500 +        * Warning: type in the wrong address and you will get garbage in the
13501 +        * backtrace.
13502 +        */
13503 +       if (addr) {
13504 +               rsp = addr;
13505 +               kdb_getword(&rip, rsp, sizeof(rip));
13506 +               rip_at_rsp = 1;
13507 +               suppress = 0;
13508 +               kdba_get_stack_info(rsp, -1, &ar, NULL);
13509 +       } else {
13510 +               if (task_curr(p)) {
13511 +                       struct kdb_running_process *krp =
13512 +                           kdb_running_process + task_cpu(p);
13513 +                       kdb_machreg_t cs;
13514 +                       regs = krp->regs;
13515 +                       if (krp->seqno &&
13516 +                           krp->p == p &&
13517 +                           krp->seqno >= kdb_seqno - 1 &&
13518 +                           !KDB_NULL_REGS(regs)) {
13519 +                               /* valid saved state, continue processing */
13520 +                       } else {
13521 +                               kdb_printf
13522 +                                   ("Process did not save state, cannot backtrace\n");
13523 +                               kdb_ps1(p);
13524 +                               return 0;
13525 +                       }
13526 +                       kdba_getregcontents(XCS, regs, &cs);
13527 +                       if ((cs & 0xffff) != __KERNEL_CS) {
13528 +                               kdb_printf("Stack is not in kernel space, backtrace not available\n");
13529 +                               return 0;
13530 +                       }
13531 +                       rip = krp->arch.ARCH_RIP;
13532 +                       rsp = krp->arch.ARCH_RSP;
13533 +                       kdba_get_stack_info(rsp, kdb_process_cpu(p), &ar, p);
13534 +               } else {
13535 +                       /* Not on cpu, assume blocked.  Blocked tasks do not
13536 +                        * have pt_regs.  p->thread contains some data, alas
13537 +                        * what it contains differs between i386 and x86_64.
13538 +                        */
13539 +                       rip = kdba_bt_stack_rip(p);
13540 +                       rsp = p->thread.sp;
13541 +                       suppress = 0;
13542 +                       kdba_get_stack_info(rsp, -1, &ar, p);
13543 +               }
13544 +       }
13545 +       if (!ar.stack.physical_start) {
13546 +               kdb_printf(RSP "=0x%lx is not in a valid kernel stack, backtrace not available\n",
13547 +                          rsp);
13548 +               return 0;
13549 +       }
13550 +       memset(&bb_actual, 0, sizeof(bb_actual));
13551 +       bb_actual_set_value(BBRG_RSP, rsp);
13552 +       bb_actual_set_valid(BBRG_RSP, 1);
13553 +
13554 +       kdb_printf(RSP "%*s" RIP "%*sFunction (args)\n",
13555 +                  2*KDB_WORD_SIZE, " ",
13556 +                  2*KDB_WORD_SIZE, " ");
13557 +       if (ar.stack.next && !suppress)
13558 +               kdb_printf(" ======================= <%s>\n",
13559 +                          ar.stack.id);
13560 +
13561 +       bb_cleanup();
13562 +       /* Run through all the stacks */
13563 +       while (ar.stack.physical_start) {
13564 +               if (rip_at_rsp) {
13565 +                       rip = *(kdb_machreg_t *)rsp;
13566 +                       /* I wish that gcc was fixed to include a nop
13567 +                        * instruction after ATTRIB_NORET functions.  The lack
13568 +                        * of a nop means that the return address points to the
13569 +                        * start of next function, so fudge it to point to one
13570 +                        * byte previous.
13571 +                        *
13572 +                        * No, we cannot just decrement all rip values.
13573 +                        * Sometimes an rip legally points to the start of a
13574 +                        * function, e.g. interrupted code or hand crafted
13575 +                        * assembler.
13576 +                        */
13577 +                       if (prev_noret) {
13578 +                               kdbnearsym(rip, &symtab);
13579 +                               if (rip == symtab.sym_start) {
13580 +                                       --rip;
13581 +                                       if (KDB_DEBUG(ARA))
13582 +                                               kdb_printf("\tprev_noret, " RIP
13583 +                                                          "=0x%lx\n", rip);
13584 +                               }
13585 +                       }
13586 +               }
13587 +               kdbnearsym(rip, &symtab);
13588 +               if (old_style) {
13589 +                       if (__kernel_text_address(rip) && !suppress) {
13590 +                               bt_print_one(rip, rsp, &ar, &symtab, 0);
13591 +                               ++count;
13592 +                       }
13593 +                       if (rsp == (unsigned long)regs) {
13594 +                               if (ar.stack.next && suppress)
13595 +                                       kdb_printf(" ======================= <%s>\n",
13596 +                                                  ar.stack.id);
13597 +                               ++count;
13598 +                               suppress = 0;
13599 +                       }
13600 +                       rsp += sizeof(rip);
13601 +                       rip_at_rsp = 1;
13602 +                       if (rsp >= ar.stack.logical_end) {
13603 +                               if (!ar.stack.next)
13604 +                                       break;
13605 +                               kdba_bt_new_stack(&ar, &rsp, &count, &suppress);
13606 +                               rip_at_rsp = 0;
13607 +                               continue;
13608 +                       }
13609 +               } else {
13610 +                       /* Start each analysis with no dynamic data from the
13611 +                        * previous kdb_bb() run.
13612 +                        */
13613 +                       bb_cleanup();
13614 +                       kdb_bb(rip);
13615 +                       if (bb_giveup)
13616 +                               break;
13617 +                       prev_interrupt_handler = interrupt_handler;
13618 +                       interrupt_handler = bb_interrupt_handler(rip);
13619 +                       prev_rsp = rsp;
13620 +                       if (rip_at_rsp) {
13621 +                               if (prev_interrupt_handler) {
13622 +                                       cs = *((kdb_machreg_t *)rsp + 1) & 0xffff;
13623 +                                       hardware_pushed =
13624 +                                               bb_hardware_pushed_arch(rsp, &ar);
13625 +                               } else {
13626 +                                       cs = __KERNEL_CS;
13627 +                                       hardware_pushed = 0;
13628 +                               }
13629 +                               rsp += sizeof(rip) + hardware_pushed;
13630 +                               if (KDB_DEBUG(ARA))
13631 +                                       kdb_printf("%s: " RSP " "
13632 +                                                  kdb_machreg_fmt0
13633 +                                                  " -> " kdb_machreg_fmt0
13634 +                                                  " hardware_pushed %d"
13635 +                                                  " prev_interrupt_handler %d"
13636 +                                                  " cs 0x%lx\n",
13637 +                                                  __FUNCTION__,
13638 +                                                  prev_rsp,
13639 +                                                  rsp,
13640 +                                                  hardware_pushed,
13641 +                                                  prev_interrupt_handler,
13642 +                                                  cs);
13643 +                               if (rsp >= ar.stack.logical_end &&
13644 +                                   ar.stack.next) {
13645 +                                       kdba_bt_new_stack(&ar, &rsp, &count,
13646 +                                                          &suppress);
13647 +                                       rip_at_rsp = 0;
13648 +                                       continue;
13649 +                               }
13650 +                               bb_actual_set_value(BBRG_RSP, rsp);
13651 +                       } else {
13652 +                               cs = __KERNEL_CS;
13653 +                       }
13654 +                       rip_at_rsp = 1;
13655 +                       bb_actual_rollback(&ar);
13656 +                       if (bb_giveup)
13657 +                               break;
13658 +                       if (bb_actual_value(BBRG_RSP) < rsp) {
13659 +                               kdb_printf("%s: " RSP " is going backwards, "
13660 +                                          kdb_machreg_fmt0 " -> "
13661 +                                          kdb_machreg_fmt0 "\n",
13662 +                                          __FUNCTION__,
13663 +                                          rsp,
13664 +                                          bb_actual_value(BBRG_RSP));
13665 +                               bb_giveup = 1;
13666 +                               break;
13667 +                       }
13668 +                       bb_arguments(&ar);
13669 +                       if (!suppress) {
13670 +                               bt_print_one(rip, prev_rsp, &ar, &symtab, argcount);
13671 +                               ++count;
13672 +                       }
13673 +                       /* Functions that terminate the backtrace */
13674 +                       if (strcmp(bb_func_name, "cpu_idle") == 0 ||
13675 +                           strcmp(bb_func_name, "child_rip") == 0)
13676 +                               break;
13677 +                       if (rsp >= ar.stack.logical_end &&
13678 +                           !ar.stack.next)
13679 +                               break;
13680 +                       if (rsp <= (unsigned long)regs &&
13681 +                           bb_actual_value(BBRG_RSP) > (unsigned long)regs) {
13682 +                               if (ar.stack.next && suppress)
13683 +                                       kdb_printf(" ======================= <%s>\n",
13684 +                                                  ar.stack.id);
13685 +                               ++count;
13686 +                               suppress = 0;
13687 +                       }
13688 +                       if (cs != __KERNEL_CS) {
13689 +                               kdb_printf("Reached user space\n");
13690 +                               break;
13691 +                       }
13692 +                       rsp = bb_actual_value(BBRG_RSP);
13693 +               }
13694 +               prev_noret = bb_noret(bb_func_name);
13695 +               if (count > 200)
13696 +                       break;
13697 +       }
13698 +       if (bb_giveup)
13699 +               return 1;
13700 +       bb_cleanup();
13701 +       kdbnearsym_cleanup();
13702 +
13703 +       if (count > 200) {
13704 +               kdb_printf("bt truncated, count limit reached\n");
13705 +               return 1;
13706 +       } else if (suppress) {
13707 +               kdb_printf
13708 +                   ("bt did not find pt_regs - no trace produced.  Suggest 'set BTSP 1'\n");
13709 +               return 1;
13710 +       }
13711 +
13712 +       return 0;
13713 +}
13714 +
13715 +/*
13716 + * kdba_bt_address
13717 + *
13718 + *     Do a backtrace starting at a specified stack address.  Use this if the
13719 + *     heuristics get the stack decode wrong.
13720 + *
13721 + * Inputs:
13722 + *     addr    Address provided to 'bt' command.
13723 + *     argcount
13724 + * Outputs:
13725 + *     None.
13726 + * Returns:
13727 + *     zero for success, a kdb diagnostic if error
13728 + * Locking:
13729 + *     none.
13730 + * Remarks:
13731 + *     mds %rsp comes in handy when examining the stack to do a manual
13732 + *     traceback.
13733 + */
13734 +
13735 +int kdba_bt_address(kdb_machreg_t addr, int argcount)
13736 +{
13737 +       int ret;
13738 +       kdba_id_init(&kdb_di);                  /* kdb_bb needs this done once */
13739 +       ret = kdba_bt_stack(addr, argcount, NULL, 0);
13740 +       if (ret == 1)
13741 +               ret = kdba_bt_stack(addr, argcount, NULL, 1);
13742 +       return ret;
13743 +}
13744 +
13745 +/*
13746 + * kdba_bt_process
13747 + *
13748 + *     Do a backtrace for a specified process.
13749 + *
13750 + * Inputs:
13751 + *     p       Struct task pointer extracted by 'bt' command.
13752 + *     argcount
13753 + * Outputs:
13754 + *     None.
13755 + * Returns:
13756 + *     zero for success, a kdb diagnostic if error
13757 + * Locking:
13758 + *     none.
13759 + */
13760 +
13761 +int kdba_bt_process(const struct task_struct *p, int argcount)
13762 +{
13763 +       int ret;
13764 +       kdba_id_init(&kdb_di);                  /* kdb_bb needs this done once */
13765 +       ret = kdba_bt_stack(0, argcount, p, 0);
13766 +       if (ret == 1)
13767 +               ret = kdba_bt_stack(0, argcount, p, 1);
13768 +       return ret;
13769 +}
13770 +
13771 +static int __init kdba_bt_x86_init(void)
13772 +{
13773 +       int i, c, cp = -1;
13774 +       struct bb_name_state *r;
13775 +
13776 +       kdb_register_repeat("bb1", kdb_bb1, "<vaddr>",  "Analyse one basic block", 0, KDB_REPEAT_NONE);
13777 +       kdb_register_repeat("bb_all", kdb_bb_all, "",   "Backtrace check on all built in functions", 0, KDB_REPEAT_NONE);
13778 +
13779 +       /* Split the opcode usage table by the first letter of each set of
13780 +        * opcodes, for faster mapping of opcode to its operand usage.
13781 +        */
13782 +       for (i = 0; i < ARRAY_SIZE(bb_opcode_usage_all); ++i) {
13783 +               c = bb_opcode_usage_all[i].opcode[0] - 'a';
13784 +               if (c != cp) {
13785 +                       cp = c;
13786 +                       bb_opcode_usage[c].opcode = bb_opcode_usage_all + i;
13787 +               }
13788 +               ++bb_opcode_usage[c].size;
13789 +       }
13790 +
13791 +       bb_common_interrupt = kallsyms_lookup_name("common_interrupt");
13792 +       bb_error_entry = kallsyms_lookup_name("error_entry");
13793 +       bb_ret_from_intr = kallsyms_lookup_name("ret_from_intr");
13794 +       bb_thread_return = kallsyms_lookup_name("thread_return");
13795 +       bb_sync_regs = kallsyms_lookup_name("sync_regs");
13796 +       bb_save_v86_state = kallsyms_lookup_name("save_v86_state");
13797 +       bb__sched_text_start = kallsyms_lookup_name("__sched_text_start");
13798 +       bb__sched_text_end = kallsyms_lookup_name("__sched_text_end");
13799 +       for (i = 0, r = bb_special_cases;
13800 +            i < ARRAY_SIZE(bb_special_cases);
13801 +            ++i, ++r) {
13802 +               r->address = kallsyms_lookup_name(r->name);
13803 +       }
13804 +
13805 +#ifdef CONFIG_4KSTACKS
13806 +       kdba_hardirq_ctx = (struct thread_info **)kallsyms_lookup_name("hardirq_ctx");
13807 +       kdba_softirq_ctx = (struct thread_info **)kallsyms_lookup_name("softirq_ctx");
13808 +#endif /* CONFIG_4KSTACKS */
13809 +
13810 +       return 0;
13811 +}
13812 +
13813 +static void __exit kdba_bt_x86_exit(void)
13814 +{
13815 +       kdb_unregister("bb1");
13816 +       kdb_unregister("bb_all");
13817 +}
13818 +
13819 +module_init(kdba_bt_x86_init)
13820 +module_exit(kdba_bt_x86_exit)
13821 --- /dev/null
13822 +++ b/arch/x86/kdb/kdba_id.c
13823 @@ -0,0 +1,261 @@
13824 +/*
13825 + * Kernel Debugger Architecture Dependent Instruction Disassembly
13826 + *
13827 + * This file is subject to the terms and conditions of the GNU General Public
13828 + * License.  See the file "COPYING" in the main directory of this archive
13829 + * for more details.
13830 + *
13831 + * Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
13832 + */
13833 +
13834 +#include <stdarg.h>
13835 +#include <linux/kernel.h>
13836 +#include <linux/init.h>
13837 +#include <linux/ctype.h>
13838 +#include <linux/string.h>
13839 +#include <linux/kdb.h>
13840 +#include <linux/kdbprivate.h>
13841 +
13842 +/*
13843 + * kdba_dis_getsym
13844 + *
13845 + *     Get a symbol for the disassembler.
13846 + *
13847 + * Parameters:
13848 + *     addr    Address for which to get symbol
13849 + *     dip     Pointer to disassemble_info
13850 + * Returns:
13851 + *     0
13852 + * Locking:
13853 + * Remarks:
13854 + *     Not used for kdb.
13855 + */
13856 +
13857 +/* ARGSUSED */
13858 +static int
13859 +kdba_dis_getsym(bfd_vma addr, disassemble_info *dip)
13860 +{
13861 +
13862 +       return 0;
13863 +}
13864 +
13865 +/*
13866 + * kdba_printaddress
13867 + *
13868 + *     Print (symbolically) an address.
13869 + *
13870 + * Parameters:
13871 + *     addr    Address for which to get symbol
13872 + *     dip     Pointer to disassemble_info
13873 + *     flag    True if a ":<tab>" sequence should follow the address
13874 + * Returns:
13875 + *     0
13876 + * Locking:
13877 + * Remarks:
13878 + *
13879 + */
13880 +
13881 +/* ARGSUSED */
13882 +static void
13883 +kdba_printaddress(kdb_machreg_t addr, disassemble_info *dip, int flag)
13884 +{
13885 +       kdb_symtab_t symtab;
13886 +       int spaces = 5;
13887 +       unsigned int offset;
13888 +
13889 +       /*
13890 +        * Print a symbol name or address as necessary.
13891 +        */
13892 +       kdbnearsym(addr, &symtab);
13893 +       if (symtab.sym_name) {
13894 +               /* Do not use kdb_symbol_print here, it always does
13895 +                * kdb_printf but we want dip->fprintf_func.
13896 +                */
13897 +               dip->fprintf_func(dip->stream,
13898 +                       "0x%0*lx %s",
13899 +                       (int)(2*sizeof(addr)), addr, symtab.sym_name);
13900 +               if ((offset = addr - symtab.sym_start) == 0) {
13901 +                       spaces += 4;
13902 +               }
13903 +               else {
13904 +                       unsigned int o = offset;
13905 +                       while (o >>= 4)
13906 +                               --spaces;
13907 +                       dip->fprintf_func(dip->stream, "+0x%x", offset);
13908 +               }
13909 +
13910 +       } else {
13911 +               dip->fprintf_func(dip->stream, "0x%lx", addr);
13912 +       }
13913 +
13914 +       if (flag) {
13915 +               if (spaces < 1) {
13916 +                       spaces = 1;
13917 +               }
13918 +               dip->fprintf_func(dip->stream, ":%*s", spaces, " ");
13919 +       }
13920 +}
13921 +
13922 +/*
13923 + * kdba_dis_printaddr
13924 + *
13925 + *     Print (symbolically) an address.  Called by GNU disassembly
13926 + *     code via disassemble_info structure.
13927 + *
13928 + * Parameters:
13929 + *     addr    Address for which to get symbol
13930 + *     dip     Pointer to disassemble_info
13931 + * Returns:
13932 + *     0
13933 + * Locking:
13934 + * Remarks:
13935 + *     This function will never append ":<tab>" to the printed
13936 + *     symbolic address.
13937 + */
13938 +
13939 +static void
13940 +kdba_dis_printaddr(bfd_vma addr, disassemble_info *dip)
13941 +{
13942 +       kdba_printaddress(addr, dip, 0);
13943 +}
13944 +
13945 +/*
13946 + * kdba_dis_getmem
13947 + *
13948 + *     Fetch 'length' bytes from 'addr' into 'buf'.
13949 + *
13950 + * Parameters:
13951 + *     addr    Address for which to get symbol
13952 + *     buf     Address of buffer to fill with bytes from 'addr'
13953 + *     length  Number of bytes to fetch
13954 + *     dip     Pointer to disassemble_info
13955 + * Returns:
13956 + *     0 if data is available, otherwise error.
13957 + * Locking:
13958 + * Remarks:
13959 + *
13960 + */
13961 +
13962 +/* ARGSUSED */
13963 +static int
13964 +kdba_dis_getmem(bfd_vma addr, bfd_byte *buf, unsigned int length, disassemble_info *dip)
13965 +{
13966 +       return kdb_getarea_size(buf, addr, length);
13967 +}
13968 +
13969 +/*
13970 + * kdba_id_parsemode
13971 + *
13972 + *     Parse IDMODE environment variable string and
13973 + *     set appropriate value into "disassemble_info" structure.
13974 + *
13975 + * Parameters:
13976 + *     mode    Mode string
13977 + *     dip     Disassemble_info structure pointer
13978 + * Returns:
13979 + * Locking:
13980 + * Remarks:
13981 + *     We handle the values 'x86' and '8086' to enable either
13982 + *     32-bit instruction set or 16-bit legacy instruction set.
13983 + */
13984 +
13985 +int
13986 +kdba_id_parsemode(const char *mode, disassemble_info *dip)
13987 +{
13988 +       if (mode) {
13989 +               if (strcmp(mode, "x86_64") == 0) {
13990 +                       dip->mach = bfd_mach_x86_64;
13991 +               } else if (strcmp(mode, "x86") == 0) {
13992 +                       dip->mach = bfd_mach_i386_i386;
13993 +               } else if (strcmp(mode, "8086") == 0) {
13994 +                       dip->mach = bfd_mach_i386_i8086;
13995 +               } else {
13996 +                       return KDB_BADMODE;
13997 +               }
13998 +       }
13999 +
14000 +       return 0;
14001 +}
14002 +
14003 +/*
14004 + * kdba_check_pc
14005 + *
14006 + *     Check that the pc is satisfactory.
14007 + *
14008 + * Parameters:
14009 + *     pc      Program Counter Value.
14010 + * Returns:
14011 + *     None
14012 + * Locking:
14013 + *     None.
14014 + * Remarks:
14015 + *     Can change pc.
14016 + */
14017 +
14018 +void
14019 +kdba_check_pc(kdb_machreg_t *pc)
14020 +{
14021 +       /* No action */
14022 +}
14023 +
14024 +/*
14025 + * kdba_id_printinsn
14026 + *
14027 + *     Format and print a single instruction at 'pc'. Return the
14028 + *     length of the instruction.
14029 + *
14030 + * Parameters:
14031 + *     pc      Program Counter Value.
14032 + *     dip     Disassemble_info structure pointer
14033 + * Returns:
14034 + *     Length of instruction, -1 for error.
14035 + * Locking:
14036 + *     None.
14037 + * Remarks:
14038 + *     Depends on 'IDMODE' environment variable.
14039 + */
14040 +
14041 +int
14042 +kdba_id_printinsn(kdb_machreg_t pc, disassemble_info *dip)
14043 +{
14044 +       kdba_printaddress(pc, dip, 1);
14045 +       return print_insn_i386_att(pc, dip);
14046 +}
14047 +
14048 +/*
14049 + * kdba_id_init
14050 + *
14051 + *     Initialize the architecture dependent elements of
14052 + *     the disassembly information structure
14053 + *     for the GNU disassembler.
14054 + *
14055 + * Parameters:
14056 + *     None.
14057 + * Outputs:
14058 + *     None.
14059 + * Returns:
14060 + *     None.
14061 + * Locking:
14062 + *     None.
14063 + * Remarks:
14064 + */
14065 +
14066 +void
14067 +kdba_id_init(disassemble_info *dip)
14068 +{
14069 +       dip->read_memory_func       = kdba_dis_getmem;
14070 +       dip->print_address_func     = kdba_dis_printaddr;
14071 +       dip->symbol_at_address_func = kdba_dis_getsym;
14072 +
14073 +       dip->flavour                = bfd_target_elf_flavour;
14074 +       dip->arch                   = bfd_arch_i386;
14075 +#ifdef CONFIG_X86_64
14076 +       dip->mach                   = bfd_mach_x86_64;
14077 +#endif
14078 +#ifdef CONFIG_X86_32
14079 +       dip->mach                   = bfd_mach_i386_i386;
14080 +#endif
14081 +       dip->endian                 = BFD_ENDIAN_LITTLE;
14082 +
14083 +       dip->display_endian         = BFD_ENDIAN_LITTLE;
14084 +}
14085 --- /dev/null
14086 +++ b/arch/x86/kdb/kdba_io.c
14087 @@ -0,0 +1,609 @@
14088 +/*
14089 + * Kernel Debugger Architecture Dependent Console I/O handler
14090 + *
14091 + * This file is subject to the terms and conditions of the GNU General Public
14092 + * License.  See the file "COPYING" in the main directory of this archive
14093 + * for more details.
14094 + *
14095 + * Copyright (c) 1999-2006 Silicon Graphics, Inc.  All Rights Reserved.
14096 + */
14097 +
14098 +#include <linux/sched.h>
14099 +#include <linux/kernel.h>
14100 +#include <asm/io.h>
14101 +#include <linux/delay.h>
14102 +#include <linux/console.h>
14103 +#include <linux/ctype.h>
14104 +#include <linux/keyboard.h>
14105 +#include <linux/serial.h>
14106 +#include <linux/serial_reg.h>
14107 +
14108 +#include <linux/kdb.h>
14109 +#include <linux/kdbprivate.h>
14110 +#include <pc_keyb.h>
14111 +
14112 +#ifdef CONFIG_VT_CONSOLE
14113 +#define KDB_BLINK_LED 1
14114 +#else
14115 +#undef KDB_BLINK_LED
14116 +#endif
14117 +
14118 +#ifdef CONFIG_KDB_USB
14119 +
14120 +/* support up to 8 USB keyboards (probably excessive, but...) */
14121 +#define KDB_USB_NUM_KEYBOARDS   8
14122 +struct kdb_usb_kbd_info kdb_usb_kbds[KDB_USB_NUM_KEYBOARDS];
14123 +
14124 +extern int kdb_no_usb;
14125 +
14126 +static unsigned char kdb_usb_keycode[256] = {
14127 +         0,  0,  0,  0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
14128 +        50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44,  2,  3,
14129 +         4,  5,  6,  7,  8,  9, 10, 11, 28,  1, 14, 15, 57, 12, 13, 26,
14130 +        27, 43, 84, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
14131 +        65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
14132 +       105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
14133 +        72, 73, 82, 83, 86,127,116,117, 85, 89, 90, 91, 92, 93, 94, 95,
14134 +       120,121,122,123,134,138,130,132,128,129,131,137,133,135,136,113,
14135 +       115,114,  0,  0,  0,124,  0,181,182,183,184,185,186,187,188,189,
14136 +       190,191,192,193,194,195,196,197,198,  0,  0,  0,  0,  0,  0,  0,
14137 +         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
14138 +         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
14139 +         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
14140 +         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
14141 +        29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
14142 +       150,158,159,128,136,177,178,176,142,152,173,140
14143 +};
14144 +
14145 +/*
14146 + * kdb_usb_keyboard_attach()
14147 + * Attach a USB keyboard to kdb.
14148 + */
14149 +int
14150 +kdb_usb_keyboard_attach(struct urb *urb, unsigned char *buffer, void *poll_func)
14151 +{
14152 +        int     i;
14153 +        int     rc = -1;
14154 +
14155 +        if (kdb_no_usb)
14156 +                return 0;
14157 +
14158 +        /*
14159 +         * Search through the array of KDB USB keyboards (kdb_usb_kbds)
14160 +         * looking for a free index. If found, assign the keyboard to
14161 +         * the array index.
14162 +         */
14163 +
14164 +        for (i = 0; i < KDB_USB_NUM_KEYBOARDS; i++) {
14165 +                if (kdb_usb_kbds[i].urb) /* index is already assigned */
14166 +                        continue;
14167 +
14168 +                /* found a free array index */
14169 +                kdb_usb_kbds[i].urb = urb;
14170 +                kdb_usb_kbds[i].buffer = buffer;
14171 +                kdb_usb_kbds[i].poll_func = poll_func;
14172 +
14173 +                rc = 0; /* success */
14174 +
14175 +                break;
14176 +        }
14177 +
14178 +        return rc;
14179 +}
14180 +EXPORT_SYMBOL_GPL (kdb_usb_keyboard_attach);
14181 +
14182 +/*
14183 + * kdb_usb_keyboard_detach()
14184 + * Detach a USB keyboard from kdb.
14185 + */
14186 +int
14187 +kdb_usb_keyboard_detach(struct urb *urb)
14188 +{
14189 +        int     i;
14190 +        int     rc = -1;
14191 +
14192 +        if (kdb_no_usb)
14193 +                return 0;
14194 +
14195 +        /*
14196 +         * Search through the array of KDB USB keyboards (kdb_usb_kbds)
14197 +         * looking for the index with the matching URB. If found,
14198 +         * clear the array index.
14199 +         */
14200 +
14201 +        for (i = 0; i < KDB_USB_NUM_KEYBOARDS; i++) {
14202 +                if (kdb_usb_kbds[i].urb != urb)
14203 +                        continue;
14204 +
14205 +                /* found it, clear the index */
14206 +                kdb_usb_kbds[i].urb = NULL;
14207 +                kdb_usb_kbds[i].buffer = NULL;
14208 +                kdb_usb_kbds[i].poll_func = NULL;
14209 +                kdb_usb_kbds[i].caps_lock = 0;
14210 +
14211 +                rc = 0; /* success */
14212 +
14213 +                break;
14214 +        }
14215 +
14216 +        return rc;
14217 +}
14218 +EXPORT_SYMBOL_GPL (kdb_usb_keyboard_detach);
14219 +
14220 +/*
14221 + * get_usb_char
14222 + * This function drives the USB attached keyboards.
14223 + * Fetch the USB scancode and decode it.
14224 + */
14225 +static int
14226 +get_usb_char(void)
14227 +{
14228 +        int     i;
14229 +        int     ret;
14230 +        unsigned char keycode, spec;
14231 +        extern u_short plain_map[], shift_map[], ctrl_map[];
14232 +
14233 +        if (kdb_no_usb)
14234 +                return -1;
14235 +
14236 +        /*
14237 +         * Loop through all the USB keyboard(s) and return
14238 +         * the first character obtained from them.
14239 +         */
14240 +
14241 +        for (i = 0; i < KDB_USB_NUM_KEYBOARDS; i++) {
14242 +                /* skip uninitialized keyboard array entries */
14243 +                if (!kdb_usb_kbds[i].urb || !kdb_usb_kbds[i].buffer ||
14244 +                    !kdb_usb_kbds[i].poll_func)
14245 +                        continue;
14246 +
14247 +                /* Transfer char */
14248 +                ret = (*kdb_usb_kbds[i].poll_func)(kdb_usb_kbds[i].urb);
14249 +                if (ret == -EBUSY && kdb_usb_kbds[i].poll_ret != -EBUSY)
14250 +                        kdb_printf("NOTICE: USB HD driver BUSY. "
14251 +                            "USB keyboard has been disabled.\n");
14252 +
14253 +                kdb_usb_kbds[i].poll_ret = ret;
14254 +
14255 +                if (ret < 0) /* error or no characters, try the next kbd */
14256 +                        continue;
14257 +
14258 +                spec = kdb_usb_kbds[i].buffer[0];
14259 +                keycode = kdb_usb_kbds[i].buffer[2];
14260 +                kdb_usb_kbds[i].buffer[0] = (char)0;
14261 +                kdb_usb_kbds[i].buffer[2] = (char)0;
14262 +
14263 +                if(kdb_usb_kbds[i].buffer[3]) {
14264 +                        kdb_usb_kbds[i].buffer[3] = (char)0;
14265 +                        continue;
14266 +                }
14267 +
14268 +                /* A normal key is pressed, decode it */
14269 +                if(keycode)
14270 +                        keycode = kdb_usb_keycode[keycode];
14271 +
14272 +                /* 2 Keys pressed at one time ? */
14273 +                if (spec && keycode) {
14274 +                        switch(spec)
14275 +                        {
14276 +                        case 0x2:
14277 +                        case 0x20: /* Shift */
14278 +                                return shift_map[keycode];
14279 +                        case 0x1:
14280 +                        case 0x10: /* Ctrl */
14281 +                                return ctrl_map[keycode];
14282 +                        case 0x4:
14283 +                        case 0x40: /* Alt */
14284 +                                break;
14285 +                        }
14286 +                } else if (keycode) { /* If only one key pressed */
14287 +                        switch(keycode)
14288 +                        {
14289 +                        case 0x1C: /* Enter */
14290 +                                return 13;
14291 +
14292 +                        case 0x3A: /* Capslock */
14293 +                                kdb_usb_kbds[i].caps_lock = !(kdb_usb_kbds[i].caps_lock);
14294 +                                break;
14295 +                        case 0x0E: /* Backspace */
14296 +                                return 8;
14297 +                        case 0x0F: /* TAB */
14298 +                                return 9;
14299 +                        case 0x77: /* Pause */
14300 +                                break ;
14301 +                        default:
14302 +                                if(!kdb_usb_kbds[i].caps_lock) {
14303 +                                        return plain_map[keycode];
14304 +                                }
14305 +                                else {
14306 +                                        return shift_map[keycode];
14307 +                                }
14308 +                        }
14309 +                }
14310 +        }
14311 +
14312 +        /* no chars were returned from any of the USB keyboards */
14313 +
14314 +        return -1;
14315 +}
14316 +#endif /* CONFIG_KDB_USB */
14317 +
14318 +/*
14319 + * This module contains code to read characters from the keyboard or a serial
14320 + * port.
14321 + *
14322 + * It is used by the kernel debugger, and is polled, not interrupt driven.
14323 + *
14324 + */
14325 +
14326 +#ifdef KDB_BLINK_LED
14327 +/*
14328 + * send:  Send a byte to the keyboard controller.  Used primarily to
14329 + *       alter LED settings.
14330 + */
14331 +
14332 +static void
14333 +kdb_kbdsend(unsigned char byte)
14334 +{
14335 +       int timeout;
14336 +       for (timeout = 200 * 1000; timeout && (inb(KBD_STATUS_REG) & KBD_STAT_IBF); timeout--);
14337 +       outb(byte, KBD_DATA_REG);
14338 +       udelay(40);
14339 +       for (timeout = 200 * 1000; timeout && (~inb(KBD_STATUS_REG) & KBD_STAT_OBF); timeout--);
14340 +       inb(KBD_DATA_REG);
14341 +       udelay(40);
14342 +}
14343 +
14344 +static void
14345 +kdb_toggleled(int led)
14346 +{
14347 +       static int leds;
14348 +
14349 +       leds ^= led;
14350 +
14351 +       kdb_kbdsend(KBD_CMD_SET_LEDS);
14352 +       kdb_kbdsend((unsigned char)leds);
14353 +}
14354 +#endif /* KDB_BLINK_LED */
14355 +
14356 +#if defined(CONFIG_SERIAL_8250_CONSOLE) || defined(CONFIG_SERIAL_CORE_CONSOLE)
14357 +#define CONFIG_SERIAL_CONSOLE
14358 +#endif
14359 +
14360 +#if defined(CONFIG_SERIAL_CONSOLE)
14361 +
14362 +struct kdb_serial kdb_serial;
14363 +
14364 +static unsigned int
14365 +serial_inp(struct kdb_serial *kdb_serial, unsigned long offset)
14366 +{
14367 +       offset <<= kdb_serial->ioreg_shift;
14368 +
14369 +       switch (kdb_serial->io_type) {
14370 +       case SERIAL_IO_MEM:
14371 +               return readb((void __iomem *)(kdb_serial->iobase + offset));
14372 +               break;
14373 +       default:
14374 +               return inb(kdb_serial->iobase + offset);
14375 +               break;
14376 +       }
14377 +}
14378 +
14379 +/* Check if there is a byte ready at the serial port */
14380 +static int get_serial_char(void)
14381 +{
14382 +       unsigned char ch;
14383 +
14384 +       if (kdb_serial.iobase == 0)
14385 +               return -1;
14386 +
14387 +       if (serial_inp(&kdb_serial, UART_LSR) & UART_LSR_DR) {
14388 +               ch = serial_inp(&kdb_serial, UART_RX);
14389 +               if (ch == 0x7f)
14390 +                       ch = 8;
14391 +               return ch;
14392 +       }
14393 +       return -1;
14394 +}
14395 +#endif /* CONFIG_SERIAL_CONSOLE */
14396 +
14397 +#ifdef CONFIG_VT_CONSOLE
14398 +
14399 +static int kbd_exists;
14400 +
14401 +/*
14402 + * Check if the keyboard controller has a keypress for us.
14403 + * Some parts (Enter Release, LED change) are still blocking polled here,
14404 + * but hopefully they are all short.
14405 + */
14406 +static int get_kbd_char(void)
14407 +{
14408 +       int scancode, scanstatus;
14409 +       static int shift_lock;  /* CAPS LOCK state (0-off, 1-on) */
14410 +       static int shift_key;   /* Shift next keypress */
14411 +       static int ctrl_key;
14412 +       u_short keychar;
14413 +       extern u_short plain_map[], shift_map[], ctrl_map[];
14414 +
14415 +       if (KDB_FLAG(NO_I8042) || KDB_FLAG(NO_VT_CONSOLE) ||
14416 +           (inb(KBD_STATUS_REG) == 0xff && inb(KBD_DATA_REG) == 0xff)) {
14417 +               kbd_exists = 0;
14418 +               return -1;
14419 +       }
14420 +       kbd_exists = 1;
14421 +
14422 +       if ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
14423 +               return -1;
14424 +
14425 +       /*
14426 +        * Fetch the scancode
14427 +        */
14428 +       scancode = inb(KBD_DATA_REG);
14429 +       scanstatus = inb(KBD_STATUS_REG);
14430 +
14431 +       /*
14432 +        * Ignore mouse events.
14433 +        */
14434 +       if (scanstatus & KBD_STAT_MOUSE_OBF)
14435 +               return -1;
14436 +
14437 +       /*
14438 +        * Ignore release, trigger on make
14439 +        * (except for shift keys, where we want to
14440 +        *  keep the shift state so long as the key is
14441 +        *  held down).
14442 +        */
14443 +
14444 +       if (((scancode&0x7f) == 0x2a) || ((scancode&0x7f) == 0x36)) {
14445 +               /*
14446 +                * Next key may use shift table
14447 +                */
14448 +               if ((scancode & 0x80) == 0) {
14449 +                       shift_key=1;
14450 +               } else {
14451 +                       shift_key=0;
14452 +               }
14453 +               return -1;
14454 +       }
14455 +
14456 +       if ((scancode&0x7f) == 0x1d) {
14457 +               /*
14458 +                * Left ctrl key
14459 +                */
14460 +               if ((scancode & 0x80) == 0) {
14461 +                       ctrl_key = 1;
14462 +               } else {
14463 +                       ctrl_key = 0;
14464 +               }
14465 +               return -1;
14466 +       }
14467 +
14468 +       if ((scancode & 0x80) != 0)
14469 +               return -1;
14470 +
14471 +       scancode &= 0x7f;
14472 +
14473 +       /*
14474 +        * Translate scancode
14475 +        */
14476 +
14477 +       if (scancode == 0x3a) {
14478 +               /*
14479 +                * Toggle caps lock
14480 +                */
14481 +               shift_lock ^= 1;
14482 +
14483 +#ifdef KDB_BLINK_LED
14484 +               kdb_toggleled(0x4);
14485 +#endif
14486 +               return -1;
14487 +       }
14488 +
14489 +       if (scancode == 0x0e) {
14490 +               /*
14491 +                * Backspace
14492 +                */
14493 +               return 8;
14494 +       }
14495 +
14496 +       /* Special Key */
14497 +       switch (scancode) {
14498 +       case 0xF: /* Tab */
14499 +               return 9;
14500 +       case 0x53: /* Del */
14501 +               return 4;
14502 +       case 0x47: /* Home */
14503 +               return 1;
14504 +       case 0x4F: /* End */
14505 +               return 5;
14506 +       case 0x4B: /* Left */
14507 +               return 2;
14508 +       case 0x48: /* Up */
14509 +               return 16;
14510 +       case 0x50: /* Down */
14511 +               return 14;
14512 +       case 0x4D: /* Right */
14513 +               return 6;
14514 +       }
14515 +
14516 +       if (scancode == 0xe0) {
14517 +               return -1;
14518 +       }
14519 +
14520 +       /*
14521 +        * For Japanese 86/106 keyboards
14522 +        *      See comment in drivers/char/pc_keyb.c.
14523 +        *      - Masahiro Adegawa
14524 +        */
14525 +       if (scancode == 0x73) {
14526 +               scancode = 0x59;
14527 +       } else if (scancode == 0x7d) {
14528 +               scancode = 0x7c;
14529 +       }
14530 +
14531 +       if (!shift_lock && !shift_key && !ctrl_key) {
14532 +               keychar = plain_map[scancode];
14533 +       } else if (shift_lock || shift_key) {
14534 +               keychar = shift_map[scancode];
14535 +       } else if (ctrl_key) {
14536 +               keychar = ctrl_map[scancode];
14537 +       } else {
14538 +               keychar = 0x0020;
14539 +               kdb_printf("Unknown state/scancode (%d)\n", scancode);
14540 +       }
14541 +       keychar &= 0x0fff;
14542 +       if (keychar == '\t')
14543 +               keychar = ' ';
14544 +       switch (KTYP(keychar)) {
14545 +       case KT_LETTER:
14546 +       case KT_LATIN:
14547 +               if (isprint(keychar))
14548 +                       break;          /* printable characters */
14549 +               /* drop through */
14550 +       case KT_SPEC:
14551 +               if (keychar == K_ENTER)
14552 +                       break;
14553 +               /* drop through */
14554 +       default:
14555 +               return(-1);     /* ignore unprintables */
14556 +       }
14557 +
14558 +       if ((scancode & 0x7f) == 0x1c) {
14559 +               /*
14560 +                * enter key.  All done.  Absorb the release scancode.
14561 +                */
14562 +               while ((inb(KBD_STATUS_REG) & KBD_STAT_OBF) == 0)
14563 +                       ;
14564 +
14565 +               /*
14566 +                * Fetch the scancode
14567 +                */
14568 +               scancode = inb(KBD_DATA_REG);
14569 +               scanstatus = inb(KBD_STATUS_REG);
14570 +
14571 +               while (scanstatus & KBD_STAT_MOUSE_OBF) {
14572 +                       scancode = inb(KBD_DATA_REG);
14573 +                       scanstatus = inb(KBD_STATUS_REG);
14574 +               }
14575 +
14576 +               if (scancode != 0x9c) {
14577 +                       /*
14578 +                        * Wasn't an enter-release,  why not?
14579 +                        */
14580 +                       kdb_printf("kdb: expected enter got 0x%x status 0x%x\n",
14581 +                              scancode, scanstatus);
14582 +               }
14583 +
14584 +               kdb_printf("\n");
14585 +               return 13;
14586 +       }
14587 +
14588 +       return keychar & 0xff;
14589 +}
14590 +#endif /* CONFIG_VT_CONSOLE */
14591 +
14592 +#ifdef KDB_BLINK_LED
14593 +
14594 +/* Leave numlock alone, setting it messes up laptop keyboards with the keypad
14595 + * mapped over normal keys.
14596 + */
14597 +static int kdba_blink_mask = 0x1 | 0x4;
14598 +
14599 +#define BOGOMIPS (boot_cpu_data.loops_per_jiffy/(500000/HZ))
14600 +static int blink_led(void)
14601 +{
14602 +       static long delay;
14603 +
14604 +       if (kbd_exists == 0)
14605 +               return -1;
14606 +
14607 +       if (--delay < 0) {
14608 +               if (BOGOMIPS == 0)      /* early kdb */
14609 +                       delay = 150000000/1000;     /* arbitrary bogomips */
14610 +               else
14611 +                       delay = 150000000/BOGOMIPS; /* Roughly 1 second when polling */
14612 +               kdb_toggleled(kdba_blink_mask);
14613 +       }
14614 +       return -1;
14615 +}
14616 +#endif
14617 +
14618 +get_char_func poll_funcs[] = {
14619 +#if defined(CONFIG_VT_CONSOLE)
14620 +       get_kbd_char,
14621 +#endif
14622 +#if defined(CONFIG_SERIAL_CONSOLE)
14623 +       get_serial_char,
14624 +#endif
14625 +#ifdef KDB_BLINK_LED
14626 +       blink_led,
14627 +#endif
14628 +#ifdef CONFIG_KDB_USB
14629 +       get_usb_char,
14630 +#endif
14631 +       NULL
14632 +};
14633 +
14634 +/*
14635 + * On some Compaq Deskpro's, there is a keyboard freeze many times after
14636 + * exiting from the kdb. As kdb's keyboard handler is not interrupt-driven and
14637 + * uses a polled interface, it makes more sense to disable motherboard keyboard
14638 + * controller's OBF interrupts during kdb's polling.In case, of interrupts
14639 + * remaining enabled during kdb's polling, it may cause un-necessary
14640 + * interrupts being signalled during keypresses, which are also sometimes seen
14641 + * as spurious interrupts after exiting from kdb. This hack to disable OBF
14642 + * interrupts before entry to kdb and re-enabling them at kdb exit point also
14643 + * solves the keyboard freeze issue. These functions are called from
14644 + * kdb_local(), hence these are arch. specific setup and cleanup functions
14645 + * executing only on the local processor - ashishk@sco.com
14646 + */
14647 +
14648 +void kdba_local_arch_setup(void)
14649 +{
14650 +#ifdef CONFIG_VT_CONSOLE
14651 +       int timeout;
14652 +       unsigned char c;
14653 +
14654 +       while (kbd_read_status() & KBD_STAT_IBF);
14655 +       kbd_write_command(KBD_CCMD_READ_MODE);
14656 +       mdelay(1);
14657 +       while (kbd_read_status() & KBD_STAT_IBF);
14658 +       for (timeout = 200 * 1000; timeout &&
14659 +                       (!(kbd_read_status() & KBD_STAT_OBF)); timeout--);
14660 +       c = kbd_read_input();
14661 +       c &= ~KBD_MODE_KBD_INT;
14662 +       while (kbd_read_status() & KBD_STAT_IBF);
14663 +       kbd_write_command(KBD_CCMD_WRITE_MODE);
14664 +       mdelay(1);
14665 +       while (kbd_read_status() & KBD_STAT_IBF);
14666 +       kbd_write_output(c);
14667 +       mdelay(1);
14668 +       while (kbd_read_status() & KBD_STAT_IBF);
14669 +       mdelay(1);
14670 +#endif /* CONFIG_VT_CONSOLE */
14671 +}
14672 +
14673 +void kdba_local_arch_cleanup(void)
14674 +{
14675 +#ifdef CONFIG_VT_CONSOLE
14676 +       int timeout;
14677 +       unsigned char c;
14678 +
14679 +       while (kbd_read_status() & KBD_STAT_IBF);
14680 +       kbd_write_command(KBD_CCMD_READ_MODE);
14681 +       mdelay(1);
14682 +       while (kbd_read_status() & KBD_STAT_IBF);
14683 +       for (timeout = 200 * 1000; timeout &&
14684 +                       (!(kbd_read_status() & KBD_STAT_OBF)); timeout--);
14685 +       c = kbd_read_input();
14686 +       c |= KBD_MODE_KBD_INT;
14687 +       while (kbd_read_status() & KBD_STAT_IBF);
14688 +       kbd_write_command(KBD_CCMD_WRITE_MODE);
14689 +       mdelay(1);
14690 +       while (kbd_read_status() & KBD_STAT_IBF);
14691 +       kbd_write_output(c);
14692 +       mdelay(1);
14693 +       while (kbd_read_status() & KBD_STAT_IBF);
14694 +       mdelay(1);
14695 +#endif /* CONFIG_VT_CONSOLE */
14696 +}
14697 --- /dev/null
14698 +++ b/arch/x86/kdb/kdbasupport_32.c
14699 @@ -0,0 +1,1072 @@
14700 +/*
14701 + * Kernel Debugger Architecture Independent Support Functions
14702 + *
14703 + * This file is subject to the terms and conditions of the GNU General Public
14704 + * License.  See the file "COPYING" in the main directory of this archive
14705 + * for more details.
14706 + *
14707 + * Copyright (c) 1999-2006 Silicon Graphics, Inc.  All Rights Reserved.
14708 + */
14709 +
14710 +#include <linux/string.h>
14711 +#include <linux/stddef.h>
14712 +#include <linux/kernel.h>
14713 +#include <linux/module.h>
14714 +#include <linux/init.h>
14715 +#include <linux/irq.h>
14716 +#include <linux/ptrace.h>
14717 +#include <linux/mm.h>
14718 +#include <linux/sched.h>
14719 +#include <linux/hardirq.h>
14720 +#include <linux/kdb.h>
14721 +#include <linux/kdbprivate.h>
14722 +
14723 +#include <asm/processor.h>
14724 +#include <asm/msr.h>
14725 +#include <asm/uaccess.h>
14726 +#include <asm/desc.h>
14727 +
14728 +static kdb_machreg_t
14729 +kdba_getcr(int regnum)
14730 +{
14731 +       kdb_machreg_t contents = 0;
14732 +       switch(regnum) {
14733 +       case 0:
14734 +               __asm__ ("movl %%cr0,%0\n\t":"=r"(contents));
14735 +               break;
14736 +       case 1:
14737 +               break;
14738 +       case 2:
14739 +               __asm__ ("movl %%cr2,%0\n\t":"=r"(contents));
14740 +               break;
14741 +       case 3:
14742 +               __asm__ ("movl %%cr3,%0\n\t":"=r"(contents));
14743 +               break;
14744 +       case 4:
14745 +               __asm__ ("movl %%cr4,%0\n\t":"=r"(contents));
14746 +               break;
14747 +       default:
14748 +               break;
14749 +       }
14750 +
14751 +       return contents;
14752 +}
14753 +
14754 +static void
14755 +kdba_putdr(int regnum, kdb_machreg_t contents)
14756 +{
14757 +       switch(regnum) {
14758 +       case 0:
14759 +               __asm__ ("movl %0,%%db0\n\t"::"r"(contents));
14760 +               break;
14761 +       case 1:
14762 +               __asm__ ("movl %0,%%db1\n\t"::"r"(contents));
14763 +               break;
14764 +       case 2:
14765 +               __asm__ ("movl %0,%%db2\n\t"::"r"(contents));
14766 +               break;
14767 +       case 3:
14768 +               __asm__ ("movl %0,%%db3\n\t"::"r"(contents));
14769 +               break;
14770 +       case 4:
14771 +       case 5:
14772 +               break;
14773 +       case 6:
14774 +               __asm__ ("movl %0,%%db6\n\t"::"r"(contents));
14775 +               break;
14776 +       case 7:
14777 +               __asm__ ("movl %0,%%db7\n\t"::"r"(contents));
14778 +               break;
14779 +       default:
14780 +               break;
14781 +       }
14782 +}
14783 +
14784 +kdb_machreg_t
14785 +kdba_getdr(int regnum)
14786 +{
14787 +       kdb_machreg_t contents = 0;
14788 +       switch(regnum) {
14789 +       case 0:
14790 +               __asm__ ("movl %%db0,%0\n\t":"=r"(contents));
14791 +               break;
14792 +       case 1:
14793 +               __asm__ ("movl %%db1,%0\n\t":"=r"(contents));
14794 +               break;
14795 +       case 2:
14796 +               __asm__ ("movl %%db2,%0\n\t":"=r"(contents));
14797 +               break;
14798 +       case 3:
14799 +               __asm__ ("movl %%db3,%0\n\t":"=r"(contents));
14800 +               break;
14801 +       case 4:
14802 +       case 5:
14803 +               break;
14804 +       case 6:
14805 +               __asm__ ("movl %%db6,%0\n\t":"=r"(contents));
14806 +               break;
14807 +       case 7:
14808 +               __asm__ ("movl %%db7,%0\n\t":"=r"(contents));
14809 +               break;
14810 +       default:
14811 +               break;
14812 +       }
14813 +
14814 +       return contents;
14815 +}
14816 +
14817 +kdb_machreg_t
14818 +kdba_getdr6(void)
14819 +{
14820 +       return kdba_getdr(6);
14821 +}
14822 +
14823 +kdb_machreg_t
14824 +kdba_getdr7(void)
14825 +{
14826 +       return kdba_getdr(7);
14827 +}
14828 +
14829 +void
14830 +kdba_putdr6(kdb_machreg_t contents)
14831 +{
14832 +       kdba_putdr(6, contents);
14833 +}
14834 +
14835 +static void
14836 +kdba_putdr7(kdb_machreg_t contents)
14837 +{
14838 +       kdba_putdr(7, contents);
14839 +}
14840 +
14841 +void
14842 +kdba_installdbreg(kdb_bp_t *bp)
14843 +{
14844 +       int cpu = smp_processor_id();
14845 +
14846 +       kdb_machreg_t dr7;
14847 +
14848 +       dr7 = kdba_getdr7();
14849 +
14850 +       kdba_putdr(bp->bp_hard[cpu]->bph_reg, bp->bp_addr);
14851 +
14852 +       dr7 |= DR7_GE;
14853 +       if (cpu_has_de)
14854 +               set_in_cr4(X86_CR4_DE);
14855 +
14856 +       switch (bp->bp_hard[cpu]->bph_reg){
14857 +       case 0:
14858 +               DR7_RW0SET(dr7,bp->bp_hard[cpu]->bph_mode);
14859 +               DR7_LEN0SET(dr7,bp->bp_hard[cpu]->bph_length);
14860 +               DR7_G0SET(dr7);
14861 +               break;
14862 +       case 1:
14863 +               DR7_RW1SET(dr7,bp->bp_hard[cpu]->bph_mode);
14864 +               DR7_LEN1SET(dr7,bp->bp_hard[cpu]->bph_length);
14865 +               DR7_G1SET(dr7);
14866 +               break;
14867 +       case 2:
14868 +               DR7_RW2SET(dr7,bp->bp_hard[cpu]->bph_mode);
14869 +               DR7_LEN2SET(dr7,bp->bp_hard[cpu]->bph_length);
14870 +               DR7_G2SET(dr7);
14871 +               break;
14872 +       case 3:
14873 +               DR7_RW3SET(dr7,bp->bp_hard[cpu]->bph_mode);
14874 +               DR7_LEN3SET(dr7,bp->bp_hard[cpu]->bph_length);
14875 +               DR7_G3SET(dr7);
14876 +               break;
14877 +       default:
14878 +               kdb_printf("kdb: Bad debug register!! %ld\n",
14879 +                          bp->bp_hard[cpu]->bph_reg);
14880 +               break;
14881 +       }
14882 +
14883 +       kdba_putdr7(dr7);
14884 +       return;
14885 +}
14886 +
14887 +void
14888 +kdba_removedbreg(kdb_bp_t *bp)
14889 +{
14890 +       int regnum;
14891 +       kdb_machreg_t dr7;
14892 +       int cpu = smp_processor_id();
14893 +
14894 +       if (!bp->bp_hard[cpu])
14895 +               return;
14896 +
14897 +       regnum = bp->bp_hard[cpu]->bph_reg;
14898 +
14899 +       dr7 = kdba_getdr7();
14900 +
14901 +       kdba_putdr(regnum, 0);
14902 +
14903 +       switch (regnum) {
14904 +       case 0:
14905 +               DR7_G0CLR(dr7);
14906 +               DR7_L0CLR(dr7);
14907 +               break;
14908 +       case 1:
14909 +               DR7_G1CLR(dr7);
14910 +               DR7_L1CLR(dr7);
14911 +               break;
14912 +       case 2:
14913 +               DR7_G2CLR(dr7);
14914 +               DR7_L2CLR(dr7);
14915 +               break;
14916 +       case 3:
14917 +               DR7_G3CLR(dr7);
14918 +               DR7_L3CLR(dr7);
14919 +               break;
14920 +       default:
14921 +               kdb_printf("kdb: Bad debug register!! %d\n", regnum);
14922 +               break;
14923 +       }
14924 +
14925 +       kdba_putdr7(dr7);
14926 +}
14927 +
14928 +
14929 +/*
14930 + * kdba_getregcontents
14931 + *
14932 + *     Return the contents of the register specified by the
14933 + *     input string argument.   Return an error if the string
14934 + *     does not match a machine register.
14935 + *
14936 + *     The following pseudo register names are supported:
14937 + *        &regs         - Prints address of exception frame
14938 + *        kesp          - Prints kernel stack pointer at time of fault
14939 + *        cesp          - Prints current kernel stack pointer, inside kdb
14940 + *        ceflags       - Prints current flags, inside kdb
14941 + *        %<regname>    - Uses the value of the registers at the
14942 + *                        last time the user process entered kernel
14943 + *                        mode, instead of the registers at the time
14944 + *                        kdb was entered.
14945 + *
14946 + * Parameters:
14947 + *     regname         Pointer to string naming register
14948 + *     regs            Pointer to structure containing registers.
14949 + * Outputs:
14950 + *     *contents       Pointer to unsigned long to recieve register contents
14951 + * Returns:
14952 + *     0               Success
14953 + *     KDB_BADREG      Invalid register name
14954 + * Locking:
14955 + *     None.
14956 + * Remarks:
14957 + *     If kdb was entered via an interrupt from the kernel itself then
14958 + *     ss and sp are *not* on the stack.
14959 + */
14960 +
14961 +static struct kdbregs {
14962 +       char   *reg_name;
14963 +       size_t  reg_offset;
14964 +} kdbreglist[] = {
14965 +       { "ax",         offsetof(struct pt_regs, ax) },
14966 +       { "bx",         offsetof(struct pt_regs, bx) },
14967 +       { "cx",         offsetof(struct pt_regs, cx) },
14968 +       { "dx",         offsetof(struct pt_regs, dx) },
14969 +
14970 +       { "si",         offsetof(struct pt_regs, si) },
14971 +       { "di",         offsetof(struct pt_regs, di) },
14972 +       { "sp",         offsetof(struct pt_regs, sp) },
14973 +       { "ip",         offsetof(struct pt_regs, ip) },
14974 +
14975 +       { "bp",         offsetof(struct pt_regs, bp) },
14976 +       { "ss",         offsetof(struct pt_regs, ss) },
14977 +       { "cs",         offsetof(struct pt_regs, cs) },
14978 +       { "flags",      offsetof(struct pt_regs, flags) },
14979 +
14980 +       { "ds",         offsetof(struct pt_regs, ds) },
14981 +       { "es",         offsetof(struct pt_regs, es) },
14982 +       { "origax",     offsetof(struct pt_regs, orig_ax) },
14983 +
14984 +};
14985 +
14986 +static const int nkdbreglist = sizeof(kdbreglist) / sizeof(struct kdbregs);
14987 +
14988 +static struct kdbregs dbreglist[] = {
14989 +       { "dr0",        0 },
14990 +       { "dr1",        1 },
14991 +       { "dr2",        2 },
14992 +       { "dr3",        3 },
14993 +       { "dr6",        6 },
14994 +       { "dr7",        7 },
14995 +};
14996 +
14997 +static const int ndbreglist = sizeof(dbreglist) / sizeof(struct kdbregs);
14998 +
14999 +int
15000 +kdba_getregcontents(const char *regname,
15001 +                   struct pt_regs *regs,
15002 +                   kdb_machreg_t *contents)
15003 +{
15004 +       int i;
15005 +
15006 +       if (strcmp(regname, "cesp") == 0) {
15007 +               asm volatile("movl %%esp,%0":"=m" (*contents));
15008 +               return 0;
15009 +       }
15010 +
15011 +       if (strcmp(regname, "ceflags") == 0) {
15012 +               unsigned long flags;
15013 +               local_save_flags(flags);
15014 +               *contents = flags;
15015 +               return 0;
15016 +       }
15017 +
15018 +       if (regname[0] == '%') {
15019 +               /* User registers:  %%e[a-c]x, etc */
15020 +               regname++;
15021 +               regs = (struct pt_regs *)
15022 +                       (kdb_current_task->thread.sp0 - sizeof(struct pt_regs));
15023 +       }
15024 +
15025 +       for (i=0; i<ndbreglist; i++) {
15026 +               if (strnicmp(dbreglist[i].reg_name,
15027 +                            regname,
15028 +                            strlen(regname)) == 0)
15029 +                       break;
15030 +       }
15031 +
15032 +       if ((i < ndbreglist)
15033 +        && (strlen(dbreglist[i].reg_name) == strlen(regname))) {
15034 +               *contents = kdba_getdr(dbreglist[i].reg_offset);
15035 +               return 0;
15036 +       }
15037 +
15038 +       if (!regs) {
15039 +               kdb_printf("%s: pt_regs not available, use bt* or pid to select a different task\n", __FUNCTION__);
15040 +               return KDB_BADREG;
15041 +       }
15042 +
15043 +       if (strcmp(regname, "&regs") == 0) {
15044 +               *contents = (unsigned long)regs;
15045 +               return 0;
15046 +       }
15047 +
15048 +       if (strcmp(regname, "kesp") == 0) {
15049 +               *contents = (unsigned long)regs + sizeof(struct pt_regs);
15050 +               if ((regs->cs & 0xffff) == __KERNEL_CS) {
15051 +                       /* sp and ss are not on stack */
15052 +                       *contents -= 2*4;
15053 +               }
15054 +               return 0;
15055 +       }
15056 +
15057 +       for (i=0; i<nkdbreglist; i++) {
15058 +               if (strnicmp(kdbreglist[i].reg_name,
15059 +                            regname,
15060 +                            strlen(regname)) == 0)
15061 +                       break;
15062 +       }
15063 +
15064 +       if ((i < nkdbreglist)
15065 +        && (strlen(kdbreglist[i].reg_name) == strlen(regname))) {
15066 +               if ((regs->cs & 0xffff) == __KERNEL_CS) {
15067 +                       /* No cpl switch, sp and ss are not on stack */
15068 +                       if (strcmp(kdbreglist[i].reg_name, "sp") == 0) {
15069 +                               *contents = (kdb_machreg_t)regs +
15070 +                                       sizeof(struct pt_regs) - 2*4;
15071 +                               return(0);
15072 +                       }
15073 +                       if (strcmp(kdbreglist[i].reg_name, "xss") == 0) {
15074 +                               asm volatile(
15075 +                                       "pushl %%ss\n"
15076 +                                       "popl %0\n"
15077 +                                       :"=m" (*contents));
15078 +                               return(0);
15079 +                       }
15080 +               }
15081 +               *contents = *(unsigned long *)((unsigned long)regs +
15082 +                               kdbreglist[i].reg_offset);
15083 +               return(0);
15084 +       }
15085 +
15086 +       return KDB_BADREG;
15087 +}
15088 +
15089 +/*
15090 + * kdba_setregcontents
15091 + *
15092 + *     Set the contents of the register specified by the
15093 + *     input string argument.   Return an error if the string
15094 + *     does not match a machine register.
15095 + *
15096 + *     Supports modification of user-mode registers via
15097 + *     %<register-name>
15098 + *
15099 + * Parameters:
15100 + *     regname         Pointer to string naming register
15101 + *     regs            Pointer to structure containing registers.
15102 + *     contents        Unsigned long containing new register contents
15103 + * Outputs:
15104 + * Returns:
15105 + *     0               Success
15106 + *     KDB_BADREG      Invalid register name
15107 + * Locking:
15108 + *     None.
15109 + * Remarks:
15110 + */
15111 +
15112 +int
15113 +kdba_setregcontents(const char *regname,
15114 +                 struct pt_regs *regs,
15115 +                 unsigned long contents)
15116 +{
15117 +       int i;
15118 +
15119 +       if (regname[0] == '%') {
15120 +               regname++;
15121 +               regs = (struct pt_regs *)
15122 +                       (kdb_current_task->thread.sp0 - sizeof(struct pt_regs));
15123 +       }
15124 +
15125 +       for (i=0; i<ndbreglist; i++) {
15126 +               if (strnicmp(dbreglist[i].reg_name,
15127 +                            regname,
15128 +                            strlen(regname)) == 0)
15129 +                       break;
15130 +       }
15131 +
15132 +       if ((i < ndbreglist)
15133 +        && (strlen(dbreglist[i].reg_name) == strlen(regname))) {
15134 +               kdba_putdr(dbreglist[i].reg_offset, contents);
15135 +               return 0;
15136 +       }
15137 +
15138 +       if (!regs) {
15139 +               kdb_printf("%s: pt_regs not available, use bt* or pid to select a different task\n", __FUNCTION__);
15140 +               return KDB_BADREG;
15141 +       }
15142 +
15143 +       for (i=0; i<nkdbreglist; i++) {
15144 +               if (strnicmp(kdbreglist[i].reg_name,
15145 +                            regname,
15146 +                            strlen(regname)) == 0)
15147 +                       break;
15148 +       }
15149 +
15150 +       if ((i < nkdbreglist)
15151 +        && (strlen(kdbreglist[i].reg_name) == strlen(regname))) {
15152 +               *(unsigned long *)((unsigned long)regs
15153 +                                  + kdbreglist[i].reg_offset) = contents;
15154 +               return 0;
15155 +       }
15156 +
15157 +       return KDB_BADREG;
15158 +}
15159 +
15160 +/*
15161 + * kdba_dumpregs
15162 + *
15163 + *     Dump the specified register set to the display.
15164 + *
15165 + * Parameters:
15166 + *     regs            Pointer to structure containing registers.
15167 + *     type            Character string identifying register set to dump
15168 + *     extra           string further identifying register (optional)
15169 + * Outputs:
15170 + * Returns:
15171 + *     0               Success
15172 + * Locking:
15173 + *     None.
15174 + * Remarks:
15175 + *     This function will dump the general register set if the type
15176 + *     argument is NULL (struct pt_regs).   The alternate register
15177 + *     set types supported by this function:
15178 + *
15179 + *     d               Debug registers
15180 + *     c               Control registers
15181 + *     u               User registers at most recent entry to kernel
15182 + *                     for the process currently selected with "pid" command.
15183 + * Following not yet implemented:
15184 + *     r               Memory Type Range Registers (extra defines register)
15185 + *
15186 + * MSR on i386/x86_64 are handled by rdmsr/wrmsr commands.
15187 + */
15188 +
15189 +int
15190 +kdba_dumpregs(struct pt_regs *regs,
15191 +           const char *type,
15192 +           const char *extra)
15193 +{
15194 +       int i;
15195 +       int count = 0;
15196 +
15197 +       if (type
15198 +        && (type[0] == 'u')) {
15199 +               type = NULL;
15200 +               regs = (struct pt_regs *)
15201 +                       (kdb_current_task->thread.sp0 - sizeof(struct pt_regs));
15202 +       }
15203 +
15204 +       if (type == NULL) {
15205 +               struct kdbregs *rlp;
15206 +               kdb_machreg_t contents;
15207 +
15208 +               if (!regs) {
15209 +                       kdb_printf("%s: pt_regs not available, use bt* or pid to select a different task\n", __FUNCTION__);
15210 +                       return KDB_BADREG;
15211 +               }
15212 +
15213 +               for (i=0, rlp=kdbreglist; i<nkdbreglist; i++,rlp++) {
15214 +                       kdb_printf("%s = ", rlp->reg_name);
15215 +                       kdba_getregcontents(rlp->reg_name, regs, &contents);
15216 +                       kdb_printf("0x%08lx ", contents);
15217 +                       if ((++count % 4) == 0)
15218 +                               kdb_printf("\n");
15219 +               }
15220 +
15221 +               kdb_printf("&regs = 0x%p\n", regs);
15222 +
15223 +               return 0;
15224 +       }
15225 +
15226 +       switch (type[0]) {
15227 +       case 'd':
15228 +       {
15229 +               unsigned long dr[8];
15230 +
15231 +               for(i=0; i<8; i++) {
15232 +                       if ((i == 4) || (i == 5)) continue;
15233 +                       dr[i] = kdba_getdr(i);
15234 +               }
15235 +               kdb_printf("dr0 = 0x%08lx  dr1 = 0x%08lx  dr2 = 0x%08lx  dr3 = 0x%08lx\n",
15236 +                          dr[0], dr[1], dr[2], dr[3]);
15237 +               kdb_printf("dr6 = 0x%08lx  dr7 = 0x%08lx\n",
15238 +                          dr[6], dr[7]);
15239 +               return 0;
15240 +       }
15241 +       case 'c':
15242 +       {
15243 +               unsigned long cr[5];
15244 +
15245 +               for (i=0; i<5; i++) {
15246 +                       cr[i] = kdba_getcr(i);
15247 +               }
15248 +               kdb_printf("cr0 = 0x%08lx  cr1 = 0x%08lx  cr2 = 0x%08lx  cr3 = 0x%08lx\ncr4 = 0x%08lx\n",
15249 +                          cr[0], cr[1], cr[2], cr[3], cr[4]);
15250 +               return 0;
15251 +       }
15252 +       case 'r':
15253 +               break;
15254 +       default:
15255 +               return KDB_BADREG;
15256 +       }
15257 +
15258 +       /* NOTREACHED */
15259 +       return 0;
15260 +}
15261 +EXPORT_SYMBOL(kdba_dumpregs);
15262 +
15263 +kdb_machreg_t
15264 +kdba_getpc(struct pt_regs *regs)
15265 +{
15266 +       return regs ? regs->ip : 0;
15267 +}
15268 +
15269 +int
15270 +kdba_setpc(struct pt_regs *regs, kdb_machreg_t newpc)
15271 +{
15272 +       if (KDB_NULL_REGS(regs))
15273 +               return KDB_BADREG;
15274 +       regs->ip = newpc;
15275 +       KDB_STATE_SET(IP_ADJUSTED);
15276 +       return 0;
15277 +}
15278 +
15279 +/*
15280 + * kdba_main_loop
15281 + *
15282 + *     Do any architecture specific set up before entering the main kdb loop.
15283 + *     The primary function of this routine is to make all processes look the
15284 + *     same to kdb, kdb must be able to list a process without worrying if the
15285 + *     process is running or blocked, so make all process look as though they
15286 + *     are blocked.
15287 + *
15288 + * Inputs:
15289 + *     reason          The reason KDB was invoked
15290 + *     error           The hardware-defined error code
15291 + *     error2          kdb's current reason code.  Initially error but can change
15292 + *                     acording to kdb state.
15293 + *     db_result       Result from break or debug point.
15294 + *     regs            The exception frame at time of fault/breakpoint.  If reason
15295 + *                     is SILENT or CPU_UP then regs is NULL, otherwise it should
15296 + *                     always be valid.
15297 + * Returns:
15298 + *     0       KDB was invoked for an event which it wasn't responsible
15299 + *     1       KDB handled the event for which it was invoked.
15300 + * Outputs:
15301 + *     Sets ip and sp in current->thread.
15302 + * Locking:
15303 + *     None.
15304 + * Remarks:
15305 + *     none.
15306 + */
15307 +
15308 +int
15309 +kdba_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
15310 +              kdb_dbtrap_t db_result, struct pt_regs *regs)
15311 +{
15312 +       int ret;
15313 +       ret = kdb_save_running(regs, reason, reason2, error, db_result);
15314 +       kdb_unsave_running(regs);
15315 +       return ret;
15316 +}
15317 +
15318 +void
15319 +kdba_disableint(kdb_intstate_t *state)
15320 +{
15321 +       unsigned long *fp = (unsigned long *)state;
15322 +       unsigned long flags;
15323 +
15324 +       local_irq_save(flags);
15325 +
15326 +       *fp = flags;
15327 +}
15328 +
15329 +void
15330 +kdba_restoreint(kdb_intstate_t *state)
15331 +{
15332 +       unsigned long flags = *(int *)state;
15333 +       local_irq_restore(flags);
15334 +}
15335 +
15336 +void
15337 +kdba_setsinglestep(struct pt_regs *regs)
15338 +{
15339 +       if (KDB_NULL_REGS(regs))
15340 +               return;
15341 +       if (regs->flags & EF_IE)
15342 +               KDB_STATE_SET(A_IF);
15343 +       else
15344 +               KDB_STATE_CLEAR(A_IF);
15345 +       regs->flags = (regs->flags | EF_TF) & ~EF_IE;
15346 +}
15347 +
15348 +void
15349 +kdba_clearsinglestep(struct pt_regs *regs)
15350 +{
15351 +       if (KDB_NULL_REGS(regs))
15352 +               return;
15353 +       if (KDB_STATE(A_IF))
15354 +               regs->flags |= EF_IE;
15355 +       else
15356 +               regs->flags &= ~EF_IE;
15357 +}
15358 +
15359 +int asmlinkage
15360 +kdba_setjmp(kdb_jmp_buf *jb)
15361 +{
15362 +#if defined(CONFIG_FRAME_POINTER)
15363 +       __asm__ ("movl 8(%esp), %eax\n\t"
15364 +                "movl %ebx, 0(%eax)\n\t"
15365 +                "movl %esi, 4(%eax)\n\t"
15366 +                "movl %edi, 8(%eax)\n\t"
15367 +                "movl (%esp), %ecx\n\t"
15368 +                "movl %ecx, 12(%eax)\n\t"
15369 +                "leal 8(%esp), %ecx\n\t"
15370 +                "movl %ecx, 16(%eax)\n\t"
15371 +                "movl 4(%esp), %ecx\n\t"
15372 +                "movl %ecx, 20(%eax)\n\t");
15373 +#else   /* CONFIG_FRAME_POINTER */
15374 +       __asm__ ("movl 4(%esp), %eax\n\t"
15375 +                "movl %ebx, 0(%eax)\n\t"
15376 +                "movl %esi, 4(%eax)\n\t"
15377 +                "movl %edi, 8(%eax)\n\t"
15378 +                "movl %ebp, 12(%eax)\n\t"
15379 +                "leal 4(%esp), %ecx\n\t"
15380 +                "movl %ecx, 16(%eax)\n\t"
15381 +                "movl 0(%esp), %ecx\n\t"
15382 +                "movl %ecx, 20(%eax)\n\t");
15383 +#endif   /* CONFIG_FRAME_POINTER */
15384 +       return 0;
15385 +}
15386 +
15387 +void asmlinkage
15388 +kdba_longjmp(kdb_jmp_buf *jb, int reason)
15389 +{
15390 +#if defined(CONFIG_FRAME_POINTER)
15391 +       __asm__("movl 8(%esp), %ecx\n\t"
15392 +               "movl 12(%esp), %eax\n\t"
15393 +               "movl 20(%ecx), %edx\n\t"
15394 +               "movl 0(%ecx), %ebx\n\t"
15395 +               "movl 4(%ecx), %esi\n\t"
15396 +               "movl 8(%ecx), %edi\n\t"
15397 +               "movl 12(%ecx), %ebp\n\t"
15398 +               "movl 16(%ecx), %esp\n\t"
15399 +               "jmp *%edx\n");
15400 +#else    /* CONFIG_FRAME_POINTER */
15401 +       __asm__("movl 4(%esp), %ecx\n\t"
15402 +               "movl 8(%esp), %eax\n\t"
15403 +               "movl 20(%ecx), %edx\n\t"
15404 +               "movl 0(%ecx), %ebx\n\t"
15405 +               "movl 4(%ecx), %esi\n\t"
15406 +               "movl 8(%ecx), %edi\n\t"
15407 +               "movl 12(%ecx), %ebp\n\t"
15408 +               "movl 16(%ecx), %esp\n\t"
15409 +               "jmp *%edx\n");
15410 +#endif  /* CONFIG_FRAME_POINTER */
15411 +}
15412 +
15413 +/*
15414 + * kdba_pt_regs
15415 + *
15416 + *     Format a struct pt_regs
15417 + *
15418 + * Inputs:
15419 + *     argc    argument count
15420 + *     argv    argument vector
15421 + * Outputs:
15422 + *     None.
15423 + * Returns:
15424 + *     zero for success, a kdb diagnostic if error
15425 + * Locking:
15426 + *     none.
15427 + * Remarks:
15428 + *     If no address is supplied, it uses the last irq pt_regs.
15429 + */
15430 +
15431 +static int
15432 +kdba_pt_regs(int argc, const char **argv)
15433 +{
15434 +       int diag;
15435 +       kdb_machreg_t addr;
15436 +       long offset = 0;
15437 +       int nextarg;
15438 +       struct pt_regs *p;
15439 +       static const char *fmt = "  %-11.11s 0x%lx\n";
15440 +
15441 +       if (argc == 0) {
15442 +               addr = (kdb_machreg_t) get_irq_regs();
15443 +       } else if (argc == 1) {
15444 +               nextarg = 1;
15445 +               diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
15446 +               if (diag)
15447 +                       return diag;
15448 +       } else {
15449 +               return KDB_ARGCOUNT;
15450 +       }
15451 +
15452 +       p = (struct pt_regs *) addr;
15453 +       kdb_printf("struct pt_regs 0x%p-0x%p\n", p, (unsigned char *)p + sizeof(*p) - 1);
15454 +       kdb_print_nameval("bx", p->bx);
15455 +       kdb_print_nameval("cx", p->cx);
15456 +       kdb_print_nameval("dx", p->dx);
15457 +       kdb_print_nameval("si", p->si);
15458 +       kdb_print_nameval("di", p->di);
15459 +       kdb_print_nameval("bp", p->bp);
15460 +       kdb_print_nameval("ax", p->ax);
15461 +       kdb_printf(fmt, "ds", p->ds);
15462 +       kdb_printf(fmt, "es", p->es);
15463 +       kdb_print_nameval("orig_ax", p->orig_ax);
15464 +       kdb_print_nameval("ip", p->ip);
15465 +       kdb_printf(fmt, "cs", p->cs);
15466 +       kdb_printf(fmt, "flags", p->flags);
15467 +       kdb_printf(fmt, "sp", p->sp);
15468 +       kdb_printf(fmt, "ss", p->ss);
15469 +       return 0;
15470 +}
15471 +
15472 +/*
15473 + * kdba_stackdepth
15474 + *
15475 + *     Print processes that are using more than a specific percentage of their
15476 + *     stack.
15477 + *
15478 + * Inputs:
15479 + *     argc    argument count
15480 + *     argv    argument vector
15481 + * Outputs:
15482 + *     None.
15483 + * Returns:
15484 + *     zero for success, a kdb diagnostic if error
15485 + * Locking:
15486 + *     none.
15487 + * Remarks:
15488 + *     If no percentage is supplied, it uses 60.
15489 + */
15490 +
15491 +static void
15492 +kdba_stackdepth1(struct task_struct *p, unsigned long sp)
15493 +{
15494 +       struct thread_info *tinfo;
15495 +       int used;
15496 +       const char *type;
15497 +       kdb_ps1(p);
15498 +       do {
15499 +               tinfo = (struct thread_info *)(sp & -THREAD_SIZE);
15500 +               used = sizeof(*tinfo) + THREAD_SIZE - (sp & (THREAD_SIZE-1));
15501 +               type = NULL;
15502 +               if (kdb_task_has_cpu(p)) {
15503 +                       struct kdb_activation_record ar;
15504 +                       memset(&ar, 0, sizeof(ar));
15505 +                       kdba_get_stack_info_alternate(sp, -1, &ar);
15506 +                       type = ar.stack.id;
15507 +               }
15508 +               if (!type)
15509 +                       type = "process";
15510 +               kdb_printf("  %s stack %p sp %lx used %d\n", type, tinfo, sp, used);
15511 +               sp = tinfo->previous_esp;
15512 +       } while (sp);
15513 +}
15514 +
15515 +static int
15516 +kdba_stackdepth(int argc, const char **argv)
15517 +{
15518 +       int diag, cpu, threshold, used, over;
15519 +       unsigned long percentage;
15520 +       unsigned long esp;
15521 +       long offset = 0;
15522 +       int nextarg;
15523 +       struct task_struct *p, *g;
15524 +       struct kdb_running_process *krp;
15525 +       struct thread_info *tinfo;
15526 +
15527 +       if (argc == 0) {
15528 +               percentage = 60;
15529 +       } else if (argc == 1) {
15530 +               nextarg = 1;
15531 +               diag = kdbgetaddrarg(argc, argv, &nextarg, &percentage, &offset, NULL);
15532 +               if (diag)
15533 +                       return diag;
15534 +       } else {
15535 +               return KDB_ARGCOUNT;
15536 +       }
15537 +       percentage = max_t(int, percentage, 1);
15538 +       percentage = min_t(int, percentage, 100);
15539 +       threshold = ((2 * THREAD_SIZE * percentage) / 100 + 1) >> 1;
15540 +       kdb_printf("stackdepth: processes using more than %ld%% (%d bytes) of stack\n",
15541 +               percentage, threshold);
15542 +
15543 +       /* Run the active tasks first, they can have multiple stacks */
15544 +       for (cpu = 0, krp = kdb_running_process; cpu < NR_CPUS; ++cpu, ++krp) {
15545 +               if (!cpu_online(cpu))
15546 +                       continue;
15547 +               p = krp->p;
15548 +               esp = krp->arch.sp;
15549 +               over = 0;
15550 +               do {
15551 +                       tinfo = (struct thread_info *)(esp & -THREAD_SIZE);
15552 +                       used = sizeof(*tinfo) + THREAD_SIZE - (esp & (THREAD_SIZE-1));
15553 +                       if (used >= threshold)
15554 +                               over = 1;
15555 +                       esp = tinfo->previous_esp;
15556 +               } while (esp);
15557 +               if (over)
15558 +                       kdba_stackdepth1(p, krp->arch.sp);
15559 +       }
15560 +       /* Now the tasks that are not on cpus */
15561 +       kdb_do_each_thread(g, p) {
15562 +               if (kdb_task_has_cpu(p))
15563 +                       continue;
15564 +               esp = p->thread.sp;
15565 +               used = sizeof(*tinfo) + THREAD_SIZE - (esp & (THREAD_SIZE-1));
15566 +               over = used >= threshold;
15567 +               if (over)
15568 +                       kdba_stackdepth1(p, esp);
15569 +       } kdb_while_each_thread(g, p);
15570 +
15571 +       return 0;
15572 +}
15573 +
15574 +asmlinkage int kdb_call(void);
15575 +
15576 +/* Executed once on each cpu at startup. */
15577 +void
15578 +kdba_cpu_up(void)
15579 +{
15580 +}
15581 +
15582 +static int __init
15583 +kdba_arch_init(void)
15584 +{
15585 +#ifdef CONFIG_SMP
15586 +       set_intr_gate(KDB_VECTOR, kdb_interrupt);
15587 +#endif
15588 +       set_intr_gate(KDBENTER_VECTOR, kdb_call);
15589 +       return 0;
15590 +}
15591 +
15592 +arch_initcall(kdba_arch_init);
15593 +
15594 +/*
15595 + * kdba_init
15596 + *
15597 + *     Architecture specific initialization.
15598 + *
15599 + * Parameters:
15600 + *     None.
15601 + * Returns:
15602 + *     None.
15603 + * Locking:
15604 + *     None.
15605 + * Remarks:
15606 + *     None.
15607 + */
15608 +
15609 +void __init
15610 +kdba_init(void)
15611 +{
15612 +       kdba_arch_init();       /* Need to register KDBENTER_VECTOR early */
15613 +       kdb_register("pt_regs", kdba_pt_regs, "address", "Format struct pt_regs", 0);
15614 +       kdb_register("stackdepth", kdba_stackdepth, "[percentage]", "Print processes using >= stack percentage", 0);
15615 +
15616 +       return;
15617 +}
15618 +
15619 +/*
15620 + * kdba_adjust_ip
15621 + *
15622 + *     Architecture specific adjustment of instruction pointer before leaving
15623 + *     kdb.
15624 + *
15625 + * Parameters:
15626 + *     reason          The reason KDB was invoked
15627 + *     error           The hardware-defined error code
15628 + *     regs            The exception frame at time of fault/breakpoint.  If reason
15629 + *                     is SILENT or CPU_UP then regs is NULL, otherwise it should
15630 + *                     always be valid.
15631 + * Returns:
15632 + *     None.
15633 + * Locking:
15634 + *     None.
15635 + * Remarks:
15636 + *     noop on ix86.
15637 + */
15638 +
15639 +void
15640 +kdba_adjust_ip(kdb_reason_t reason, int error, struct pt_regs *regs)
15641 +{
15642 +       return;
15643 +}
15644 +
15645 +void
15646 +kdba_set_current_task(const struct task_struct *p)
15647 +{
15648 +       kdb_current_task = p;
15649 +       if (kdb_task_has_cpu(p)) {
15650 +               struct kdb_running_process *krp = kdb_running_process + kdb_process_cpu(p);
15651 +               kdb_current_regs = krp->regs;
15652 +               return;
15653 +       }
15654 +       kdb_current_regs = NULL;
15655 +}
15656 +
15657 +/*
15658 + * asm-i386 uaccess.h supplies __copy_to_user which relies on MMU to
15659 + * trap invalid addresses in the _xxx fields.  Verify the other address
15660 + * of the pair is valid by accessing the first and last byte ourselves,
15661 + * then any access violations should only be caused by the _xxx
15662 + * addresses,
15663 + */
15664 +
15665 +int
15666 +kdba_putarea_size(unsigned long to_xxx, void *from, size_t size)
15667 +{
15668 +       mm_segment_t oldfs = get_fs();
15669 +       int r;
15670 +       char c;
15671 +       c = *((volatile char *)from);
15672 +       c = *((volatile char *)from + size - 1);
15673 +
15674 +       if (to_xxx < PAGE_OFFSET) {
15675 +               return kdb_putuserarea_size(to_xxx, from, size);
15676 +       }
15677 +
15678 +       set_fs(KERNEL_DS);
15679 +       r = __copy_to_user_inatomic((void __user *)to_xxx, from, size);
15680 +       set_fs(oldfs);
15681 +       return r;
15682 +}
15683 +
15684 +int
15685 +kdba_getarea_size(void *to, unsigned long from_xxx, size_t size)
15686 +{
15687 +       mm_segment_t oldfs = get_fs();
15688 +       int r;
15689 +       *((volatile char *)to) = '\0';
15690 +       *((volatile char *)to + size - 1) = '\0';
15691 +
15692 +       if (from_xxx < PAGE_OFFSET) {
15693 +               return kdb_getuserarea_size(to, from_xxx, size);
15694 +       }
15695 +
15696 +       set_fs(KERNEL_DS);
15697 +       switch (size) {
15698 +       case 1:
15699 +               r = __copy_to_user_inatomic((void __user *)to, (void *)from_xxx, 1);
15700 +               break;
15701 +       case 2:
15702 +               r = __copy_to_user_inatomic((void __user *)to, (void *)from_xxx, 2);
15703 +               break;
15704 +       case 4:
15705 +               r = __copy_to_user_inatomic((void __user *)to, (void *)from_xxx, 4);
15706 +               break;
15707 +       case 8:
15708 +               r = __copy_to_user_inatomic((void __user *)to, (void *)from_xxx, 8);
15709 +               break;
15710 +       default:
15711 +               r = __copy_to_user_inatomic((void __user *)to, (void *)from_xxx, size);
15712 +               break;
15713 +       }
15714 +       set_fs(oldfs);
15715 +       return r;
15716 +}
15717 +
15718 +int
15719 +kdba_verify_rw(unsigned long addr, size_t size)
15720 +{
15721 +       unsigned char data[size];
15722 +       return(kdba_getarea_size(data, addr, size) || kdba_putarea_size(addr, data, size));
15723 +}
15724 +
15725 +#ifdef CONFIG_SMP
15726 +
15727 +#include <mach_ipi.h>
15728 +
15729 +/* When first entering KDB, try a normal IPI.  That reduces backtrace problems
15730 + * on the other cpus.
15731 + */
15732 +void
15733 +smp_kdb_stop(void)
15734 +{
15735 +       if (!KDB_FLAG(NOIPI))
15736 +               send_IPI_allbutself(KDB_VECTOR);
15737 +}
15738 +
15739 +/* The normal KDB IPI handler */
15740 +void
15741 +smp_kdb_interrupt(struct pt_regs *regs)
15742 +{
15743 +       struct pt_regs *old_regs = set_irq_regs(regs);
15744 +       ack_APIC_irq();
15745 +       irq_enter();
15746 +       kdb_ipi(regs, NULL);
15747 +       irq_exit();
15748 +       set_irq_regs(old_regs);
15749 +}
15750 +
15751 +/* Invoked once from kdb_wait_for_cpus when waiting for cpus.  For those cpus
15752 + * that have not responded to the normal KDB interrupt yet, hit them with an
15753 + * NMI event.
15754 + */
15755 +void
15756 +kdba_wait_for_cpus(void)
15757 +{
15758 +       int c;
15759 +       if (KDB_FLAG(CATASTROPHIC))
15760 +               return;
15761 +       kdb_printf("  Sending NMI to non-responding cpu(s): ");
15762 +       for_each_online_cpu(c) {
15763 +               if (kdb_running_process[c].seqno < kdb_seqno - 1) {
15764 +                       kdb_printf(" %d", c);
15765 +                       send_IPI_mask(&cpumask_of_cpu(c), NMI_VECTOR);
15766 +               }
15767 +       }
15768 +       kdb_printf(".\n");
15769 +}
15770 +
15771 +#endif /* CONFIG_SMP */
15772 --- /dev/null
15773 +++ b/arch/x86/kdb/kdbasupport_64.c
15774 @@ -0,0 +1,1022 @@
15775 +/*
15776 + * Kernel Debugger Architecture Independent Support Functions
15777 + *
15778 + * This file is subject to the terms and conditions of the GNU General Public
15779 + * License.  See the file "COPYING" in the main directory of this archive
15780 + * for more details.
15781 + *
15782 + * Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
15783 + */
15784 +
15785 +#include <linux/string.h>
15786 +#include <linux/stddef.h>
15787 +#include <linux/kernel.h>
15788 +#include <linux/init.h>
15789 +#include <linux/ptrace.h>
15790 +#include <linux/mm.h>
15791 +#include <linux/sched.h>
15792 +#include <linux/hardirq.h>
15793 +#include <linux/kdb.h>
15794 +#include <linux/kdbprivate.h>
15795 +#include <linux/interrupt.h>
15796 +#include <linux/module.h>
15797 +#include <linux/kdebug.h>
15798 +#include <asm/processor.h>
15799 +#include <asm/msr.h>
15800 +#include <asm/uaccess.h>
15801 +#include <asm/hw_irq.h>
15802 +#include <asm/desc.h>
15803 +
15804 +kdb_machreg_t
15805 +kdba_getdr6(void)
15806 +{
15807 +       return kdba_getdr(6);
15808 +}
15809 +
15810 +kdb_machreg_t
15811 +kdba_getdr7(void)
15812 +{
15813 +       return kdba_getdr(7);
15814 +}
15815 +
15816 +void
15817 +kdba_putdr6(kdb_machreg_t contents)
15818 +{
15819 +       kdba_putdr(6, contents);
15820 +}
15821 +
15822 +static void
15823 +kdba_putdr7(kdb_machreg_t contents)
15824 +{
15825 +       kdba_putdr(7, contents);
15826 +}
15827 +
15828 +void
15829 +kdba_installdbreg(kdb_bp_t *bp)
15830 +{
15831 +       int cpu = smp_processor_id();
15832 +
15833 +       kdb_machreg_t   dr7;
15834 +
15835 +       dr7 = kdba_getdr7();
15836 +
15837 +       kdba_putdr(bp->bp_hard[cpu]->bph_reg, bp->bp_addr);
15838 +
15839 +       dr7 |= DR7_GE;
15840 +       if (cpu_has_de)
15841 +               set_in_cr4(X86_CR4_DE);
15842 +
15843 +       switch (bp->bp_hard[cpu]->bph_reg){
15844 +       case 0:
15845 +               DR7_RW0SET(dr7,bp->bp_hard[cpu]->bph_mode);
15846 +               DR7_LEN0SET(dr7,bp->bp_hard[cpu]->bph_length);
15847 +               DR7_G0SET(dr7);
15848 +               break;
15849 +       case 1:
15850 +               DR7_RW1SET(dr7,bp->bp_hard[cpu]->bph_mode);
15851 +               DR7_LEN1SET(dr7,bp->bp_hard[cpu]->bph_length);
15852 +               DR7_G1SET(dr7);
15853 +               break;
15854 +       case 2:
15855 +               DR7_RW2SET(dr7,bp->bp_hard[cpu]->bph_mode);
15856 +               DR7_LEN2SET(dr7,bp->bp_hard[cpu]->bph_length);
15857 +               DR7_G2SET(dr7);
15858 +               break;
15859 +       case 3:
15860 +               DR7_RW3SET(dr7,bp->bp_hard[cpu]->bph_mode);
15861 +               DR7_LEN3SET(dr7,bp->bp_hard[cpu]->bph_length);
15862 +               DR7_G3SET(dr7);
15863 +               break;
15864 +       default:
15865 +               kdb_printf("kdb: Bad debug register!! %ld\n",
15866 +                          bp->bp_hard[cpu]->bph_reg);
15867 +               break;
15868 +       }
15869 +
15870 +       kdba_putdr7(dr7);
15871 +       return;
15872 +}
15873 +
15874 +void
15875 +kdba_removedbreg(kdb_bp_t *bp)
15876 +{
15877 +       int             regnum;
15878 +       kdb_machreg_t   dr7;
15879 +       int cpu = smp_processor_id();
15880 +
15881 +       if (!bp->bp_hard[cpu])
15882 +               return;
15883 +
15884 +       regnum = bp->bp_hard[cpu]->bph_reg;
15885 +
15886 +       dr7 = kdba_getdr7();
15887 +
15888 +       kdba_putdr(regnum, 0);
15889 +
15890 +       switch (regnum) {
15891 +       case 0:
15892 +               DR7_G0CLR(dr7);
15893 +               DR7_L0CLR(dr7);
15894 +               break;
15895 +       case 1:
15896 +               DR7_G1CLR(dr7);
15897 +               DR7_L1CLR(dr7);
15898 +               break;
15899 +       case 2:
15900 +               DR7_G2CLR(dr7);
15901 +               DR7_L2CLR(dr7);
15902 +               break;
15903 +       case 3:
15904 +               DR7_G3CLR(dr7);
15905 +               DR7_L3CLR(dr7);
15906 +               break;
15907 +       default:
15908 +               kdb_printf("kdb: Bad debug register!! %d\n", regnum);
15909 +               break;
15910 +       }
15911 +
15912 +       kdba_putdr7(dr7);
15913 +}
15914 +
15915 +kdb_machreg_t
15916 +kdba_getdr(int regnum)
15917 +{
15918 +       kdb_machreg_t contents = 0;
15919 +       switch(regnum) {
15920 +       case 0:
15921 +               __asm__ ("movq %%db0,%0\n\t":"=r"(contents));
15922 +               break;
15923 +       case 1:
15924 +               __asm__ ("movq %%db1,%0\n\t":"=r"(contents));
15925 +               break;
15926 +       case 2:
15927 +               __asm__ ("movq %%db2,%0\n\t":"=r"(contents));
15928 +               break;
15929 +       case 3:
15930 +               __asm__ ("movq %%db3,%0\n\t":"=r"(contents));
15931 +               break;
15932 +       case 4:
15933 +       case 5:
15934 +               break;
15935 +       case 6:
15936 +               __asm__ ("movq %%db6,%0\n\t":"=r"(contents));
15937 +               break;
15938 +       case 7:
15939 +               __asm__ ("movq %%db7,%0\n\t":"=r"(contents));
15940 +               break;
15941 +       default:
15942 +               break;
15943 +       }
15944 +
15945 +       return contents;
15946 +}
15947 +
15948 +
15949 +kdb_machreg_t
15950 +kdb_getcr(int regnum)
15951 +{
15952 +       kdb_machreg_t contents = 0;
15953 +       switch(regnum) {
15954 +       case 0:
15955 +               __asm__ ("movq %%cr0,%0\n\t":"=r"(contents));
15956 +               break;
15957 +       case 1:
15958 +               break;
15959 +       case 2:
15960 +               __asm__ ("movq %%cr2,%0\n\t":"=r"(contents));
15961 +               break;
15962 +       case 3:
15963 +               __asm__ ("movq %%cr3,%0\n\t":"=r"(contents));
15964 +               break;
15965 +       case 4:
15966 +               __asm__ ("movq %%cr4,%0\n\t":"=r"(contents));
15967 +               break;
15968 +       default:
15969 +               break;
15970 +       }
15971 +
15972 +       return contents;
15973 +}
15974 +
15975 +void
15976 +kdba_putdr(int regnum, kdb_machreg_t contents)
15977 +{
15978 +       switch(regnum) {
15979 +       case 0:
15980 +               __asm__ ("movq %0,%%db0\n\t"::"r"(contents));
15981 +               break;
15982 +       case 1:
15983 +               __asm__ ("movq %0,%%db1\n\t"::"r"(contents));
15984 +               break;
15985 +       case 2:
15986 +               __asm__ ("movq %0,%%db2\n\t"::"r"(contents));
15987 +               break;
15988 +       case 3:
15989 +               __asm__ ("movq %0,%%db3\n\t"::"r"(contents));
15990 +               break;
15991 +       case 4:
15992 +       case 5:
15993 +               break;
15994 +       case 6:
15995 +               __asm__ ("movq %0,%%db6\n\t"::"r"(contents));
15996 +               break;
15997 +       case 7:
15998 +               __asm__ ("movq %0,%%db7\n\t"::"r"(contents));
15999 +               break;
16000 +       default:
16001 +               break;
16002 +       }
16003 +}
16004 +
16005 +/*
16006 + * kdba_getregcontents
16007 + *
16008 + *     Return the contents of the register specified by the
16009 + *     input string argument.   Return an error if the string
16010 + *     does not match a machine register.
16011 + *
16012 + *     The following pseudo register names are supported:
16013 + *        &regs         - Prints address of exception frame
16014 + *        krsp          - Prints kernel stack pointer at time of fault
16015 + *        crsp          - Prints current kernel stack pointer, inside kdb
16016 + *        ceflags       - Prints current flags, inside kdb
16017 + *        %<regname>    - Uses the value of the registers at the
16018 + *                        last time the user process entered kernel
16019 + *                        mode, instead of the registers at the time
16020 + *                        kdb was entered.
16021 + *
16022 + * Parameters:
16023 + *     regname         Pointer to string naming register
16024 + *     regs            Pointer to structure containing registers.
16025 + * Outputs:
16026 + *     *contents       Pointer to unsigned long to recieve register contents
16027 + * Returns:
16028 + *     0               Success
16029 + *     KDB_BADREG      Invalid register name
16030 + * Locking:
16031 + *     None.
16032 + * Remarks:
16033 + *     If kdb was entered via an interrupt from the kernel itself then
16034 + *     ss and sp are *not* on the stack.
16035 + */
16036 +
16037 +static struct kdbregs {
16038 +       char   *reg_name;
16039 +       size_t  reg_offset;
16040 +} kdbreglist[] = {
16041 +       { "r15",        offsetof(struct pt_regs, r15) },
16042 +       { "r14",        offsetof(struct pt_regs, r14) },
16043 +       { "r13",        offsetof(struct pt_regs, r13) },
16044 +       { "r12",        offsetof(struct pt_regs, r12) },
16045 +       { "bp",         offsetof(struct pt_regs, bp) },
16046 +       { "bx",         offsetof(struct pt_regs, bx) },
16047 +       { "r11",        offsetof(struct pt_regs, r11) },
16048 +       { "r10",        offsetof(struct pt_regs, r10) },
16049 +       { "r9",         offsetof(struct pt_regs, r9) },
16050 +       { "r8",         offsetof(struct pt_regs, r8) },
16051 +       { "ax",         offsetof(struct pt_regs, ax) },
16052 +       { "cx",         offsetof(struct pt_regs, cx) },
16053 +       { "dx",         offsetof(struct pt_regs, dx) },
16054 +       { "si",         offsetof(struct pt_regs, si) },
16055 +       { "di",         offsetof(struct pt_regs, di) },
16056 +       { "orig_ax",    offsetof(struct pt_regs, orig_ax) },
16057 +       { "ip",         offsetof(struct pt_regs, ip) },
16058 +       { "cs",         offsetof(struct pt_regs, cs) },
16059 +       { "flags",      offsetof(struct pt_regs, flags) },
16060 +       { "sp",         offsetof(struct pt_regs, sp) },
16061 +       { "ss",         offsetof(struct pt_regs, ss) },
16062 +};
16063 +
16064 +static const int nkdbreglist = sizeof(kdbreglist) / sizeof(struct kdbregs);
16065 +
16066 +static struct kdbregs dbreglist[] = {
16067 +       { "dr0",        0 },
16068 +       { "dr1",        1 },
16069 +       { "dr2",        2 },
16070 +       { "dr3",        3 },
16071 +       { "dr6",        6 },
16072 +       { "dr7",        7 },
16073 +};
16074 +
16075 +static const int ndbreglist = sizeof(dbreglist) / sizeof(struct kdbregs);
16076 +
16077 +int
16078 +kdba_getregcontents(const char *regname,
16079 +                   struct pt_regs *regs,
16080 +                   kdb_machreg_t *contents)
16081 +{
16082 +       int i;
16083 +
16084 +       if (strcmp(regname, "&regs") == 0) {
16085 +               *contents = (unsigned long)regs;
16086 +               return 0;
16087 +       }
16088 +
16089 +       if (strcmp(regname, "krsp") == 0) {
16090 +               *contents = (unsigned long)regs + sizeof(struct pt_regs);
16091 +               if ((regs->cs & 0xffff) == __KERNEL_CS) {
16092 +                       /* sp and ss are not on stack */
16093 +                       *contents -= 2*4;
16094 +               }
16095 +               return 0;
16096 +       }
16097 +
16098 +       if (strcmp(regname, "crsp") == 0) {
16099 +               asm volatile("movq %%rsp,%0":"=m" (*contents));
16100 +               return 0;
16101 +       }
16102 +
16103 +       if (strcmp(regname, "ceflags") == 0) {
16104 +               unsigned long flags;
16105 +               local_save_flags(flags);
16106 +               *contents = flags;
16107 +               return 0;
16108 +       }
16109 +
16110 +       if (regname[0] == '%') {
16111 +               /* User registers:  %%r[a-c]x, etc */
16112 +               regname++;
16113 +               regs = (struct pt_regs *)
16114 +                       (current->thread.sp0 - sizeof(struct pt_regs));
16115 +       }
16116 +
16117 +       for (i=0; i<nkdbreglist; i++) {
16118 +               if (strnicmp(kdbreglist[i].reg_name,
16119 +                            regname,
16120 +                            strlen(regname)) == 0)
16121 +                       break;
16122 +       }
16123 +
16124 +       if ((i < nkdbreglist)
16125 +        && (strlen(kdbreglist[i].reg_name) == strlen(regname))) {
16126 +               if ((regs->cs & 0xffff) == __KERNEL_CS) {
16127 +                       /* No cpl switch, sp is not on stack */
16128 +                       if (strcmp(kdbreglist[i].reg_name, "sp") == 0) {
16129 +                               *contents = (kdb_machreg_t)regs +
16130 +                                       sizeof(struct pt_regs) - 2*8;
16131 +                               return(0);
16132 +                       }
16133 +#if 0  /* FIXME */
16134 +                       if (strcmp(kdbreglist[i].reg_name, "ss") == 0) {
16135 +                               kdb_machreg_t r;
16136 +
16137 +                               r = (kdb_machreg_t)regs +
16138 +                                       sizeof(struct pt_regs) - 2*8;
16139 +                               *contents = (kdb_machreg_t)SS(r);       /* XXX */
16140 +                               return(0);
16141 +                       }
16142 +#endif
16143 +               }
16144 +               *contents = *(unsigned long *)((unsigned long)regs +
16145 +                               kdbreglist[i].reg_offset);
16146 +               return(0);
16147 +       }
16148 +
16149 +       for (i=0; i<ndbreglist; i++) {
16150 +               if (strnicmp(dbreglist[i].reg_name,
16151 +                            regname,
16152 +                            strlen(regname)) == 0)
16153 +                       break;
16154 +       }
16155 +
16156 +       if ((i < ndbreglist)
16157 +        && (strlen(dbreglist[i].reg_name) == strlen(regname))) {
16158 +               *contents = kdba_getdr(dbreglist[i].reg_offset);
16159 +               return 0;
16160 +       }
16161 +       return KDB_BADREG;
16162 +}
16163 +
16164 +/*
16165 + * kdba_setregcontents
16166 + *
16167 + *     Set the contents of the register specified by the
16168 + *     input string argument.   Return an error if the string
16169 + *     does not match a machine register.
16170 + *
16171 + *     Supports modification of user-mode registers via
16172 + *     %<register-name>
16173 + *
16174 + * Parameters:
16175 + *     regname         Pointer to string naming register
16176 + *     regs            Pointer to structure containing registers.
16177 + *     contents        Unsigned long containing new register contents
16178 + * Outputs:
16179 + * Returns:
16180 + *     0               Success
16181 + *     KDB_BADREG      Invalid register name
16182 + * Locking:
16183 + *     None.
16184 + * Remarks:
16185 + */
16186 +
16187 +int
16188 +kdba_setregcontents(const char *regname,
16189 +                 struct pt_regs *regs,
16190 +                 unsigned long contents)
16191 +{
16192 +       int i;
16193 +
16194 +       if (regname[0] == '%') {
16195 +               regname++;
16196 +               regs = (struct pt_regs *)
16197 +                       (current->thread.sp0 - sizeof(struct pt_regs));
16198 +       }
16199 +
16200 +       for (i=0; i<nkdbreglist; i++) {
16201 +               if (strnicmp(kdbreglist[i].reg_name,
16202 +                            regname,
16203 +                            strlen(regname)) == 0)
16204 +                       break;
16205 +       }
16206 +
16207 +       if ((i < nkdbreglist)
16208 +        && (strlen(kdbreglist[i].reg_name) == strlen(regname))) {
16209 +               *(unsigned long *)((unsigned long)regs
16210 +                                  + kdbreglist[i].reg_offset) = contents;
16211 +               return 0;
16212 +       }
16213 +
16214 +       for (i=0; i<ndbreglist; i++) {
16215 +               if (strnicmp(dbreglist[i].reg_name,
16216 +                            regname,
16217 +                            strlen(regname)) == 0)
16218 +                       break;
16219 +       }
16220 +
16221 +       if ((i < ndbreglist)
16222 +        && (strlen(dbreglist[i].reg_name) == strlen(regname))) {
16223 +               kdba_putdr(dbreglist[i].reg_offset, contents);
16224 +               return 0;
16225 +       }
16226 +
16227 +       return KDB_BADREG;
16228 +}
16229 +
16230 +/*
16231 + * kdba_dumpregs
16232 + *
16233 + *     Dump the specified register set to the display.
16234 + *
16235 + * Parameters:
16236 + *     regs            Pointer to structure containing registers.
16237 + *     type            Character string identifying register set to dump
16238 + *     extra           string further identifying register (optional)
16239 + * Outputs:
16240 + * Returns:
16241 + *     0               Success
16242 + * Locking:
16243 + *     None.
16244 + * Remarks:
16245 + *     This function will dump the general register set if the type
16246 + *     argument is NULL (struct pt_regs).   The alternate register
16247 + *     set types supported by this function:
16248 + *
16249 + *     d               Debug registers
16250 + *     c               Control registers
16251 + *     u               User registers at most recent entry to kernel
16252 + * Following not yet implemented:
16253 + *     r               Memory Type Range Registers (extra defines register)
16254 + *
16255 + * MSR on i386/x86_64 are handled by rdmsr/wrmsr commands.
16256 + */
16257 +
16258 +int
16259 +kdba_dumpregs(struct pt_regs *regs,
16260 +           const char *type,
16261 +           const char *extra)
16262 +{
16263 +       int i;
16264 +       int count = 0;
16265 +
16266 +       if (type
16267 +        && (type[0] == 'u')) {
16268 +               type = NULL;
16269 +               regs = (struct pt_regs *)
16270 +                       (current->thread.sp0 - sizeof(struct pt_regs));
16271 +       }
16272 +
16273 +       if (type == NULL) {
16274 +               struct kdbregs *rlp;
16275 +               kdb_machreg_t contents;
16276 +
16277 +               for (i=0, rlp=kdbreglist; i<nkdbreglist; i++,rlp++) {
16278 +                       kdb_printf("%8s = ", rlp->reg_name);
16279 +                       kdba_getregcontents(rlp->reg_name, regs, &contents);
16280 +                       kdb_printf("0x%016lx ", contents);
16281 +                       if ((++count % 2) == 0)
16282 +                               kdb_printf("\n");
16283 +               }
16284 +
16285 +               kdb_printf("&regs = 0x%p\n", regs);
16286 +
16287 +               return 0;
16288 +       }
16289 +
16290 +       switch (type[0]) {
16291 +       case 'd':
16292 +       {
16293 +               unsigned long dr[8];
16294 +
16295 +               for(i=0; i<8; i++) {
16296 +                       if ((i == 4) || (i == 5)) continue;
16297 +                       dr[i] = kdba_getdr(i);
16298 +               }
16299 +               kdb_printf("dr0 = 0x%08lx  dr1 = 0x%08lx  dr2 = 0x%08lx  dr3 = 0x%08lx\n",
16300 +                          dr[0], dr[1], dr[2], dr[3]);
16301 +               kdb_printf("dr6 = 0x%08lx  dr7 = 0x%08lx\n",
16302 +                          dr[6], dr[7]);
16303 +               return 0;
16304 +       }
16305 +       case 'c':
16306 +       {
16307 +               unsigned long cr[5];
16308 +
16309 +               for (i=0; i<5; i++) {
16310 +                       cr[i] = kdb_getcr(i);
16311 +               }
16312 +               kdb_printf("cr0 = 0x%08lx  cr1 = 0x%08lx  cr2 = 0x%08lx  cr3 = 0x%08lx\ncr4 = 0x%08lx\n",
16313 +                          cr[0], cr[1], cr[2], cr[3], cr[4]);
16314 +               return 0;
16315 +       }
16316 +       case 'r':
16317 +               break;
16318 +       default:
16319 +               return KDB_BADREG;
16320 +       }
16321 +
16322 +       /* NOTREACHED */
16323 +       return 0;
16324 +}
16325 +EXPORT_SYMBOL(kdba_dumpregs);
16326 +
16327 +kdb_machreg_t
16328 +kdba_getpc(struct pt_regs *regs)
16329 +{
16330 +       return regs->ip;
16331 +}
16332 +
16333 +int
16334 +kdba_setpc(struct pt_regs *regs, kdb_machreg_t newpc)
16335 +{
16336 +       if (KDB_NULL_REGS(regs))
16337 +               return KDB_BADREG;
16338 +       regs->ip = newpc;
16339 +       KDB_STATE_SET(IP_ADJUSTED);
16340 +       return 0;
16341 +}
16342 +
16343 +/*
16344 + * kdba_main_loop
16345 + *
16346 + *     Do any architecture specific set up before entering the main kdb loop.
16347 + *     The primary function of this routine is to make all processes look the
16348 + *     same to kdb, kdb must be able to list a process without worrying if the
16349 + *     process is running or blocked, so make all process look as though they
16350 + *     are blocked.
16351 + *
16352 + * Inputs:
16353 + *     reason          The reason KDB was invoked
16354 + *     error           The hardware-defined error code
16355 + *     error2          kdb's current reason code.  Initially error but can change
16356 + *                     acording to kdb state.
16357 + *     db_result       Result from break or debug point.
16358 + *     ef              The exception frame at time of fault/breakpoint.  If reason
16359 + *                     is SILENT or CPU_UP then regs is NULL, otherwise it should
16360 + *                     always be valid.
16361 + * Returns:
16362 + *     0       KDB was invoked for an event which it wasn't responsible
16363 + *     1       KDB handled the event for which it was invoked.
16364 + * Outputs:
16365 + *     Sets ip and sp in current->thread.
16366 + * Locking:
16367 + *     None.
16368 + * Remarks:
16369 + *     none.
16370 + */
16371 +
16372 +int
16373 +kdba_main_loop(kdb_reason_t reason, kdb_reason_t reason2, int error,
16374 +              kdb_dbtrap_t db_result, struct pt_regs *regs)
16375 +{
16376 +       int ret;
16377 +
16378 +       if (regs)
16379 +               kdba_getregcontents("sp", regs, &(current->thread.sp));
16380 +       ret = kdb_save_running(regs, reason, reason2, error, db_result);
16381 +       kdb_unsave_running(regs);
16382 +       return ret;
16383 +}
16384 +
16385 +void
16386 +kdba_disableint(kdb_intstate_t *state)
16387 +{
16388 +       unsigned long *fp = (unsigned long *)state;
16389 +       unsigned long flags;
16390 +
16391 +       local_irq_save(flags);
16392 +       *fp = flags;
16393 +}
16394 +
16395 +void
16396 +kdba_restoreint(kdb_intstate_t *state)
16397 +{
16398 +       unsigned long flags = *(unsigned long *)state;
16399 +       local_irq_restore(flags);
16400 +}
16401 +
16402 +void
16403 +kdba_setsinglestep(struct pt_regs *regs)
16404 +{
16405 +       if (KDB_NULL_REGS(regs))
16406 +               return;
16407 +       if (regs->flags & X86_EFLAGS_IF)
16408 +               KDB_STATE_SET(A_IF);
16409 +       else
16410 +               KDB_STATE_CLEAR(A_IF);
16411 +       regs->flags = (regs->flags | X86_EFLAGS_TF) & ~X86_EFLAGS_IF;
16412 +}
16413 +
16414 +void
16415 +kdba_clearsinglestep(struct pt_regs *regs)
16416 +{
16417 +       if (KDB_NULL_REGS(regs))
16418 +               return;
16419 +       if (KDB_STATE(A_IF))
16420 +               regs->flags |= X86_EFLAGS_IF;
16421 +       else
16422 +               regs->flags &= ~X86_EFLAGS_IF;
16423 +}
16424 +
16425 +int asmlinkage
16426 +kdba_setjmp(kdb_jmp_buf *jb)
16427 +{
16428 +#ifdef CONFIG_FRAME_POINTER
16429 +       __asm__ __volatile__
16430 +               ("movq %%rbx, (0*8)(%%rdi);"
16431 +               "movq %%rcx, (1*8)(%%rdi);"
16432 +               "movq %%r12, (2*8)(%%rdi);"
16433 +               "movq %%r13, (3*8)(%%rdi);"
16434 +               "movq %%r14, (4*8)(%%rdi);"
16435 +               "movq %%r15, (5*8)(%%rdi);"
16436 +               "leaq 16(%%rsp), %%rdx;"
16437 +               "movq %%rdx, (6*8)(%%rdi);"
16438 +               "movq %%rax, (7*8)(%%rdi)"
16439 +               :
16440 +               : "a" (__builtin_return_address(0)),
16441 +                 "c" (__builtin_frame_address(1))
16442 +               );
16443 +#else   /* !CONFIG_FRAME_POINTER */
16444 +       __asm__ __volatile__
16445 +               ("movq %%rbx, (0*8)(%%rdi);"
16446 +               "movq %%rbp, (1*8)(%%rdi);"
16447 +               "movq %%r12, (2*8)(%%rdi);"
16448 +               "movq %%r13, (3*8)(%%rdi);"
16449 +               "movq %%r14, (4*8)(%%rdi);"
16450 +               "movq %%r15, (5*8)(%%rdi);"
16451 +               "leaq 8(%%rsp), %%rdx;"
16452 +               "movq %%rdx, (6*8)(%%rdi);"
16453 +               "movq %%rax, (7*8)(%%rdi)"
16454 +               :
16455 +               : "a" (__builtin_return_address(0))
16456 +               );
16457 +#endif   /* CONFIG_FRAME_POINTER */
16458 +       return 0;
16459 +}
16460 +
16461 +void asmlinkage
16462 +kdba_longjmp(kdb_jmp_buf *jb, int reason)
16463 +{
16464 +       __asm__("movq (0*8)(%rdi),%rbx;"
16465 +               "movq (1*8)(%rdi),%rbp;"
16466 +               "movq (2*8)(%rdi),%r12;"
16467 +               "movq (3*8)(%rdi),%r13;"
16468 +               "movq (4*8)(%rdi),%r14;"
16469 +               "movq (5*8)(%rdi),%r15;"
16470 +               "movq (7*8)(%rdi),%rdx;"
16471 +               "movq (6*8)(%rdi),%rsp;"
16472 +               "mov %rsi, %rax;"
16473 +               "jmpq *%rdx");
16474 +}
16475 +
16476 +/*
16477 + * kdba_pt_regs
16478 + *
16479 + *     Format a struct pt_regs
16480 + *
16481 + * Inputs:
16482 + *     argc    argument count
16483 + *     argv    argument vector
16484 + * Outputs:
16485 + *     None.
16486 + * Returns:
16487 + *     zero for success, a kdb diagnostic if error
16488 + * Locking:
16489 + *     none.
16490 + * Remarks:
16491 + *     If no address is supplied, it uses the current irq pt_regs.
16492 + */
16493 +
16494 +static int
16495 +kdba_pt_regs(int argc, const char **argv)
16496 +{
16497 +       int diag;
16498 +       kdb_machreg_t addr;
16499 +       long offset = 0;
16500 +       int nextarg;
16501 +       struct pt_regs *p;
16502 +       static const char *fmt = "  %-11.11s 0x%lx\n";
16503 +       static int first_time = 1;
16504 +
16505 +       if (argc == 0) {
16506 +               addr = (kdb_machreg_t) get_irq_regs();
16507 +       } else if (argc == 1) {
16508 +               nextarg = 1;
16509 +               diag = kdbgetaddrarg(argc, argv, &nextarg, &addr, &offset, NULL);
16510 +               if (diag)
16511 +                       return diag;
16512 +       } else {
16513 +               return KDB_ARGCOUNT;
16514 +       }
16515 +
16516 +       p = (struct pt_regs *) addr;
16517 +       if (first_time) {
16518 +               first_time = 0;
16519 +               kdb_printf("\n+++ Warning: x86_64 pt_regs are not always "
16520 +                          "completely defined, r15-bx may be invalid\n\n");
16521 +       }
16522 +       kdb_printf("struct pt_regs 0x%p-0x%p\n", p, (unsigned char *)p + sizeof(*p) - 1);
16523 +       kdb_print_nameval("r15", p->r15);
16524 +       kdb_print_nameval("r14", p->r14);
16525 +       kdb_print_nameval("r13", p->r13);
16526 +       kdb_print_nameval("r12", p->r12);
16527 +       kdb_print_nameval("bp", p->bp);
16528 +       kdb_print_nameval("bx", p->bx);
16529 +       kdb_print_nameval("r11", p->r11);
16530 +       kdb_print_nameval("r10", p->r10);
16531 +       kdb_print_nameval("r9", p->r9);
16532 +       kdb_print_nameval("r8", p->r8);
16533 +       kdb_print_nameval("ax", p->ax);
16534 +       kdb_print_nameval("cx", p->cx);
16535 +       kdb_print_nameval("dx", p->dx);
16536 +       kdb_print_nameval("si", p->si);
16537 +       kdb_print_nameval("di", p->di);
16538 +       kdb_print_nameval("orig_ax", p->orig_ax);
16539 +       kdb_print_nameval("ip", p->ip);
16540 +       kdb_printf(fmt, "cs", p->cs);
16541 +       kdb_printf(fmt, "flags", p->flags);
16542 +       kdb_printf(fmt, "sp", p->sp);
16543 +       kdb_printf(fmt, "ss", p->ss);
16544 +       return 0;
16545 +}
16546 +
16547 +/*
16548 + * kdba_cpu_pda
16549 + *
16550 + *     Format a struct cpu_pda
16551 + *
16552 + * Inputs:
16553 + *     argc    argument count
16554 + *     argv    argument vector
16555 + * Outputs:
16556 + *     None.
16557 + * Returns:
16558 + *     zero for success, a kdb diagnostic if error
16559 + * Locking:
16560 + *     none.
16561 + * Remarks:
16562 + *     If no cpu is supplied, it prints the current cpu.  If the cpu is '*'
16563 + *     then it prints all cpus.
16564 + */
16565 +
16566 +static int
16567 +kdba_cpu_pda(int argc, const char **argv)
16568 +{
16569 +       int diag, nextarg, all_cpus = 0;
16570 +       long offset = 0;
16571 +       unsigned long cpu;
16572 +       struct x8664_pda *c;
16573 +       static const char *fmtl = "  %-17.17s 0x%lx\n";
16574 +       static const char *fmtd = "  %-17.17s %d\n";
16575 +       static const char *fmtp = "  %-17.17s 0x%p\n";
16576 +
16577 +       if (argc == 0) {
16578 +               cpu = smp_processor_id();
16579 +       } else if (argc == 1) {
16580 +               if (strcmp(argv[1], "*") == 0) {
16581 +                       all_cpus = 1;
16582 +                       cpu = 0;
16583 +               } else {
16584 +                       nextarg = 1;
16585 +                       diag = kdbgetaddrarg(argc, argv, &nextarg, &cpu, &offset, NULL);
16586 +                       if (diag)
16587 +                               return diag;
16588 +               }
16589 +       } else {
16590 +               return KDB_ARGCOUNT;
16591 +       }
16592 +
16593 +       for (; cpu < NR_CPUS; ++cpu) {
16594 +               if (cpu_online(cpu)) {
16595 +                       c = cpu_pda(cpu);
16596 +                       kdb_printf("struct cpu_pda 0x%p-0x%p\n", c, (unsigned char *)c + sizeof(*c) - 1);
16597 +                       kdb_printf(fmtp, "pcurrent", c->pcurrent);
16598 +                       kdb_printf(fmtl, "data_offset", c->data_offset);
16599 +                       kdb_printf(fmtl, "kernelstack", c->kernelstack);
16600 +                       kdb_printf(fmtl, "oldrsp", c->oldrsp);
16601 +                       kdb_printf(fmtd, "irqcount", c->irqcount);
16602 +                       kdb_printf(fmtd, "cpunumber", c->cpunumber);
16603 +                       kdb_printf(fmtp, "irqstackptr", c->irqstackptr);
16604 +                       kdb_printf(fmtp, "nodenumber", cpu_to_node(cpu));
16605 +                       kdb_printf(fmtd, "__softirq_pending", c->__softirq_pending);
16606 +                       kdb_printf(fmtd, "__nmi_count", c->__nmi_count);
16607 +                       kdb_printf(fmtd, "mmu_state", c->mmu_state);
16608 +                       kdb_printf(fmtp, "active_mm", c->active_mm);
16609 +                       kdb_printf(fmtd, "apic_timer_irqs", c->apic_timer_irqs);
16610 +               }
16611 +               if (!all_cpus)
16612 +                       break;
16613 +       }
16614 +       return 0;
16615 +}
16616 +
16617 +/*
16618 + * kdba_entry
16619 + *
16620 + *     This is the interface routine between
16621 + *     the notifier die_chain and kdb
16622 + */
16623 +static int kdba_entry( struct notifier_block *b, unsigned long val, void *v)
16624 +{
16625 +       struct die_args *args = v;
16626 +       int err, trap, ret = 0;
16627 +       struct pt_regs *regs;
16628 +
16629 +       regs = args->regs;
16630 +       err  = args->err;
16631 +       trap  = args->trapnr;
16632 +       switch (val){
16633 +#ifdef CONFIG_SMP
16634 +               case DIE_NMI_IPI:
16635 +                       ret = kdb_ipi(regs, NULL);
16636 +                       break;
16637 +#endif /* CONFIG_SMP */
16638 +               case DIE_OOPS:
16639 +                       ret = kdb(KDB_REASON_OOPS, err, regs);
16640 +                       break;
16641 +               case DIE_CALL:
16642 +                       ret = kdb(KDB_REASON_ENTER, err, regs);
16643 +                       break;
16644 +               case DIE_DEBUG:
16645 +                       ret = kdb(KDB_REASON_DEBUG, err, regs);
16646 +                       break;
16647 +               case DIE_NMIWATCHDOG:
16648 +                       ret = kdb(KDB_REASON_NMI, err, regs);
16649 +                       break;
16650 +               case DIE_INT3:
16651 +                        ret = kdb(KDB_REASON_BREAK, err, regs);
16652 +                       // falls thru
16653 +               default:
16654 +                       break;
16655 +       }
16656 +       return (ret ? NOTIFY_STOP : NOTIFY_DONE);
16657 +}
16658 +
16659 +/*
16660 + * notifier block for kdb entry
16661 + */
16662 +static struct notifier_block kdba_notifier = {
16663 +       .notifier_call = kdba_entry
16664 +};
16665 +
16666 +asmlinkage int kdb_call(void);
16667 +
16668 +/* Executed once on each cpu at startup. */
16669 +void
16670 +kdba_cpu_up(void)
16671 +{
16672 +}
16673 +
16674 +static int __init
16675 +kdba_arch_init(void)
16676 +{
16677 +#ifdef CONFIG_SMP
16678 +       set_intr_gate(KDB_VECTOR, kdb_interrupt);
16679 +#endif
16680 +       set_intr_gate(KDBENTER_VECTOR, kdb_call);
16681 +       return 0;
16682 +}
16683 +
16684 +arch_initcall(kdba_arch_init);
16685 +
16686 +/*
16687 + * kdba_init
16688 + *
16689 + *     Architecture specific initialization.
16690 + *
16691 + * Parameters:
16692 + *     None.
16693 + * Returns:
16694 + *     None.
16695 + * Locking:
16696 + *     None.
16697 + * Remarks:
16698 + *     None.
16699 + */
16700 +
16701 +void __init
16702 +kdba_init(void)
16703 +{
16704 +       kdba_arch_init();       /* Need to register KDBENTER_VECTOR early */
16705 +       kdb_register("pt_regs", kdba_pt_regs, "address", "Format struct pt_regs", 0);
16706 +       kdb_register("cpu_pda", kdba_cpu_pda, "<cpu>", "Format struct cpu_pda", 0);
16707 +       register_die_notifier(&kdba_notifier);
16708 +       return;
16709 +}
16710 +
16711 +/*
16712 + * kdba_adjust_ip
16713 + *
16714 + *     Architecture specific adjustment of instruction pointer before leaving
16715 + *     kdb.
16716 + *
16717 + * Parameters:
16718 + *     reason          The reason KDB was invoked
16719 + *     error           The hardware-defined error code
16720 + *     ef              The exception frame at time of fault/breakpoint.  If reason
16721 + *                     is SILENT or CPU_UP then regs is NULL, otherwise it should
16722 + *                     always be valid.
16723 + * Returns:
16724 + *     None.
16725 + * Locking:
16726 + *     None.
16727 + * Remarks:
16728 + *     noop on ix86.
16729 + */
16730 +
16731 +void
16732 +kdba_adjust_ip(kdb_reason_t reason, int error, struct pt_regs *ef)
16733 +{
16734 +       return;
16735 +}
16736 +
16737 +void
16738 +kdba_set_current_task(const struct task_struct *p)
16739 +{
16740 +       kdb_current_task = p;
16741 +       if (kdb_task_has_cpu(p)) {
16742 +               struct kdb_running_process *krp = kdb_running_process + kdb_process_cpu(p);
16743 +               kdb_current_regs = krp->regs;
16744 +               return;
16745 +       }
16746 +       kdb_current_regs = NULL;
16747 +}
16748 +
16749 +#ifdef CONFIG_SMP
16750 +
16751 +#include <mach_ipi.h>
16752 +
16753 +/* When first entering KDB, try a normal IPI.  That reduces backtrace problems
16754 + * on the other cpus.
16755 + */
16756 +void
16757 +smp_kdb_stop(void)
16758 +{
16759 +       if (!KDB_FLAG(NOIPI))
16760 +               send_IPI_allbutself(KDB_VECTOR);
16761 +}
16762 +
16763 +/* The normal KDB IPI handler */
16764 +extern asmlinkage void smp_kdb_interrupt(struct pt_regs *regs);        /* for sparse */
16765 +asmlinkage void
16766 +smp_kdb_interrupt(struct pt_regs *regs)
16767 +{
16768 +       struct pt_regs *old_regs = set_irq_regs(regs);
16769 +       ack_APIC_irq();
16770 +       irq_enter();
16771 +       kdb_ipi(regs, NULL);
16772 +       irq_exit();
16773 +       set_irq_regs(old_regs);
16774 +}
16775 +
16776 +/* Invoked once from kdb_wait_for_cpus when waiting for cpus.  For those cpus
16777 + * that have not responded to the normal KDB interrupt yet, hit them with an
16778 + * NMI event.
16779 + */
16780 +void
16781 +kdba_wait_for_cpus(void)
16782 +{
16783 +       int c;
16784 +       if (KDB_FLAG(CATASTROPHIC))
16785 +               return;
16786 +       kdb_printf("  Sending NMI to non-responding cpus: ");
16787 +       for_each_online_cpu(c) {
16788 +               if (kdb_running_process[c].seqno < kdb_seqno - 1) {
16789 +                       kdb_printf(" %d", c);
16790 +                       send_IPI_mask(&cpumask_of_cpu(c), NMI_VECTOR);
16791 +               }
16792 +       }
16793 +       kdb_printf(".\n");
16794 +}
16795 +
16796 +#endif /* CONFIG_SMP */
16797 --- /dev/null
16798 +++ b/arch/x86/kdb/kdba_support.c
16799 @@ -0,0 +1,59 @@
16800 +/*
16801 + * Kernel Debugger Architecture Independent Support Functions
16802 + *
16803 + * This file is subject to the terms and conditions of the GNU General Public
16804 + * License.  See the file "COPYING" in the main directory of this archive
16805 + * for more details.
16806 + *
16807 + * Copyright (c) 1999-2008 Silicon Graphics, Inc.  All Rights Reserved.
16808 + */
16809 +
16810 +#include <linux/string.h>
16811 +#include <linux/stddef.h>
16812 +#include <linux/kernel.h>
16813 +#include <linux/init.h>
16814 +#include <linux/ptrace.h>
16815 +#include <linux/mm.h>
16816 +#include <linux/sched.h>
16817 +#include <linux/hardirq.h>
16818 +#include <linux/kdb.h>
16819 +#include <linux/kdbprivate.h>
16820 +#include <linux/interrupt.h>
16821 +#include <linux/module.h>
16822 +#include <linux/kdebug.h>
16823 +#include <asm/processor.h>
16824 +#include <asm/msr.h>
16825 +#include <asm/uaccess.h>
16826 +#include <asm/hw_irq.h>
16827 +#include <asm/desc.h>
16828 +
16829 +#ifdef CONFIG_KDB_KDUMP
16830 +void kdba_kdump_prepare(struct pt_regs *regs)
16831 +{
16832 +       int i;
16833 +       struct pt_regs r;
16834 +       if (regs == NULL)
16835 +               regs = &r;
16836 +
16837 +       machine_crash_shutdown_begin();
16838 +
16839 +       for (i = 1; i < NR_CPUS; ++i) {
16840 +               if (!cpu_online(i))
16841 +                       continue;
16842 +
16843 +               KDB_STATE_SET_CPU(KEXEC, i);
16844 +       }
16845 +
16846 +       machine_crash_shutdown_end(regs);
16847 +}
16848 +
16849 +extern void halt_current_cpu(struct pt_regs *);
16850 +
16851 +void kdba_kdump_shutdown_slave(struct pt_regs *regs)
16852 +{
16853 +#ifndef CONFIG_XEN
16854 +       halt_current_cpu(regs);
16855 +#endif /* CONFIG_XEN */
16856 +}
16857 +
16858 +#endif
16859 --- /dev/null
16860 +++ b/arch/x86/kdb/kdb_cmds_32
16861 @@ -0,0 +1,17 @@
16862 +# Standard architecture specific commands for kdb.
16863 +# These commands are appended to those in kdb/kdb_cmds, see that file for
16864 +# restrictions.
16865 +
16866 +# Standard debugging information for first level support, invoked from archkdb*
16867 +# commands that are defined in kdb/kdb_cmds.
16868 +
16869 +defcmd archkdbcommon "" "Common arch debugging"
16870 +  set LINES 2000000
16871 +  set BTAPROMPT 0
16872 +  -summary
16873 +  -id %eip-24
16874 +  -cpu
16875 +  -ps
16876 +  -dmesg 600
16877 +  -bt
16878 +endefcmd
16879 --- /dev/null
16880 +++ b/arch/x86/kdb/kdb_cmds_64
16881 @@ -0,0 +1,18 @@
16882 +# Standard architecture specific commands for kdb.
16883 +# These commands are appended to those in kdb/kdb_cmds, see that file for
16884 +# restrictions.
16885 +
16886 +# Standard debugging information for first level support, invoked from archkdb*
16887 +# commands that are defined in kdb/kdb_cmds.
16888 +
16889 +defcmd archkdbcommon "" "Common arch debugging"
16890 +  set LINES 2000000
16891 +  set BTAPROMPT 0
16892 +  -summary
16893 +  -id %rip-24
16894 +  -cpu
16895 +  -ps
16896 +  -dmesg 600
16897 +  -bt
16898 +  -cpu_pda *
16899 +endefcmd
16900 --- /dev/null
16901 +++ b/arch/x86/kdb/Makefile
16902 @@ -0,0 +1,5 @@
16903 +ifeq ($(CONFIG_X86_32),y)
16904 +include ${srctree}/arch/x86/kdb/Makefile_32
16905 +else
16906 +include ${srctree}/arch/x86/kdb/Makefile_64
16907 +endif
16908 --- /dev/null
16909 +++ b/arch/x86/kdb/Makefile_32
16910 @@ -0,0 +1,25 @@
16911 +#
16912 +# This file is subject to the terms and conditions of the GNU General Public
16913 +# License.  See the file "COPYING" in the main directory of this archive
16914 +# for more details.
16915 +#
16916 +# Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
16917 +#
16918 +
16919 +obj-$(CONFIG_KDB)      := kdba_bp_32.o kdbasupport_32.o i386-dis.o
16920 +
16921 +# The i386 and x86_64 backtrace commands are handled by common code.
16922 +obj-y          += kdba_bt.o kdba_io.o kdba_id.o kdba_support.o
16923 +ifneq (,$(findstring -fno-optimize-sibling-calls,$(KBUILD_CFLAGS)))
16924 +  CFLAGS_kdba_bt.o += -DNO_SIBLINGS
16925 +endif
16926 +REGPARM := $(subst -mregparm=,,$(filter -mregparm=%,$(KBUILD_CFLAGS)))
16927 +ifeq (,$(REGPARM))
16928 +  REGPARM := 3
16929 +endif
16930 +
16931 +CFLAGS_kdba_bt.o += -DREGPARM=$(REGPARM) -DCCVERSION="$(CCVERSION)"
16932 +
16933 +override CFLAGS := $(CFLAGS:%-pg=% )
16934 +
16935 +CFLAGS_kdba_io.o += -I $(TOPDIR)/arch/$(SRCARCH)/kdb
16936 --- /dev/null
16937 +++ b/arch/x86/kdb/Makefile_64
16938 @@ -0,0 +1,25 @@
16939 +#
16940 +# This file is subject to the terms and conditions of the GNU General Public
16941 +# License.  See the file "COPYING" in the main directory of this archive
16942 +# for more details.
16943 +#
16944 +# Copyright (c) 1999-2004 Silicon Graphics, Inc.  All Rights Reserved.
16945 +#
16946 +
16947 +obj-$(CONFIG_KDB)      := kdba_bp_64.o kdbasupport_64.o x86_64-dis.o
16948 +
16949 +# The i386 and x86_64 backtrace commands are handled by common code.
16950 +obj-y          += kdba_bt.o kdba_io.o kdba_id.o kdba_support.o
16951 +ifneq (,$(findstring -fno-optimize-sibling-calls,$(KBUILD_CFLAGS)))
16952 +  CFLAGS_kdba_bt.o += -DNO_SIBLINGS
16953 +endif
16954 +REGPARM := $(subst -mregparm=,,$(filter -mregparm=%,$(KBUILD_CFLAGS)))
16955 +ifeq (,$(REGPARM))
16956 +  REGPARM := 6
16957 +endif
16958 +
16959 +CFLAGS_kdba_bt.o += -DREGPARM=$(REGPARM) -DCCVERSION="$(CCVERSION)"
16960 +
16961 +override CFLAGS := $(CFLAGS:%-pg=% )
16962 +
16963 +CFLAGS_kdba_io.o += -I $(TOPDIR)/arch/$(SRCARCH)/kdb
16964 --- /dev/null
16965 +++ b/arch/x86/kdb/pc_keyb.h
16966 @@ -0,0 +1,137 @@
16967 +/*
16968 + *     include/linux/pc_keyb.h
16969 + *
16970 + *     PC Keyboard And Keyboard Controller
16971 + *
16972 + *     (c) 1997 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
16973 + */
16974 +
16975 +/*
16976 + *     Configuration Switches
16977 + */
16978 +
16979 +#undef KBD_REPORT_ERR                  /* Report keyboard errors */
16980 +#define        KBD_REPORT_UNKN                 /* Report unknown scan codes */
16981 +#define        KBD_REPORT_TIMEOUTS             /* Report keyboard timeouts */
16982 +#undef KBD_IS_FOCUS_9000               /* We have the brain-damaged FOCUS-9000 keyboard */
16983 +#undef INITIALIZE_MOUSE                /* Define if your PS/2 mouse needs initialization. */
16984 +
16985 +
16986 +
16987 +#define KBD_INIT_TIMEOUT 1000          /* Timeout in ms for initializing the keyboard */
16988 +#define KBC_TIMEOUT 250                        /* Timeout in ms for sending to keyboard controller */
16989 +#define KBD_TIMEOUT 1000               /* Timeout in ms for keyboard command acknowledge */
16990 +
16991 +/*
16992 + *     Internal variables of the driver
16993 + */
16994 +
16995 +extern unsigned char pckbd_read_mask;
16996 +extern unsigned char aux_device_present;
16997 +
16998 +/*
16999 + *     Keyboard Controller Registers on normal PCs.
17000 + */
17001 +
17002 +#define KBD_STATUS_REG         0x64    /* Status register (R) */
17003 +#define KBD_CNTL_REG           0x64    /* Controller command register (W) */
17004 +#define KBD_DATA_REG           0x60    /* Keyboard data register (R/W) */
17005 +
17006 +/*
17007 + *     Keyboard Controller Commands
17008 + */
17009 +
17010 +#define KBD_CCMD_READ_MODE     0x20    /* Read mode bits */
17011 +#define KBD_CCMD_WRITE_MODE    0x60    /* Write mode bits */
17012 +#define KBD_CCMD_GET_VERSION   0xA1    /* Get controller version */
17013 +#define KBD_CCMD_MOUSE_DISABLE 0xA7    /* Disable mouse interface */
17014 +#define KBD_CCMD_MOUSE_ENABLE  0xA8    /* Enable mouse interface */
17015 +#define KBD_CCMD_TEST_MOUSE    0xA9    /* Mouse interface test */
17016 +#define KBD_CCMD_SELF_TEST     0xAA    /* Controller self test */
17017 +#define KBD_CCMD_KBD_TEST      0xAB    /* Keyboard interface test */
17018 +#define KBD_CCMD_KBD_DISABLE   0xAD    /* Keyboard interface disable */
17019 +#define KBD_CCMD_KBD_ENABLE    0xAE    /* Keyboard interface enable */
17020 +#define KBD_CCMD_WRITE_AUX_OBUF        0xD3    /* Write to output buffer as if
17021 +                                          initiated by the auxiliary device */
17022 +#define KBD_CCMD_WRITE_MOUSE   0xD4    /* Write the following byte to the mouse */
17023 +
17024 +/*
17025 + *     Keyboard Commands
17026 + */
17027 +
17028 +#define KBD_CMD_SET_LEDS       0xED    /* Set keyboard leds */
17029 +#define KBD_CMD_SET_RATE       0xF3    /* Set typematic rate */
17030 +#define KBD_CMD_ENABLE         0xF4    /* Enable scanning */
17031 +#define KBD_CMD_DISABLE                0xF5    /* Disable scanning */
17032 +#define KBD_CMD_RESET          0xFF    /* Reset */
17033 +
17034 +/*
17035 + *     Keyboard Replies
17036 + */
17037 +
17038 +#define KBD_REPLY_POR          0xAA    /* Power on reset */
17039 +#define KBD_REPLY_ACK          0xFA    /* Command ACK */
17040 +#define KBD_REPLY_RESEND       0xFE    /* Command NACK, send the cmd again */
17041 +
17042 +/*
17043 + *     Status Register Bits
17044 + */
17045 +
17046 +#define KBD_STAT_OBF           0x01    /* Keyboard output buffer full */
17047 +#define KBD_STAT_IBF           0x02    /* Keyboard input buffer full */
17048 +#define KBD_STAT_SELFTEST      0x04    /* Self test successful */
17049 +#define KBD_STAT_CMD           0x08    /* Last write was a command write (0=data) */
17050 +#define KBD_STAT_UNLOCKED      0x10    /* Zero if keyboard locked */
17051 +#define KBD_STAT_MOUSE_OBF     0x20    /* Mouse output buffer full */
17052 +#define KBD_STAT_GTO           0x40    /* General receive/xmit timeout */
17053 +#define KBD_STAT_PERR          0x80    /* Parity error */
17054 +
17055 +#define AUX_STAT_OBF (KBD_STAT_OBF | KBD_STAT_MOUSE_OBF)
17056 +
17057 +/*
17058 + *     Controller Mode Register Bits
17059 + */
17060 +
17061 +#define KBD_MODE_KBD_INT       0x01    /* Keyboard data generate IRQ1 */
17062 +#define KBD_MODE_MOUSE_INT     0x02    /* Mouse data generate IRQ12 */
17063 +#define KBD_MODE_SYS           0x04    /* The system flag (?) */
17064 +#define KBD_MODE_NO_KEYLOCK    0x08    /* The keylock doesn't affect the keyboard if set */
17065 +#define KBD_MODE_DISABLE_KBD   0x10    /* Disable keyboard interface */
17066 +#define KBD_MODE_DISABLE_MOUSE 0x20    /* Disable mouse interface */
17067 +#define KBD_MODE_KCC           0x40    /* Scan code conversion to PC format */
17068 +#define KBD_MODE_RFU           0x80
17069 +
17070 +/*
17071 + *     Mouse Commands
17072 + */
17073 +
17074 +#define AUX_SET_RES            0xE8    /* Set resolution */
17075 +#define AUX_SET_SCALE11                0xE6    /* Set 1:1 scaling */
17076 +#define AUX_SET_SCALE21                0xE7    /* Set 2:1 scaling */
17077 +#define AUX_GET_SCALE          0xE9    /* Get scaling factor */
17078 +#define AUX_SET_STREAM         0xEA    /* Set stream mode */
17079 +#define AUX_SET_SAMPLE         0xF3    /* Set sample rate */
17080 +#define AUX_ENABLE_DEV         0xF4    /* Enable aux device */
17081 +#define AUX_DISABLE_DEV                0xF5    /* Disable aux device */
17082 +#define AUX_RESET              0xFF    /* Reset aux device */
17083 +#define AUX_ACK                        0xFA    /* Command byte ACK. */
17084 +
17085 +#define AUX_BUF_SIZE           2048    /* This might be better divisible by
17086 +                                          three to make overruns stay in sync
17087 +                                          but then the read function would need
17088 +                                          a lock etc - ick */
17089 +
17090 +struct aux_queue {
17091 +       unsigned long head;
17092 +       unsigned long tail;
17093 +       wait_queue_head_t proc_list;
17094 +       struct fasync_struct *fasync;
17095 +       unsigned char buf[AUX_BUF_SIZE];
17096 +};
17097 +
17098 +
17099 +/* How to access the keyboard macros on this platform.  */
17100 +#define kbd_read_input() inb(KBD_DATA_REG)
17101 +#define kbd_read_status() inb(KBD_STATUS_REG)
17102 +#define kbd_write_output(val) outb(val, KBD_DATA_REG)
17103 +#define kbd_write_command(val) outb(val, KBD_CNTL_REG)
17104 --- /dev/null
17105 +++ b/arch/x86/kdb/x86_64-dis.c
17106 @@ -0,0 +1,4686 @@
17107 +/* Print i386 instructions for GDB, the GNU debugger.
17108 +   Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
17109 +   2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
17110 +
17111 +   This file is part of GDB.
17112 +
17113 +   This program is free software; you can redistribute it and/or modify
17114 +   it under the terms of the GNU General Public License as published by
17115 +   the Free Software Foundation; either version 2 of the License, or
17116 +   (at your option) any later version.
17117 +
17118 +   This program is distributed in the hope that it will be useful,
17119 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
17120 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.         See the
17121 +   GNU General Public License for more details.
17122 +
17123 +   You should have received a copy of the GNU General Public License
17124 +   along with this program; if not, write to the Free Software
17125 +   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
17126 +
17127 +/* Extracted from binutils 2.16.91.0.2 (OpenSUSE 10.0) and modified for kdb use.
17128 + * Run through col -b to remove trailing whitespace and various #ifdef/ifndef
17129 + * __KERNEL__ added.
17130 + * Keith Owens <kaos@sgi.com> 15 May 2006
17131 + */
17132 +
17133 +/* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
17134 +   July 1988
17135 +    modified by John Hassey (hassey@dg-rtp.dg.com)
17136 +    x86-64 support added by Jan Hubicka (jh@suse.cz)
17137 +    VIA PadLock support by Michal Ludvig (mludvig@suse.cz).  */
17138 +
17139 +/* The main tables describing the instructions is essentially a copy
17140 +   of the "Opcode Map" chapter (Appendix A) of the Intel 80386
17141 +   Programmers Manual. Usually, there is a capital letter, followed
17142 +   by a small letter.  The capital letter tell the addressing mode,
17143 +   and the small letter tells about the operand size.  Refer to
17144 +   the Intel manual for details.  */
17145 +
17146 +#ifdef __KERNEL__
17147 +#include <linux/kernel.h>
17148 +#include <linux/string.h>
17149 +#include <linux/dis-asm.h>
17150 +#include <linux/kdb.h>
17151 +#define abort() BUG()
17152 +#else  /* __KERNEL__ */
17153 +#include "dis-asm.h"
17154 +#include "sysdep.h"
17155 +#include "opintl.h"
17156 +#endif /* __KERNEL__ */
17157 +
17158 +#define MAXLEN 20
17159 +
17160 +#ifndef __KERNEL__
17161 +#include <setjmp.h>
17162 +#endif /* __KERNEL__ */
17163 +
17164 +#ifndef UNIXWARE_COMPAT
17165 +/* Set non-zero for broken, compatible instructions.  Set to zero for
17166 +   non-broken opcodes. */
17167 +#define UNIXWARE_COMPAT 1
17168 +#endif
17169 +
17170 +static int fetch_data (struct disassemble_info *, bfd_byte *);
17171 +static void ckprefix (void);
17172 +static const char *prefix_name (int, int);
17173 +static int print_insn (bfd_vma, disassemble_info *);
17174 +static void dofloat (int);
17175 +static void OP_ST (int, int);
17176 +static void OP_STi (int, int);
17177 +static int putop (const char *, int);
17178 +static void oappend (const char *);
17179 +static void append_seg (void);
17180 +static void OP_indirE (int, int);
17181 +static void print_operand_value (char *, int, bfd_vma);
17182 +static void OP_E (int, int);
17183 +static void OP_G (int, int);
17184 +static bfd_vma get64 (void);
17185 +static bfd_signed_vma get32 (void);
17186 +static bfd_signed_vma get32s (void);
17187 +static int get16 (void);
17188 +static void set_op (bfd_vma, int);
17189 +static void OP_REG (int, int);
17190 +static void OP_IMREG (int, int);
17191 +static void OP_I (int, int);
17192 +static void OP_I64 (int, int);
17193 +static void OP_sI (int, int);
17194 +static void OP_J (int, int);
17195 +static void OP_SEG (int, int);
17196 +static void OP_DIR (int, int);
17197 +static void OP_OFF (int, int);
17198 +static void OP_OFF64 (int, int);
17199 +static void ptr_reg (int, int);
17200 +static void OP_ESreg (int, int);
17201 +static void OP_DSreg (int, int);
17202 +static void OP_C (int, int);
17203 +static void OP_D (int, int);
17204 +static void OP_T (int, int);
17205 +static void OP_Rd (int, int);
17206 +static void OP_MMX (int, int);
17207 +static void OP_XMM (int, int);
17208 +static void OP_EM (int, int);
17209 +static void OP_EX (int, int);
17210 +static void OP_MS (int, int);
17211 +static void OP_XS (int, int);
17212 +static void OP_M (int, int);
17213 +static void OP_VMX (int, int);
17214 +static void OP_0fae (int, int);
17215 +static void OP_0f07 (int, int);
17216 +static void NOP_Fixup (int, int);
17217 +static void OP_3DNowSuffix (int, int);
17218 +static void OP_SIMD_Suffix (int, int);
17219 +static void SIMD_Fixup (int, int);
17220 +static void PNI_Fixup (int, int);
17221 +static void SVME_Fixup (int, int);
17222 +static void INVLPG_Fixup (int, int);
17223 +static void BadOp (void);
17224 +static void SEG_Fixup (int, int);
17225 +static void VMX_Fixup (int, int);
17226 +
17227 +struct dis_private {
17228 +  /* Points to first byte not fetched. */
17229 +  bfd_byte *max_fetched;
17230 +  bfd_byte the_buffer[MAXLEN];
17231 +  bfd_vma insn_start;
17232 +  int orig_sizeflag;
17233 +#ifndef __KERNEL__
17234 +  jmp_buf bailout;
17235 +#endif /* __KERNEL__ */
17236 +};
17237 +
17238 +/* The opcode for the fwait instruction, which we treat as a prefix
17239 +   when we can.         */
17240 +#define FWAIT_OPCODE (0x9b)
17241 +
17242 +/* Set to 1 for 64bit mode disassembly.         */
17243 +static int mode_64bit;
17244 +
17245 +/* Flags for the prefixes for the current instruction. See below.  */
17246 +static int prefixes;
17247 +
17248 +/* REX prefix the current instruction. See below.  */
17249 +static int rex;
17250 +/* Bits of REX we've already used.  */
17251 +static int rex_used;
17252 +#define REX_MODE64     8
17253 +#define REX_EXTX       4
17254 +#define REX_EXTY       2
17255 +#define REX_EXTZ       1
17256 +/* Mark parts used in the REX prefix.  When we are testing for
17257 +   empty prefix (for 8bit register REX extension), just mask it
17258 +   out.         Otherwise test for REX bit is excuse for existence of REX
17259 +   only in case value is nonzero.  */
17260 +#define USED_REX(value)                                        \
17261 +  {                                                    \
17262 +    if (value)                                         \
17263 +      rex_used |= (rex & value) ? (value) | 0x40 : 0;  \
17264 +    else                                               \
17265 +      rex_used |= 0x40;                                        \
17266 +  }
17267 +
17268 +/* Flags for prefixes which we somehow handled when printing the
17269 +   current instruction.         */
17270 +static int used_prefixes;
17271 +
17272 +/* Flags stored in PREFIXES.  */
17273 +#define PREFIX_REPZ 1
17274 +#define PREFIX_REPNZ 2
17275 +#define PREFIX_LOCK 4
17276 +#define PREFIX_CS 8
17277 +#define PREFIX_SS 0x10
17278 +#define PREFIX_DS 0x20
17279 +#define PREFIX_ES 0x40
17280 +#define PREFIX_FS 0x80
17281 +#define PREFIX_GS 0x100
17282 +#define PREFIX_DATA 0x200
17283 +#define PREFIX_ADDR 0x400
17284 +#define PREFIX_FWAIT 0x800
17285 +
17286 +/* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
17287 +   to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
17288 +   on error.  */
17289 +#define FETCH_DATA(info, addr) \
17290 +  ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
17291 +   ? 1 : fetch_data ((info), (addr)))
17292 +
17293 +static int
17294 +fetch_data (struct disassemble_info *info, bfd_byte *addr)
17295 +{
17296 +  int status;
17297 +  struct dis_private *priv = (struct dis_private *) info->private_data;
17298 +  bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
17299 +
17300 +  status = (*info->read_memory_func) (start,
17301 +                                     priv->max_fetched,
17302 +                                     addr - priv->max_fetched,
17303 +                                     info);
17304 +  if (status != 0)
17305 +    {
17306 +      /* If we did manage to read at least one byte, then
17307 +        print_insn_i386 will do something sensible.  Otherwise, print
17308 +        an error.  We do that here because this is where we know
17309 +        STATUS.  */
17310 +      if (priv->max_fetched == priv->the_buffer)
17311 +       (*info->memory_error_func) (status, start, info);
17312 +#ifndef __KERNEL__
17313 +      longjmp (priv->bailout, 1);
17314 +#else  /* __KERNEL__ */
17315 +       /* XXX - what to do? */
17316 +       kdb_printf("Hmm. longjmp.\n");
17317 +#endif /* __KERNEL__ */
17318 +    }
17319 +  else
17320 +    priv->max_fetched = addr;
17321 +  return 1;
17322 +}
17323 +
17324 +#define XX NULL, 0
17325 +
17326 +#define Eb OP_E, b_mode
17327 +#define Ev OP_E, v_mode
17328 +#define Ed OP_E, d_mode
17329 +#define Eq OP_E, q_mode
17330 +#define Edq OP_E, dq_mode
17331 +#define Edqw OP_E, dqw_mode
17332 +#define indirEv OP_indirE, branch_v_mode
17333 +#define indirEp OP_indirE, f_mode
17334 +#define Em OP_E, m_mode
17335 +#define Ew OP_E, w_mode
17336 +#define Ma OP_E, v_mode
17337 +#define M OP_M, 0              /* lea, lgdt, etc. */
17338 +#define Mp OP_M, f_mode                /* 32 or 48 bit memory operand for LDS, LES etc */
17339 +#define Gb OP_G, b_mode
17340 +#define Gv OP_G, v_mode
17341 +#define Gd OP_G, d_mode
17342 +#define Gdq OP_G, dq_mode
17343 +#define Gm OP_G, m_mode
17344 +#define Gw OP_G, w_mode
17345 +#define Rd OP_Rd, d_mode
17346 +#define Rm OP_Rd, m_mode
17347 +#define Ib OP_I, b_mode
17348 +#define sIb OP_sI, b_mode      /* sign extened byte */
17349 +#define Iv OP_I, v_mode
17350 +#define Iq OP_I, q_mode
17351 +#define Iv64 OP_I64, v_mode
17352 +#define Iw OP_I, w_mode
17353 +#define I1 OP_I, const_1_mode
17354 +#define Jb OP_J, b_mode
17355 +#define Jv OP_J, v_mode
17356 +#define Cm OP_C, m_mode
17357 +#define Dm OP_D, m_mode
17358 +#define Td OP_T, d_mode
17359 +#define Sv SEG_Fixup, v_mode
17360 +
17361 +#define RMeAX OP_REG, eAX_reg
17362 +#define RMeBX OP_REG, eBX_reg
17363 +#define RMeCX OP_REG, eCX_reg
17364 +#define RMeDX OP_REG, eDX_reg
17365 +#define RMeSP OP_REG, eSP_reg
17366 +#define RMeBP OP_REG, eBP_reg
17367 +#define RMeSI OP_REG, eSI_reg
17368 +#define RMeDI OP_REG, eDI_reg
17369 +#define RMrAX OP_REG, rAX_reg
17370 +#define RMrBX OP_REG, rBX_reg
17371 +#define RMrCX OP_REG, rCX_reg
17372 +#define RMrDX OP_REG, rDX_reg
17373 +#define RMrSP OP_REG, rSP_reg
17374 +#define RMrBP OP_REG, rBP_reg
17375 +#define RMrSI OP_REG, rSI_reg
17376 +#define RMrDI OP_REG, rDI_reg
17377 +#define RMAL OP_REG, al_reg
17378 +#define RMAL OP_REG, al_reg
17379 +#define RMCL OP_REG, cl_reg
17380 +#define RMDL OP_REG, dl_reg
17381 +#define RMBL OP_REG, bl_reg
17382 +#define RMAH OP_REG, ah_reg
17383 +#define RMCH OP_REG, ch_reg
17384 +#define RMDH OP_REG, dh_reg
17385 +#define RMBH OP_REG, bh_reg
17386 +#define RMAX OP_REG, ax_reg
17387 +#define RMDX OP_REG, dx_reg
17388 +
17389 +#define eAX OP_IMREG, eAX_reg
17390 +#define eBX OP_IMREG, eBX_reg
17391 +#define eCX OP_IMREG, eCX_reg
17392 +#define eDX OP_IMREG, eDX_reg
17393 +#define eSP OP_IMREG, eSP_reg
17394 +#define eBP OP_IMREG, eBP_reg
17395 +#define eSI OP_IMREG, eSI_reg
17396 +#define eDI OP_IMREG, eDI_reg
17397 +#define AL OP_IMREG, al_reg
17398 +#define AL OP_IMREG, al_reg
17399 +#define CL OP_IMREG, cl_reg
17400 +#define DL OP_IMREG, dl_reg
17401 +#define BL OP_IMREG, bl_reg
17402 +#define AH OP_IMREG, ah_reg
17403 +#define CH OP_IMREG, ch_reg
17404 +#define DH OP_IMREG, dh_reg
17405 +#define BH OP_IMREG, bh_reg
17406 +#define AX OP_IMREG, ax_reg
17407 +#define DX OP_IMREG, dx_reg
17408 +#define indirDX OP_IMREG, indir_dx_reg
17409 +
17410 +#define Sw OP_SEG, w_mode
17411 +#define Ap OP_DIR, 0
17412 +#define Ob OP_OFF, b_mode
17413 +#define Ob64 OP_OFF64, b_mode
17414 +#define Ov OP_OFF, v_mode
17415 +#define Ov64 OP_OFF64, v_mode
17416 +#define Xb OP_DSreg, eSI_reg
17417 +#define Xv OP_DSreg, eSI_reg
17418 +#define Yb OP_ESreg, eDI_reg
17419 +#define Yv OP_ESreg, eDI_reg
17420 +#define DSBX OP_DSreg, eBX_reg
17421 +
17422 +#define es OP_REG, es_reg
17423 +#define ss OP_REG, ss_reg
17424 +#define cs OP_REG, cs_reg
17425 +#define ds OP_REG, ds_reg
17426 +#define fs OP_REG, fs_reg
17427 +#define gs OP_REG, gs_reg
17428 +
17429 +#define MX OP_MMX, 0
17430 +#define XM OP_XMM, 0
17431 +#define EM OP_EM, v_mode
17432 +#define EX OP_EX, v_mode
17433 +#define MS OP_MS, v_mode
17434 +#define XS OP_XS, v_mode
17435 +#define VM OP_VMX, q_mode
17436 +#define OPSUF OP_3DNowSuffix, 0
17437 +#define OPSIMD OP_SIMD_Suffix, 0
17438 +
17439 +#define cond_jump_flag NULL, cond_jump_mode
17440 +#define loop_jcxz_flag NULL, loop_jcxz_mode
17441 +
17442 +/* bits in sizeflag */
17443 +#define SUFFIX_ALWAYS 4
17444 +#define AFLAG 2
17445 +#define DFLAG 1
17446 +
17447 +#define b_mode 1  /* byte operand */
17448 +#define v_mode 2  /* operand size depends on prefixes */
17449 +#define w_mode 3  /* word operand */
17450 +#define d_mode 4  /* double word operand  */
17451 +#define q_mode 5  /* quad word operand */
17452 +#define t_mode 6  /* ten-byte operand */
17453 +#define x_mode 7  /* 16-byte XMM operand */
17454 +#define m_mode 8  /* d_mode in 32bit, q_mode in 64bit mode.  */
17455 +#define cond_jump_mode 9
17456 +#define loop_jcxz_mode 10
17457 +#define dq_mode 11 /* operand size depends on REX prefixes.  */
17458 +#define dqw_mode 12 /* registers like dq_mode, memory like w_mode.  */
17459 +#define f_mode 13 /* 4- or 6-byte pointer operand */
17460 +#define const_1_mode 14
17461 +#define branch_v_mode 15 /* v_mode for branch. */
17462 +
17463 +#define es_reg 100
17464 +#define cs_reg 101
17465 +#define ss_reg 102
17466 +#define ds_reg 103
17467 +#define fs_reg 104
17468 +#define gs_reg 105
17469 +
17470 +#define eAX_reg 108
17471 +#define eCX_reg 109
17472 +#define eDX_reg 110
17473 +#define eBX_reg 111
17474 +#define eSP_reg 112
17475 +#define eBP_reg 113
17476 +#define eSI_reg 114
17477 +#define eDI_reg 115
17478 +
17479 +#define al_reg 116
17480 +#define cl_reg 117
17481 +#define dl_reg 118
17482 +#define bl_reg 119
17483 +#define ah_reg 120
17484 +#define ch_reg 121
17485 +#define dh_reg 122
17486 +#define bh_reg 123
17487 +
17488 +#define ax_reg 124
17489 +#define cx_reg 125
17490 +#define dx_reg 126
17491 +#define bx_reg 127
17492 +#define sp_reg 128
17493 +#define bp_reg 129
17494 +#define si_reg 130
17495 +#define di_reg 131
17496 +
17497 +#define rAX_reg 132
17498 +#define rCX_reg 133
17499 +#define rDX_reg 134
17500 +#define rBX_reg 135
17501 +#define rSP_reg 136
17502 +#define rBP_reg 137
17503 +#define rSI_reg 138
17504 +#define rDI_reg 139
17505 +
17506 +#define indir_dx_reg 150
17507 +
17508 +#define FLOATCODE 1
17509 +#define USE_GROUPS 2
17510 +#define USE_PREFIX_USER_TABLE 3
17511 +#define X86_64_SPECIAL 4
17512 +
17513 +#define FLOAT    NULL, NULL, FLOATCODE, NULL, 0, NULL, 0
17514 +
17515 +#define GRP1b    NULL, NULL, USE_GROUPS, NULL,  0, NULL, 0
17516 +#define GRP1S    NULL, NULL, USE_GROUPS, NULL,  1, NULL, 0
17517 +#define GRP1Ss   NULL, NULL, USE_GROUPS, NULL,  2, NULL, 0
17518 +#define GRP2b    NULL, NULL, USE_GROUPS, NULL,  3, NULL, 0
17519 +#define GRP2S    NULL, NULL, USE_GROUPS, NULL,  4, NULL, 0
17520 +#define GRP2b_one NULL, NULL, USE_GROUPS, NULL,         5, NULL, 0
17521 +#define GRP2S_one NULL, NULL, USE_GROUPS, NULL,         6, NULL, 0
17522 +#define GRP2b_cl  NULL, NULL, USE_GROUPS, NULL,         7, NULL, 0
17523 +#define GRP2S_cl  NULL, NULL, USE_GROUPS, NULL,         8, NULL, 0
17524 +#define GRP3b    NULL, NULL, USE_GROUPS, NULL,  9, NULL, 0
17525 +#define GRP3S    NULL, NULL, USE_GROUPS, NULL, 10, NULL, 0
17526 +#define GRP4     NULL, NULL, USE_GROUPS, NULL, 11, NULL, 0
17527 +#define GRP5     NULL, NULL, USE_GROUPS, NULL, 12, NULL, 0
17528 +#define GRP6     NULL, NULL, USE_GROUPS, NULL, 13, NULL, 0
17529 +#define GRP7     NULL, NULL, USE_GROUPS, NULL, 14, NULL, 0
17530 +#define GRP8     NULL, NULL, USE_GROUPS, NULL, 15, NULL, 0
17531 +#define GRP9     NULL, NULL, USE_GROUPS, NULL, 16, NULL, 0
17532 +#define GRP10    NULL, NULL, USE_GROUPS, NULL, 17, NULL, 0
17533 +#define GRP11    NULL, NULL, USE_GROUPS, NULL, 18, NULL, 0
17534 +#define GRP12    NULL, NULL, USE_GROUPS, NULL, 19, NULL, 0
17535 +#define GRP13    NULL, NULL, USE_GROUPS, NULL, 20, NULL, 0
17536 +#define GRP14    NULL, NULL, USE_GROUPS, NULL, 21, NULL, 0
17537 +#define GRPAMD   NULL, NULL, USE_GROUPS, NULL, 22, NULL, 0
17538 +#define GRPPADLCK1 NULL, NULL, USE_GROUPS, NULL, 23, NULL, 0
17539 +#define GRPPADLCK2 NULL, NULL, USE_GROUPS, NULL, 24, NULL, 0
17540 +
17541 +#define PREGRP0          NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  0, NULL, 0
17542 +#define PREGRP1          NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  1, NULL, 0
17543 +#define PREGRP2          NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  2, NULL, 0
17544 +#define PREGRP3          NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  3, NULL, 0
17545 +#define PREGRP4          NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  4, NULL, 0
17546 +#define PREGRP5          NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  5, NULL, 0
17547 +#define PREGRP6          NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  6, NULL, 0
17548 +#define PREGRP7          NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  7, NULL, 0
17549 +#define PREGRP8          NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  8, NULL, 0
17550 +#define PREGRP9          NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  9, NULL, 0
17551 +#define PREGRP10  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 10, NULL, 0
17552 +#define PREGRP11  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 11, NULL, 0
17553 +#define PREGRP12  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 12, NULL, 0
17554 +#define PREGRP13  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 13, NULL, 0
17555 +#define PREGRP14  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 14, NULL, 0
17556 +#define PREGRP15  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 15, NULL, 0
17557 +#define PREGRP16  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 16, NULL, 0
17558 +#define PREGRP17  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 17, NULL, 0
17559 +#define PREGRP18  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 18, NULL, 0
17560 +#define PREGRP19  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 19, NULL, 0
17561 +#define PREGRP20  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 20, NULL, 0
17562 +#define PREGRP21  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 21, NULL, 0
17563 +#define PREGRP22  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 22, NULL, 0
17564 +#define PREGRP23  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 23, NULL, 0
17565 +#define PREGRP24  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0
17566 +#define PREGRP25  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0
17567 +#define PREGRP26  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 26, NULL, 0
17568 +#define PREGRP27  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 27, NULL, 0
17569 +#define PREGRP28  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 28, NULL, 0
17570 +#define PREGRP29  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 29, NULL, 0
17571 +#define PREGRP30  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 30, NULL, 0
17572 +#define PREGRP31  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 31, NULL, 0
17573 +#define PREGRP32  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 32, NULL, 0
17574 +
17575 +#define X86_64_0  NULL, NULL, X86_64_SPECIAL, NULL,  0, NULL, 0
17576 +
17577 +typedef void (*op_rtn) (int bytemode, int sizeflag);
17578 +
17579 +struct dis386 {
17580 +  const char *name;
17581 +  op_rtn op1;
17582 +  int bytemode1;
17583 +  op_rtn op2;
17584 +  int bytemode2;
17585 +  op_rtn op3;
17586 +  int bytemode3;
17587 +};
17588 +
17589 +/* Upper case letters in the instruction names here are macros.
17590 +   'A' => print 'b' if no register operands or suffix_always is true
17591 +   'B' => print 'b' if suffix_always is true
17592 +   'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
17593 +   .     size prefix
17594 +   'E' => print 'e' if 32-bit form of jcxz
17595 +   'F' => print 'w' or 'l' depending on address size prefix (loop insns)
17596 +   'H' => print ",pt" or ",pn" branch hint
17597 +   'I' => honor following macro letter even in Intel mode (implemented only
17598 +   .     for some of the macro letters)
17599 +   'J' => print 'l'
17600 +   'L' => print 'l' if suffix_always is true
17601 +   'N' => print 'n' if instruction has no wait "prefix"
17602 +   'O' => print 'd', or 'o'
17603 +   'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
17604 +   .     or suffix_always is true.  print 'q' if rex prefix is present.
17605 +   'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always
17606 +   .     is true
17607 +   'R' => print 'w', 'l' or 'q' ("wd" or "dq" in intel mode)
17608 +   'S' => print 'w', 'l' or 'q' if suffix_always is true
17609 +   'T' => print 'q' in 64bit mode and behave as 'P' otherwise
17610 +   'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
17611 +   'W' => print 'b' or 'w' ("w" or "de" in intel mode)
17612 +   'X' => print 's', 'd' depending on data16 prefix (for XMM)
17613 +   'Y' => 'q' if instruction has an REX 64bit overwrite prefix
17614 +
17615 +   Many of the above letters print nothing in Intel mode.  See "putop"
17616 +   for the details.
17617 +
17618 +   Braces '{' and '}', and vertical bars '|', indicate alternative
17619 +   mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel
17620 +   modes.  In cases where there are only two alternatives, the X86_64
17621 +   instruction is reserved, and "(bad)" is printed.
17622 +*/
17623 +
17624 +static const struct dis386 dis386[] = {
17625 +  /* 00 */
17626 +  { "addB",            Eb, Gb, XX },
17627 +  { "addS",            Ev, Gv, XX },
17628 +  { "addB",            Gb, Eb, XX },
17629 +  { "addS",            Gv, Ev, XX },
17630 +  { "addB",            AL, Ib, XX },
17631 +  { "addS",            eAX, Iv, XX },
17632 +  { "push{T|}",                es, XX, XX },
17633 +  { "pop{T|}",         es, XX, XX },
17634 +  /* 08 */
17635 +  { "orB",             Eb, Gb, XX },
17636 +  { "orS",             Ev, Gv, XX },
17637 +  { "orB",             Gb, Eb, XX },
17638 +  { "orS",             Gv, Ev, XX },
17639 +  { "orB",             AL, Ib, XX },
17640 +  { "orS",             eAX, Iv, XX },
17641 +  { "push{T|}",                cs, XX, XX },
17642 +  { "(bad)",           XX, XX, XX },   /* 0x0f extended opcode escape */
17643 +  /* 10 */
17644 +  { "adcB",            Eb, Gb, XX },
17645 +  { "adcS",            Ev, Gv, XX },
17646 +  { "adcB",            Gb, Eb, XX },
17647 +  { "adcS",            Gv, Ev, XX },
17648 +  { "adcB",            AL, Ib, XX },
17649 +  { "adcS",            eAX, Iv, XX },
17650 +  { "push{T|}",                ss, XX, XX },
17651 +  { "popT|}",          ss, XX, XX },
17652 +  /* 18 */
17653 +  { "sbbB",            Eb, Gb, XX },
17654 +  { "sbbS",            Ev, Gv, XX },
17655 +  { "sbbB",            Gb, Eb, XX },
17656 +  { "sbbS",            Gv, Ev, XX },
17657 +  { "sbbB",            AL, Ib, XX },
17658 +  { "sbbS",            eAX, Iv, XX },
17659 +  { "push{T|}",                ds, XX, XX },
17660 +  { "pop{T|}",         ds, XX, XX },
17661 +  /* 20 */
17662 +  { "andB",            Eb, Gb, XX },
17663 +  { "andS",            Ev, Gv, XX },
17664 +  { "andB",            Gb, Eb, XX },
17665 +  { "andS",            Gv, Ev, XX },
17666 +  { "andB",            AL, Ib, XX },
17667 +  { "andS",            eAX, Iv, XX },
17668 +  { "(bad)",           XX, XX, XX },   /* SEG ES prefix */
17669 +  { "daa{|}",          XX, XX, XX },
17670 +  /* 28 */
17671 +  { "subB",            Eb, Gb, XX },
17672 +  { "subS",            Ev, Gv, XX },
17673 +  { "subB",            Gb, Eb, XX },
17674 +  { "subS",            Gv, Ev, XX },
17675 +  { "subB",            AL, Ib, XX },
17676 +  { "subS",            eAX, Iv, XX },
17677 +  { "(bad)",           XX, XX, XX },   /* SEG CS prefix */
17678 +  { "das{|}",          XX, XX, XX },
17679 +  /* 30 */
17680 +  { "xorB",            Eb, Gb, XX },
17681 +  { "xorS",            Ev, Gv, XX },
17682 +  { "xorB",            Gb, Eb, XX },
17683 +  { "xorS",            Gv, Ev, XX },
17684 +  { "xorB",            AL, Ib, XX },
17685 +  { "xorS",            eAX, Iv, XX },
17686 +  { "(bad)",           XX, XX, XX },   /* SEG SS prefix */
17687 +  { "aaa{|}",          XX, XX, XX },
17688 +  /* 38 */
17689 +  { "cmpB",            Eb, Gb, XX },
17690 +  { "cmpS",            Ev, Gv, XX },
17691 +  { "cmpB",            Gb, Eb, XX },
17692 +  { "cmpS",            Gv, Ev, XX },
17693 +  { "cmpB",            AL, Ib, XX },
17694 +  { "cmpS",            eAX, Iv, XX },
17695 +  { "(bad)",           XX, XX, XX },   /* SEG DS prefix */
17696 +  { "aas{|}",          XX, XX, XX },
17697 +  /* 40 */
17698 +  { "inc{S|}",         RMeAX, XX, XX },
17699 +  { "inc{S|}",         RMeCX, XX, XX },
17700 +  { "inc{S|}",         RMeDX, XX, XX },
17701 +  { "inc{S|}",         RMeBX, XX, XX },
17702 +  { "inc{S|}",         RMeSP, XX, XX },
17703 +  { "inc{S|}",         RMeBP, XX, XX },
17704 +  { "inc{S|}",         RMeSI, XX, XX },
17705 +  { "inc{S|}",         RMeDI, XX, XX },
17706 +  /* 48 */
17707 +  { "dec{S|}",         RMeAX, XX, XX },
17708 +  { "dec{S|}",         RMeCX, XX, XX },
17709 +  { "dec{S|}",         RMeDX, XX, XX },
17710 +  { "dec{S|}",         RMeBX, XX, XX },
17711 +  { "dec{S|}",         RMeSP, XX, XX },
17712 +  { "dec{S|}",         RMeBP, XX, XX },
17713 +  { "dec{S|}",         RMeSI, XX, XX },
17714 +  { "dec{S|}",         RMeDI, XX, XX },
17715 +  /* 50 */
17716 +  { "pushS",           RMrAX, XX, XX },
17717 +  { "pushS",           RMrCX, XX, XX },
17718 +  { "pushS",           RMrDX, XX, XX },
17719 +  { "pushS",           RMrBX, XX, XX },
17720 +  { "pushS",           RMrSP, XX, XX },
17721 +  { "pushS",           RMrBP, XX, XX },
17722 +  { "pushS",           RMrSI, XX, XX },
17723 +  { "pushS",           RMrDI, XX, XX },
17724 +  /* 58 */
17725 +  { "popS",            RMrAX, XX, XX },
17726 +  { "popS",            RMrCX, XX, XX },
17727 +  { "popS",            RMrDX, XX, XX },
17728 +  { "popS",            RMrBX, XX, XX },
17729 +  { "popS",            RMrSP, XX, XX },
17730 +  { "popS",            RMrBP, XX, XX },
17731 +  { "popS",            RMrSI, XX, XX },
17732 +  { "popS",            RMrDI, XX, XX },
17733 +  /* 60 */
17734 +  { "pusha{P|}",       XX, XX, XX },
17735 +  { "popa{P|}",                XX, XX, XX },
17736 +  { "bound{S|}",       Gv, Ma, XX },
17737 +  { X86_64_0 },
17738 +  { "(bad)",           XX, XX, XX },   /* seg fs */
17739 +  { "(bad)",           XX, XX, XX },   /* seg gs */
17740 +  { "(bad)",           XX, XX, XX },   /* op size prefix */
17741 +  { "(bad)",           XX, XX, XX },   /* adr size prefix */
17742 +  /* 68 */
17743 +  { "pushT",           Iq, XX, XX },
17744 +  { "imulS",           Gv, Ev, Iv },
17745 +  { "pushT",           sIb, XX, XX },
17746 +  { "imulS",           Gv, Ev, sIb },
17747 +  { "ins{b||b|}",      Yb, indirDX, XX },
17748 +  { "ins{R||R|}",      Yv, indirDX, XX },
17749 +  { "outs{b||b|}",     indirDX, Xb, XX },
17750 +  { "outs{R||R|}",     indirDX, Xv, XX },
17751 +  /* 70 */
17752 +  { "joH",             Jb, XX, cond_jump_flag },
17753 +  { "jnoH",            Jb, XX, cond_jump_flag },
17754 +  { "jbH",             Jb, XX, cond_jump_flag },
17755 +  { "jaeH",            Jb, XX, cond_jump_flag },
17756 +  { "jeH",             Jb, XX, cond_jump_flag },
17757 +  { "jneH",            Jb, XX, cond_jump_flag },
17758 +  { "jbeH",            Jb, XX, cond_jump_flag },
17759 +  { "jaH",             Jb, XX, cond_jump_flag },
17760 +  /* 78 */
17761 +  { "jsH",             Jb, XX, cond_jump_flag },
17762 +  { "jnsH",            Jb, XX, cond_jump_flag },
17763 +  { "jpH",             Jb, XX, cond_jump_flag },
17764 +  { "jnpH",            Jb, XX, cond_jump_flag },
17765 +  { "jlH",             Jb, XX, cond_jump_flag },
17766 +  { "jgeH",            Jb, XX, cond_jump_flag },
17767 +  { "jleH",            Jb, XX, cond_jump_flag },
17768 +  { "jgH",             Jb, XX, cond_jump_flag },
17769 +  /* 80 */
17770 +  { GRP1b },
17771 +  { GRP1S },
17772 +  { "(bad)",           XX, XX, XX },
17773 +  { GRP1Ss },
17774 +  { "testB",           Eb, Gb, XX },
17775 +  { "testS",           Ev, Gv, XX },
17776 +  { "xchgB",           Eb, Gb, XX },
17777 +  { "xchgS",           Ev, Gv, XX },
17778 +  /* 88 */
17779 +  { "movB",            Eb, Gb, XX },
17780 +  { "movS",            Ev, Gv, XX },
17781 +  { "movB",            Gb, Eb, XX },
17782 +  { "movS",            Gv, Ev, XX },
17783 +  { "movQ",            Sv, Sw, XX },
17784 +  { "leaS",            Gv, M, XX },
17785 +  { "movQ",            Sw, Sv, XX },
17786 +  { "popU",            Ev, XX, XX },
17787 +  /* 90 */
17788 +  { "nop",             NOP_Fixup, 0, XX, XX },
17789 +  { "xchgS",           RMeCX, eAX, XX },
17790 +  { "xchgS",           RMeDX, eAX, XX },
17791 +  { "xchgS",           RMeBX, eAX, XX },
17792 +  { "xchgS",           RMeSP, eAX, XX },
17793 +  { "xchgS",           RMeBP, eAX, XX },
17794 +  { "xchgS",           RMeSI, eAX, XX },
17795 +  { "xchgS",           RMeDI, eAX, XX },
17796 +  /* 98 */
17797 +  { "cW{tR||tR|}",     XX, XX, XX },
17798 +  { "cR{tO||tO|}",     XX, XX, XX },
17799 +  { "Jcall{T|}",       Ap, XX, XX },
17800 +  { "(bad)",           XX, XX, XX },   /* fwait */
17801 +  { "pushfT",          XX, XX, XX },
17802 +  { "popfT",           XX, XX, XX },
17803 +  { "sahf{|}",         XX, XX, XX },
17804 +  { "lahf{|}",         XX, XX, XX },
17805 +  /* a0 */
17806 +  { "movB",            AL, Ob64, XX },
17807 +  { "movS",            eAX, Ov64, XX },
17808 +  { "movB",            Ob64, AL, XX },
17809 +  { "movS",            Ov64, eAX, XX },
17810 +  { "movs{b||b|}",     Yb, Xb, XX },
17811 +  { "movs{R||R|}",     Yv, Xv, XX },
17812 +  { "cmps{b||b|}",     Xb, Yb, XX },
17813 +  { "cmps{R||R|}",     Xv, Yv, XX },
17814 +  /* a8 */
17815 +  { "testB",           AL, Ib, XX },
17816 +  { "testS",           eAX, Iv, XX },
17817 +  { "stosB",           Yb, AL, XX },
17818 +  { "stosS",           Yv, eAX, XX },
17819 +  { "lodsB",           AL, Xb, XX },
17820 +  { "lodsS",           eAX, Xv, XX },
17821 +  { "scasB",           AL, Yb, XX },
17822 +  { "scasS",           eAX, Yv, XX },
17823 +  /* b0 */
17824 +  { "movB",            RMAL, Ib, XX },
17825 +  { "movB",            RMCL, Ib, XX },
17826 +  { "movB",            RMDL, Ib, XX },
17827 +  { "movB",            RMBL, Ib, XX },
17828 +  { "movB",            RMAH, Ib, XX },
17829 +  { "movB",            RMCH, Ib, XX },
17830 +  { "movB",            RMDH, Ib, XX },
17831 +  { "movB",            RMBH, Ib, XX },
17832 +  /* b8 */
17833 +  { "movS",            RMeAX, Iv64, XX },
17834 +  { "movS",            RMeCX, Iv64, XX },
17835 +  { "movS",            RMeDX, Iv64, XX },
17836 +  { "movS",            RMeBX, Iv64, XX },
17837 +  { "movS",            RMeSP, Iv64, XX },
17838 +  { "movS",            RMeBP, Iv64, XX },
17839 +  { "movS",            RMeSI, Iv64, XX },
17840 +  { "movS",            RMeDI, Iv64, XX },
17841 +  /* c0 */
17842 +  { GRP2b },
17843 +  { GRP2S },
17844 +  { "retT",            Iw, XX, XX },
17845 +  { "retT",            XX, XX, XX },
17846 +  { "les{S|}",         Gv, Mp, XX },
17847 +  { "ldsS",            Gv, Mp, XX },
17848 +  { "movA",            Eb, Ib, XX },
17849 +  { "movQ",            Ev, Iv, XX },
17850 +  /* c8 */
17851 +  { "enterT",          Iw, Ib, XX },
17852 +  { "leaveT",          XX, XX, XX },
17853 +  { "lretP",           Iw, XX, XX },
17854 +  { "lretP",           XX, XX, XX },
17855 +  { "int3",            XX, XX, XX },
17856 +  { "int",             Ib, XX, XX },
17857 +  { "into{|}",         XX, XX, XX },
17858 +  { "iretP",           XX, XX, XX },
17859 +  /* d0 */
17860 +  { GRP2b_one },
17861 +  { GRP2S_one },
17862 +  { GRP2b_cl },
17863 +  { GRP2S_cl },
17864 +  { "aam{|}",          sIb, XX, XX },
17865 +  { "aad{|}",          sIb, XX, XX },
17866 +  { "(bad)",           XX, XX, XX },
17867 +  { "xlat",            DSBX, XX, XX },
17868 +  /* d8 */
17869 +  { FLOAT },
17870 +  { FLOAT },
17871 +  { FLOAT },
17872 +  { FLOAT },
17873 +  { FLOAT },
17874 +  { FLOAT },
17875 +  { FLOAT },
17876 +  { FLOAT },
17877 +  /* e0 */
17878 +  { "loopneFH",                Jb, XX, loop_jcxz_flag },
17879 +  { "loopeFH",         Jb, XX, loop_jcxz_flag },
17880 +  { "loopFH",          Jb, XX, loop_jcxz_flag },
17881 +  { "jEcxzH",          Jb, XX, loop_jcxz_flag },
17882 +  { "inB",             AL, Ib, XX },
17883 +  { "inS",             eAX, Ib, XX },
17884 +  { "outB",            Ib, AL, XX },
17885 +  { "outS",            Ib, eAX, XX },
17886 +  /* e8 */
17887 +  { "callT",           Jv, XX, XX },
17888 +  { "jmpT",            Jv, XX, XX },
17889 +  { "Jjmp{T|}",                Ap, XX, XX },
17890 +  { "jmp",             Jb, XX, XX },
17891 +  { "inB",             AL, indirDX, XX },
17892 +  { "inS",             eAX, indirDX, XX },
17893 +  { "outB",            indirDX, AL, XX },
17894 +  { "outS",            indirDX, eAX, XX },
17895 +  /* f0 */
17896 +  { "(bad)",           XX, XX, XX },   /* lock prefix */
17897 +  { "icebp",           XX, XX, XX },
17898 +  { "(bad)",           XX, XX, XX },   /* repne */
17899 +  { "(bad)",           XX, XX, XX },   /* repz */
17900 +  { "hlt",             XX, XX, XX },
17901 +  { "cmc",             XX, XX, XX },
17902 +  { GRP3b },
17903 +  { GRP3S },
17904 +  /* f8 */
17905 +  { "clc",             XX, XX, XX },
17906 +  { "stc",             XX, XX, XX },
17907 +  { "cli",             XX, XX, XX },
17908 +  { "sti",             XX, XX, XX },
17909 +  { "cld",             XX, XX, XX },
17910 +  { "std",             XX, XX, XX },
17911 +  { GRP4 },
17912 +  { GRP5 },
17913 +};
17914 +
17915 +static const struct dis386 dis386_twobyte[] = {
17916 +  /* 00 */
17917 +  { GRP6 },
17918 +  { GRP7 },
17919 +  { "larS",            Gv, Ew, XX },
17920 +  { "lslS",            Gv, Ew, XX },
17921 +  { "(bad)",           XX, XX, XX },
17922 +  { "syscall",         XX, XX, XX },
17923 +  { "clts",            XX, XX, XX },
17924 +  { "sysretP",         XX, XX, XX },
17925 +  /* 08 */
17926 +  { "invd",            XX, XX, XX },
17927 +  { "wbinvd",          XX, XX, XX },
17928 +  { "(bad)",           XX, XX, XX },
17929 +  { "ud2a",            XX, XX, XX },
17930 +  { "(bad)",           XX, XX, XX },
17931 +  { GRPAMD },
17932 +  { "femms",           XX, XX, XX },
17933 +  { "",                        MX, EM, OPSUF }, /* See OP_3DNowSuffix.  */
17934 +  /* 10 */
17935 +  { PREGRP8 },
17936 +  { PREGRP9 },
17937 +  { PREGRP30 },
17938 +  { "movlpX",          EX, XM, SIMD_Fixup, 'h' },
17939 +  { "unpcklpX",                XM, EX, XX },
17940 +  { "unpckhpX",                XM, EX, XX },
17941 +  { PREGRP31 },
17942 +  { "movhpX",          EX, XM, SIMD_Fixup, 'l' },
17943 +  /* 18 */
17944 +  { GRP14 },
17945 +  { "(bad)",           XX, XX, XX },
17946 +  { "(bad)",           XX, XX, XX },
17947 +  { "(bad)",           XX, XX, XX },
17948 +  { "(bad)",           XX, XX, XX },
17949 +  { "(bad)",           XX, XX, XX },
17950 +  { "(bad)",           XX, XX, XX },
17951 +  { "(bad)",           XX, XX, XX },
17952 +  /* 20 */
17953 +  { "movL",            Rm, Cm, XX },
17954 +  { "movL",            Rm, Dm, XX },
17955 +  { "movL",            Cm, Rm, XX },
17956 +  { "movL",            Dm, Rm, XX },
17957 +  { "movL",            Rd, Td, XX },
17958 +  { "(bad)",           XX, XX, XX },
17959 +  { "movL",            Td, Rd, XX },
17960 +  { "(bad)",           XX, XX, XX },
17961 +  /* 28 */
17962 +  { "movapX",          XM, EX, XX },
17963 +  { "movapX",          EX, XM, XX },
17964 +  { PREGRP2 },
17965 +  { "movntpX",         Ev, XM, XX },
17966 +  { PREGRP4 },
17967 +  { PREGRP3 },
17968 +  { "ucomisX",         XM,EX, XX },
17969 +  { "comisX",          XM,EX, XX },
17970 +  /* 30 */
17971 +  { "wrmsr",           XX, XX, XX },
17972 +  { "rdtsc",           XX, XX, XX },
17973 +  { "rdmsr",           XX, XX, XX },
17974 +  { "rdpmc",           XX, XX, XX },
17975 +  { "sysenter",                XX, XX, XX },
17976 +  { "sysexit",         XX, XX, XX },
17977 +  { "(bad)",           XX, XX, XX },
17978 +  { "(bad)",           XX, XX, XX },
17979 +  /* 38 */
17980 +  { "(bad)",           XX, XX, XX },
17981 +  { "(bad)",           XX, XX, XX },
17982 +  { "(bad)",           XX, XX, XX },
17983 +  { "(bad)",           XX, XX, XX },
17984 +  { "(bad)",           XX, XX, XX },
17985 +  { "(bad)",           XX, XX, XX },
17986 +  { "(bad)",           XX, XX, XX },
17987 +  { "(bad)",           XX, XX, XX },
17988 +  /* 40 */
17989 +  { "cmovo",           Gv, Ev, XX },
17990 +  { "cmovno",          Gv, Ev, XX },
17991 +  { "cmovb",           Gv, Ev, XX },
17992 +  { "cmovae",          Gv, Ev, XX },
17993 +  { "cmove",           Gv, Ev, XX },
17994 +  { "cmovne",          Gv, Ev, XX },
17995 +  { "cmovbe",          Gv, Ev, XX },
17996 +  { "cmova",           Gv, Ev, XX },
17997 +  /* 48 */
17998 +  { "cmovs",           Gv, Ev, XX },
17999 +  { "cmovns",          Gv, Ev, XX },
18000 +  { "cmovp",           Gv, Ev, XX },
18001 +  { "cmovnp",          Gv, Ev, XX },
18002 +  { "cmovl",           Gv, Ev, XX },
18003 +  { "cmovge",          Gv, Ev, XX },
18004 +  { "cmovle",          Gv, Ev, XX },
18005 +  { "cmovg",           Gv, Ev, XX },
18006 +  /* 50 */
18007 +  { "movmskpX",                Gdq, XS, XX },
18008 +  { PREGRP13 },
18009 +  { PREGRP12 },
18010 +  { PREGRP11 },
18011 +  { "andpX",           XM, EX, XX },
18012 +  { "andnpX",          XM, EX, XX },
18013 +  { "orpX",            XM, EX, XX },
18014 +  { "xorpX",           XM, EX, XX },
18015 +  /* 58 */
18016 +  { PREGRP0 },
18017 +  { PREGRP10 },
18018 +  { PREGRP17 },
18019 +  { PREGRP16 },
18020 +  { PREGRP14 },
18021 +  { PREGRP7 },
18022 +  { PREGRP5 },
18023 +  { PREGRP6 },
18024 +  /* 60 */
18025 +  { "punpcklbw",       MX, EM, XX },
18026 +  { "punpcklwd",       MX, EM, XX },
18027 +  { "punpckldq",       MX, EM, XX },
18028 +  { "packsswb",                MX, EM, XX },
18029 +  { "pcmpgtb",         MX, EM, XX },
18030 +  { "pcmpgtw",         MX, EM, XX },
18031 +  { "pcmpgtd",         MX, EM, XX },
18032 +  { "packuswb",                MX, EM, XX },
18033 +  /* 68 */
18034 +  { "punpckhbw",       MX, EM, XX },
18035 +  { "punpckhwd",       MX, EM, XX },
18036 +  { "punpckhdq",       MX, EM, XX },
18037 +  { "packssdw",                MX, EM, XX },
18038 +  { PREGRP26 },
18039 +  { PREGRP24 },
18040 +  { "movd",            MX, Edq, XX },
18041 +  { PREGRP19 },
18042 +  /* 70 */
18043 +  { PREGRP22 },
18044 +  { GRP10 },
18045 +  { GRP11 },
18046 +  { GRP12 },
18047 +  { "pcmpeqb",         MX, EM, XX },
18048 +  { "pcmpeqw",         MX, EM, XX },
18049 +  { "pcmpeqd",         MX, EM, XX },
18050 +  { "emms",            XX, XX, XX },
18051 +  /* 78 */
18052 +  { "vmread",          Em, Gm, XX },
18053 +  { "vmwrite",         Gm, Em, XX },
18054 +  { "(bad)",           XX, XX, XX },
18055 +  { "(bad)",           XX, XX, XX },
18056 +  { PREGRP28 },
18057 +  { PREGRP29 },
18058 +  { PREGRP23 },
18059 +  { PREGRP20 },
18060 +  /* 80 */
18061 +  { "joH",             Jv, XX, cond_jump_flag },
18062 +  { "jnoH",            Jv, XX, cond_jump_flag },
18063 +  { "jbH",             Jv, XX, cond_jump_flag },
18064 +  { "jaeH",            Jv, XX, cond_jump_flag },
18065 +  { "jeH",             Jv, XX, cond_jump_flag },
18066 +  { "jneH",            Jv, XX, cond_jump_flag },
18067 +  { "jbeH",            Jv, XX, cond_jump_flag },
18068 +  { "jaH",             Jv, XX, cond_jump_flag },
18069 +  /* 88 */
18070 +  { "jsH",             Jv, XX, cond_jump_flag },
18071 +  { "jnsH",            Jv, XX, cond_jump_flag },
18072 +  { "jpH",             Jv, XX, cond_jump_flag },
18073 +  { "jnpH",            Jv, XX, cond_jump_flag },
18074 +  { "jlH",             Jv, XX, cond_jump_flag },
18075 +  { "jgeH",            Jv, XX, cond_jump_flag },
18076 +  { "jleH",            Jv, XX, cond_jump_flag },
18077 +  { "jgH",             Jv, XX, cond_jump_flag },
18078 +  /* 90 */
18079 +  { "seto",            Eb, XX, XX },
18080 +  { "setno",           Eb, XX, XX },
18081 +  { "setb",            Eb, XX, XX },
18082 +  { "setae",           Eb, XX, XX },
18083 +  { "sete",            Eb, XX, XX },
18084 +  { "setne",           Eb, XX, XX },
18085 +  { "setbe",           Eb, XX, XX },
18086 +  { "seta",            Eb, XX, XX },
18087 +  /* 98 */
18088 +  { "sets",            Eb, XX, XX },
18089 +  { "setns",           Eb, XX, XX },
18090 +  { "setp",            Eb, XX, XX },
18091 +  { "setnp",           Eb, XX, XX },
18092 +  { "setl",            Eb, XX, XX },
18093 +  { "setge",           Eb, XX, XX },
18094 +  { "setle",           Eb, XX, XX },
18095 +  { "setg",            Eb, XX, XX },
18096 +  /* a0 */
18097 +  { "pushT",           fs, XX, XX },
18098 +  { "popT",            fs, XX, XX },
18099 +  { "cpuid",           XX, XX, XX },
18100 +  { "btS",             Ev, Gv, XX },
18101 +  { "shldS",           Ev, Gv, Ib },
18102 +  { "shldS",           Ev, Gv, CL },
18103 +  { GRPPADLCK2 },
18104 +  { GRPPADLCK1 },
18105 +  /* a8 */
18106 +  { "pushT",           gs, XX, XX },
18107 +  { "popT",            gs, XX, XX },
18108 +  { "rsm",             XX, XX, XX },
18109 +  { "btsS",            Ev, Gv, XX },
18110 +  { "shrdS",           Ev, Gv, Ib },
18111 +  { "shrdS",           Ev, Gv, CL },
18112 +  { GRP13 },
18113 +  { "imulS",           Gv, Ev, XX },
18114 +  /* b0 */
18115 +  { "cmpxchgB",                Eb, Gb, XX },
18116 +  { "cmpxchgS",                Ev, Gv, XX },
18117 +  { "lssS",            Gv, Mp, XX },
18118 +  { "btrS",            Ev, Gv, XX },
18119 +  { "lfsS",            Gv, Mp, XX },
18120 +  { "lgsS",            Gv, Mp, XX },
18121 +  { "movz{bR|x|bR|x}", Gv, Eb, XX },
18122 +  { "movz{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movzww ! */
18123 +  /* b8 */
18124 +  { "(bad)",           XX, XX, XX },
18125 +  { "ud2b",            XX, XX, XX },
18126 +  { GRP8 },
18127 +  { "btcS",            Ev, Gv, XX },
18128 +  { "bsfS",            Gv, Ev, XX },
18129 +  { "bsrS",            Gv, Ev, XX },
18130 +  { "movs{bR|x|bR|x}", Gv, Eb, XX },
18131 +  { "movs{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movsww ! */
18132 +  /* c0 */
18133 +  { "xaddB",           Eb, Gb, XX },
18134 +  { "xaddS",           Ev, Gv, XX },
18135 +  { PREGRP1 },
18136 +  { "movntiS",         Ev, Gv, XX },
18137 +  { "pinsrw",          MX, Edqw, Ib },
18138 +  { "pextrw",          Gdq, MS, Ib },
18139 +  { "shufpX",          XM, EX, Ib },
18140 +  { GRP9 },
18141 +  /* c8 */
18142 +  { "bswap",           RMeAX, XX, XX },
18143 +  { "bswap",           RMeCX, XX, XX },
18144 +  { "bswap",           RMeDX, XX, XX },
18145 +  { "bswap",           RMeBX, XX, XX },
18146 +  { "bswap",           RMeSP, XX, XX },
18147 +  { "bswap",           RMeBP, XX, XX },
18148 +  { "bswap",           RMeSI, XX, XX },
18149 +  { "bswap",           RMeDI, XX, XX },
18150 +  /* d0 */
18151 +  { PREGRP27 },
18152 +  { "psrlw",           MX, EM, XX },
18153 +  { "psrld",           MX, EM, XX },
18154 +  { "psrlq",           MX, EM, XX },
18155 +  { "paddq",           MX, EM, XX },
18156 +  { "pmullw",          MX, EM, XX },
18157 +  { PREGRP21 },
18158 +  { "pmovmskb",                Gdq, MS, XX },
18159 +  /* d8 */
18160 +  { "psubusb",         MX, EM, XX },
18161 +  { "psubusw",         MX, EM, XX },
18162 +  { "pminub",          MX, EM, XX },
18163 +  { "pand",            MX, EM, XX },
18164 +  { "paddusb",         MX, EM, XX },
18165 +  { "paddusw",         MX, EM, XX },
18166 +  { "pmaxub",          MX, EM, XX },
18167 +  { "pandn",           MX, EM, XX },
18168 +  /* e0 */
18169 +  { "pavgb",           MX, EM, XX },
18170 +  { "psraw",           MX, EM, XX },
18171 +  { "psrad",           MX, EM, XX },
18172 +  { "pavgw",           MX, EM, XX },
18173 +  { "pmulhuw",         MX, EM, XX },
18174 +  { "pmulhw",          MX, EM, XX },
18175 +  { PREGRP15 },
18176 +  { PREGRP25 },
18177 +  /* e8 */
18178 +  { "psubsb",          MX, EM, XX },
18179 +  { "psubsw",          MX, EM, XX },
18180 +  { "pminsw",          MX, EM, XX },
18181 +  { "por",             MX, EM, XX },
18182 +  { "paddsb",          MX, EM, XX },
18183 +  { "paddsw",          MX, EM, XX },
18184 +  { "pmaxsw",          MX, EM, XX },
18185 +  { "pxor",            MX, EM, XX },
18186 +  /* f0 */
18187 +  { PREGRP32 },
18188 +  { "psllw",           MX, EM, XX },
18189 +  { "pslld",           MX, EM, XX },
18190 +  { "psllq",           MX, EM, XX },
18191 +  { "pmuludq",         MX, EM, XX },
18192 +  { "pmaddwd",         MX, EM, XX },
18193 +  { "psadbw",          MX, EM, XX },
18194 +  { PREGRP18 },
18195 +  /* f8 */
18196 +  { "psubb",           MX, EM, XX },
18197 +  { "psubw",           MX, EM, XX },
18198 +  { "psubd",           MX, EM, XX },
18199 +  { "psubq",           MX, EM, XX },
18200 +  { "paddb",           MX, EM, XX },
18201 +  { "paddw",           MX, EM, XX },
18202 +  { "paddd",           MX, EM, XX },
18203 +  { "(bad)",           XX, XX, XX }
18204 +};
18205 +
18206 +static const unsigned char onebyte_has_modrm[256] = {
18207 +  /*      0 1 2 3 4 5 6 7 8 9 a b c d e f        */
18208 +  /*      -------------------------------        */
18209 +  /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
18210 +  /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
18211 +  /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
18212 +  /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
18213 +  /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
18214 +  /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
18215 +  /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
18216 +  /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
18217 +  /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
18218 +  /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
18219 +  /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
18220 +  /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
18221 +  /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
18222 +  /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
18223 +  /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
18224 +  /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1  /* f0 */
18225 +  /*      -------------------------------        */
18226 +  /*      0 1 2 3 4 5 6 7 8 9 a b c d e f        */
18227 +};
18228 +
18229 +static const unsigned char twobyte_has_modrm[256] = {
18230 +  /*      0 1 2 3 4 5 6 7 8 9 a b c d e f        */
18231 +  /*      -------------------------------        */
18232 +  /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
18233 +  /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0, /* 1f */
18234 +  /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */
18235 +  /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
18236 +  /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
18237 +  /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
18238 +  /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
18239 +  /* 70 */ 1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, /* 7f */
18240 +  /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
18241 +  /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
18242 +  /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
18243 +  /* b0 */ 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1, /* bf */
18244 +  /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
18245 +  /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
18246 +  /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
18247 +  /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0  /* ff */
18248 +  /*      -------------------------------        */
18249 +  /*      0 1 2 3 4 5 6 7 8 9 a b c d e f        */
18250 +};
18251 +
18252 +static const unsigned char twobyte_uses_SSE_prefix[256] = {
18253 +  /*      0 1 2 3 4 5 6 7 8 9 a b c d e f        */
18254 +  /*      -------------------------------        */
18255 +  /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
18256 +  /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */
18257 +  /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0, /* 2f */
18258 +  /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
18259 +  /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
18260 +  /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
18261 +  /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */
18262 +  /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1, /* 7f */
18263 +  /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
18264 +  /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
18265 +  /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
18266 +  /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
18267 +  /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
18268 +  /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
18269 +  /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
18270 +  /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0  /* ff */
18271 +  /*      -------------------------------        */
18272 +  /*      0 1 2 3 4 5 6 7 8 9 a b c d e f        */
18273 +};
18274 +
18275 +static char obuf[100];
18276 +static char *obufp;
18277 +static char scratchbuf[100];
18278 +static unsigned char *start_codep;
18279 +static unsigned char *insn_codep;
18280 +static unsigned char *codep;
18281 +static disassemble_info *the_info;
18282 +static int mod;
18283 +static int rm;
18284 +static int reg;
18285 +static unsigned char need_modrm;
18286 +
18287 +/* If we are accessing mod/rm/reg without need_modrm set, then the
18288 +   values are stale.  Hitting this abort likely indicates that you
18289 +   need to update onebyte_has_modrm or twobyte_has_modrm.  */
18290 +#define MODRM_CHECK  if (!need_modrm) abort ()
18291 +
18292 +static const char **names64;
18293 +static const char **names32;
18294 +static const char **names16;
18295 +static const char **names8;
18296 +static const char **names8rex;
18297 +static const char **names_seg;
18298 +static const char **index16;
18299 +
18300 +static const char *intel_names64[] = {
18301 +  "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
18302 +  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
18303 +};
18304 +static const char *intel_names32[] = {
18305 +  "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
18306 +  "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
18307 +};
18308 +static const char *intel_names16[] = {
18309 +  "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
18310 +  "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
18311 +};
18312 +static const char *intel_names8[] = {
18313 +  "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
18314 +};
18315 +static const char *intel_names8rex[] = {
18316 +  "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
18317 +  "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
18318 +};
18319 +static const char *intel_names_seg[] = {
18320 +  "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
18321 +};
18322 +static const char *intel_index16[] = {
18323 +  "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
18324 +};
18325 +
18326 +static const char *att_names64[] = {
18327 +  "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
18328 +  "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
18329 +};
18330 +static const char *att_names32[] = {
18331 +  "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
18332 +  "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
18333 +};
18334 +static const char *att_names16[] = {
18335 +  "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
18336 +  "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
18337 +};
18338 +static const char *att_names8[] = {
18339 +  "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
18340 +};
18341 +static const char *att_names8rex[] = {
18342 +  "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
18343 +  "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
18344 +};
18345 +static const char *att_names_seg[] = {
18346 +  "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
18347 +};
18348 +static const char *att_index16[] = {
18349 +  "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
18350 +};
18351 +
18352 +static const struct dis386 grps[][8] = {
18353 +  /* GRP1b */
18354 +  {
18355 +    { "addA",  Eb, Ib, XX },
18356 +    { "orA",   Eb, Ib, XX },
18357 +    { "adcA",  Eb, Ib, XX },
18358 +    { "sbbA",  Eb, Ib, XX },
18359 +    { "andA",  Eb, Ib, XX },
18360 +    { "subA",  Eb, Ib, XX },
18361 +    { "xorA",  Eb, Ib, XX },
18362 +    { "cmpA",  Eb, Ib, XX }
18363 +  },
18364 +  /* GRP1S */
18365 +  {
18366 +    { "addQ",  Ev, Iv, XX },
18367 +    { "orQ",   Ev, Iv, XX },
18368 +    { "adcQ",  Ev, Iv, XX },
18369 +    { "sbbQ",  Ev, Iv, XX },
18370 +    { "andQ",  Ev, Iv, XX },
18371 +    { "subQ",  Ev, Iv, XX },
18372 +    { "xorQ",  Ev, Iv, XX },
18373 +    { "cmpQ",  Ev, Iv, XX }
18374 +  },
18375 +  /* GRP1Ss */
18376 +  {
18377 +    { "addQ",  Ev, sIb, XX },
18378 +    { "orQ",   Ev, sIb, XX },
18379 +    { "adcQ",  Ev, sIb, XX },
18380 +    { "sbbQ",  Ev, sIb, XX },
18381 +    { "andQ",  Ev, sIb, XX },
18382 +    { "subQ",  Ev, sIb, XX },
18383 +    { "xorQ",  Ev, sIb, XX },
18384 +    { "cmpQ",  Ev, sIb, XX }
18385 +  },
18386 +  /* GRP2b */
18387 +  {
18388 +    { "rolA",  Eb, Ib, XX },
18389 +    { "rorA",  Eb, Ib, XX },
18390 +    { "rclA",  Eb, Ib, XX },
18391 +    { "rcrA",  Eb, Ib, XX },
18392 +    { "shlA",  Eb, Ib, XX },
18393 +    { "shrA",  Eb, Ib, XX },
18394 +    { "(bad)", XX, XX, XX },
18395 +    { "sarA",  Eb, Ib, XX },
18396 +  },
18397 +  /* GRP2S */
18398 +  {
18399 +    { "rolQ",  Ev, Ib, XX },
18400 +    { "rorQ",  Ev, Ib, XX },
18401 +    { "rclQ",  Ev, Ib, XX },
18402 +    { "rcrQ",  Ev, Ib, XX },
18403 +    { "shlQ",  Ev, Ib, XX },
18404 +    { "shrQ",  Ev, Ib, XX },
18405 +    { "(bad)", XX, XX, XX },
18406 +    { "sarQ",  Ev, Ib, XX },
18407 +  },
18408 +  /* GRP2b_one */
18409 +  {
18410 +    { "rolA",  Eb, I1, XX },
18411 +    { "rorA",  Eb, I1, XX },
18412 +    { "rclA",  Eb, I1, XX },
18413 +    { "rcrA",  Eb, I1, XX },
18414 +    { "shlA",  Eb, I1, XX },
18415 +    { "shrA",  Eb, I1, XX },
18416 +    { "(bad)", XX, XX, XX },
18417 +    { "sarA",  Eb, I1, XX },
18418 +  },
18419 +  /* GRP2S_one */
18420 +  {
18421 +    { "rolQ",  Ev, I1, XX },
18422 +    { "rorQ",  Ev, I1, XX },
18423 +    { "rclQ",  Ev, I1, XX },
18424 +    { "rcrQ",  Ev, I1, XX },
18425 +    { "shlQ",  Ev, I1, XX },
18426 +    { "shrQ",  Ev, I1, XX },
18427 +    { "(bad)", XX, XX, XX},
18428 +    { "sarQ",  Ev, I1, XX },
18429 +  },
18430 +  /* GRP2b_cl */
18431 +  {
18432 +    { "rolA",  Eb, CL, XX },
18433 +    { "rorA",  Eb, CL, XX },
18434 +    { "rclA",  Eb, CL, XX },
18435 +    { "rcrA",  Eb, CL, XX },
18436 +    { "shlA",  Eb, CL, XX },
18437 +    { "shrA",  Eb, CL, XX },
18438 +    { "(bad)", XX, XX, XX },
18439 +    { "sarA",  Eb, CL, XX },
18440 +  },
18441 +  /* GRP2S_cl */
18442 +  {
18443 +    { "rolQ",  Ev, CL, XX },
18444 +    { "rorQ",  Ev, CL, XX },
18445 +    { "rclQ",  Ev, CL, XX },
18446 +    { "rcrQ",  Ev, CL, XX },
18447 +    { "shlQ",  Ev, CL, XX },
18448 +    { "shrQ",  Ev, CL, XX },
18449 +    { "(bad)", XX, XX, XX },
18450 +    { "sarQ",  Ev, CL, XX }
18451 +  },
18452 +  /* GRP3b */
18453 +  {
18454 +    { "testA", Eb, Ib, XX },
18455 +    { "(bad)", Eb, XX, XX },
18456 +    { "notA",  Eb, XX, XX },
18457 +    { "negA",  Eb, XX, XX },
18458 +    { "mulA",  Eb, XX, XX },   /* Don't print the implicit %al register,  */
18459 +    { "imulA", Eb, XX, XX },   /* to distinguish these opcodes from other */
18460 +    { "divA",  Eb, XX, XX },   /* mul/imul opcodes.  Do the same for div  */
18461 +    { "idivA", Eb, XX, XX }    /* and idiv for consistency.               */
18462 +  },
18463 +  /* GRP3S */
18464 +  {
18465 +    { "testQ", Ev, Iv, XX },
18466 +    { "(bad)", XX, XX, XX },
18467 +    { "notQ",  Ev, XX, XX },
18468 +    { "negQ",  Ev, XX, XX },
18469 +    { "mulQ",  Ev, XX, XX },   /* Don't print the implicit register.  */
18470 +    { "imulQ", Ev, XX, XX },
18471 +    { "divQ",  Ev, XX, XX },
18472 +    { "idivQ", Ev, XX, XX },
18473 +  },
18474 +  /* GRP4 */
18475 +  {
18476 +    { "incA",  Eb, XX, XX },
18477 +    { "decA",  Eb, XX, XX },
18478 +    { "(bad)", XX, XX, XX },
18479 +    { "(bad)", XX, XX, XX },
18480 +    { "(bad)", XX, XX, XX },
18481 +    { "(bad)", XX, XX, XX },
18482 +    { "(bad)", XX, XX, XX },
18483 +    { "(bad)", XX, XX, XX },
18484 +  },
18485 +  /* GRP5 */
18486 +  {
18487 +    { "incQ",  Ev, XX, XX },
18488 +    { "decQ",  Ev, XX, XX },
18489 +    { "callT", indirEv, XX, XX },
18490 +    { "JcallT", indirEp, XX, XX },
18491 +    { "jmpT",  indirEv, XX, XX },
18492 +    { "JjmpT", indirEp, XX, XX },
18493 +    { "pushU", Ev, XX, XX },
18494 +    { "(bad)", XX, XX, XX },
18495 +  },
18496 +  /* GRP6 */
18497 +  {
18498 +    { "sldtQ", Ev, XX, XX },
18499 +    { "strQ",  Ev, XX, XX },
18500 +    { "lldt",  Ew, XX, XX },
18501 +    { "ltr",   Ew, XX, XX },
18502 +    { "verr",  Ew, XX, XX },
18503 +    { "verw",  Ew, XX, XX },
18504 +    { "(bad)", XX, XX, XX },
18505 +    { "(bad)", XX, XX, XX }
18506 +  },
18507 +  /* GRP7 */
18508 +  {
18509 +    { "sgdtIQ", VMX_Fixup, 0, XX, XX },
18510 +    { "sidtIQ", PNI_Fixup, 0, XX, XX },
18511 +    { "lgdt{Q|Q||}",    M, XX, XX },
18512 +    { "lidt{Q|Q||}",    SVME_Fixup, 0, XX, XX },
18513 +    { "smswQ", Ev, XX, XX },
18514 +    { "(bad)", XX, XX, XX },
18515 +    { "lmsw",  Ew, XX, XX },
18516 +    { "invlpg", INVLPG_Fixup, w_mode, XX, XX },
18517 +  },
18518 +  /* GRP8 */
18519 +  {
18520 +    { "(bad)", XX, XX, XX },
18521 +    { "(bad)", XX, XX, XX },
18522 +    { "(bad)", XX, XX, XX },
18523 +    { "(bad)", XX, XX, XX },
18524 +    { "btQ",   Ev, Ib, XX },
18525 +    { "btsQ",  Ev, Ib, XX },
18526 +    { "btrQ",  Ev, Ib, XX },
18527 +    { "btcQ",  Ev, Ib, XX },
18528 +  },
18529 +  /* GRP9 */
18530 +  {
18531 +    { "(bad)", XX, XX, XX },
18532 +    { "cmpxchg8b", Eq, XX, XX },
18533 +    { "(bad)", XX, XX, XX },
18534 +    { "(bad)", XX, XX, XX },
18535 +    { "(bad)", XX, XX, XX },
18536 +    { "(bad)", XX, XX, XX },
18537 +    { "",      VM, XX, XX },           /* See OP_VMX.  */
18538 +    { "vmptrst", Eq, XX, XX },
18539 +  },
18540 +  /* GRP10 */
18541 +  {
18542 +    { "(bad)", XX, XX, XX },
18543 +    { "(bad)", XX, XX, XX },
18544 +    { "psrlw", MS, Ib, XX },
18545 +    { "(bad)", XX, XX, XX },
18546 +    { "psraw", MS, Ib, XX },
18547 +    { "(bad)", XX, XX, XX },
18548 +    { "psllw", MS, Ib, XX },
18549 +    { "(bad)", XX, XX, XX },
18550 +  },
18551 +  /* GRP11 */
18552 +  {
18553 +    { "(bad)", XX, XX, XX },
18554 +    { "(bad)", XX, XX, XX },
18555 +    { "psrld", MS, Ib, XX },
18556 +    { "(bad)", XX, XX, XX },
18557 +    { "psrad", MS, Ib, XX },
18558 +    { "(bad)", XX, XX, XX },
18559 +    { "pslld", MS, Ib, XX },
18560 +    { "(bad)", XX, XX, XX },
18561 +  },
18562 +  /* GRP12 */
18563 +  {
18564 +    { "(bad)", XX, XX, XX },
18565 +    { "(bad)", XX, XX, XX },
18566 +    { "psrlq", MS, Ib, XX },
18567 +    { "psrldq", MS, Ib, XX },
18568 +    { "(bad)", XX, XX, XX },
18569 +    { "(bad)", XX, XX, XX },
18570 +    { "psllq", MS, Ib, XX },
18571 +    { "pslldq", MS, Ib, XX },
18572 +  },
18573 +  /* GRP13 */
18574 +  {
18575 +    { "fxsave", Ev, XX, XX },
18576 +    { "fxrstor", Ev, XX, XX },
18577 +    { "ldmxcsr", Ev, XX, XX },
18578 +    { "stmxcsr", Ev, XX, XX },
18579 +    { "(bad)", XX, XX, XX },
18580 +    { "lfence", OP_0fae, 0, XX, XX },
18581 +    { "mfence", OP_0fae, 0, XX, XX },
18582 +    { "clflush", OP_0fae, 0, XX, XX },
18583 +  },
18584 +  /* GRP14 */
18585 +  {
18586 +    { "prefetchnta", Ev, XX, XX },
18587 +    { "prefetcht0", Ev, XX, XX },
18588 +    { "prefetcht1", Ev, XX, XX },
18589 +    { "prefetcht2", Ev, XX, XX },
18590 +    { "(bad)", XX, XX, XX },
18591 +    { "(bad)", XX, XX, XX },
18592 +    { "(bad)", XX, XX, XX },
18593 +    { "(bad)", XX, XX, XX },
18594 +  },
18595 +  /* GRPAMD */
18596 +  {
18597 +    { "prefetch", Eb, XX, XX },
18598 +    { "prefetchw", Eb, XX, XX },
18599 +    { "(bad)", XX, XX, XX },
18600 +    { "(bad)", XX, XX, XX },
18601 +    { "(bad)", XX, XX, XX },
18602 +    { "(bad)", XX, XX, XX },
18603 +    { "(bad)", XX, XX, XX },
18604 +    { "(bad)", XX, XX, XX },
18605 +  },
18606 +  /* GRPPADLCK1 */
18607 +  {
18608 +    { "xstore-rng", OP_0f07, 0, XX, XX },
18609 +    { "xcrypt-ecb", OP_0f07, 0, XX, XX },
18610 +    { "xcrypt-cbc", OP_0f07, 0, XX, XX },
18611 +    { "xcrypt-ctr", OP_0f07, 0, XX, XX },
18612 +    { "xcrypt-cfb", OP_0f07, 0, XX, XX },
18613 +    { "xcrypt-ofb", OP_0f07, 0, XX, XX },
18614 +    { "(bad)", OP_0f07, 0, XX, XX },
18615 +    { "(bad)", OP_0f07, 0, XX, XX },
18616 +  },
18617 +  /* GRPPADLCK2 */
18618 +  {
18619 +    { "montmul", OP_0f07, 0, XX, XX },
18620 +    { "xsha1",  OP_0f07, 0, XX, XX },
18621 +    { "xsha256", OP_0f07, 0, XX, XX },
18622 +    { "(bad)",  OP_0f07, 0, XX, XX },
18623 +    { "(bad)",  OP_0f07, 0, XX, XX },
18624 +    { "(bad)",  OP_0f07, 0, XX, XX },
18625 +    { "(bad)",  OP_0f07, 0, XX, XX },
18626 +    { "(bad)",  OP_0f07, 0, XX, XX },
18627 +  }
18628 +};
18629 +
18630 +static const struct dis386 prefix_user_table[][4] = {
18631 +  /* PREGRP0 */
18632 +  {
18633 +    { "addps", XM, EX, XX },
18634 +    { "addss", XM, EX, XX },
18635 +    { "addpd", XM, EX, XX },
18636 +    { "addsd", XM, EX, XX },
18637 +  },
18638 +  /* PREGRP1 */
18639 +  {
18640 +    { "", XM, EX, OPSIMD },    /* See OP_SIMD_SUFFIX.  */
18641 +    { "", XM, EX, OPSIMD },
18642 +    { "", XM, EX, OPSIMD },
18643 +    { "", XM, EX, OPSIMD },
18644 +  },
18645 +  /* PREGRP2 */
18646 +  {
18647 +    { "cvtpi2ps", XM, EM, XX },
18648 +    { "cvtsi2ssY", XM, Ev, XX },
18649 +    { "cvtpi2pd", XM, EM, XX },
18650 +    { "cvtsi2sdY", XM, Ev, XX },
18651 +  },
18652 +  /* PREGRP3 */
18653 +  {
18654 +    { "cvtps2pi", MX, EX, XX },
18655 +    { "cvtss2siY", Gv, EX, XX },
18656 +    { "cvtpd2pi", MX, EX, XX },
18657 +    { "cvtsd2siY", Gv, EX, XX },
18658 +  },
18659 +  /* PREGRP4 */
18660 +  {
18661 +    { "cvttps2pi", MX, EX, XX },
18662 +    { "cvttss2siY", Gv, EX, XX },
18663 +    { "cvttpd2pi", MX, EX, XX },
18664 +    { "cvttsd2siY", Gv, EX, XX },
18665 +  },
18666 +  /* PREGRP5 */
18667 +  {
18668 +    { "divps", XM, EX, XX },
18669 +    { "divss", XM, EX, XX },
18670 +    { "divpd", XM, EX, XX },
18671 +    { "divsd", XM, EX, XX },
18672 +  },
18673 +  /* PREGRP6 */
18674 +  {
18675 +    { "maxps", XM, EX, XX },
18676 +    { "maxss", XM, EX, XX },
18677 +    { "maxpd", XM, EX, XX },
18678 +    { "maxsd", XM, EX, XX },
18679 +  },
18680 +  /* PREGRP7 */
18681 +  {
18682 +    { "minps", XM, EX, XX },
18683 +    { "minss", XM, EX, XX },
18684 +    { "minpd", XM, EX, XX },
18685 +    { "minsd", XM, EX, XX },
18686 +  },
18687 +  /* PREGRP8 */
18688 +  {
18689 +    { "movups", XM, EX, XX },
18690 +    { "movss", XM, EX, XX },
18691 +    { "movupd", XM, EX, XX },
18692 +    { "movsd", XM, EX, XX },
18693 +  },
18694 +  /* PREGRP9 */
18695 +  {
18696 +    { "movups", EX, XM, XX },
18697 +    { "movss", EX, XM, XX },
18698 +    { "movupd", EX, XM, XX },
18699 +    { "movsd", EX, XM, XX },
18700 +  },
18701 +  /* PREGRP10 */
18702 +  {
18703 +    { "mulps", XM, EX, XX },
18704 +    { "mulss", XM, EX, XX },
18705 +    { "mulpd", XM, EX, XX },
18706 +    { "mulsd", XM, EX, XX },
18707 +  },
18708 +  /* PREGRP11 */
18709 +  {
18710 +    { "rcpps", XM, EX, XX },
18711 +    { "rcpss", XM, EX, XX },
18712 +    { "(bad)", XM, EX, XX },
18713 +    { "(bad)", XM, EX, XX },
18714 +  },
18715 +  /* PREGRP12 */
18716 +  {
18717 +    { "rsqrtps", XM, EX, XX },
18718 +    { "rsqrtss", XM, EX, XX },
18719 +    { "(bad)", XM, EX, XX },
18720 +    { "(bad)", XM, EX, XX },
18721 +  },
18722 +  /* PREGRP13 */
18723 +  {
18724 +    { "sqrtps", XM, EX, XX },
18725 +    { "sqrtss", XM, EX, XX },
18726 +    { "sqrtpd", XM, EX, XX },
18727 +    { "sqrtsd", XM, EX, XX },
18728 +  },
18729 +  /* PREGRP14 */
18730 +  {
18731 +    { "subps", XM, EX, XX },
18732 +    { "subss", XM, EX, XX },
18733 +    { "subpd", XM, EX, XX },
18734 +    { "subsd", XM, EX, XX },
18735 +  },
18736 +  /* PREGRP15 */
18737 +  {
18738 +    { "(bad)", XM, EX, XX },
18739 +    { "cvtdq2pd", XM, EX, XX },
18740 +    { "cvttpd2dq", XM, EX, XX },
18741 +    { "cvtpd2dq", XM, EX, XX },
18742 +  },
18743 +  /* PREGRP16 */
18744 +  {
18745 +    { "cvtdq2ps", XM, EX, XX },
18746 +    { "cvttps2dq",XM, EX, XX },
18747 +    { "cvtps2dq",XM, EX, XX },
18748 +    { "(bad)", XM, EX, XX },
18749 +  },
18750 +  /* PREGRP17 */
18751 +  {
18752 +    { "cvtps2pd", XM, EX, XX },
18753 +    { "cvtss2sd", XM, EX, XX },
18754 +    { "cvtpd2ps", XM, EX, XX },
18755 +    { "cvtsd2ss", XM, EX, XX },
18756 +  },
18757 +  /* PREGRP18 */
18758 +  {
18759 +    { "maskmovq", MX, MS, XX },
18760 +    { "(bad)", XM, EX, XX },
18761 +    { "maskmovdqu", XM, EX, XX },
18762 +    { "(bad)", XM, EX, XX },
18763 +  },
18764 +  /* PREGRP19 */
18765 +  {
18766 +    { "movq", MX, EM, XX },
18767 +    { "movdqu", XM, EX, XX },
18768 +    { "movdqa", XM, EX, XX },
18769 +    { "(bad)", XM, EX, XX },
18770 +  },
18771 +  /* PREGRP20 */
18772 +  {
18773 +    { "movq", EM, MX, XX },
18774 +    { "movdqu", EX, XM, XX },
18775 +    { "movdqa", EX, XM, XX },
18776 +    { "(bad)", EX, XM, XX },
18777 +  },
18778 +  /* PREGRP21 */
18779 +  {
18780 +    { "(bad)", EX, XM, XX },
18781 +    { "movq2dq", XM, MS, XX },
18782 +    { "movq", EX, XM, XX },
18783 +    { "movdq2q", MX, XS, XX },
18784 +  },
18785 +  /* PREGRP22 */
18786 +  {
18787 +    { "pshufw", MX, EM, Ib },
18788 +    { "pshufhw", XM, EX, Ib },
18789 +    { "pshufd", XM, EX, Ib },
18790 +    { "pshuflw", XM, EX, Ib },
18791 +  },
18792 +  /* PREGRP23 */
18793 +  {
18794 +    { "movd", Edq, MX, XX },
18795 +    { "movq", XM, EX, XX },
18796 +    { "movd", Edq, XM, XX },
18797 +    { "(bad)", Ed, XM, XX },
18798 +  },
18799 +  /* PREGRP24 */
18800 +  {
18801 +    { "(bad)", MX, EX, XX },
18802 +    { "(bad)", XM, EX, XX },
18803 +    { "punpckhqdq", XM, EX, XX },
18804 +    { "(bad)", XM, EX, XX },
18805 +  },
18806 +  /* PREGRP25 */
18807 +  {
18808 +    { "movntq", EM, MX, XX },
18809 +    { "(bad)", EM, XM, XX },
18810 +    { "movntdq", EM, XM, XX },
18811 +    { "(bad)", EM, XM, XX },
18812 +  },
18813 +  /* PREGRP26 */
18814 +  {
18815 +    { "(bad)", MX, EX, XX },
18816 +    { "(bad)", XM, EX, XX },
18817 +    { "punpcklqdq", XM, EX, XX },
18818 +    { "(bad)", XM, EX, XX },
18819 +  },
18820 +  /* PREGRP27 */
18821 +  {
18822 +    { "(bad)", MX, EX, XX },
18823 +    { "(bad)", XM, EX, XX },
18824 +    { "addsubpd", XM, EX, XX },
18825 +    { "addsubps", XM, EX, XX },
18826 +  },
18827 +  /* PREGRP28 */
18828 +  {
18829 +    { "(bad)", MX, EX, XX },
18830 +    { "(bad)", XM, EX, XX },
18831 +    { "haddpd", XM, EX, XX },
18832 +    { "haddps", XM, EX, XX },
18833 +  },
18834 +  /* PREGRP29 */
18835 +  {
18836 +    { "(bad)", MX, EX, XX },
18837 +    { "(bad)", XM, EX, XX },
18838 +    { "hsubpd", XM, EX, XX },
18839 +    { "hsubps", XM, EX, XX },
18840 +  },
18841 +  /* PREGRP30 */
18842 +  {
18843 +    { "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */
18844 +    { "movsldup", XM, EX, XX },
18845 +    { "movlpd", XM, EX, XX },
18846 +    { "movddup", XM, EX, XX },
18847 +  },
18848 +  /* PREGRP31 */
18849 +  {
18850 +    { "movhpX", XM, EX, SIMD_Fixup, 'l' },
18851 +    { "movshdup", XM, EX, XX },
18852 +    { "movhpd", XM, EX, XX },
18853 +    { "(bad)", XM, EX, XX },
18854 +  },
18855 +  /* PREGRP32 */
18856 +  {
18857 +    { "(bad)", XM, EX, XX },
18858 +    { "(bad)", XM, EX, XX },
18859 +    { "(bad)", XM, EX, XX },
18860 +    { "lddqu", XM, M, XX },
18861 +  },
18862 +};
18863 +
18864 +static const struct dis386 x86_64_table[][2] = {
18865 +  {
18866 +    { "arpl", Ew, Gw, XX },
18867 +    { "movs{||lq|xd}", Gv, Ed, XX },
18868 +  },
18869 +};
18870 +
18871 +#ifdef __KERNEL__
18872 +#define INTERNAL_DISASSEMBLER_ERROR "<internal disassembler error>"
18873 +#else  /* __KERNEL__ */
18874 +#define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
18875 +#endif /* __KERNEL__ */
18876 +
18877 +static void
18878 +ckprefix (void)
18879 +{
18880 +  int newrex;
18881 +  rex = 0;
18882 +  prefixes = 0;
18883 +  used_prefixes = 0;
18884 +  rex_used = 0;
18885 +  while (1)
18886 +    {
18887 +      FETCH_DATA (the_info, codep + 1);
18888 +      newrex = 0;
18889 +      switch (*codep)
18890 +       {
18891 +       /* REX prefixes family.  */
18892 +       case 0x40:
18893 +       case 0x41:
18894 +       case 0x42:
18895 +       case 0x43:
18896 +       case 0x44:
18897 +       case 0x45:
18898 +       case 0x46:
18899 +       case 0x47:
18900 +       case 0x48:
18901 +       case 0x49:
18902 +       case 0x4a:
18903 +       case 0x4b:
18904 +       case 0x4c:
18905 +       case 0x4d:
18906 +       case 0x4e:
18907 +       case 0x4f:
18908 +           if (mode_64bit)
18909 +             newrex = *codep;
18910 +           else
18911 +             return;
18912 +         break;
18913 +       case 0xf3:
18914 +         prefixes |= PREFIX_REPZ;
18915 +         break;
18916 +       case 0xf2:
18917 +         prefixes |= PREFIX_REPNZ;
18918 +         break;
18919 +       case 0xf0:
18920 +         prefixes |= PREFIX_LOCK;
18921 +         break;
18922 +       case 0x2e:
18923 +         prefixes |= PREFIX_CS;
18924 +         break;
18925 +       case 0x36:
18926 +         prefixes |= PREFIX_SS;
18927 +         break;
18928 +       case 0x3e:
18929 +         prefixes |= PREFIX_DS;
18930 +         break;
18931 +       case 0x26:
18932 +         prefixes |= PREFIX_ES;
18933 +         break;
18934 +       case 0x64:
18935 +         prefixes |= PREFIX_FS;
18936 +         break;
18937 +       case 0x65:
18938 +         prefixes |= PREFIX_GS;
18939 +         break;
18940 +       case 0x66:
18941 +         prefixes |= PREFIX_DATA;
18942 +         break;
18943 +       case 0x67:
18944 +         prefixes |= PREFIX_ADDR;
18945 +         break;
18946 +       case FWAIT_OPCODE:
18947 +         /* fwait is really an instruction.  If there are prefixes
18948 +            before the fwait, they belong to the fwait, *not* to the
18949 +            following instruction.  */
18950 +         if (prefixes)
18951 +           {
18952 +             prefixes |= PREFIX_FWAIT;
18953 +             codep++;
18954 +             return;
18955 +           }
18956 +         prefixes = PREFIX_FWAIT;
18957 +         break;
18958 +       default:
18959 +         return;
18960 +       }
18961 +      /* Rex is ignored when followed by another prefix.  */
18962 +      if (rex)
18963 +       {
18964 +         oappend (prefix_name (rex, 0));
18965 +         oappend (" ");
18966 +       }
18967 +      rex = newrex;
18968 +      codep++;
18969 +    }
18970 +}
18971 +
18972 +/* Return the name of the prefix byte PREF, or NULL if PREF is not a
18973 +   prefix byte.         */
18974 +
18975 +static const char *
18976 +prefix_name (int pref, int sizeflag)
18977 +{
18978 +  switch (pref)
18979 +    {
18980 +    /* REX prefixes family.  */
18981 +    case 0x40:
18982 +      return "rex";
18983 +    case 0x41:
18984 +      return "rexZ";
18985 +    case 0x42:
18986 +      return "rexY";
18987 +    case 0x43:
18988 +      return "rexYZ";
18989 +    case 0x44:
18990 +      return "rexX";
18991 +    case 0x45:
18992 +      return "rexXZ";
18993 +    case 0x46:
18994 +      return "rexXY";
18995 +    case 0x47:
18996 +      return "rexXYZ";
18997 +    case 0x48:
18998 +      return "rex64";
18999 +    case 0x49:
19000 +      return "rex64Z";
19001 +    case 0x4a:
19002 +      return "rex64Y";
19003 +    case 0x4b:
19004 +      return "rex64YZ";
19005 +    case 0x4c:
19006 +      return "rex64X";
19007 +    case 0x4d:
19008 +      return "rex64XZ";
19009 +    case 0x4e:
19010 +      return "rex64XY";
19011 +    case 0x4f:
19012 +      return "rex64XYZ";
19013 +    case 0xf3:
19014 +      return "repz";
19015 +    case 0xf2:
19016 +      return "repnz";
19017 +    case 0xf0:
19018 +      return "lock";
19019 +    case 0x2e:
19020 +      return "cs";
19021 +    case 0x36:
19022 +      return "ss";
19023 +    case 0x3e:
19024 +      return "ds";
19025 +    case 0x26:
19026 +      return "es";
19027 +    case 0x64:
19028 +      return "fs";
19029 +    case 0x65:
19030 +      return "gs";
19031 +    case 0x66:
19032 +      return (sizeflag & DFLAG) ? "data16" : "data32";
19033 +    case 0x67:
19034 +      if (mode_64bit)
19035 +       return (sizeflag & AFLAG) ? "addr32" : "addr64";
19036 +      else
19037 +       return (sizeflag & AFLAG) ? "addr16" : "addr32";
19038 +    case FWAIT_OPCODE:
19039 +      return "fwait";
19040 +    default:
19041 +      return NULL;
19042 +    }
19043 +}
19044 +
19045 +static char op1out[100], op2out[100], op3out[100];
19046 +static int op_ad, op_index[3];
19047 +static int two_source_ops;
19048 +static bfd_vma op_address[3];
19049 +static bfd_vma op_riprel[3];
19050 +static bfd_vma start_pc;
19051 +
19052 +/*
19053 + *   On the 386's of 1988, the maximum length of an instruction is 15 bytes.
19054 + *   (see topic "Redundant prefixes" in the "Differences from 8086"
19055 + *   section of the "Virtual 8086 Mode" chapter.)
19056 + * 'pc' should be the address of this instruction, it will
19057 + *   be used to print the target address if this is a relative jump or call
19058 + * The function returns the length of this instruction in bytes.
19059 + */
19060 +
19061 +static char intel_syntax;
19062 +static char open_char;
19063 +static char close_char;
19064 +static char separator_char;
19065 +static char scale_char;
19066 +
19067 +/* Here for backwards compatibility.  When gdb stops using
19068 +   print_insn_i386_att and print_insn_i386_intel these functions can
19069 +   disappear, and print_insn_i386 be merged into print_insn.  */
19070 +int
19071 +print_insn_i386_att (bfd_vma pc, disassemble_info *info)
19072 +{
19073 +  intel_syntax = 0;
19074 +
19075 +  return print_insn (pc, info);
19076 +}
19077 +
19078 +int
19079 +print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
19080 +{
19081 +  intel_syntax = 1;
19082 +
19083 +  return print_insn (pc, info);
19084 +}
19085 +
19086 +int
19087 +print_insn_i386 (bfd_vma pc, disassemble_info *info)
19088 +{
19089 +  intel_syntax = -1;
19090 +
19091 +  return print_insn (pc, info);
19092 +}
19093 +
19094 +static int
19095 +print_insn (bfd_vma pc, disassemble_info *info)
19096 +{
19097 +  const struct dis386 *dp;
19098 +  int i;
19099 +  char *first, *second, *third;
19100 +  int needcomma;
19101 +  unsigned char uses_SSE_prefix, uses_LOCK_prefix;
19102 +  int sizeflag;
19103 +  const char *p;
19104 +  struct dis_private priv;
19105 +
19106 +  mode_64bit = (info->mach == bfd_mach_x86_64_intel_syntax
19107 +               || info->mach == bfd_mach_x86_64);
19108 +
19109 +  if (intel_syntax == (char) -1)
19110 +    intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
19111 +                   || info->mach == bfd_mach_x86_64_intel_syntax);
19112 +
19113 +  if (info->mach == bfd_mach_i386_i386
19114 +      || info->mach == bfd_mach_x86_64
19115 +      || info->mach == bfd_mach_i386_i386_intel_syntax
19116 +      || info->mach == bfd_mach_x86_64_intel_syntax)
19117 +    priv.orig_sizeflag = AFLAG | DFLAG;
19118 +  else if (info->mach == bfd_mach_i386_i8086)
19119 +    priv.orig_sizeflag = 0;
19120 +  else
19121 +    abort ();
19122 +
19123 +  for (p = info->disassembler_options; p != NULL; )
19124 +    {
19125 +      if (strncmp (p, "x86-64", 6) == 0)
19126 +       {
19127 +         mode_64bit = 1;
19128 +         priv.orig_sizeflag = AFLAG | DFLAG;
19129 +       }
19130 +      else if (strncmp (p, "i386", 4) == 0)
19131 +       {
19132 +         mode_64bit = 0;
19133 +         priv.orig_sizeflag = AFLAG | DFLAG;
19134 +       }
19135 +      else if (strncmp (p, "i8086", 5) == 0)
19136 +       {
19137 +         mode_64bit = 0;
19138 +         priv.orig_sizeflag = 0;
19139 +       }
19140 +      else if (strncmp (p, "intel", 5) == 0)
19141 +       {
19142 +         intel_syntax = 1;
19143 +       }
19144 +      else if (strncmp (p, "att", 3) == 0)
19145 +       {
19146 +         intel_syntax = 0;
19147 +       }
19148 +      else if (strncmp (p, "addr", 4) == 0)
19149 +       {
19150 +         if (p[4] == '1' && p[5] == '6')
19151 +           priv.orig_sizeflag &= ~AFLAG;
19152 +         else if (p[4] == '3' && p[5] == '2')
19153 +           priv.orig_sizeflag |= AFLAG;
19154 +       }
19155 +      else if (strncmp (p, "data", 4) == 0)
19156 +       {
19157 +         if (p[4] == '1' && p[5] == '6')
19158 +           priv.orig_sizeflag &= ~DFLAG;
19159 +         else if (p[4] == '3' && p[5] == '2')
19160 +           priv.orig_sizeflag |= DFLAG;
19161 +       }
19162 +      else if (strncmp (p, "suffix", 6) == 0)
19163 +       priv.orig_sizeflag |= SUFFIX_ALWAYS;
19164 +
19165 +      p = strchr (p, ',');
19166 +      if (p != NULL)
19167 +       p++;
19168 +    }
19169 +
19170 +  if (intel_syntax)
19171 +    {
19172 +      names64 = intel_names64;
19173 +      names32 = intel_names32;
19174 +      names16 = intel_names16;
19175 +      names8 = intel_names8;
19176 +      names8rex = intel_names8rex;
19177 +      names_seg = intel_names_seg;
19178 +      index16 = intel_index16;
19179 +      open_char = '[';
19180 +      close_char = ']';
19181 +      separator_char = '+';
19182 +      scale_char = '*';
19183 +    }
19184 +  else
19185 +    {
19186 +      names64 = att_names64;
19187 +      names32 = att_names32;
19188 +      names16 = att_names16;
19189 +      names8 = att_names8;
19190 +      names8rex = att_names8rex;
19191 +      names_seg = att_names_seg;
19192 +      index16 = att_index16;
19193 +      open_char = '(';
19194 +      close_char =  ')';
19195 +      separator_char = ',';
19196 +      scale_char = ',';
19197 +    }
19198 +
19199 +  /* The output looks better if we put 7 bytes on a line, since that
19200 +     puts most long word instructions on a single line.         */
19201 +  info->bytes_per_line = 7;
19202 +
19203 +  info->private_data = &priv;
19204 +  priv.max_fetched = priv.the_buffer;
19205 +  priv.insn_start = pc;
19206 +
19207 +  obuf[0] = 0;
19208 +  op1out[0] = 0;
19209 +  op2out[0] = 0;
19210 +  op3out[0] = 0;
19211 +
19212 +  op_index[0] = op_index[1] = op_index[2] = -1;
19213 +
19214 +  the_info = info;
19215 +  start_pc = pc;
19216 +  start_codep = priv.the_buffer;
19217 +  codep = priv.the_buffer;
19218 +
19219 +#ifndef __KERNEL__
19220 +  if (setjmp (priv.bailout) != 0)
19221 +    {
19222 +      const char *name;
19223 +
19224 +      /* Getting here means we tried for data but didn't get it.  That
19225 +        means we have an incomplete instruction of some sort.  Just
19226 +        print the first byte as a prefix or a .byte pseudo-op.  */
19227 +      if (codep > priv.the_buffer)
19228 +       {
19229 +         name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
19230 +         if (name != NULL)
19231 +           (*info->fprintf_func) (info->stream, "%s", name);
19232 +         else
19233 +           {
19234 +             /* Just print the first byte as a .byte instruction.  */
19235 +             (*info->fprintf_func) (info->stream, ".byte 0x%x",
19236 +                                    (unsigned int) priv.the_buffer[0]);
19237 +           }
19238 +
19239 +         return 1;
19240 +       }
19241 +
19242 +      return -1;
19243 +    }
19244 +#endif /* __KERNEL__ */
19245 +
19246 +  obufp = obuf;
19247 +  ckprefix ();
19248 +
19249 +  insn_codep = codep;
19250 +  sizeflag = priv.orig_sizeflag;
19251 +
19252 +  FETCH_DATA (info, codep + 1);
19253 +  two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
19254 +
19255 +  if ((prefixes & PREFIX_FWAIT)
19256 +      && ((*codep < 0xd8) || (*codep > 0xdf)))
19257 +    {
19258 +      const char *name;
19259 +
19260 +      /* fwait not followed by floating point instruction.  Print the
19261 +        first prefix, which is probably fwait itself.  */
19262 +      name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
19263 +      if (name == NULL)
19264 +       name = INTERNAL_DISASSEMBLER_ERROR;
19265 +      (*info->fprintf_func) (info->stream, "%s", name);
19266 +      return 1;
19267 +    }
19268 +
19269 +  if (*codep == 0x0f)
19270 +    {
19271 +      FETCH_DATA (info, codep + 2);
19272 +      dp = &dis386_twobyte[*++codep];
19273 +      need_modrm = twobyte_has_modrm[*codep];
19274 +      uses_SSE_prefix = twobyte_uses_SSE_prefix[*codep];
19275 +      uses_LOCK_prefix = (*codep & ~0x02) == 0x20;
19276 +    }
19277 +  else
19278 +    {
19279 +      dp = &dis386[*codep];
19280 +      need_modrm = onebyte_has_modrm[*codep];
19281 +      uses_SSE_prefix = 0;
19282 +      uses_LOCK_prefix = 0;
19283 +    }
19284 +  codep++;
19285 +
19286 +  if (!uses_SSE_prefix && (prefixes & PREFIX_REPZ))
19287 +    {
19288 +      oappend ("repz ");
19289 +      used_prefixes |= PREFIX_REPZ;
19290 +    }
19291 +  if (!uses_SSE_prefix && (prefixes & PREFIX_REPNZ))
19292 +    {
19293 +      oappend ("repnz ");
19294 +      used_prefixes |= PREFIX_REPNZ;
19295 +    }
19296 +  if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK))
19297 +    {
19298 +      oappend ("lock ");
19299 +      used_prefixes |= PREFIX_LOCK;
19300 +    }
19301 +
19302 +  if (prefixes & PREFIX_ADDR)
19303 +    {
19304 +      sizeflag ^= AFLAG;
19305 +      if (dp->bytemode3 != loop_jcxz_mode || intel_syntax)
19306 +       {
19307 +         if ((sizeflag & AFLAG) || mode_64bit)
19308 +           oappend ("addr32 ");
19309 +         else
19310 +           oappend ("addr16 ");
19311 +         used_prefixes |= PREFIX_ADDR;
19312 +       }
19313 +    }
19314 +
19315 +  if (!uses_SSE_prefix && (prefixes & PREFIX_DATA))
19316 +    {
19317 +      sizeflag ^= DFLAG;
19318 +      if (dp->bytemode3 == cond_jump_mode
19319 +         && dp->bytemode1 == v_mode
19320 +         && !intel_syntax)
19321 +       {
19322 +         if (sizeflag & DFLAG)
19323 +           oappend ("data32 ");
19324 +         else
19325 +           oappend ("data16 ");
19326 +         used_prefixes |= PREFIX_DATA;
19327 +       }
19328 +    }
19329 +
19330 +  if (need_modrm)
19331 +    {
19332 +      FETCH_DATA (info, codep + 1);
19333 +      mod = (*codep >> 6) & 3;
19334 +      reg = (*codep >> 3) & 7;
19335 +      rm = *codep & 7;
19336 +    }
19337 +
19338 +  if (dp->name == NULL && dp->bytemode1 == FLOATCODE)
19339 +    {
19340 +      dofloat (sizeflag);
19341 +    }
19342 +  else
19343 +    {
19344 +      int index;
19345 +      if (dp->name == NULL)
19346 +       {
19347 +         switch (dp->bytemode1)
19348 +           {
19349 +           case USE_GROUPS:
19350 +             dp = &grps[dp->bytemode2][reg];
19351 +             break;
19352 +
19353 +           case USE_PREFIX_USER_TABLE:
19354 +             index = 0;
19355 +             used_prefixes |= (prefixes & PREFIX_REPZ);
19356 +             if (prefixes & PREFIX_REPZ)
19357 +               index = 1;
19358 +             else
19359 +               {
19360 +                 used_prefixes |= (prefixes & PREFIX_DATA);
19361 +                 if (prefixes & PREFIX_DATA)
19362 +                   index = 2;
19363 +                 else
19364 +                   {
19365 +                     used_prefixes |= (prefixes & PREFIX_REPNZ);
19366 +                     if (prefixes & PREFIX_REPNZ)
19367 +                       index = 3;
19368 +                   }
19369 +               }
19370 +             dp = &prefix_user_table[dp->bytemode2][index];
19371 +             break;
19372 +
19373 +           case X86_64_SPECIAL:
19374 +             dp = &x86_64_table[dp->bytemode2][mode_64bit];
19375 +             break;
19376 +
19377 +           default:
19378 +             oappend (INTERNAL_DISASSEMBLER_ERROR);
19379 +             break;
19380 +           }
19381 +       }
19382 +
19383 +      if (putop (dp->name, sizeflag) == 0)
19384 +       {
19385 +         obufp = op1out;
19386 +         op_ad = 2;
19387 +         if (dp->op1)
19388 +           (*dp->op1) (dp->bytemode1, sizeflag);
19389 +
19390 +         obufp = op2out;
19391 +         op_ad = 1;
19392 +         if (dp->op2)
19393 +           (*dp->op2) (dp->bytemode2, sizeflag);
19394 +
19395 +         obufp = op3out;
19396 +         op_ad = 0;
19397 +         if (dp->op3)
19398 +           (*dp->op3) (dp->bytemode3, sizeflag);
19399 +       }
19400 +    }
19401 +
19402 +  /* See if any prefixes were not used.         If so, print the first one
19403 +     separately.  If we don't do this, we'll wind up printing an
19404 +     instruction stream which does not precisely correspond to the
19405 +     bytes we are disassembling.  */
19406 +  if ((prefixes & ~used_prefixes) != 0)
19407 +    {
19408 +      const char *name;
19409 +
19410 +      name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
19411 +      if (name == NULL)
19412 +       name = INTERNAL_DISASSEMBLER_ERROR;
19413 +      (*info->fprintf_func) (info->stream, "%s", name);
19414 +      return 1;
19415 +    }
19416 +  if (rex & ~rex_used)
19417 +    {
19418 +      const char *name;
19419 +      name = prefix_name (rex | 0x40, priv.orig_sizeflag);
19420 +      if (name == NULL)
19421 +       name = INTERNAL_DISASSEMBLER_ERROR;
19422 +      (*info->fprintf_func) (info->stream, "%s ", name);
19423 +    }
19424 +
19425 +  obufp = obuf + strlen (obuf);
19426 +  for (i = strlen (obuf); i < 6; i++)
19427 +    oappend (" ");
19428 +  oappend (" ");
19429 +  (*info->fprintf_func) (info->stream, "%s", obuf);
19430 +
19431 +  /* The enter and bound instructions are printed with operands in the same
19432 +     order as the intel book; everything else is printed in reverse order.  */
19433 +  if (intel_syntax || two_source_ops)
19434 +    {
19435 +      first = op1out;
19436 +      second = op2out;
19437 +      third = op3out;
19438 +      op_ad = op_index[0];
19439 +      op_index[0] = op_index[2];
19440 +      op_index[2] = op_ad;
19441 +    }
19442 +  else
19443 +    {
19444 +      first = op3out;
19445 +      second = op2out;
19446 +      third = op1out;
19447 +    }
19448 +  needcomma = 0;
19449 +  if (*first)
19450 +    {
19451 +      if (op_index[0] != -1 && !op_riprel[0])
19452 +       (*info->print_address_func) ((bfd_vma) op_address[op_index[0]], info);
19453 +      else
19454 +       (*info->fprintf_func) (info->stream, "%s", first);
19455 +      needcomma = 1;
19456 +    }
19457 +  if (*second)
19458 +    {
19459 +      if (needcomma)
19460 +       (*info->fprintf_func) (info->stream, ",");
19461 +      if (op_index[1] != -1 && !op_riprel[1])
19462 +       (*info->print_address_func) ((bfd_vma) op_address[op_index[1]], info);
19463 +      else
19464 +       (*info->fprintf_func) (info->stream, "%s", second);
19465 +      needcomma = 1;
19466 +    }
19467 +  if (*third)
19468 +    {
19469 +      if (needcomma)
19470 +       (*info->fprintf_func) (info->stream, ",");
19471 +      if (op_index[2] != -1 && !op_riprel[2])
19472 +       (*info->print_address_func) ((bfd_vma) op_address[op_index[2]], info);
19473 +      else
19474 +       (*info->fprintf_func) (info->stream, "%s", third);
19475 +    }
19476 +  for (i = 0; i < 3; i++)
19477 +    if (op_index[i] != -1 && op_riprel[i])
19478 +      {
19479 +       (*info->fprintf_func) (info->stream, "        # ");
19480 +       (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
19481 +                                               + op_address[op_index[i]]), info);
19482 +      }
19483 +  return codep - priv.the_buffer;
19484 +}
19485 +
19486 +static const char *float_mem[] = {
19487 +  /* d8 */
19488 +  "fadd{s||s|}",
19489 +  "fmul{s||s|}",
19490 +  "fcom{s||s|}",
19491 +  "fcomp{s||s|}",
19492 +  "fsub{s||s|}",
19493 +  "fsubr{s||s|}",
19494 +  "fdiv{s||s|}",
19495 +  "fdivr{s||s|}",
19496 +  /* d9 */
19497 +  "fld{s||s|}",
19498 +  "(bad)",
19499 +  "fst{s||s|}",
19500 +  "fstp{s||s|}",
19501 +  "fldenvIC",
19502 +  "fldcw",
19503 +  "fNstenvIC",
19504 +  "fNstcw",
19505 +  /* da */
19506 +  "fiadd{l||l|}",
19507 +  "fimul{l||l|}",
19508 +  "ficom{l||l|}",
19509 +  "ficomp{l||l|}",
19510 +  "fisub{l||l|}",
19511 +  "fisubr{l||l|}",
19512 +  "fidiv{l||l|}",
19513 +  "fidivr{l||l|}",
19514 +  /* db */
19515 +  "fild{l||l|}",
19516 +  "fisttp{l||l|}",
19517 +  "fist{l||l|}",
19518 +  "fistp{l||l|}",
19519 +  "(bad)",
19520 +  "fld{t||t|}",
19521 +  "(bad)",
19522 +  "fstp{t||t|}",
19523 +  /* dc */
19524 +  "fadd{l||l|}",
19525 +  "fmul{l||l|}",
19526 +  "fcom{l||l|}",
19527 +  "fcomp{l||l|}",
19528 +  "fsub{l||l|}",
19529 +  "fsubr{l||l|}",
19530 +  "fdiv{l||l|}",
19531 +  "fdivr{l||l|}",
19532 +  /* dd */
19533 +  "fld{l||l|}",
19534 +  "fisttp{ll||ll|}",
19535 +  "fst{l||l|}",
19536 +  "fstp{l||l|}",
19537 +  "frstorIC",
19538 +  "(bad)",
19539 +  "fNsaveIC",
19540 +  "fNstsw",
19541 +  /* de */
19542 +  "fiadd",
19543 +  "fimul",
19544 +  "ficom",
19545 +  "ficomp",
19546 +  "fisub",
19547 +  "fisubr",
19548 +  "fidiv",
19549 +  "fidivr",
19550 +  /* df */
19551 +  "fild",
19552 +  "fisttp",
19553 +  "fist",
19554 +  "fistp",
19555 +  "fbld",
19556 +  "fild{ll||ll|}",
19557 +  "fbstp",
19558 +  "fistp{ll||ll|}",
19559 +};
19560 +
19561 +static const unsigned char float_mem_mode[] = {
19562 +  /* d8 */
19563 +  d_mode,
19564 +  d_mode,
19565 +  d_mode,
19566 +  d_mode,
19567 +  d_mode,
19568 +  d_mode,
19569 +  d_mode,
19570 +  d_mode,
19571 +  /* d9 */
19572 +  d_mode,
19573 +  0,
19574 +  d_mode,
19575 +  d_mode,
19576 +  0,
19577 +  w_mode,
19578 +  0,
19579 +  w_mode,
19580 +  /* da */
19581 +  d_mode,
19582 +  d_mode,
19583 +  d_mode,
19584 +  d_mode,
19585 +  d_mode,
19586 +  d_mode,
19587 +  d_mode,
19588 +  d_mode,
19589 +  /* db */
19590 +  d_mode,
19591 +  d_mode,
19592 +  d_mode,
19593 +  d_mode,
19594 +  0,
19595 +  t_mode,
19596 +  0,
19597 +  t_mode,
19598 +  /* dc */
19599 +  q_mode,
19600 +  q_mode,
19601 +  q_mode,
19602 +  q_mode,
19603 +  q_mode,
19604 +  q_mode,
19605 +  q_mode,
19606 +  q_mode,
19607 +  /* dd */
19608 +  q_mode,
19609 +  q_mode,
19610 +  q_mode,
19611 +  q_mode,
19612 +  0,
19613 +  0,
19614 +  0,
19615 +  w_mode,
19616 +  /* de */
19617 +  w_mode,
19618 +  w_mode,
19619 +  w_mode,
19620 +  w_mode,
19621 +  w_mode,
19622 +  w_mode,
19623 +  w_mode,
19624 +  w_mode,
19625 +  /* df */
19626 +  w_mode,
19627 +  w_mode,
19628 +  w_mode,
19629 +  w_mode,
19630 +  t_mode,
19631 +  q_mode,
19632 +  t_mode,
19633 +  q_mode
19634 +};
19635 +
19636 +#define ST OP_ST, 0
19637 +#define STi OP_STi, 0
19638 +
19639 +#define FGRPd9_2 NULL, NULL, 0, NULL, 0, NULL, 0
19640 +#define FGRPd9_4 NULL, NULL, 1, NULL, 0, NULL, 0
19641 +#define FGRPd9_5 NULL, NULL, 2, NULL, 0, NULL, 0
19642 +#define FGRPd9_6 NULL, NULL, 3, NULL, 0, NULL, 0
19643 +#define FGRPd9_7 NULL, NULL, 4, NULL, 0, NULL, 0
19644 +#define FGRPda_5 NULL, NULL, 5, NULL, 0, NULL, 0
19645 +#define FGRPdb_4 NULL, NULL, 6, NULL, 0, NULL, 0
19646 +#define FGRPde_3 NULL, NULL, 7, NULL, 0, NULL, 0
19647 +#define FGRPdf_4 NULL, NULL, 8, NULL, 0, NULL, 0
19648 +
19649 +static const struct dis386 float_reg[][8] = {
19650 +  /* d8 */
19651 +  {
19652 +    { "fadd",  ST, STi, XX },
19653 +    { "fmul",  ST, STi, XX },
19654 +    { "fcom",  STi, XX, XX },
19655 +    { "fcomp", STi, XX, XX },
19656 +    { "fsub",  ST, STi, XX },
19657 +    { "fsubr", ST, STi, XX },
19658 +    { "fdiv",  ST, STi, XX },
19659 +    { "fdivr", ST, STi, XX },
19660 +  },
19661 +  /* d9 */
19662 +  {
19663 +    { "fld",   STi, XX, XX },
19664 +    { "fxch",  STi, XX, XX },
19665 +    { FGRPd9_2 },
19666 +    { "(bad)", XX, XX, XX },
19667 +    { FGRPd9_4 },
19668 +    { FGRPd9_5 },
19669 +    { FGRPd9_6 },
19670 +    { FGRPd9_7 },
19671 +  },
19672 +  /* da */
19673 +  {
19674 +    { "fcmovb", ST, STi, XX },
19675 +    { "fcmove", ST, STi, XX },
19676 +    { "fcmovbe",ST, STi, XX },
19677 +    { "fcmovu", ST, STi, XX },
19678 +    { "(bad)", XX, XX, XX },
19679 +    { FGRPda_5 },
19680 +    { "(bad)", XX, XX, XX },
19681 +    { "(bad)", XX, XX, XX },
19682 +  },
19683 +  /* db */
19684 +  {
19685 +    { "fcmovnb",ST, STi, XX },
19686 +    { "fcmovne",ST, STi, XX },
19687 +    { "fcmovnbe",ST, STi, XX },
19688 +    { "fcmovnu",ST, STi, XX },
19689 +    { FGRPdb_4 },
19690 +    { "fucomi", ST, STi, XX },
19691 +    { "fcomi", ST, STi, XX },
19692 +    { "(bad)", XX, XX, XX },
19693 +  },
19694 +  /* dc */
19695 +  {
19696 +    { "fadd",  STi, ST, XX },
19697 +    { "fmul",  STi, ST, XX },
19698 +    { "(bad)", XX, XX, XX },
19699 +    { "(bad)", XX, XX, XX },
19700 +#if UNIXWARE_COMPAT
19701 +    { "fsub",  STi, ST, XX },
19702 +    { "fsubr", STi, ST, XX },
19703 +    { "fdiv",  STi, ST, XX },
19704 +    { "fdivr", STi, ST, XX },
19705 +#else
19706 +    { "fsubr", STi, ST, XX },
19707 +    { "fsub",  STi, ST, XX },
19708 +    { "fdivr", STi, ST, XX },
19709 +    { "fdiv",  STi, ST, XX },
19710 +#endif
19711 +  },
19712 +  /* dd */
19713 +  {
19714 +    { "ffree", STi, XX, XX },
19715 +    { "(bad)", XX, XX, XX },
19716 +    { "fst",   STi, XX, XX },
19717 +    { "fstp",  STi, XX, XX },
19718 +    { "fucom", STi, XX, XX },
19719 +    { "fucomp", STi, XX, XX },
19720 +    { "(bad)", XX, XX, XX },
19721 +    { "(bad)", XX, XX, XX },
19722 +  },
19723 +  /* de */
19724 +  {
19725 +    { "faddp", STi, ST, XX },
19726 +    { "fmulp", STi, ST, XX },
19727 +    { "(bad)", XX, XX, XX },
19728 +    { FGRPde_3 },
19729 +#if UNIXWARE_COMPAT
19730 +    { "fsubp", STi, ST, XX },
19731 +    { "fsubrp", STi, ST, XX },
19732 +    { "fdivp", STi, ST, XX },
19733 +    { "fdivrp", STi, ST, XX },
19734 +#else
19735 +    { "fsubrp", STi, ST, XX },
19736 +    { "fsubp", STi, ST, XX },
19737 +    { "fdivrp", STi, ST, XX },
19738 +    { "fdivp", STi, ST, XX },
19739 +#endif
19740 +  },
19741 +  /* df */
19742 +  {
19743 +    { "ffreep", STi, XX, XX },
19744 +    { "(bad)", XX, XX, XX },
19745 +    { "(bad)", XX, XX, XX },
19746 +    { "(bad)", XX, XX, XX },
19747 +    { FGRPdf_4 },
19748 +    { "fucomip",ST, STi, XX },
19749 +    { "fcomip", ST, STi, XX },
19750 +    { "(bad)", XX, XX, XX },
19751 +  },
19752 +};
19753 +
19754 +static char *fgrps[][8] = {
19755 +  /* d9_2  0 */
19756 +  {
19757 +    "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
19758 +  },
19759 +
19760 +  /* d9_4  1 */
19761 +  {
19762 +    "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
19763 +  },
19764 +
19765 +  /* d9_5  2 */
19766 +  {
19767 +    "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
19768 +  },
19769 +
19770 +  /* d9_6  3 */
19771 +  {
19772 +    "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
19773 +  },
19774 +
19775 +  /* d9_7  4 */
19776 +  {
19777 +    "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
19778 +  },
19779 +
19780 +  /* da_5  5 */
19781 +  {
19782 +    "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
19783 +  },
19784 +
19785 +  /* db_4  6 */
19786 +  {
19787 +    "feni(287 only)","fdisi(287 only)","fNclex","fNinit",
19788 +    "fNsetpm(287 only)","(bad)","(bad)","(bad)",
19789 +  },
19790 +
19791 +  /* de_3  7 */
19792 +  {
19793 +    "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
19794 +  },
19795 +
19796 +  /* df_4  8 */
19797 +  {
19798 +    "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
19799 +  },
19800 +};
19801 +
19802 +static void
19803 +dofloat (int sizeflag)
19804 +{
19805 +  const struct dis386 *dp;
19806 +  unsigned char floatop;
19807 +
19808 +  floatop = codep[-1];
19809 +
19810 +  if (mod != 3)
19811 +    {
19812 +      int fp_indx = (floatop - 0xd8) * 8 + reg;
19813 +
19814 +      putop (float_mem[fp_indx], sizeflag);
19815 +      obufp = op1out;
19816 +      OP_E (float_mem_mode[fp_indx], sizeflag);
19817 +      return;
19818 +    }
19819 +  /* Skip mod/rm byte. */
19820 +  MODRM_CHECK;
19821 +  codep++;
19822 +
19823 +  dp = &float_reg[floatop - 0xd8][reg];
19824 +  if (dp->name == NULL)
19825 +    {
19826 +      putop (fgrps[dp->bytemode1][rm], sizeflag);
19827 +
19828 +      /* Instruction fnstsw is only one with strange arg.  */
19829 +      if (floatop == 0xdf && codep[-1] == 0xe0)
19830 +       strcpy (op1out, names16[0]);
19831 +    }
19832 +  else
19833 +    {
19834 +      putop (dp->name, sizeflag);
19835 +
19836 +      obufp = op1out;
19837 +      if (dp->op1)
19838 +       (*dp->op1) (dp->bytemode1, sizeflag);
19839 +      obufp = op2out;
19840 +      if (dp->op2)
19841 +       (*dp->op2) (dp->bytemode2, sizeflag);
19842 +    }
19843 +}
19844 +
19845 +static void
19846 +OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
19847 +{
19848 +  oappend ("%st");
19849 +}
19850 +
19851 +static void
19852 +OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
19853 +{
19854 +  sprintf (scratchbuf, "%%st(%d)", rm);
19855 +  oappend (scratchbuf + intel_syntax);
19856 +}
19857 +
19858 +/* Capital letters in template are macros.  */
19859 +static int
19860 +putop (const char *template, int sizeflag)
19861 +{
19862 +  const char *p;
19863 +  int alt = 0;
19864 +
19865 +  for (p = template; *p; p++)
19866 +    {
19867 +      switch (*p)
19868 +       {
19869 +       default:
19870 +         *obufp++ = *p;
19871 +         break;
19872 +       case '{':
19873 +         alt = 0;
19874 +         if (intel_syntax)
19875 +           alt += 1;
19876 +         if (mode_64bit)
19877 +           alt += 2;
19878 +         while (alt != 0)
19879 +           {
19880 +             while (*++p != '|')
19881 +               {
19882 +                 if (*p == '}')
19883 +                   {
19884 +                     /* Alternative not valid.  */
19885 +                     strcpy (obuf, "(bad)");
19886 +                     obufp = obuf + 5;
19887 +                     return 1;
19888 +                   }
19889 +                 else if (*p == '\0')
19890 +                   abort ();
19891 +               }
19892 +             alt--;
19893 +           }
19894 +         /* Fall through.  */
19895 +       case 'I':
19896 +         alt = 1;
19897 +         continue;
19898 +       case '|':
19899 +         while (*++p != '}')
19900 +           {
19901 +             if (*p == '\0')
19902 +               abort ();
19903 +           }
19904 +         break;
19905 +       case '}':
19906 +         break;
19907 +       case 'A':
19908 +         if (intel_syntax)
19909 +           break;
19910 +         if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
19911 +           *obufp++ = 'b';
19912 +         break;
19913 +       case 'B':
19914 +         if (intel_syntax)
19915 +           break;
19916 +         if (sizeflag & SUFFIX_ALWAYS)
19917 +           *obufp++ = 'b';
19918 +         break;
19919 +       case 'C':
19920 +         if (intel_syntax && !alt)
19921 +           break;
19922 +         if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
19923 +           {
19924 +             if (sizeflag & DFLAG)
19925 +               *obufp++ = intel_syntax ? 'd' : 'l';
19926 +             else
19927 +               *obufp++ = intel_syntax ? 'w' : 's';
19928 +             used_prefixes |= (prefixes & PREFIX_DATA);
19929 +           }
19930 +         break;
19931 +       case 'E':               /* For jcxz/jecxz */
19932 +         if (mode_64bit)
19933 +           {
19934 +             if (sizeflag & AFLAG)
19935 +               *obufp++ = 'r';
19936 +             else
19937 +               *obufp++ = 'e';
19938 +           }
19939 +         else
19940 +           if (sizeflag & AFLAG)
19941 +             *obufp++ = 'e';
19942 +         used_prefixes |= (prefixes & PREFIX_ADDR);
19943 +         break;
19944 +       case 'F':
19945 +         if (intel_syntax)
19946 +           break;
19947 +         if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
19948 +           {
19949 +             if (sizeflag & AFLAG)
19950 +               *obufp++ = mode_64bit ? 'q' : 'l';
19951 +             else
19952 +               *obufp++ = mode_64bit ? 'l' : 'w';
19953 +             used_prefixes |= (prefixes & PREFIX_ADDR);
19954 +           }
19955 +         break;
19956 +       case 'H':
19957 +         if (intel_syntax)
19958 +           break;
19959 +         if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
19960 +             || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
19961 +           {
19962 +             used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
19963 +             *obufp++ = ',';
19964 +             *obufp++ = 'p';
19965 +             if (prefixes & PREFIX_DS)
19966 +               *obufp++ = 't';
19967 +             else
19968 +               *obufp++ = 'n';
19969 +           }
19970 +         break;
19971 +       case 'J':
19972 +         if (intel_syntax)
19973 +           break;
19974 +         *obufp++ = 'l';
19975 +         break;
19976 +       case 'L':
19977 +         if (intel_syntax)
19978 +           break;
19979 +         if (sizeflag & SUFFIX_ALWAYS)
19980 +           *obufp++ = 'l';
19981 +         break;
19982 +       case 'N':
19983 +         if ((prefixes & PREFIX_FWAIT) == 0)
19984 +           *obufp++ = 'n';
19985 +         else
19986 +           used_prefixes |= PREFIX_FWAIT;
19987 +         break;
19988 +       case 'O':
19989 +         USED_REX (REX_MODE64);
19990 +         if (rex & REX_MODE64)
19991 +           *obufp++ = 'o';
19992 +         else
19993 +           *obufp++ = 'd';
19994 +         break;
19995 +       case 'T':
19996 +         if (intel_syntax)
19997 +           break;
19998 +         if (mode_64bit)
19999 +           {
20000 +             *obufp++ = 'q';
20001 +             break;
20002 +           }
20003 +         /* Fall through.  */
20004 +       case 'P':
20005 +         if (intel_syntax)
20006 +           break;
20007 +         if ((prefixes & PREFIX_DATA)
20008 +             || (rex & REX_MODE64)
20009 +             || (sizeflag & SUFFIX_ALWAYS))
20010 +           {
20011 +             USED_REX (REX_MODE64);
20012 +             if (rex & REX_MODE64)
20013 +               *obufp++ = 'q';
20014 +             else
20015 +               {
20016 +                  if (sizeflag & DFLAG)
20017 +                     *obufp++ = 'l';
20018 +                  else
20019 +                    *obufp++ = 'w';
20020 +                  used_prefixes |= (prefixes & PREFIX_DATA);
20021 +               }
20022 +           }
20023 +         break;
20024 +       case 'U':
20025 +         if (intel_syntax)
20026 +           break;
20027 +         if (mode_64bit)
20028 +           {
20029 +             *obufp++ = 'q';
20030 +             break;
20031 +           }
20032 +         /* Fall through.  */
20033 +       case 'Q':
20034 +         if (intel_syntax && !alt)
20035 +           break;
20036 +         USED_REX (REX_MODE64);
20037 +         if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
20038 +           {
20039 +             if (rex & REX_MODE64)
20040 +               *obufp++ = 'q';
20041 +             else
20042 +               {
20043 +                 if (sizeflag & DFLAG)
20044 +                   *obufp++ = intel_syntax ? 'd' : 'l';
20045 +                 else
20046 +                   *obufp++ = 'w';
20047 +                 used_prefixes |= (prefixes & PREFIX_DATA);
20048 +               }
20049 +           }
20050 +         break;
20051 +       case 'R':
20052 +         USED_REX (REX_MODE64);
20053 +         if (intel_syntax)
20054 +           {
20055 +             if (rex & REX_MODE64)
20056 +               {
20057 +                 *obufp++ = 'q';
20058 +                 *obufp++ = 't';
20059 +               }
20060 +             else if (sizeflag & DFLAG)
20061 +               {
20062 +                 *obufp++ = 'd';
20063 +                 *obufp++ = 'q';
20064 +               }
20065 +             else
20066 +               {
20067 +                 *obufp++ = 'w';
20068 +                 *obufp++ = 'd';
20069 +               }
20070 +           }
20071 +         else
20072 +           {
20073 +             if (rex & REX_MODE64)
20074 +               *obufp++ = 'q';
20075 +             else if (sizeflag & DFLAG)
20076 +               *obufp++ = 'l';
20077 +             else
20078 +               *obufp++ = 'w';
20079 +           }
20080 +         if (!(rex & REX_MODE64))
20081 +           used_prefixes |= (prefixes & PREFIX_DATA);
20082 +         break;
20083 +       case 'S':
20084 +         if (intel_syntax)
20085 +           break;
20086 +         if (sizeflag & SUFFIX_ALWAYS)
20087 +           {
20088 +             if (rex & REX_MODE64)
20089 +               *obufp++ = 'q';
20090 +             else
20091 +               {
20092 +                 if (sizeflag & DFLAG)
20093 +                   *obufp++ = 'l';
20094 +                 else
20095 +                   *obufp++ = 'w';
20096 +                 used_prefixes |= (prefixes & PREFIX_DATA);
20097 +               }
20098 +           }
20099 +         break;
20100 +       case 'X':
20101 +         if (prefixes & PREFIX_DATA)
20102 +           *obufp++ = 'd';
20103 +         else
20104 +           *obufp++ = 's';
20105 +         used_prefixes |= (prefixes & PREFIX_DATA);
20106 +         break;
20107 +       case 'Y':
20108 +         if (intel_syntax)
20109 +           break;
20110 +         if (rex & REX_MODE64)
20111 +           {
20112 +             USED_REX (REX_MODE64);
20113 +             *obufp++ = 'q';
20114 +           }
20115 +         break;
20116 +         /* implicit operand size 'l' for i386 or 'q' for x86-64 */
20117 +       case 'W':
20118 +         /* operand size flag for cwtl, cbtw */
20119 +         USED_REX (0);
20120 +         if (rex)
20121 +           *obufp++ = 'l';
20122 +         else if (sizeflag & DFLAG)
20123 +           *obufp++ = 'w';
20124 +         else
20125 +           *obufp++ = 'b';
20126 +         if (intel_syntax)
20127 +           {
20128 +             if (rex)
20129 +               {
20130 +                 *obufp++ = 'q';
20131 +                 *obufp++ = 'e';
20132 +               }
20133 +             if (sizeflag & DFLAG)
20134 +               {
20135 +                 *obufp++ = 'd';
20136 +                 *obufp++ = 'e';
20137 +               }
20138 +             else
20139 +               {
20140 +                 *obufp++ = 'w';
20141 +               }
20142 +           }
20143 +         if (!rex)
20144 +           used_prefixes |= (prefixes & PREFIX_DATA);
20145 +         break;
20146 +       }
20147 +      alt = 0;
20148 +    }
20149 +  *obufp = 0;
20150 +  return 0;
20151 +}
20152 +
20153 +static void
20154 +oappend (const char *s)
20155 +{
20156 +  strcpy (obufp, s);
20157 +  obufp += strlen (s);
20158 +}
20159 +
20160 +static void
20161 +append_seg (void)
20162 +{
20163 +  if (prefixes & PREFIX_CS)
20164 +    {
20165 +      used_prefixes |= PREFIX_CS;
20166 +      oappend ("%cs:" + intel_syntax);
20167 +    }
20168 +  if (prefixes & PREFIX_DS)
20169 +    {
20170 +      used_prefixes |= PREFIX_DS;
20171 +      oappend ("%ds:" + intel_syntax);
20172 +    }
20173 +  if (prefixes & PREFIX_SS)
20174 +    {
20175 +      used_prefixes |= PREFIX_SS;
20176 +      oappend ("%ss:" + intel_syntax);
20177 +    }
20178 +  if (prefixes & PREFIX_ES)
20179 +    {
20180 +      used_prefixes |= PREFIX_ES;
20181 +      oappend ("%es:" + intel_syntax);
20182 +    }
20183 +  if (prefixes & PREFIX_FS)
20184 +    {
20185 +      used_prefixes |= PREFIX_FS;
20186 +      oappend ("%fs:" + intel_syntax);
20187 +    }
20188 +  if (prefixes & PREFIX_GS)
20189 +    {
20190 +      used_prefixes |= PREFIX_GS;
20191 +      oappend ("%gs:" + intel_syntax);
20192 +    }
20193 +}
20194 +
20195 +static void
20196 +OP_indirE (int bytemode, int sizeflag)
20197 +{
20198 +  if (!intel_syntax)
20199 +    oappend ("*");
20200 +  OP_E (bytemode, sizeflag);
20201 +}
20202 +
20203 +static void
20204 +print_operand_value (char *buf, int hex, bfd_vma disp)
20205 +{
20206 +  if (mode_64bit)
20207 +    {
20208 +      if (hex)
20209 +       {
20210 +         char tmp[30];
20211 +         int i;
20212 +         buf[0] = '0';
20213 +         buf[1] = 'x';
20214 +         sprintf_vma (tmp, disp);
20215 +         for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
20216 +         strcpy (buf + 2, tmp + i);
20217 +       }
20218 +      else
20219 +       {
20220 +         bfd_signed_vma v = disp;
20221 +         char tmp[30];
20222 +         int i;
20223 +         if (v < 0)
20224 +           {
20225 +             *(buf++) = '-';
20226 +             v = -disp;
20227 +             /* Check for possible overflow on 0x8000000000000000.  */
20228 +             if (v < 0)
20229 +               {
20230 +                 strcpy (buf, "9223372036854775808");
20231 +                 return;
20232 +               }
20233 +           }
20234 +         if (!v)
20235 +           {
20236 +             strcpy (buf, "0");
20237 +             return;
20238 +           }
20239 +
20240 +         i = 0;
20241 +         tmp[29] = 0;
20242 +         while (v)
20243 +           {
20244 +             tmp[28 - i] = (v % 10) + '0';
20245 +             v /= 10;
20246 +             i++;
20247 +           }
20248 +         strcpy (buf, tmp + 29 - i);
20249 +       }
20250 +    }
20251 +  else
20252 +    {
20253 +      if (hex)
20254 +       sprintf (buf, "0x%x", (unsigned int) disp);
20255 +      else
20256 +       sprintf (buf, "%d", (int) disp);
20257 +    }
20258 +}
20259 +
20260 +static void
20261 +OP_E (int bytemode, int sizeflag)
20262 +{
20263 +  bfd_vma disp;
20264 +  int add = 0;
20265 +  int riprel = 0;
20266 +  USED_REX (REX_EXTZ);
20267 +  if (rex & REX_EXTZ)
20268 +    add += 8;
20269 +
20270 +  /* Skip mod/rm byte. */
20271 +  MODRM_CHECK;
20272 +  codep++;
20273 +
20274 +  if (mod == 3)
20275 +    {
20276 +      switch (bytemode)
20277 +       {
20278 +       case b_mode:
20279 +         USED_REX (0);
20280 +         if (rex)
20281 +           oappend (names8rex[rm + add]);
20282 +         else
20283 +           oappend (names8[rm + add]);
20284 +         break;
20285 +       case w_mode:
20286 +         oappend (names16[rm + add]);
20287 +         break;
20288 +       case d_mode:
20289 +         oappend (names32[rm + add]);
20290 +         break;
20291 +       case q_mode:
20292 +         oappend (names64[rm + add]);
20293 +         break;
20294 +       case m_mode:
20295 +         if (mode_64bit)
20296 +           oappend (names64[rm + add]);
20297 +         else
20298 +           oappend (names32[rm + add]);
20299 +         break;
20300 +       case branch_v_mode:
20301 +         if (mode_64bit)
20302 +           oappend (names64[rm + add]);
20303 +         else
20304 +           {
20305 +             if ((sizeflag & DFLAG) || bytemode != branch_v_mode)
20306 +               oappend (names32[rm + add]);
20307 +             else
20308 +               oappend (names16[rm + add]);
20309 +             used_prefixes |= (prefixes & PREFIX_DATA);
20310 +           }
20311 +         break;
20312 +       case v_mode:
20313 +       case dq_mode:
20314 +       case dqw_mode:
20315 +         USED_REX (REX_MODE64);
20316 +         if (rex & REX_MODE64)
20317 +           oappend (names64[rm + add]);
20318 +         else if ((sizeflag & DFLAG) || bytemode != v_mode)
20319 +           oappend (names32[rm + add]);
20320 +         else
20321 +           oappend (names16[rm + add]);
20322 +         used_prefixes |= (prefixes & PREFIX_DATA);
20323 +         break;
20324 +       case 0:
20325 +         break;
20326 +       default:
20327 +         oappend (INTERNAL_DISASSEMBLER_ERROR);
20328 +         break;
20329 +       }
20330 +      return;
20331 +    }
20332 +
20333 +  disp = 0;
20334 +  append_seg ();
20335 +
20336 +  if ((sizeflag & AFLAG) || mode_64bit) /* 32 bit address mode */
20337 +    {
20338 +      int havesib;
20339 +      int havebase;
20340 +      int base;
20341 +      int index = 0;
20342 +      int scale = 0;
20343 +
20344 +      havesib = 0;
20345 +      havebase = 1;
20346 +      base = rm;
20347 +
20348 +      if (base == 4)
20349 +       {
20350 +         havesib = 1;
20351 +         FETCH_DATA (the_info, codep + 1);
20352 +         index = (*codep >> 3) & 7;
20353 +         if (mode_64bit || index != 0x4)
20354 +           /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored.  */
20355 +           scale = (*codep >> 6) & 3;
20356 +         base = *codep & 7;
20357 +         USED_REX (REX_EXTY);
20358 +         if (rex & REX_EXTY)
20359 +           index += 8;
20360 +         codep++;
20361 +       }
20362 +      base += add;
20363 +
20364 +      switch (mod)
20365 +       {
20366 +       case 0:
20367 +         if ((base & 7) == 5)
20368 +           {
20369 +             havebase = 0;
20370 +             if (mode_64bit && !havesib)
20371 +               riprel = 1;
20372 +             disp = get32s ();
20373 +           }
20374 +         break;
20375 +       case 1:
20376 +         FETCH_DATA (the_info, codep + 1);
20377 +         disp = *codep++;
20378 +         if ((disp & 0x80) != 0)
20379 +           disp -= 0x100;
20380 +         break;
20381 +       case 2:
20382 +         disp = get32s ();
20383 +         break;
20384 +       }
20385 +
20386 +      if (!intel_syntax)
20387 +       if (mod != 0 || (base & 7) == 5)
20388 +         {
20389 +           print_operand_value (scratchbuf, !riprel, disp);
20390 +           oappend (scratchbuf);
20391 +           if (riprel)
20392 +             {
20393 +               set_op (disp, 1);
20394 +               oappend ("(%rip)");
20395 +             }
20396 +         }
20397 +
20398 +      if (havebase || (havesib && (index != 4 || scale != 0)))
20399 +       {
20400 +         if (intel_syntax)
20401 +           {
20402 +             switch (bytemode)
20403 +               {
20404 +               case b_mode:
20405 +                 oappend ("BYTE PTR ");
20406 +                 break;
20407 +               case w_mode:
20408 +               case dqw_mode:
20409 +                 oappend ("WORD PTR ");
20410 +                 break;
20411 +               case branch_v_mode:
20412 +               case v_mode:
20413 +               case dq_mode:
20414 +                 USED_REX (REX_MODE64);
20415 +                 if (rex & REX_MODE64)
20416 +                   oappend ("QWORD PTR ");
20417 +                 else if ((sizeflag & DFLAG) || bytemode == dq_mode)
20418 +                   oappend ("DWORD PTR ");
20419 +                 else
20420 +                   oappend ("WORD PTR ");
20421 +                 used_prefixes |= (prefixes & PREFIX_DATA);
20422 +                 break;
20423 +               case d_mode:
20424 +                 oappend ("DWORD PTR ");
20425 +                 break;
20426 +               case q_mode:
20427 +                 oappend ("QWORD PTR ");
20428 +                 break;
20429 +               case m_mode:
20430 +                 if (mode_64bit)
20431 +                   oappend ("QWORD PTR ");
20432 +                 else
20433 +                   oappend ("DWORD PTR ");
20434 +                 break;
20435 +               case f_mode:
20436 +                 if (sizeflag & DFLAG)
20437 +                   {
20438 +                     used_prefixes |= (prefixes & PREFIX_DATA);
20439 +                     oappend ("FWORD PTR ");
20440 +                   }
20441 +                 else
20442 +                   oappend ("DWORD PTR ");
20443 +                 break;
20444 +               case t_mode:
20445 +                 oappend ("TBYTE PTR ");
20446 +                 break;
20447 +               case x_mode:
20448 +                 oappend ("XMMWORD PTR ");
20449 +                 break;
20450 +               default:
20451 +                 break;
20452 +               }
20453 +           }
20454 +         *obufp++ = open_char;
20455 +         if (intel_syntax && riprel)
20456 +           oappend ("rip + ");
20457 +         *obufp = '\0';
20458 +         if (havebase)
20459 +           oappend (mode_64bit && (sizeflag & AFLAG)
20460 +                    ? names64[base] : names32[base]);
20461 +         if (havesib)
20462 +           {
20463 +             if (index != 4)
20464 +               {
20465 +                 if (!intel_syntax || havebase)
20466 +                   {
20467 +                     *obufp++ = separator_char;
20468 +                     *obufp = '\0';
20469 +                   }
20470 +                 oappend (mode_64bit && (sizeflag & AFLAG)
20471 +                          ? names64[index] : names32[index]);
20472 +               }
20473 +             if (scale != 0 || (!intel_syntax && index != 4))
20474 +               {
20475 +                 *obufp++ = scale_char;
20476 +                 *obufp = '\0';
20477 +                 sprintf (scratchbuf, "%d", 1 << scale);
20478 +                 oappend (scratchbuf);
20479 +               }
20480 +           }
20481 +         if (intel_syntax && disp)
20482 +           {
20483 +             if ((bfd_signed_vma) disp > 0)
20484 +               {
20485 +                 *obufp++ = '+';
20486 +                 *obufp = '\0';
20487 +               }
20488 +             else if (mod != 1)
20489 +               {
20490 +                 *obufp++ = '-';
20491 +                 *obufp = '\0';
20492 +                 disp = - (bfd_signed_vma) disp;
20493 +               }
20494 +
20495 +             print_operand_value (scratchbuf, mod != 1, disp);
20496 +             oappend (scratchbuf);
20497 +           }
20498 +
20499 +         *obufp++ = close_char;
20500 +         *obufp = '\0';
20501 +       }
20502 +      else if (intel_syntax)
20503 +       {
20504 +         if (mod != 0 || (base & 7) == 5)
20505 +           {
20506 +             if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
20507 +                             | PREFIX_ES | PREFIX_FS | PREFIX_GS))
20508 +               ;
20509 +             else
20510 +               {
20511 +                 oappend (names_seg[ds_reg - es_reg]);
20512 +                 oappend (":");
20513 +               }
20514 +             print_operand_value (scratchbuf, 1, disp);
20515 +             oappend (scratchbuf);
20516 +           }
20517 +       }
20518 +    }
20519 +  else
20520 +    { /* 16 bit address mode */
20521 +      switch (mod)
20522 +       {
20523 +       case 0:
20524 +         if (rm == 6)
20525 +           {
20526 +             disp = get16 ();
20527 +             if ((disp & 0x8000) != 0)
20528 +               disp -= 0x10000;
20529 +           }
20530 +         break;
20531 +       case 1:
20532 +         FETCH_DATA (the_info, codep + 1);
20533 +         disp = *codep++;
20534 +         if ((disp & 0x80) != 0)
20535 +           disp -= 0x100;
20536 +         break;
20537 +       case 2:
20538 +         disp = get16 ();
20539 +         if ((disp & 0x8000) != 0)
20540 +           disp -= 0x10000;
20541 +         break;
20542 +       }
20543 +
20544 +      if (!intel_syntax)
20545 +       if (mod != 0 || rm == 6)
20546 +         {
20547 +           print_operand_value (scratchbuf, 0, disp);
20548 +           oappend (scratchbuf);
20549 +         }
20550 +
20551 +      if (mod != 0 || rm != 6)
20552 +       {
20553 +         *obufp++ = open_char;
20554 +         *obufp = '\0';
20555 +         oappend (index16[rm]);
20556 +         if (intel_syntax && disp)
20557 +           {
20558 +             if ((bfd_signed_vma) disp > 0)
20559 +               {
20560 +                 *obufp++ = '+';
20561 +                 *obufp = '\0';
20562 +               }
20563 +             else if (mod != 1)
20564 +               {
20565 +                 *obufp++ = '-';
20566 +                 *obufp = '\0';
20567 +                 disp = - (bfd_signed_vma) disp;
20568 +               }
20569 +
20570 +             print_operand_value (scratchbuf, mod != 1, disp);
20571 +             oappend (scratchbuf);
20572 +           }
20573 +
20574 +         *obufp++ = close_char;
20575 +         *obufp = '\0';
20576 +       }
20577 +      else if (intel_syntax)
20578 +       {
20579 +         if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
20580 +                         | PREFIX_ES | PREFIX_FS | PREFIX_GS))
20581 +           ;
20582 +         else
20583 +           {
20584 +             oappend (names_seg[ds_reg - es_reg]);
20585 +             oappend (":");
20586 +           }
20587 +         print_operand_value (scratchbuf, 1, disp & 0xffff);
20588 +         oappend (scratchbuf);
20589 +       }
20590 +    }
20591 +}
20592 +
20593 +static void
20594 +OP_G (int bytemode, int sizeflag)
20595 +{
20596 +  int add = 0;
20597 +  USED_REX (REX_EXTX);
20598 +  if (rex & REX_EXTX)
20599 +    add += 8;
20600 +  switch (bytemode)
20601 +    {
20602 +    case b_mode:
20603 +      USED_REX (0);
20604 +      if (rex)
20605 +       oappend (names8rex[reg + add]);
20606 +      else
20607 +       oappend (names8[reg + add]);
20608 +      break;
20609 +    case w_mode:
20610 +      oappend (names16[reg + add]);
20611 +      break;
20612 +    case d_mode:
20613 +      oappend (names32[reg + add]);
20614 +      break;
20615 +    case q_mode:
20616 +      oappend (names64[reg + add]);
20617 +      break;
20618 +    case v_mode:
20619 +    case dq_mode:
20620 +    case dqw_mode:
20621 +      USED_REX (REX_MODE64);
20622 +      if (rex & REX_MODE64)
20623 +       oappend (names64[reg + add]);
20624 +      else if ((sizeflag & DFLAG) || bytemode != v_mode)
20625 +       oappend (names32[reg + add]);
20626 +      else
20627 +       oappend (names16[reg + add]);
20628 +      used_prefixes |= (prefixes & PREFIX_DATA);
20629 +      break;
20630 +    case m_mode:
20631 +      if (mode_64bit)
20632 +       oappend (names64[reg + add]);
20633 +      else
20634 +       oappend (names32[reg + add]);
20635 +      break;
20636 +    default:
20637 +      oappend (INTERNAL_DISASSEMBLER_ERROR);
20638 +      break;
20639 +    }
20640 +}
20641 +
20642 +static bfd_vma
20643 +get64 (void)
20644 +{
20645 +  bfd_vma x;
20646 +#ifdef BFD64
20647 +  unsigned int a;
20648 +  unsigned int b;
20649 +
20650 +  FETCH_DATA (the_info, codep + 8);
20651 +  a = *codep++ & 0xff;
20652 +  a |= (*codep++ & 0xff) << 8;
20653 +  a |= (*codep++ & 0xff) << 16;
20654 +  a |= (*codep++ & 0xff) << 24;
20655 +  b = *codep++ & 0xff;
20656 +  b |= (*codep++ & 0xff) << 8;
20657 +  b |= (*codep++ & 0xff) << 16;
20658 +  b |= (*codep++ & 0xff) << 24;
20659 +  x = a + ((bfd_vma) b << 32);
20660 +#else
20661 +  abort ();
20662 +  x = 0;
20663 +#endif
20664 +  return x;
20665 +}
20666 +
20667 +static bfd_signed_vma
20668 +get32 (void)
20669 +{
20670 +  bfd_signed_vma x = 0;
20671 +
20672 +  FETCH_DATA (the_info, codep + 4);
20673 +  x = *codep++ & (bfd_signed_vma) 0xff;
20674 +  x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
20675 +  x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
20676 +  x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
20677 +  return x;
20678 +}
20679 +
20680 +static bfd_signed_vma
20681 +get32s (void)
20682 +{
20683 +  bfd_signed_vma x = 0;
20684 +
20685 +  FETCH_DATA (the_info, codep + 4);
20686 +  x = *codep++ & (bfd_signed_vma) 0xff;
20687 +  x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
20688 +  x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
20689 +  x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
20690 +
20691 +  x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
20692 +
20693 +  return x;
20694 +}
20695 +
20696 +static int
20697 +get16 (void)
20698 +{
20699 +  int x = 0;
20700 +
20701 +  FETCH_DATA (the_info, codep + 2);
20702 +  x = *codep++ & 0xff;
20703 +  x |= (*codep++ & 0xff) << 8;
20704 +  return x;
20705 +}
20706 +
20707 +static void
20708 +set_op (bfd_vma op, int riprel)
20709 +{
20710 +  op_index[op_ad] = op_ad;
20711 +  if (mode_64bit)
20712 +    {
20713 +      op_address[op_ad] = op;
20714 +      op_riprel[op_ad] = riprel;
20715 +    }
20716 +  else
20717 +    {
20718 +      /* Mask to get a 32-bit address. */
20719 +      op_address[op_ad] = op & 0xffffffff;
20720 +      op_riprel[op_ad] = riprel & 0xffffffff;
20721 +    }
20722 +}
20723 +
20724 +static void
20725 +OP_REG (int code, int sizeflag)
20726 +{
20727 +  const char *s;
20728 +  int add = 0;
20729 +  USED_REX (REX_EXTZ);
20730 +  if (rex & REX_EXTZ)
20731 +    add = 8;
20732 +
20733 +  switch (code)
20734 +    {
20735 +    case indir_dx_reg:
20736 +      if (intel_syntax)
20737 +       s = "[dx]";
20738 +      else
20739 +       s = "(%dx)";
20740 +      break;
20741 +    case ax_reg: case cx_reg: case dx_reg: case bx_reg:
20742 +    case sp_reg: case bp_reg: case si_reg: case di_reg:
20743 +      s = names16[code - ax_reg + add];
20744 +      break;
20745 +    case es_reg: case ss_reg: case cs_reg:
20746 +    case ds_reg: case fs_reg: case gs_reg:
20747 +      s = names_seg[code - es_reg + add];
20748 +      break;
20749 +    case al_reg: case ah_reg: case cl_reg: case ch_reg:
20750 +    case dl_reg: case dh_reg: case bl_reg: case bh_reg:
20751 +      USED_REX (0);
20752 +      if (rex)
20753 +       s = names8rex[code - al_reg + add];
20754 +      else
20755 +       s = names8[code - al_reg];
20756 +      break;
20757 +    case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
20758 +    case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
20759 +      if (mode_64bit)
20760 +       {
20761 +         s = names64[code - rAX_reg + add];
20762 +         break;
20763 +       }
20764 +      code += eAX_reg - rAX_reg;
20765 +      /* Fall through. */
20766 +    case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
20767 +    case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
20768 +      USED_REX (REX_MODE64);
20769 +      if (rex & REX_MODE64)
20770 +       s = names64[code - eAX_reg + add];
20771 +      else if (sizeflag & DFLAG)
20772 +       s = names32[code - eAX_reg + add];
20773 +      else
20774 +       s = names16[code - eAX_reg + add];
20775 +      used_prefixes |= (prefixes & PREFIX_DATA);
20776 +      break;
20777 +    default:
20778 +      s = INTERNAL_DISASSEMBLER_ERROR;
20779 +      break;
20780 +    }
20781 +  oappend (s);
20782 +}
20783 +
20784 +static void
20785 +OP_IMREG (int code, int sizeflag)
20786 +{
20787 +  const char *s;
20788 +
20789 +  switch (code)
20790 +    {
20791 +    case indir_dx_reg:
20792 +      if (intel_syntax)
20793 +       s = "[dx]";
20794 +      else
20795 +       s = "(%dx)";
20796 +      break;
20797 +    case ax_reg: case cx_reg: case dx_reg: case bx_reg:
20798 +    case sp_reg: case bp_reg: case si_reg: case di_reg:
20799 +      s = names16[code - ax_reg];
20800 +      break;
20801 +    case es_reg: case ss_reg: case cs_reg:
20802 +    case ds_reg: case fs_reg: case gs_reg:
20803 +      s = names_seg[code - es_reg];
20804 +      break;
20805 +    case al_reg: case ah_reg: case cl_reg: case ch_reg:
20806 +    case dl_reg: case dh_reg: case bl_reg: case bh_reg:
20807 +      USED_REX (0);
20808 +      if (rex)
20809 +       s = names8rex[code - al_reg];
20810 +      else
20811 +       s = names8[code - al_reg];
20812 +      break;
20813 +    case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
20814 +    case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
20815 +      USED_REX (REX_MODE64);
20816 +      if (rex & REX_MODE64)
20817 +       s = names64[code - eAX_reg];
20818 +      else if (sizeflag & DFLAG)
20819 +       s = names32[code - eAX_reg];
20820 +      else
20821 +       s = names16[code - eAX_reg];
20822 +      used_prefixes |= (prefixes & PREFIX_DATA);
20823 +      break;
20824 +    default:
20825 +      s = INTERNAL_DISASSEMBLER_ERROR;
20826 +      break;
20827 +    }
20828 +  oappend (s);
20829 +}
20830 +
20831 +static void
20832 +OP_I (int bytemode, int sizeflag)
20833 +{
20834 +  bfd_signed_vma op;
20835 +  bfd_signed_vma mask = -1;
20836 +
20837 +  switch (bytemode)
20838 +    {
20839 +    case b_mode:
20840 +      FETCH_DATA (the_info, codep + 1);
20841 +      op = *codep++;
20842 +      mask = 0xff;
20843 +      break;
20844 +    case q_mode:
20845 +      if (mode_64bit)
20846 +       {
20847 +         op = get32s ();
20848 +         break;
20849 +       }
20850 +      /* Fall through. */
20851 +    case v_mode:
20852 +      USED_REX (REX_MODE64);
20853 +      if (rex & REX_MODE64)
20854 +       op = get32s ();
20855 +      else if (sizeflag & DFLAG)
20856 +       {
20857 +         op = get32 ();
20858 +         mask = 0xffffffff;
20859 +       }
20860 +      else
20861 +       {
20862 +         op = get16 ();
20863 +         mask = 0xfffff;
20864 +       }
20865 +      used_prefixes |= (prefixes & PREFIX_DATA);
20866 +      break;
20867 +    case w_mode:
20868 +      mask = 0xfffff;
20869 +      op = get16 ();
20870 +      break;
20871 +    case const_1_mode:
20872 +      if (intel_syntax)
20873 +       oappend ("1");
20874 +      return;
20875 +    default:
20876 +      oappend (INTERNAL_DISASSEMBLER_ERROR);
20877 +      return;
20878 +    }
20879 +
20880 +  op &= mask;
20881 +  scratchbuf[0] = '$';
20882 +  print_operand_value (scratchbuf + 1, 1, op);
20883 +  oappend (scratchbuf + intel_syntax);
20884 +  scratchbuf[0] = '\0';
20885 +}
20886 +
20887 +static void
20888 +OP_I64 (int bytemode, int sizeflag)
20889 +{
20890 +  bfd_signed_vma op;
20891 +  bfd_signed_vma mask = -1;
20892 +
20893 +  if (!mode_64bit)
20894 +    {
20895 +      OP_I (bytemode, sizeflag);
20896 +      return;
20897 +    }
20898 +
20899 +  switch (bytemode)
20900 +    {
20901 +    case b_mode:
20902 +      FETCH_DATA (the_info, codep + 1);
20903 +      op = *codep++;
20904 +      mask = 0xff;
20905 +      break;
20906 +    case v_mode:
20907 +      USED_REX (REX_MODE64);
20908 +      if (rex & REX_MODE64)
20909 +       op = get64 ();
20910 +      else if (sizeflag & DFLAG)
20911 +       {
20912 +         op = get32 ();
20913 +         mask = 0xffffffff;
20914 +       }
20915 +      else
20916 +       {
20917 +         op = get16 ();
20918 +         mask = 0xfffff;
20919 +       }
20920 +      used_prefixes |= (prefixes & PREFIX_DATA);
20921 +      break;
20922 +    case w_mode:
20923 +      mask = 0xfffff;
20924 +      op = get16 ();
20925 +      break;
20926 +    default:
20927 +      oappend (INTERNAL_DISASSEMBLER_ERROR);
20928 +      return;
20929 +    }
20930 +
20931 +  op &= mask;
20932 +  scratchbuf[0] = '$';
20933 +  print_operand_value (scratchbuf + 1, 1, op);
20934 +  oappend (scratchbuf + intel_syntax);
20935 +  scratchbuf[0] = '\0';
20936 +}
20937 +
20938 +static void
20939 +OP_sI (int bytemode, int sizeflag)
20940 +{
20941 +  bfd_signed_vma op;
20942 +  bfd_signed_vma mask = -1;
20943 +
20944 +  switch (bytemode)
20945 +    {
20946 +    case b_mode:
20947 +      FETCH_DATA (the_info, codep + 1);
20948 +      op = *codep++;
20949 +      if ((op & 0x80) != 0)
20950 +       op -= 0x100;
20951 +      mask = 0xffffffff;
20952 +      break;
20953 +    case v_mode:
20954 +      USED_REX (REX_MODE64);
20955 +      if (rex & REX_MODE64)
20956 +       op = get32s ();
20957 +      else if (sizeflag & DFLAG)
20958 +       {
20959 +         op = get32s ();
20960 +         mask = 0xffffffff;
20961 +       }
20962 +      else
20963 +       {
20964 +         mask = 0xffffffff;
20965 +         op = get16 ();
20966 +         if ((op & 0x8000) != 0)
20967 +           op -= 0x10000;
20968 +       }
20969 +      used_prefixes |= (prefixes & PREFIX_DATA);
20970 +      break;
20971 +    case w_mode:
20972 +      op = get16 ();
20973 +      mask = 0xffffffff;
20974 +      if ((op & 0x8000) != 0)
20975 +       op -= 0x10000;
20976 +      break;
20977 +    default:
20978 +      oappend (INTERNAL_DISASSEMBLER_ERROR);
20979 +      return;
20980 +    }
20981 +
20982 +  scratchbuf[0] = '$';
20983 +  print_operand_value (scratchbuf + 1, 1, op);
20984 +  oappend (scratchbuf + intel_syntax);
20985 +}
20986 +
20987 +static void
20988 +OP_J (int bytemode, int sizeflag)
20989 +{
20990 +  bfd_vma disp;
20991 +  bfd_vma mask = -1;
20992 +
20993 +  switch (bytemode)
20994 +    {
20995 +    case b_mode:
20996 +      FETCH_DATA (the_info, codep + 1);
20997 +      disp = *codep++;
20998 +      if ((disp & 0x80) != 0)
20999 +       disp -= 0x100;
21000 +      break;
21001 +    case v_mode:
21002 +      if (sizeflag & DFLAG)
21003 +       disp = get32s ();
21004 +      else
21005 +       {
21006 +         disp = get16 ();
21007 +         /* For some reason, a data16 prefix on a jump instruction
21008 +            means that the pc is masked to 16 bits after the
21009 +            displacement is added!  */
21010 +         mask = 0xffff;
21011 +       }
21012 +      break;
21013 +    default:
21014 +      oappend (INTERNAL_DISASSEMBLER_ERROR);
21015 +      return;
21016 +    }
21017 +  disp = (start_pc + codep - start_codep + disp) & mask;
21018 +  set_op (disp, 0);
21019 +  print_operand_value (scratchbuf, 1, disp);
21020 +  oappend (scratchbuf);
21021 +}
21022 +
21023 +static void
21024 +OP_SEG (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
21025 +{
21026 +  oappend (names_seg[reg]);
21027 +}
21028 +
21029 +static void
21030 +OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
21031 +{
21032 +  int seg, offset;
21033 +
21034 +  if (sizeflag & DFLAG)
21035 +    {
21036 +      offset = get32 ();
21037 +      seg = get16 ();
21038 +    }
21039 +  else
21040 +    {
21041 +      offset = get16 ();
21042 +      seg = get16 ();
21043 +    }
21044 +  used_prefixes |= (prefixes & PREFIX_DATA);
21045 +  if (intel_syntax)
21046 +    sprintf (scratchbuf, "0x%x,0x%x", seg, offset);
21047 +  else
21048 +    sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
21049 +  oappend (scratchbuf);
21050 +}
21051 +
21052 +static void
21053 +OP_OFF (int bytemode ATTRIBUTE_UNUSED, int sizeflag)
21054 +{
21055 +  bfd_vma off;
21056 +
21057 +  append_seg ();
21058 +
21059 +  if ((sizeflag & AFLAG) || mode_64bit)
21060 +    off = get32 ();
21061 +  else
21062 +    off = get16 ();
21063 +
21064 +  if (intel_syntax)
21065 +    {
21066 +      if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
21067 +                       | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
21068 +       {
21069 +         oappend (names_seg[ds_reg - es_reg]);
21070 +         oappend (":");
21071 +       }
21072 +    }
21073 +  print_operand_value (scratchbuf, 1, off);
21074 +  oappend (scratchbuf);
21075 +}
21076 +
21077 +static void
21078 +OP_OFF64 (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
21079 +{
21080 +  bfd_vma off;
21081 +
21082 +  if (!mode_64bit)
21083 +    {
21084 +      OP_OFF (bytemode, sizeflag);
21085 +      return;
21086 +    }
21087 +
21088 +  append_seg ();
21089 +
21090 +  off = get64 ();
21091 +
21092 +  if (intel_syntax)
21093 +    {
21094 +      if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
21095 +                       | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
21096 +       {
21097 +         oappend (names_seg[ds_reg - es_reg]);
21098 +         oappend (":");
21099 +       }
21100 +    }
21101 +  print_operand_value (scratchbuf, 1, off);
21102 +  oappend (scratchbuf);
21103 +}
21104 +
21105 +static void
21106 +ptr_reg (int code, int sizeflag)
21107 +{
21108 +  const char *s;
21109 +
21110 +  *obufp++ = open_char;
21111 +  used_prefixes |= (prefixes & PREFIX_ADDR);
21112 +  if (mode_64bit)
21113 +    {
21114 +      if (!(sizeflag & AFLAG))
21115 +       s = names32[code - eAX_reg];
21116 +      else
21117 +       s = names64[code - eAX_reg];
21118 +    }
21119 +  else if (sizeflag & AFLAG)
21120 +    s = names32[code - eAX_reg];
21121 +  else
21122 +    s = names16[code - eAX_reg];
21123 +  oappend (s);
21124 +  *obufp++ = close_char;
21125 +  *obufp = 0;
21126 +}
21127 +
21128 +static void
21129 +OP_ESreg (int code, int sizeflag)
21130 +{
21131 +  if (intel_syntax)
21132 +    {
21133 +      if (codep[-1] & 1)
21134 +       {
21135 +         USED_REX (REX_MODE64);
21136 +         used_prefixes |= (prefixes & PREFIX_DATA);
21137 +         if (rex & REX_MODE64)
21138 +           oappend ("QWORD PTR ");
21139 +         else if ((sizeflag & DFLAG))
21140 +           oappend ("DWORD PTR ");
21141 +         else
21142 +           oappend ("WORD PTR ");
21143 +       }
21144 +      else
21145 +       oappend ("BYTE PTR ");
21146 +    }
21147 +
21148 +  oappend ("%es:" + intel_syntax);
21149 +  ptr_reg (code, sizeflag);
21150 +}
21151 +
21152 +static void
21153 +OP_DSreg (int code, int sizeflag)
21154 +{
21155 +  if (intel_syntax)
21156 +    {
21157 +      if (codep[-1] != 0xd7 && (codep[-1] & 1))
21158 +       {
21159 +         USED_REX (REX_MODE64);
21160 +         used_prefixes |= (prefixes & PREFIX_DATA);
21161 +         if (rex & REX_MODE64)
21162 +           oappend ("QWORD PTR ");
21163 +         else if ((sizeflag & DFLAG))
21164 +           oappend ("DWORD PTR ");
21165 +         else
21166 +           oappend ("WORD PTR ");
21167 +       }
21168 +      else
21169 +       oappend ("BYTE PTR ");
21170 +    }
21171 +
21172 +  if ((prefixes
21173 +       & (PREFIX_CS
21174 +         | PREFIX_DS
21175 +         | PREFIX_SS
21176 +         | PREFIX_ES
21177 +         | PREFIX_FS
21178 +         | PREFIX_GS)) == 0)
21179 +    prefixes |= PREFIX_DS;
21180 +  append_seg ();
21181 +  ptr_reg (code, sizeflag);
21182 +}
21183 +
21184 +static void
21185 +OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
21186 +{
21187 +  int add = 0;
21188 +  if (rex & REX_EXTX)
21189 +    {
21190 +      USED_REX (REX_EXTX);
21191 +      add = 8;
21192 +    }
21193 +  else if (!mode_64bit && (prefixes & PREFIX_LOCK))
21194 +    {
21195 +      used_prefixes |= PREFIX_LOCK;
21196 +      add = 8;
21197 +    }
21198 +  sprintf (scratchbuf, "%%cr%d", reg + add);
21199 +  oappend (scratchbuf + intel_syntax);
21200 +}
21201 +
21202 +static void
21203 +OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
21204 +{
21205 +  int add = 0;
21206 +  USED_REX (REX_EXTX);
21207 +  if (rex & REX_EXTX)
21208 +    add = 8;
21209 +  if (intel_syntax)
21210 +    sprintf (scratchbuf, "db%d", reg + add);
21211 +  else
21212 +    sprintf (scratchbuf, "%%db%d", reg + add);
21213 +  oappend (scratchbuf);
21214 +}
21215 +
21216 +static void
21217 +OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
21218 +{
21219 +  sprintf (scratchbuf, "%%tr%d", reg);
21220 +  oappend (scratchbuf + intel_syntax);
21221 +}
21222 +
21223 +static void
21224 +OP_Rd (int bytemode, int sizeflag)
21225 +{
21226 +  if (mod == 3)
21227 +    OP_E (bytemode, sizeflag);
21228 +  else
21229 +    BadOp ();
21230 +}
21231 +
21232 +static void
21233 +OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
21234 +{
21235 +  used_prefixes |= (prefixes & PREFIX_DATA);
21236 +  if (prefixes & PREFIX_DATA)
21237 +    {
21238 +      int add = 0;
21239 +      USED_REX (REX_EXTX);
21240 +      if (rex & REX_EXTX)
21241 +       add = 8;
21242 +      sprintf (scratchbuf, "%%xmm%d", reg + add);
21243 +    }
21244 +  else
21245 +    sprintf (scratchbuf, "%%mm%d", reg);
21246 +  oappend (scratchbuf + intel_syntax);
21247 +}
21248 +
21249 +static void
21250 +OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
21251 +{
21252 +  int add = 0;
21253 +  USED_REX (REX_EXTX);
21254 +  if (rex & REX_EXTX)
21255 +    add = 8;
21256 +  sprintf (scratchbuf, "%%xmm%d", reg + add);
21257 +  oappend (scratchbuf + intel_syntax);
21258 +}
21259 +
21260 +static void
21261 +OP_EM (int bytemode, int sizeflag)
21262 +{
21263 +  if (mod != 3)
21264 +    {
21265 +      if (intel_syntax && bytemode == v_mode)
21266 +       {
21267 +         bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
21268 +         used_prefixes |= (prefixes & PREFIX_DATA);
21269 +       }
21270 +      OP_E (bytemode, sizeflag);
21271 +      return;
21272 +    }
21273 +
21274 +  /* Skip mod/rm byte. */
21275 +  MODRM_CHECK;
21276 +  codep++;
21277 +  used_prefixes |= (prefixes & PREFIX_DATA);
21278 +  if (prefixes & PREFIX_DATA)
21279 +    {
21280 +      int add = 0;
21281 +
21282 +      USED_REX (REX_EXTZ);
21283 +      if (rex & REX_EXTZ)
21284 +       add = 8;
21285 +      sprintf (scratchbuf, "%%xmm%d", rm + add);
21286 +    }
21287 +  else
21288 +    sprintf (scratchbuf, "%%mm%d", rm);
21289 +  oappend (scratchbuf + intel_syntax);
21290 +}
21291 +
21292 +static void
21293 +OP_EX (int bytemode, int sizeflag)
21294 +{
21295 +  int add = 0;
21296 +  if (mod != 3)
21297 +    {
21298 +      if (intel_syntax && bytemode == v_mode)
21299 +       {
21300 +         switch (prefixes & (PREFIX_DATA|PREFIX_REPZ|PREFIX_REPNZ))
21301 +           {
21302 +           case 0:            bytemode = x_mode; break;
21303 +           case PREFIX_REPZ:  bytemode = d_mode; used_prefixes |= PREFIX_REPZ;  break;
21304 +           case PREFIX_DATA:  bytemode = x_mode; used_prefixes |= PREFIX_DATA;  break;
21305 +           case PREFIX_REPNZ: bytemode = q_mode; used_prefixes |= PREFIX_REPNZ; break;
21306 +           default:           bytemode = 0; break;
21307 +           }
21308 +       }
21309 +      OP_E (bytemode, sizeflag);
21310 +      return;
21311 +    }
21312 +  USED_REX (REX_EXTZ);
21313 +  if (rex & REX_EXTZ)
21314 +    add = 8;
21315 +
21316 +  /* Skip mod/rm byte. */
21317 +  MODRM_CHECK;
21318 +  codep++;
21319 +  sprintf (scratchbuf, "%%xmm%d", rm + add);
21320 +  oappend (scratchbuf + intel_syntax);
21321 +}
21322 +
21323 +static void
21324 +OP_MS (int bytemode, int sizeflag)
21325 +{
21326 +  if (mod == 3)
21327 +    OP_EM (bytemode, sizeflag);
21328 +  else
21329 +    BadOp ();
21330 +}
21331 +
21332 +static void
21333 +OP_XS (int bytemode, int sizeflag)
21334 +{
21335 +  if (mod == 3)
21336 +    OP_EX (bytemode, sizeflag);
21337 +  else
21338 +    BadOp ();
21339 +}
21340 +
21341 +static void
21342 +OP_M (int bytemode, int sizeflag)
21343 +{
21344 +  if (mod == 3)
21345 +    BadOp ();  /* bad lea,lds,les,lfs,lgs,lss modrm */
21346 +  else
21347 +    OP_E (bytemode, sizeflag);
21348 +}
21349 +
21350 +static void
21351 +OP_0f07 (int bytemode, int sizeflag)
21352 +{
21353 +  if (mod != 3 || rm != 0)
21354 +    BadOp ();
21355 +  else
21356 +    OP_E (bytemode, sizeflag);
21357 +}
21358 +
21359 +static void
21360 +OP_0fae (int bytemode, int sizeflag)
21361 +{
21362 +  if (mod == 3)
21363 +    {
21364 +      if (reg == 7)
21365 +       strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence");
21366 +
21367 +      if (reg < 5 || rm != 0)
21368 +       {
21369 +         BadOp ();     /* bad sfence, mfence, or lfence */
21370 +         return;
21371 +       }
21372 +    }
21373 +  else if (reg != 7)
21374 +    {
21375 +      BadOp ();                /* bad clflush */
21376 +      return;
21377 +    }
21378 +
21379 +  OP_E (bytemode, sizeflag);
21380 +}
21381 +
21382 +static void
21383 +NOP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
21384 +{
21385 +  /* NOP with REPZ prefix is called PAUSE.  */
21386 +  if (prefixes == PREFIX_REPZ)
21387 +    strcpy (obuf, "pause");
21388 +}
21389 +
21390 +static const char *const Suffix3DNow[] = {
21391 +/* 00 */       NULL,           NULL,           NULL,           NULL,
21392 +/* 04 */       NULL,           NULL,           NULL,           NULL,
21393 +/* 08 */       NULL,           NULL,           NULL,           NULL,
21394 +/* 0C */       "pi2fw",        "pi2fd",        NULL,           NULL,
21395 +/* 10 */       NULL,           NULL,           NULL,           NULL,
21396 +/* 14 */       NULL,           NULL,           NULL,           NULL,
21397 +/* 18 */       NULL,           NULL,           NULL,           NULL,
21398 +/* 1C */       "pf2iw",        "pf2id",        NULL,           NULL,
21399 +/* 20 */       NULL,           NULL,           NULL,           NULL,
21400 +/* 24 */       NULL,           NULL,           NULL,           NULL,
21401 +/* 28 */       NULL,           NULL,           NULL,           NULL,
21402 +/* 2C */       NULL,           NULL,           NULL,           NULL,
21403 +/* 30 */       NULL,           NULL,           NULL,           NULL,
21404 +/* 34 */       NULL,           NULL,           NULL,           NULL,
21405 +/* 38 */       NULL,           NULL,           NULL,           NULL,
21406 +/* 3C */       NULL,           NULL,           NULL,           NULL,
21407 +/* 40 */       NULL,           NULL,           NULL,           NULL,
21408 +/* 44 */       NULL,           NULL,           NULL,           NULL,
21409 +/* 48 */       NULL,           NULL,           NULL,           NULL,
21410 +/* 4C */       NULL,           NULL,           NULL,           NULL,
21411 +/* 50 */       NULL,           NULL,           NULL,           NULL,
21412 +/* 54 */       NULL,           NULL,           NULL,           NULL,
21413 +/* 58 */       NULL,           NULL,           NULL,           NULL,
21414 +/* 5C */       NULL,           NULL,           NULL,           NULL,
21415 +/* 60 */       NULL,           NULL,           NULL,           NULL,
21416 +/* 64 */       NULL,           NULL,           NULL,           NULL,
21417 +/* 68 */       NULL,           NULL,           NULL,           NULL,
21418 +/* 6C */       NULL,           NULL,           NULL,           NULL,
21419 +/* 70 */       NULL,           NULL,           NULL,           NULL,
21420 +/* 74 */       NULL,           NULL,           NULL,           NULL,
21421 +/* 78 */       NULL,           NULL,           NULL,           NULL,
21422 +/* 7C */       NULL,           NULL,           NULL,           NULL,
21423 +/* 80 */       NULL,           NULL,           NULL,           NULL,
21424 +/* 84 */       NULL,           NULL,           NULL,           NULL,
21425 +/* 88 */       NULL,           NULL,           "pfnacc",       NULL,
21426 +/* 8C */       NULL,           NULL,           "pfpnacc",      NULL,
21427 +/* 90 */       "pfcmpge",      NULL,           NULL,           NULL,
21428 +/* 94 */       "pfmin",        NULL,           "pfrcp",        "pfrsqrt",
21429 +/* 98 */       NULL,           NULL,           "pfsub",        NULL,
21430 +/* 9C */       NULL,           NULL,           "pfadd",        NULL,
21431 +/* A0 */       "pfcmpgt",      NULL,           NULL,           NULL,
21432 +/* A4 */       "pfmax",        NULL,           "pfrcpit1",     "pfrsqit1",
21433 +/* A8 */       NULL,           NULL,           "pfsubr",       NULL,
21434 +/* AC */       NULL,           NULL,           "pfacc",        NULL,
21435 +/* B0 */       "pfcmpeq",      NULL,           NULL,           NULL,
21436 +/* B4 */       "pfmul",        NULL,           "pfrcpit2",     "pfmulhrw",
21437 +/* B8 */       NULL,           NULL,           NULL,           "pswapd",
21438 +/* BC */       NULL,           NULL,           NULL,           "pavgusb",
21439 +/* C0 */       NULL,           NULL,           NULL,           NULL,
21440 +/* C4 */       NULL,           NULL,           NULL,           NULL,
21441 +/* C8 */       NULL,           NULL,           NULL,           NULL,
21442 +/* CC */       NULL,           NULL,           NULL,           NULL,
21443 +/* D0 */       NULL,           NULL,           NULL,           NULL,
21444 +/* D4 */       NULL,           NULL,           NULL,           NULL,
21445 +/* D8 */       NULL,           NULL,           NULL,           NULL,
21446 +/* DC */       NULL,           NULL,           NULL,           NULL,
21447 +/* E0 */       NULL,           NULL,           NULL,           NULL,
21448 +/* E4 */       NULL,           NULL,           NULL,           NULL,
21449 +/* E8 */       NULL,           NULL,           NULL,           NULL,
21450 +/* EC */       NULL,           NULL,           NULL,           NULL,
21451 +/* F0 */       NULL,           NULL,           NULL,           NULL,
21452 +/* F4 */       NULL,           NULL,           NULL,           NULL,
21453 +/* F8 */       NULL,           NULL,           NULL,           NULL,
21454 +/* FC */       NULL,           NULL,           NULL,           NULL,
21455 +};
21456 +
21457 +static void
21458 +OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
21459 +{
21460 +  const char *mnemonic;
21461 +
21462 +  FETCH_DATA (the_info, codep + 1);
21463 +  /* AMD 3DNow! instructions are specified by an opcode suffix in the
21464 +     place where an 8-bit immediate would normally go. ie. the last
21465 +     byte of the instruction.  */
21466 +  obufp = obuf + strlen (obuf);
21467 +  mnemonic = Suffix3DNow[*codep++ & 0xff];
21468 +  if (mnemonic)
21469 +    oappend (mnemonic);
21470 +  else
21471 +    {
21472 +      /* Since a variable sized modrm/sib chunk is between the start
21473 +        of the opcode (0x0f0f) and the opcode suffix, we need to do
21474 +        all the modrm processing first, and don't know until now that
21475 +        we have a bad opcode.  This necessitates some cleaning up.  */
21476 +      op1out[0] = '\0';
21477 +      op2out[0] = '\0';
21478 +      BadOp ();
21479 +    }
21480 +}
21481 +
21482 +static const char *simd_cmp_op[] = {
21483 +  "eq",
21484 +  "lt",
21485 +  "le",
21486 +  "unord",
21487 +  "neq",
21488 +  "nlt",
21489 +  "nle",
21490 +  "ord"
21491 +};
21492 +
21493 +static void
21494 +OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
21495 +{
21496 +  unsigned int cmp_type;
21497 +
21498 +  FETCH_DATA (the_info, codep + 1);
21499 +  obufp = obuf + strlen (obuf);
21500 +  cmp_type = *codep++ & 0xff;
21501 +  if (cmp_type < 8)
21502 +    {
21503 +      char suffix1 = 'p', suffix2 = 's';
21504 +      used_prefixes |= (prefixes & PREFIX_REPZ);
21505 +      if (prefixes & PREFIX_REPZ)
21506 +       suffix1 = 's';
21507 +      else
21508 +       {
21509 +         used_prefixes |= (prefixes & PREFIX_DATA);
21510 +         if (prefixes & PREFIX_DATA)
21511 +           suffix2 = 'd';
21512 +         else
21513 +           {
21514 +             used_prefixes |= (prefixes & PREFIX_REPNZ);
21515 +             if (prefixes & PREFIX_REPNZ)
21516 +               suffix1 = 's', suffix2 = 'd';
21517 +           }
21518 +       }
21519 +      sprintf (scratchbuf, "cmp%s%c%c",
21520 +              simd_cmp_op[cmp_type], suffix1, suffix2);
21521 +      used_prefixes |= (prefixes & PREFIX_REPZ);
21522 +      oappend (scratchbuf);
21523 +    }
21524 +  else
21525 +    {
21526 +      /* We have a bad extension byte. Clean up.  */
21527 +      op1out[0] = '\0';
21528 +      op2out[0] = '\0';
21529 +      BadOp ();
21530 +    }
21531 +}
21532 +
21533 +static void
21534 +SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED)
21535 +{
21536 +  /* Change movlps/movhps to movhlps/movlhps for 2 register operand
21537 +     forms of these instructions.  */
21538 +  if (mod == 3)
21539 +    {
21540 +      char *p = obuf + strlen (obuf);
21541 +      *(p + 1) = '\0';
21542 +      *p       = *(p - 1);
21543 +      *(p - 1) = *(p - 2);
21544 +      *(p - 2) = *(p - 3);
21545 +      *(p - 3) = extrachar;
21546 +    }
21547 +}
21548 +
21549 +static void
21550 +PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
21551 +{
21552 +  if (mod == 3 && reg == 1 && rm <= 1)
21553 +    {
21554 +      /* Override "sidt".  */
21555 +      char *p = obuf + strlen (obuf) - 4;
21556 +
21557 +      /* We might have a suffix when disassembling with -Msuffix.  */
21558 +      if (*p == 'i')
21559 +       --p;
21560 +
21561 +      if (rm)
21562 +       {
21563 +         /* mwait %eax,%ecx  */
21564 +         strcpy (p, "mwait");
21565 +         if (!intel_syntax)
21566 +           strcpy (op1out, names32[0]);
21567 +       }
21568 +      else
21569 +       {
21570 +         /* monitor %eax,%ecx,%edx"  */
21571 +         strcpy (p, "monitor");
21572 +         if (!intel_syntax)
21573 +           {
21574 +             if (!mode_64bit)
21575 +               strcpy (op1out, names32[0]);
21576 +             else if (!(prefixes & PREFIX_ADDR))
21577 +               strcpy (op1out, names64[0]);
21578 +             else
21579 +               {
21580 +                 strcpy (op1out, names32[0]);
21581 +                 used_prefixes |= PREFIX_ADDR;
21582 +               }
21583 +             strcpy (op3out, names32[2]);
21584 +           }
21585 +       }
21586 +      if (!intel_syntax)
21587 +       {
21588 +         strcpy (op2out, names32[1]);
21589 +         two_source_ops = 1;
21590 +       }
21591 +
21592 +      codep++;
21593 +    }
21594 +  else
21595 +    OP_M (0, sizeflag);
21596 +}
21597 +
21598 +static void
21599 +SVME_Fixup (int bytemode, int sizeflag)
21600 +{
21601 +  const char *alt;
21602 +  char *p;
21603 +
21604 +  switch (*codep)
21605 +    {
21606 +    case 0xd8:
21607 +      alt = "vmrun";
21608 +      break;
21609 +    case 0xd9:
21610 +      alt = "vmmcall";
21611 +      break;
21612 +    case 0xda:
21613 +      alt = "vmload";
21614 +      break;
21615 +    case 0xdb:
21616 +      alt = "vmsave";
21617 +      break;
21618 +    case 0xdc:
21619 +      alt = "stgi";
21620 +      break;
21621 +    case 0xdd:
21622 +      alt = "clgi";
21623 +      break;
21624 +    case 0xde:
21625 +      alt = "skinit";
21626 +      break;
21627 +    case 0xdf:
21628 +      alt = "invlpga";
21629 +      break;
21630 +    default:
21631 +      OP_M (bytemode, sizeflag);
21632 +      return;
21633 +    }
21634 +  /* Override "lidt".  */
21635 +  p = obuf + strlen (obuf) - 4;
21636 +  /* We might have a suffix.  */
21637 +  if (*p == 'i')
21638 +    --p;
21639 +  strcpy (p, alt);
21640 +  if (!(prefixes & PREFIX_ADDR))
21641 +    {
21642 +      ++codep;
21643 +      return;
21644 +    }
21645 +  used_prefixes |= PREFIX_ADDR;
21646 +  switch (*codep++)
21647 +    {
21648 +    case 0xdf:
21649 +      strcpy (op2out, names32[1]);
21650 +      two_source_ops = 1;
21651 +         /* Fall through.  */
21652 +    case 0xd8:
21653 +    case 0xda:
21654 +    case 0xdb:
21655 +      *obufp++ = open_char;
21656 +      if (mode_64bit || (sizeflag & AFLAG))
21657 +       alt = names32[0];
21658 +      else
21659 +       alt = names16[0];
21660 +      strcpy (obufp, alt);
21661 +      obufp += strlen (alt);
21662 +      *obufp++ = close_char;
21663 +      *obufp = '\0';
21664 +      break;
21665 +    }
21666 +}
21667 +
21668 +static void
21669 +INVLPG_Fixup (int bytemode, int sizeflag)
21670 +{
21671 +  const char *alt;
21672 +
21673 +  switch (*codep)
21674 +    {
21675 +    case 0xf8:
21676 +      alt = "swapgs";
21677 +      break;
21678 +    case 0xf9:
21679 +      alt = "rdtscp";
21680 +      break;
21681 +    default:
21682 +      OP_M (bytemode, sizeflag);
21683 +      return;
21684 +    }
21685 +  /* Override "invlpg".         */
21686 +  strcpy (obuf + strlen (obuf) - 6, alt);
21687 +  codep++;
21688 +}
21689 +
21690 +static void
21691 +BadOp (void)
21692 +{
21693 +  /* Throw away prefixes and 1st. opcode byte. */
21694 +  codep = insn_codep + 1;
21695 +  oappend ("(bad)");
21696 +}
21697 +
21698 +static void
21699 +SEG_Fixup (int extrachar, int sizeflag)
21700 +{
21701 +  if (mod == 3)
21702 +    {
21703 +      /* We need to add a proper suffix with
21704 +
21705 +               movw %ds,%ax
21706 +               movl %ds,%eax
21707 +               movq %ds,%rax
21708 +               movw %ax,%ds
21709 +               movl %eax,%ds
21710 +               movq %rax,%ds
21711 +       */
21712 +      const char *suffix;
21713 +
21714 +      if (prefixes & PREFIX_DATA)
21715 +       suffix = "w";
21716 +      else
21717 +       {
21718 +         USED_REX (REX_MODE64);
21719 +         if (rex & REX_MODE64)
21720 +           suffix = "q";
21721 +         else
21722 +           suffix = "l";
21723 +       }
21724 +      strcat (obuf, suffix);
21725 +    }
21726 +  else
21727 +    {
21728 +      /* We need to fix the suffix for
21729 +
21730 +               movw %ds,(%eax)
21731 +               movw %ds,(%rax)
21732 +               movw (%eax),%ds
21733 +               movw (%rax),%ds
21734 +
21735 +        Override "mov[l|q]".  */
21736 +      char *p = obuf + strlen (obuf) - 1;
21737 +
21738 +      /* We might not have a suffix.  */
21739 +      if (*p == 'v')
21740 +       ++p;
21741 +      *p = 'w';
21742 +    }
21743 +
21744 +  OP_E (extrachar, sizeflag);
21745 +}
21746 +
21747 +static void
21748 +VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
21749 +{
21750 +  if (mod == 3 && reg == 0 && rm >=1 && rm <= 4)
21751 +    {
21752 +      /* Override "sgdt".  */
21753 +      char *p = obuf + strlen (obuf) - 4;
21754 +
21755 +      /* We might have a suffix when disassembling with -Msuffix.  */
21756 +      if (*p == 'g')
21757 +       --p;
21758 +
21759 +      switch (rm)
21760 +       {
21761 +       case 1:
21762 +         strcpy (p, "vmcall");
21763 +         break;
21764 +       case 2:
21765 +         strcpy (p, "vmlaunch");
21766 +         break;
21767 +       case 3:
21768 +         strcpy (p, "vmresume");
21769 +         break;
21770 +       case 4:
21771 +         strcpy (p, "vmxoff");
21772 +         break;
21773 +       }
21774 +
21775 +      codep++;
21776 +    }
21777 +  else
21778 +    OP_E (0, sizeflag);
21779 +}
21780 +
21781 +static void
21782 +OP_VMX (int bytemode, int sizeflag)
21783 +{
21784 +  used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ));
21785 +  if (prefixes & PREFIX_DATA)
21786 +    strcpy (obuf, "vmclear");
21787 +  else if (prefixes & PREFIX_REPZ)
21788 +    strcpy (obuf, "vmxon");
21789 +  else
21790 +    strcpy (obuf, "vmptrld");
21791 +  OP_E (bytemode, sizeflag);
21792 +}
21793 --- a/arch/x86/kernel/crash.c
21794 +++ b/arch/x86/kernel/crash.c
21795 @@ -35,13 +35,38 @@ static int crashing_cpu;
21796  #if defined(CONFIG_SMP) && defined(CONFIG_X86_LOCAL_APIC)
21797  static atomic_t waiting_for_crash_ipi;
21798
21799 +#ifdef CONFIG_KDB_KDUMP
21800 +void halt_current_cpu(struct pt_regs *regs)
21801 +{
21802 +#ifdef CONFIG_X86_32
21803 +       struct pt_regs fixed_regs;
21804 +#endif
21805 +       local_irq_disable();
21806 +#ifdef CONFIG_X86_32
21807 +       if (!user_mode_vm(regs)) {
21808 +               crash_fixup_ss_esp(&fixed_regs, regs);
21809 +               regs = &fixed_regs;
21810 +       }
21811 +#endif
21812 +       crash_save_cpu(regs, raw_smp_processor_id());
21813 +       disable_local_APIC();
21814 +       atomic_dec(&waiting_for_crash_ipi);
21815 +       /* Assume hlt works */
21816 +       halt();
21817 +       for(;;)
21818 +               cpu_relax();
21819 +}
21820 +#endif /* CONFIG_KDB_KDUMP */
21821 +
21822  static int crash_nmi_callback(struct notifier_block *self,
21823                         unsigned long val, void *data)
21824  {
21825         struct pt_regs *regs;
21826 +#ifndef CONFIG_KDB_KDUMP
21827  #ifdef CONFIG_X86_32
21828         struct pt_regs fixed_regs;
21829  #endif
21830 +#endif /* !CONFIG_KDB_KDUMP */
21831         int cpu;
21832
21833         if (val != DIE_NMI_IPI)
21834 @@ -56,6 +81,9 @@ static int crash_nmi_callback(struct not
21835          */
21836         if (cpu == crashing_cpu)
21837                 return NOTIFY_STOP;
21838 +#ifdef CONFIG_KDB_KDUMP
21839 +       halt_current_cpu(regs);
21840 +#else
21841         local_irq_disable();
21842
21843  #ifdef CONFIG_X86_32
21844 @@ -71,6 +99,7 @@ static int crash_nmi_callback(struct not
21845         halt();
21846         for (;;)
21847                 cpu_relax();
21848 +#endif /* !CONFIG_KDB_KDUMP */
21849
21850         return 1;
21851  }
21852 @@ -84,6 +113,43 @@ static struct notifier_block crash_nmi_n
21853         .notifier_call = crash_nmi_callback,
21854  };
21855
21856 +#ifdef CONFIG_KDB_KDUMP
21857 +static void wait_other_cpus(void)
21858 +{
21859 +       unsigned long msecs;
21860 +
21861 +       msecs = 1000; /* Wait at most a second for the other cpus to stop */
21862 +       while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) {
21863 +               udelay(1000);
21864 +       msecs--;
21865 +       }
21866 +}
21867 +
21868 +static void nmi_shootdown_cpus_init(void)
21869 +{
21870 +       atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
21871 +}
21872 +
21873 +static void nmi_shootdown_cpus(void)
21874 +{
21875 +       nmi_shootdown_cpus_init();
21876 +
21877 +       /* Would it be better to replace the trap vector here? */
21878 +       if (register_die_notifier(&crash_nmi_nb))
21879 +               return;         /* return what? */
21880 +       /* Ensure the new callback function is set before sending
21881 +        * out the NMI
21882 +        */
21883 +       wmb();
21884 +
21885 +       smp_send_nmi_allbutself();
21886 +
21887 +       wait_other_cpus();
21888 +       /* Leave the nmi callback set */
21889 +
21890 +       disable_local_APIC();
21891 +}
21892 +#else
21893  static void nmi_shootdown_cpus(void)
21894  {
21895         unsigned long msecs;
21896 @@ -108,12 +174,22 @@ static void nmi_shootdown_cpus(void)
21897         /* Leave the nmi callback set */
21898         disable_local_APIC();
21899  }
21900 -#else
21901 +#endif /* !CONFIG_KDB_KDUMP */
21902 +
21903 +#else /* defined(CONFIG_SMP) && defined(CONFIG_X86_LOCAL_APIC) */
21904 +
21905  static void nmi_shootdown_cpus(void)
21906  {
21907         /* There are no cpus to shootdown */
21908  }
21909 -#endif
21910 +
21911 +#ifdef CONFIG_KDB_KDUMP
21912 +static void nmi_shootdown_cpus_init(void) {};
21913 +static void wait_other_cpus() {}
21914 +static void halt_current_cpu(struct pt_regs *regs) {};
21915 +#endif /* CONFIG_KDB_KDUMP */
21916 +
21917 +#endif /* defined(CONFIG_SMP) && defined(CONFIG_X86_LOCAL_APIC) */
21918
21919  void native_machine_crash_shutdown(struct pt_regs *regs)
21920  {
21921 @@ -140,3 +216,33 @@ void native_machine_crash_shutdown(struc
21922  #endif
21923         crash_save_cpu(regs, safe_smp_processor_id());
21924  }
21925 +
21926 +#ifdef CONFIG_KDB_KDUMP
21927 +void machine_crash_shutdown_begin(void)
21928 +{
21929 +       local_irq_disable();
21930 +
21931 +       /* Make a note of crashing cpu. Will be used in NMI callback.*/
21932 +       crashing_cpu = safe_smp_processor_id();
21933 +#ifndef CONFIG_XEN
21934 +       nmi_shootdown_cpus_init();
21935 +#endif /* CONFIG_XEN */
21936 +}
21937 +
21938 +void machine_crash_shutdown_end(struct pt_regs *regs)
21939 +{
21940 +#ifndef CONFIG_XEN
21941 +       wait_other_cpus();
21942 +
21943 +       local_irq_disable();
21944 +       lapic_shutdown();
21945 +#if defined(CONFIG_X86_IO_APIC)
21946 +       disable_IO_APIC();
21947 +#endif
21948 +#ifdef CONFIG_HPET_TIMER
21949 +       hpet_disable();
21950 +#endif
21951 +#endif /* CONFIG_XEN */
21952 +       crash_save_cpu(regs,safe_smp_processor_id());
21953 +}
21954 +#endif /* CONFIG_KDB_KDUMP */
21955 --- a/arch/x86/kernel/entry_32.S
21956 +++ b/arch/x86/kernel/entry_32.S
21957 @@ -1015,6 +1015,26 @@ ENTRY(alignment_check)
21958         CFI_ENDPROC
21959  END(alignment_check)
21960
21961 +#ifdef CONFIG_KDB
21962 +
21963 +ENTRY(kdb_call)
21964 +       RING0_INT_FRAME
21965 +       pushl %eax              # save orig EAX
21966 +       CFI_ADJUST_CFA_OFFSET 4
21967 +       SAVE_ALL
21968 +       movl %esp,%ecx          # struct pt_regs
21969 +       movl $0,%edx            # error_code
21970 +       movl $1,%eax            # KDB_REASON_ENTER
21971 +       call  kdb
21972 +       jmp restore_all
21973 +       CFI_ENDPROC
21974 +
21975 +#ifdef CONFIG_SMP
21976 +BUILD_INTERRUPT(kdb_interrupt,KDB_VECTOR)
21977 +#endif /* CONFIG_SMP */
21978 +
21979 +#endif /* CONFIG_KDB */
21980 +
21981  ENTRY(divide_error)
21982         RING0_INT_FRAME
21983         pushl $0                        # no error code
21984 --- a/arch/x86/kernel/entry_64.S
21985 +++ b/arch/x86/kernel/entry_64.S
21986 @@ -1467,3 +1467,30 @@ ENTRY(xen_failsafe_callback)
21987  END(xen_failsafe_callback)
21988
21989  #endif /* CONFIG_XEN */
21990 +
21991 +#ifdef CONFIG_KDB
21992 +
21993 +#ifdef CONFIG_SMP
21994 +ENTRY(kdb_interrupt)
21995 +       apicinterrupt KDB_VECTOR,smp_kdb_interrupt
21996 +END(kdb_interrupt)
21997 +#endif /* CONFIG_SMP */
21998 +
21999 +ENTRY(kdb_call)
22000 +       INTR_FRAME
22001 +       cld
22002 +       pushq $-1                       # orig_eax
22003 +       CFI_ADJUST_CFA_OFFSET 8
22004 +       SAVE_ALL
22005 +       movq $1,%rdi                    # KDB_REASON_ENTER
22006 +       movq $0,%rsi                    # error_code
22007 +       movq %rsp,%rdx                  # struct pt_regs
22008 +       call kdb
22009 +       RESTORE_ALL
22010 +       addq $8,%rsp                    # forget orig_eax
22011 +       CFI_ADJUST_CFA_OFFSET -8
22012 +       iretq
22013 +       CFI_ENDPROC
22014 +END(kdb_call)
22015 +
22016 +#endif /* CONFIG_KDB */
22017 --- a/arch/x86/kernel/io_apic_32.c
22018 +++ b/arch/x86/kernel/io_apic_32.c
22019 @@ -33,6 +33,10 @@
22020  #include <linux/sysdev.h>
22021  #include <linux/pci.h>
22022  #include <linux/msi.h>
22023 +
22024 +#ifdef CONFIG_KDB
22025 +#include <linux/kdb.h>
22026 +#endif /* CONFIG_KDB */
22027  #include <linux/htirq.h>
22028  #include <linux/freezer.h>
22029  #include <linux/kthread.h>
22030 @@ -1189,6 +1193,10 @@ next:
22031                 return -ENOSPC;
22032         if (test_and_set_bit(vector, used_vectors))
22033                 goto next;
22034 +#ifdef CONFIG_KDB
22035 +       if (vector == KDBENTER_VECTOR)
22036 +               goto next;
22037 +#endif
22038
22039         current_vector = vector;
22040         current_offset = offset;
22041 --- a/arch/x86/kernel/io_apic_64.c
22042 +++ b/arch/x86/kernel/io_apic_64.c
22043 @@ -39,6 +39,10 @@
22044  #include <linux/bootmem.h>
22045  #include <linux/dmar.h>
22046
22047 +#ifdef CONFIG_KDB
22048 +#include <linux/kdb.h>
22049 +#endif /* CONFIG_KDB */
22050 +
22051  #include <asm/idle.h>
22052  #include <asm/io.h>
22053  #include <asm/smp.h>
22054 @@ -853,6 +857,10 @@ next:
22055                         continue;
22056                 if (vector == IA32_SYSCALL_VECTOR)
22057                         goto next;
22058 +#ifdef CONFIG_KDB
22059 +               if (vector == KDBENTER_VECTOR)
22060 +                       goto next;
22061 +#endif /* CONFIG_KDB */
22062                 for_each_cpu_mask_and(new_cpu, tmp_mask, cpu_online_map)
22063                         if (per_cpu(vector_irq, new_cpu)[vector] != -1)
22064                                 goto next;
22065 --- a/arch/x86/kernel/reboot.c
22066 +++ b/arch/x86/kernel/reboot.c
22067 @@ -3,6 +3,9 @@
22068  #include <linux/init.h>
22069  #include <linux/pm.h>
22070  #include <linux/efi.h>
22071 +#ifdef CONFIG_KDB
22072 +#include <linux/kdb.h>
22073 +#endif /* CONFIG_KDB */
22074  #include <acpi/reboot.h>
22075  #include <asm/io.h>
22076  #include <asm/apic.h>
22077 @@ -455,6 +458,14 @@ void native_machine_shutdown(void)
22078         /* Make certain I only run on the appropriate processor */
22079         set_cpus_allowed_ptr(current, &cpumask_of_cpu(reboot_cpu_id));
22080
22081 +#if defined(CONFIG_X86_32) && defined(CONFIG_KDB)
22082 +       /*
22083 +        * If this restart is occuring while kdb is running (e.g. reboot
22084 +        * command), the other CPU's are already stopped.  Don't try to
22085 +        * stop them yet again.
22086 +        */
22087 +       if (!KDB_IS_RUNNING())
22088 +#endif /* defined(CONFIG_X86_32) && defined(CONFIG_KDB) */
22089         /* O.K Now that I'm on the appropriate processor,
22090          * stop all of the others.
22091          */
22092 --- a/arch/x86/kernel/traps_32.c
22093 +++ b/arch/x86/kernel/traps_32.c
22094 @@ -46,6 +46,10 @@
22095  #include <linux/edac.h>
22096  #endif
22097
22098 +#ifdef CONFIG_KDB
22099 +#include <linux/kdb.h>
22100 +#endif /* CONFIG_KDB */
22101 +
22102  #include <asm/arch_hooks.h>
22103  #include <asm/stacktrace.h>
22104  #include <asm/processor.h>
22105 @@ -395,6 +399,9 @@ void __kprobes oops_end(unsigned long fl
22106         add_taint(TAINT_DIE);
22107         __raw_spin_unlock(&die_lock);
22108         raw_local_irq_restore(flags);
22109 +#ifdef CONFIG_KDB
22110 +       kdb(KDB_REASON_OOPS, signr, regs);
22111 +#endif /* CONFIG_KDB */
22112
22113         if (!regs)
22114                 return;
22115 @@ -465,6 +472,9 @@ void die(const char *str, struct pt_regs
22116                 printk(KERN_EMERG "Recursive die() failure, output suppressed\n");
22117         }
22118
22119 +#ifdef CONFIG_KDB
22120 +       kdb_diemsg = str;
22121 +#endif /* CONFIG_KDB */
22122         oops_end(flags, regs, SIGSEGV);
22123  }
22124
22125 @@ -575,7 +585,7 @@ void do_##name(struct pt_regs *regs, lon
22126  }
22127
22128  DO_VM86_ERROR_INFO(0, SIGFPE, "divide error", divide_error, FPE_INTDIV, regs->ip)
22129 -#ifndef CONFIG_KPROBES
22130 +#if !defined(CONFIG_KPROBES) && !defined(CONFIG_KDB)
22131  DO_VM86_ERROR(3, SIGTRAP, "int3", int3)
22132  #endif
22133  DO_VM86_ERROR(4, SIGSEGV, "overflow", overflow)
22134 @@ -718,6 +728,10 @@ io_check_error(unsigned char reason, str
22135  static notrace __kprobes void
22136  unknown_nmi_error(unsigned char reason, struct pt_regs *regs)
22137  {
22138 +#ifdef CONFIG_KDB
22139 +       (void)kdb(KDB_REASON_NMI, reason, regs);
22140 +#endif /* CONFIG_KDB */
22141 +
22142         if (notify_die(DIE_NMIUNKNOWN, "nmi", regs, reason, 2, SIGINT) == NOTIFY_STOP)
22143                 return;
22144  #ifdef CONFIG_MCA
22145 @@ -758,6 +772,9 @@ void notrace __kprobes die_nmi(char *str
22146         printk(" on CPU%d, ip %08lx, registers:\n",
22147                 smp_processor_id(), regs->ip);
22148         show_registers(regs);
22149 +#ifdef CONFIG_KDB
22150 +       kdb(KDB_REASON_NMI, 0, regs);
22151 +#endif /* CONFIG_KDB */
22152         if (do_panic)
22153                 panic("Non maskable interrupt");
22154         console_silent();
22155 @@ -787,6 +804,16 @@ static notrace __kprobes void default_do
22156         if (!cpu)
22157                 reason = get_nmi_reason();
22158
22159 +#if defined(CONFIG_SMP) && defined(CONFIG_KDB)
22160 +       /*
22161 +        * Call the kernel debugger to see if this NMI is due
22162 +        * to an KDB requested IPI.  If so, kdb will handle it.
22163 +        */
22164 +       if (kdb_ipi(regs, NULL)) {
22165 +               return;
22166 +       }
22167 +#endif /* defined(CONFIG_SMP) && defined(CONFIG_KDB) */
22168 +
22169         if (!(reason & 0xc0)) {
22170                 if (notify_die(DIE_NMI_IPI, "nmi_ipi", regs, reason, 2, SIGINT)
22171                                                                 == NOTIFY_STOP)
22172 @@ -854,6 +881,10 @@ void __kprobes do_int3(struct pt_regs *r
22173  {
22174         trace_hardirqs_fixup();
22175
22176 +#ifdef  CONFIG_KDB
22177 +       if (kdb(KDB_REASON_BREAK, error_code, regs))
22178 +               return;
22179 +#endif
22180         if (notify_die(DIE_INT3, "int3", regs, error_code, 3, SIGTRAP)
22181                         == NOTIFY_STOP)
22182                 return;
22183 @@ -904,6 +935,11 @@ void __kprobes do_debug(struct pt_regs *
22184         clear_tsk_thread_flag(tsk, TIF_DEBUGCTLMSR);
22185         tsk->thread.debugctlmsr = 0;
22186
22187 +#ifdef CONFIG_KDB
22188 +       if (kdb(KDB_REASON_DEBUG, error_code, regs))
22189 +               return;
22190 +#endif /* CONFIG_KDB */
22191 +
22192         if (notify_die(DIE_DEBUG, "debug", regs, condition, error_code,
22193                                                 SIGTRAP) == NOTIFY_STOP)
22194                 return;
22195 @@ -958,6 +994,16 @@ clear_TF_reenable:
22196         return;
22197  }
22198
22199 +#if    defined(CONFIG_KDB) && !defined(CONFIG_KPROBES)
22200 +void do_int3(struct pt_regs * regs, long error_code)
22201 +{
22202 +       if (kdb(KDB_REASON_BREAK, error_code, regs))
22203 +               return;
22204 +       do_trap(3, SIGTRAP, "int3", 1, regs, error_code, NULL);
22205 +}
22206 +#endif /* CONFIG_KDB && !CONFIG_KPROBES */
22207 +
22208 +
22209  /*
22210   * Note that we play around with the 'TS' bit in an attempt to get
22211   * the correct behaviour even in the presence of the asynchronous
22212 --- a/arch/x86/kernel/traps_64.c
22213 +++ b/arch/x86/kernel/traps_64.c
22214 @@ -583,6 +583,8 @@ die_nmi(char *str, struct pt_regs *regs,
22215         printk(" on CPU%d, ip %08lx, registers:\n",
22216                 smp_processor_id(), regs->ip);
22217         show_registers(regs);
22218 +       if (strncmp(str, "NMI Watchdog", 12) == 0)
22219 +               notify_die(DIE_NMIWATCHDOG, "nmi_watchdog", regs, 0, 2, SIGINT);
22220         if (kexec_should_crash(current))
22221                 crash_kexec(regs);
22222         if (do_panic || panic_on_oops)
22223 --- a/arch/x86/Makefile
22224 +++ b/arch/x86/Makefile
22225 @@ -171,6 +171,9 @@ ifeq ($(CONFIG_X86_32),y)
22226  drivers-$(CONFIG_FB) += arch/x86/video/
22227  endif
22228
22229 +# KDB support
22230 +drivers-$(CONFIG_KDB) += arch/x86/kdb/
22231 +
22232  ####
22233  # boot loader support. Several targets are kept for legacy purposes
22234
22235 --- /dev/null
22236 +++ b/include/asm-x86/ansidecl_32.h
22237 @@ -0,0 +1,383 @@
22238 +/* ANSI and traditional C compatability macros
22239 +   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
22240 +   Free Software Foundation, Inc.
22241 +   This file is part of the GNU C Library.
22242 +
22243 +This program is free software; you can redistribute it and/or modify
22244 +it under the terms of the GNU General Public License as published by
22245 +the Free Software Foundation; either version 2 of the License, or
22246 +(at your option) any later version.
22247 +
22248 +This program is distributed in the hope that it will be useful,
22249 +but WITHOUT ANY WARRANTY; without even the implied warranty of
22250 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22251 +GNU General Public License for more details.
22252 +
22253 +You should have received a copy of the GNU General Public License
22254 +along with this program; if not, write to the Free Software
22255 +Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
22256 +
22257 +/* Extracted from binutils 2.16.91.0.2 (OpenSUSE 10.0) and modified for kdb use.
22258 + * Any trailing whitespace was removed and #ifdef/ifndef __KERNEL__ added as
22259 + * required.
22260 + * Keith Owens <kaos@sgi.com> 15 May 2006
22261 + */
22262 +
22263 +/* ANSI and traditional C compatibility macros
22264 +
22265 +   ANSI C is assumed if __STDC__ is #defined.
22266 +
22267 +   Macro               ANSI C definition       Traditional C definition
22268 +   -----               ---- - ----------       ----------- - ----------
22269 +   ANSI_PROTOTYPES     1                       not defined
22270 +   PTR                 `void *'                `char *'
22271 +   PTRCONST            `void *const'           `char *'
22272 +   LONG_DOUBLE         `long double'           `double'
22273 +   const               not defined             `'
22274 +   volatile            not defined             `'
22275 +   signed              not defined             `'
22276 +   VA_START(ap, var)   va_start(ap, var)       va_start(ap)
22277 +
22278 +   Note that it is safe to write "void foo();" indicating a function
22279 +   with no return value, in all K+R compilers we have been able to test.
22280 +
22281 +   For declaring functions with prototypes, we also provide these:
22282 +
22283 +   PARAMS ((prototype))
22284 +   -- for functions which take a fixed number of arguments.  Use this
22285 +   when declaring the function.  When defining the function, write a
22286 +   K+R style argument list.  For example:
22287 +
22288 +       char *strcpy PARAMS ((char *dest, char *source));
22289 +       ...
22290 +       char *
22291 +       strcpy (dest, source)
22292 +            char *dest;
22293 +            char *source;
22294 +       { ... }
22295 +
22296 +
22297 +   VPARAMS ((prototype, ...))
22298 +   -- for functions which take a variable number of arguments.  Use
22299 +   PARAMS to declare the function, VPARAMS to define it.  For example:
22300 +
22301 +       int printf PARAMS ((const char *format, ...));
22302 +       ...
22303 +       int
22304 +       printf VPARAMS ((const char *format, ...))
22305 +       {
22306 +          ...
22307 +       }
22308 +
22309 +   For writing functions which take variable numbers of arguments, we
22310 +   also provide the VA_OPEN, VA_CLOSE, and VA_FIXEDARG macros.  These
22311 +   hide the differences between K+R <varargs.h> and C89 <stdarg.h> more
22312 +   thoroughly than the simple VA_START() macro mentioned above.
22313 +
22314 +   VA_OPEN and VA_CLOSE are used *instead of* va_start and va_end.
22315 +   Immediately after VA_OPEN, put a sequence of VA_FIXEDARG calls
22316 +   corresponding to the list of fixed arguments.  Then use va_arg
22317 +   normally to get the variable arguments, or pass your va_list object
22318 +   around.  You do not declare the va_list yourself; VA_OPEN does it
22319 +   for you.
22320 +
22321 +   Here is a complete example:
22322 +
22323 +       int
22324 +       printf VPARAMS ((const char *format, ...))
22325 +       {
22326 +          int result;
22327 +
22328 +          VA_OPEN (ap, format);
22329 +          VA_FIXEDARG (ap, const char *, format);
22330 +
22331 +          result = vfprintf (stdout, format, ap);
22332 +          VA_CLOSE (ap);
22333 +
22334 +          return result;
22335 +       }
22336 +
22337 +
22338 +   You can declare variables either before or after the VA_OPEN,
22339 +   VA_FIXEDARG sequence.  Also, VA_OPEN and VA_CLOSE are the beginning
22340 +   and end of a block.  They must appear at the same nesting level,
22341 +   and any variables declared after VA_OPEN go out of scope at
22342 +   VA_CLOSE.  Unfortunately, with a K+R compiler, that includes the
22343 +   argument list.  You can have multiple instances of VA_OPEN/VA_CLOSE
22344 +   pairs in a single function in case you need to traverse the
22345 +   argument list more than once.
22346 +
22347 +   For ease of writing code which uses GCC extensions but needs to be
22348 +   portable to other compilers, we provide the GCC_VERSION macro that
22349 +   simplifies testing __GNUC__ and __GNUC_MINOR__ together, and various
22350 +   wrappers around __attribute__.  Also, __extension__ will be #defined
22351 +   to nothing if it doesn't work.  See below.
22352 +
22353 +   This header also defines a lot of obsolete macros:
22354 +   CONST, VOLATILE, SIGNED, PROTO, EXFUN, DEFUN, DEFUN_VOID,
22355 +   AND, DOTS, NOARGS.  Don't use them.  */
22356 +
22357 +#ifndef        _ANSIDECL_H
22358 +#define _ANSIDECL_H    1
22359 +
22360 +/* Every source file includes this file,
22361 +   so they will all get the switch for lint.  */
22362 +/* LINTLIBRARY */
22363 +
22364 +/* Using MACRO(x,y) in cpp #if conditionals does not work with some
22365 +   older preprocessors.  Thus we can't define something like this:
22366 +
22367 +#define HAVE_GCC_VERSION(MAJOR, MINOR) \
22368 +  (__GNUC__ > (MAJOR) || (__GNUC__ == (MAJOR) && __GNUC_MINOR__ >= (MINOR)))
22369 +
22370 +and then test "#if HAVE_GCC_VERSION(2,7)".
22371 +
22372 +So instead we use the macro below and test it against specific values.  */
22373 +
22374 +/* This macro simplifies testing whether we are using gcc, and if it
22375 +   is of a particular minimum version. (Both major & minor numbers are
22376 +   significant.)  This macro will evaluate to 0 if we are not using
22377 +   gcc at all.  */
22378 +#ifndef GCC_VERSION
22379 +#define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
22380 +#endif /* GCC_VERSION */
22381 +
22382 +#if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(_WIN32) || (defined(__alpha) && defined(__cplusplus))
22383 +/* All known AIX compilers implement these things (but don't always
22384 +   define __STDC__).  The RISC/OS MIPS compiler defines these things
22385 +   in SVR4 mode, but does not define __STDC__.  */
22386 +/* eraxxon@alumni.rice.edu: The Compaq C++ compiler, unlike many other
22387 +   C++ compilers, does not define __STDC__, though it acts as if this
22388 +   was so. (Verified versions: 5.7, 6.2, 6.3, 6.5) */
22389 +
22390 +#define ANSI_PROTOTYPES        1
22391 +#define PTR            void *
22392 +#define PTRCONST       void *const
22393 +#define LONG_DOUBLE    long double
22394 +
22395 +/* PARAMS is often defined elsewhere (e.g. by libintl.h), so wrap it in
22396 +   a #ifndef.  */
22397 +#ifndef PARAMS
22398 +#define PARAMS(ARGS)           ARGS
22399 +#endif
22400 +
22401 +#define VPARAMS(ARGS)          ARGS
22402 +#define VA_START(VA_LIST, VAR) va_start(VA_LIST, VAR)
22403 +
22404 +/* variadic function helper macros */
22405 +/* "struct Qdmy" swallows the semicolon after VA_OPEN/VA_FIXEDARG's
22406 +   use without inhibiting further decls and without declaring an
22407 +   actual variable.  */
22408 +#define VA_OPEN(AP, VAR)       { va_list AP; va_start(AP, VAR); { struct Qdmy
22409 +#define VA_CLOSE(AP)           } va_end(AP); }
22410 +#define VA_FIXEDARG(AP, T, N)  struct Qdmy
22411 +
22412 +#undef const
22413 +#undef volatile
22414 +#undef signed
22415 +
22416 +#ifdef __KERNEL__
22417 +#ifndef        __STDC_VERSION__
22418 +#define        __STDC_VERSION__ 0
22419 +#endif
22420 +#endif /* __KERNEL__ */
22421 +
22422 +/* inline requires special treatment; it's in C99, and GCC >=2.7 supports
22423 +   it too, but it's not in C89.  */
22424 +#undef inline
22425 +#if __STDC_VERSION__ > 199901L
22426 +/* it's a keyword */
22427 +#else
22428 +# if GCC_VERSION >= 2007
22429 +#  define inline __inline__   /* __inline__ prevents -pedantic warnings */
22430 +# else
22431 +#  define inline  /* nothing */
22432 +# endif
22433 +#endif
22434 +
22435 +/* These are obsolete.  Do not use.  */
22436 +#ifndef IN_GCC
22437 +#define CONST          const
22438 +#define VOLATILE       volatile
22439 +#define SIGNED         signed
22440 +
22441 +#define PROTO(type, name, arglist)     type name arglist
22442 +#define EXFUN(name, proto)             name proto
22443 +#define DEFUN(name, arglist, args)     name(args)
22444 +#define DEFUN_VOID(name)               name(void)
22445 +#define AND            ,
22446 +#define DOTS           , ...
22447 +#define NOARGS         void
22448 +#endif /* ! IN_GCC */
22449 +
22450 +#else  /* Not ANSI C.  */
22451 +
22452 +#undef  ANSI_PROTOTYPES
22453 +#define PTR            char *
22454 +#define PTRCONST       PTR
22455 +#define LONG_DOUBLE    double
22456 +
22457 +#define PARAMS(args)           ()
22458 +#define VPARAMS(args)          (va_alist) va_dcl
22459 +#define VA_START(va_list, var) va_start(va_list)
22460 +
22461 +#define VA_OPEN(AP, VAR)               { va_list AP; va_start(AP); { struct Qdmy
22462 +#define VA_CLOSE(AP)                   } va_end(AP); }
22463 +#define VA_FIXEDARG(AP, TYPE, NAME)    TYPE NAME = va_arg(AP, TYPE)
22464 +
22465 +/* some systems define these in header files for non-ansi mode */
22466 +#undef const
22467 +#undef volatile
22468 +#undef signed
22469 +#undef inline
22470 +#define const
22471 +#define volatile
22472 +#define signed
22473 +#define inline
22474 +
22475 +#ifndef IN_GCC
22476 +#define CONST
22477 +#define VOLATILE
22478 +#define SIGNED
22479 +
22480 +#define PROTO(type, name, arglist)     type name ()
22481 +#define EXFUN(name, proto)             name()
22482 +#define DEFUN(name, arglist, args)     name arglist args;
22483 +#define DEFUN_VOID(name)               name()
22484 +#define AND            ;
22485 +#define DOTS
22486 +#define NOARGS
22487 +#endif /* ! IN_GCC */
22488 +
22489 +#endif /* ANSI C.  */
22490 +
22491 +/* Define macros for some gcc attributes.  This permits us to use the
22492 +   macros freely, and know that they will come into play for the
22493 +   version of gcc in which they are supported.  */
22494 +
22495 +#if (GCC_VERSION < 2007)
22496 +# define __attribute__(x)
22497 +#endif
22498 +
22499 +/* Attribute __malloc__ on functions was valid as of gcc 2.96. */
22500 +#ifndef ATTRIBUTE_MALLOC
22501 +# if (GCC_VERSION >= 2096)
22502 +#  define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
22503 +# else
22504 +#  define ATTRIBUTE_MALLOC
22505 +# endif /* GNUC >= 2.96 */
22506 +#endif /* ATTRIBUTE_MALLOC */
22507 +
22508 +/* Attributes on labels were valid as of gcc 2.93. */
22509 +#ifndef ATTRIBUTE_UNUSED_LABEL
22510 +# if (!defined (__cplusplus) && GCC_VERSION >= 2093)
22511 +#  define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED
22512 +# else
22513 +#  define ATTRIBUTE_UNUSED_LABEL
22514 +# endif /* !__cplusplus && GNUC >= 2.93 */
22515 +#endif /* ATTRIBUTE_UNUSED_LABEL */
22516 +
22517 +#ifndef ATTRIBUTE_UNUSED
22518 +#define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
22519 +#endif /* ATTRIBUTE_UNUSED */
22520 +
22521 +/* Before GCC 3.4, the C++ frontend couldn't parse attributes placed after the
22522 +   identifier name.  */
22523 +#if ! defined(__cplusplus) || (GCC_VERSION >= 3004)
22524 +# define ARG_UNUSED(NAME) NAME ATTRIBUTE_UNUSED
22525 +#else /* !__cplusplus || GNUC >= 3.4 */
22526 +# define ARG_UNUSED(NAME) NAME
22527 +#endif /* !__cplusplus || GNUC >= 3.4 */
22528 +
22529 +#ifndef ATTRIBUTE_NORETURN
22530 +#define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
22531 +#endif /* ATTRIBUTE_NORETURN */
22532 +
22533 +/* Attribute `nonnull' was valid as of gcc 3.3.  */
22534 +#ifndef ATTRIBUTE_NONNULL
22535 +# if (GCC_VERSION >= 3003)
22536 +#  define ATTRIBUTE_NONNULL(m) __attribute__ ((__nonnull__ (m)))
22537 +# else
22538 +#  define ATTRIBUTE_NONNULL(m)
22539 +# endif /* GNUC >= 3.3 */
22540 +#endif /* ATTRIBUTE_NONNULL */
22541 +
22542 +/* Attribute `pure' was valid as of gcc 3.0.  */
22543 +#ifndef ATTRIBUTE_PURE
22544 +# if (GCC_VERSION >= 3000)
22545 +#  define ATTRIBUTE_PURE __attribute__ ((__pure__))
22546 +# else
22547 +#  define ATTRIBUTE_PURE
22548 +# endif /* GNUC >= 3.0 */
22549 +#endif /* ATTRIBUTE_PURE */
22550 +
22551 +/* Use ATTRIBUTE_PRINTF when the format specifier must not be NULL.
22552 +   This was the case for the `printf' format attribute by itself
22553 +   before GCC 3.3, but as of 3.3 we need to add the `nonnull'
22554 +   attribute to retain this behavior.  */
22555 +#ifndef ATTRIBUTE_PRINTF
22556 +#define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n))) ATTRIBUTE_NONNULL(m)
22557 +#define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
22558 +#define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
22559 +#define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
22560 +#define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
22561 +#define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
22562 +#endif /* ATTRIBUTE_PRINTF */
22563 +
22564 +/* Use ATTRIBUTE_FPTR_PRINTF when the format attribute is to be set on
22565 +   a function pointer.  Format attributes were allowed on function
22566 +   pointers as of gcc 3.1.  */
22567 +#ifndef ATTRIBUTE_FPTR_PRINTF
22568 +# if (GCC_VERSION >= 3001)
22569 +#  define ATTRIBUTE_FPTR_PRINTF(m, n) ATTRIBUTE_PRINTF(m, n)
22570 +# else
22571 +#  define ATTRIBUTE_FPTR_PRINTF(m, n)
22572 +# endif /* GNUC >= 3.1 */
22573 +# define ATTRIBUTE_FPTR_PRINTF_1 ATTRIBUTE_FPTR_PRINTF(1, 2)
22574 +# define ATTRIBUTE_FPTR_PRINTF_2 ATTRIBUTE_FPTR_PRINTF(2, 3)
22575 +# define ATTRIBUTE_FPTR_PRINTF_3 ATTRIBUTE_FPTR_PRINTF(3, 4)
22576 +# define ATTRIBUTE_FPTR_PRINTF_4 ATTRIBUTE_FPTR_PRINTF(4, 5)
22577 +# define ATTRIBUTE_FPTR_PRINTF_5 ATTRIBUTE_FPTR_PRINTF(5, 6)
22578 +#endif /* ATTRIBUTE_FPTR_PRINTF */
22579 +
22580 +/* Use ATTRIBUTE_NULL_PRINTF when the format specifier may be NULL.  A
22581 +   NULL format specifier was allowed as of gcc 3.3.  */
22582 +#ifndef ATTRIBUTE_NULL_PRINTF
22583 +# if (GCC_VERSION >= 3003)
22584 +#  define ATTRIBUTE_NULL_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n)))
22585 +# else
22586 +#  define ATTRIBUTE_NULL_PRINTF(m, n)
22587 +# endif /* GNUC >= 3.3 */
22588 +# define ATTRIBUTE_NULL_PRINTF_1 ATTRIBUTE_NULL_PRINTF(1, 2)
22589 +# define ATTRIBUTE_NULL_PRINTF_2 ATTRIBUTE_NULL_PRINTF(2, 3)
22590 +# define ATTRIBUTE_NULL_PRINTF_3 ATTRIBUTE_NULL_PRINTF(3, 4)
22591 +# define ATTRIBUTE_NULL_PRINTF_4 ATTRIBUTE_NULL_PRINTF(4, 5)
22592 +# define ATTRIBUTE_NULL_PRINTF_5 ATTRIBUTE_NULL_PRINTF(5, 6)
22593 +#endif /* ATTRIBUTE_NULL_PRINTF */
22594 +
22595 +/* Attribute `sentinel' was valid as of gcc 3.5.  */
22596 +#ifndef ATTRIBUTE_SENTINEL
22597 +# if (GCC_VERSION >= 3005)
22598 +#  define ATTRIBUTE_SENTINEL __attribute__ ((__sentinel__))
22599 +# else
22600 +#  define ATTRIBUTE_SENTINEL
22601 +# endif /* GNUC >= 3.5 */
22602 +#endif /* ATTRIBUTE_SENTINEL */
22603 +
22604 +
22605 +#ifndef ATTRIBUTE_ALIGNED_ALIGNOF
22606 +# if (GCC_VERSION >= 3000)
22607 +#  define ATTRIBUTE_ALIGNED_ALIGNOF(m) __attribute__ ((__aligned__ (__alignof__ (m))))
22608 +# else
22609 +#  define ATTRIBUTE_ALIGNED_ALIGNOF(m)
22610 +# endif /* GNUC >= 3.0 */
22611 +#endif /* ATTRIBUTE_ALIGNED_ALIGNOF */
22612 +
22613 +/* We use __extension__ in some places to suppress -pedantic warnings
22614 +   about GCC extensions.  This feature didn't work properly before
22615 +   gcc 2.8.  */
22616 +#if GCC_VERSION < 2008
22617 +#define __extension__
22618 +#endif
22619 +
22620 +#endif /* ansidecl.h   */
22621 --- /dev/null
22622 +++ b/include/asm-x86/ansidecl_64.h
22623 @@ -0,0 +1,383 @@
22624 +/* ANSI and traditional C compatability macros
22625 +   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
22626 +   Free Software Foundation, Inc.
22627 +   This file is part of the GNU C Library.
22628 +
22629 +This program is free software; you can redistribute it and/or modify
22630 +it under the terms of the GNU General Public License as published by
22631 +the Free Software Foundation; either version 2 of the License, or
22632 +(at your option) any later version.
22633 +
22634 +This program is distributed in the hope that it will be useful,
22635 +but WITHOUT ANY WARRANTY; without even the implied warranty of
22636 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22637 +GNU General Public License for more details.
22638 +
22639 +You should have received a copy of the GNU General Public License
22640 +along with this program; if not, write to the Free Software
22641 +Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
22642 +
22643 +/* Extracted from binutils 2.16.91.0.2 (OpenSUSE 10.0) and modified for kdb use.
22644 + * Any trailing whitespace was removed and #ifdef/ifndef __KERNEL__ added as
22645 + * required.
22646 + * Keith Owens <kaos@sgi.com> 15 May 2006
22647 + */
22648 +
22649 +/* ANSI and traditional C compatibility macros
22650 +
22651 +   ANSI C is assumed if __STDC__ is #defined.
22652 +
22653 +   Macro               ANSI C definition       Traditional C definition
22654 +   -----               ---- - ----------       ----------- - ----------
22655 +   ANSI_PROTOTYPES     1                       not defined
22656 +   PTR                 `void *'                `char *'
22657 +   PTRCONST            `void *const'           `char *'
22658 +   LONG_DOUBLE         `long double'           `double'
22659 +   const               not defined             `'
22660 +   volatile            not defined             `'
22661 +   signed              not defined             `'
22662 +   VA_START(ap, var)   va_start(ap, var)       va_start(ap)
22663 +
22664 +   Note that it is safe to write "void foo();" indicating a function
22665 +   with no return value, in all K+R compilers we have been able to test.
22666 +
22667 +   For declaring functions with prototypes, we also provide these:
22668 +
22669 +   PARAMS ((prototype))
22670 +   -- for functions which take a fixed number of arguments.  Use this
22671 +   when declaring the function.  When defining the function, write a
22672 +   K+R style argument list.  For example:
22673 +
22674 +       char *strcpy PARAMS ((char *dest, char *source));
22675 +       ...
22676 +       char *
22677 +       strcpy (dest, source)
22678 +            char *dest;
22679 +            char *source;
22680 +       { ... }
22681 +
22682 +
22683 +   VPARAMS ((prototype, ...))
22684 +   -- for functions which take a variable number of arguments.  Use
22685 +   PARAMS to declare the function, VPARAMS to define it.  For example:
22686 +
22687 +       int printf PARAMS ((const char *format, ...));
22688 +       ...
22689 +       int
22690 +       printf VPARAMS ((const char *format, ...))
22691 +       {
22692 +          ...
22693 +       }
22694 +
22695 +   For writing functions which take variable numbers of arguments, we
22696 +   also provide the VA_OPEN, VA_CLOSE, and VA_FIXEDARG macros.  These
22697 +   hide the differences between K+R <varargs.h> and C89 <stdarg.h> more
22698 +   thoroughly than the simple VA_START() macro mentioned above.
22699 +
22700 +   VA_OPEN and VA_CLOSE are used *instead of* va_start and va_end.
22701 +   Immediately after VA_OPEN, put a sequence of VA_FIXEDARG calls
22702 +   corresponding to the list of fixed arguments.  Then use va_arg
22703 +   normally to get the variable arguments, or pass your va_list object
22704 +   around.  You do not declare the va_list yourself; VA_OPEN does it
22705 +   for you.
22706 +
22707 +   Here is a complete example:
22708 +
22709 +       int
22710 +       printf VPARAMS ((const char *format, ...))
22711 +       {
22712 +          int result;
22713 +
22714 +          VA_OPEN (ap, format);
22715 +          VA_FIXEDARG (ap, const char *, format);
22716 +
22717 +          result = vfprintf (stdout, format, ap);
22718 +          VA_CLOSE (ap);
22719 +
22720 +          return result;
22721 +       }
22722 +
22723 +
22724 +   You can declare variables either before or after the VA_OPEN,
22725 +   VA_FIXEDARG sequence.  Also, VA_OPEN and VA_CLOSE are the beginning
22726 +   and end of a block.  They must appear at the same nesting level,
22727 +   and any variables declared after VA_OPEN go out of scope at
22728 +   VA_CLOSE.  Unfortunately, with a K+R compiler, that includes the
22729 +   argument list.  You can have multiple instances of VA_OPEN/VA_CLOSE
22730 +   pairs in a single function in case you need to traverse the
22731 +   argument list more than once.
22732 +
22733 +   For ease of writing code which uses GCC extensions but needs to be
22734 +   portable to other compilers, we provide the GCC_VERSION macro that
22735 +   simplifies testing __GNUC__ and __GNUC_MINOR__ together, and various
22736 +   wrappers around __attribute__.  Also, __extension__ will be #defined
22737 +   to nothing if it doesn't work.  See below.
22738 +
22739 +   This header also defines a lot of obsolete macros:
22740 +   CONST, VOLATILE, SIGNED, PROTO, EXFUN, DEFUN, DEFUN_VOID,
22741 +   AND, DOTS, NOARGS.  Don't use them.  */
22742 +
22743 +#ifndef        _ANSIDECL_H
22744 +#define _ANSIDECL_H    1
22745 +
22746 +/* Every source file includes this file,
22747 +   so they will all get the switch for lint.  */
22748 +/* LINTLIBRARY */
22749 +
22750 +/* Using MACRO(x,y) in cpp #if conditionals does not work with some
22751 +   older preprocessors.  Thus we can't define something like this:
22752 +
22753 +#define HAVE_GCC_VERSION(MAJOR, MINOR) \
22754 +  (__GNUC__ > (MAJOR) || (__GNUC__ == (MAJOR) && __GNUC_MINOR__ >= (MINOR)))
22755 +
22756 +and then test "#if HAVE_GCC_VERSION(2,7)".
22757 +
22758 +So instead we use the macro below and test it against specific values.  */
22759 +
22760 +/* This macro simplifies testing whether we are using gcc, and if it
22761 +   is of a particular minimum version. (Both major & minor numbers are
22762 +   significant.)  This macro will evaluate to 0 if we are not using
22763 +   gcc at all.  */
22764 +#ifndef GCC_VERSION
22765 +#define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
22766 +#endif /* GCC_VERSION */
22767 +
22768 +#if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(_WIN32) || (defined(__alpha) && defined(__cplusplus))
22769 +/* All known AIX compilers implement these things (but don't always
22770 +   define __STDC__).  The RISC/OS MIPS compiler defines these things
22771 +   in SVR4 mode, but does not define __STDC__.  */
22772 +/* eraxxon@alumni.rice.edu: The Compaq C++ compiler, unlike many other
22773 +   C++ compilers, does not define __STDC__, though it acts as if this
22774 +   was so. (Verified versions: 5.7, 6.2, 6.3, 6.5) */
22775 +
22776 +#define ANSI_PROTOTYPES        1
22777 +#define PTR            void *
22778 +#define PTRCONST       void *const
22779 +#define LONG_DOUBLE    long double
22780 +
22781 +/* PARAMS is often defined elsewhere (e.g. by libintl.h), so wrap it in
22782 +   a #ifndef.  */
22783 +#ifndef PARAMS
22784 +#define PARAMS(ARGS)           ARGS
22785 +#endif
22786 +
22787 +#define VPARAMS(ARGS)          ARGS
22788 +#define VA_START(VA_LIST, VAR) va_start(VA_LIST, VAR)
22789 +
22790 +/* variadic function helper macros */
22791 +/* "struct Qdmy" swallows the semicolon after VA_OPEN/VA_FIXEDARG's
22792 +   use without inhibiting further decls and without declaring an
22793 +   actual variable.  */
22794 +#define VA_OPEN(AP, VAR)       { va_list AP; va_start(AP, VAR); { struct Qdmy
22795 +#define VA_CLOSE(AP)           } va_end(AP); }
22796 +#define VA_FIXEDARG(AP, T, N)  struct Qdmy
22797 +
22798 +#undef const
22799 +#undef volatile
22800 +#undef signed
22801 +
22802 +#ifdef __KERNEL__
22803 +#ifndef        __STDC_VERSION__
22804 +#define        __STDC_VERSION__ 0
22805 +#endif
22806 +#endif /* __KERNEL__ */
22807 +
22808 +/* inline requires special treatment; it's in C99, and GCC >=2.7 supports
22809 +   it too, but it's not in C89.  */
22810 +#undef inline
22811 +#if __STDC_VERSION__ > 199901L
22812 +/* it's a keyword */
22813 +#else
22814 +# if GCC_VERSION >= 2007
22815 +#  define inline __inline__   /* __inline__ prevents -pedantic warnings */
22816 +# else
22817 +#  define inline  /* nothing */
22818 +# endif
22819 +#endif
22820 +
22821 +/* These are obsolete.  Do not use.  */
22822 +#ifndef IN_GCC
22823 +#define CONST          const
22824 +#define VOLATILE       volatile
22825 +#define SIGNED         signed
22826 +
22827 +#define PROTO(type, name, arglist)     type name arglist
22828 +#define EXFUN(name, proto)             name proto
22829 +#define DEFUN(name, arglist, args)     name(args)
22830 +#define DEFUN_VOID(name)               name(void)
22831 +#define AND            ,
22832 +#define DOTS           , ...
22833 +#define NOARGS         void
22834 +#endif /* ! IN_GCC */
22835 +
22836 +#else  /* Not ANSI C.  */
22837 +
22838 +#undef  ANSI_PROTOTYPES
22839 +#define PTR            char *
22840 +#define PTRCONST       PTR
22841 +#define LONG_DOUBLE    double
22842 +
22843 +#define PARAMS(args)           ()
22844 +#define VPARAMS(args)          (va_alist) va_dcl
22845 +#define VA_START(va_list, var) va_start(va_list)
22846 +
22847 +#define VA_OPEN(AP, VAR)               { va_list AP; va_start(AP); { struct Qdmy
22848 +#define VA_CLOSE(AP)                   } va_end(AP); }
22849 +#define VA_FIXEDARG(AP, TYPE, NAME)    TYPE NAME = va_arg(AP, TYPE)
22850 +
22851 +/* some systems define these in header files for non-ansi mode */
22852 +#undef const
22853 +#undef volatile
22854 +#undef signed
22855 +#undef inline
22856 +#define const
22857 +#define volatile
22858 +#define signed
22859 +#define inline
22860 +
22861 +#ifndef IN_GCC
22862 +#define CONST
22863 +#define VOLATILE
22864 +#define SIGNED
22865 +
22866 +#define PROTO(type, name, arglist)     type name ()
22867 +#define EXFUN(name, proto)             name()
22868 +#define DEFUN(name, arglist, args)     name arglist args;
22869 +#define DEFUN_VOID(name)               name()
22870 +#define AND            ;
22871 +#define DOTS
22872 +#define NOARGS
22873 +#endif /* ! IN_GCC */
22874 +
22875 +#endif /* ANSI C.  */
22876 +
22877 +/* Define macros for some gcc attributes.  This permits us to use the
22878 +   macros freely, and know that they will come into play for the
22879 +   version of gcc in which they are supported.  */
22880 +
22881 +#if (GCC_VERSION < 2007)
22882 +# define __attribute__(x)
22883 +#endif
22884 +
22885 +/* Attribute __malloc__ on functions was valid as of gcc 2.96. */
22886 +#ifndef ATTRIBUTE_MALLOC
22887 +# if (GCC_VERSION >= 2096)
22888 +#  define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
22889 +# else
22890 +#  define ATTRIBUTE_MALLOC
22891 +# endif /* GNUC >= 2.96 */
22892 +#endif /* ATTRIBUTE_MALLOC */
22893 +
22894 +/* Attributes on labels were valid as of gcc 2.93. */
22895 +#ifndef ATTRIBUTE_UNUSED_LABEL
22896 +# if (!defined (__cplusplus) && GCC_VERSION >= 2093)
22897 +#  define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED
22898 +# else
22899 +#  define ATTRIBUTE_UNUSED_LABEL
22900 +# endif /* !__cplusplus && GNUC >= 2.93 */
22901 +#endif /* ATTRIBUTE_UNUSED_LABEL */
22902 +
22903 +#ifndef ATTRIBUTE_UNUSED
22904 +#define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
22905 +#endif /* ATTRIBUTE_UNUSED */
22906 +
22907 +/* Before GCC 3.4, the C++ frontend couldn't parse attributes placed after the
22908 +   identifier name.  */
22909 +#if ! defined(__cplusplus) || (GCC_VERSION >= 3004)
22910 +# define ARG_UNUSED(NAME) NAME ATTRIBUTE_UNUSED
22911 +#else /* !__cplusplus || GNUC >= 3.4 */
22912 +# define ARG_UNUSED(NAME) NAME
22913 +#endif /* !__cplusplus || GNUC >= 3.4 */
22914 +
22915 +#ifndef ATTRIBUTE_NORETURN
22916 +#define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
22917 +#endif /* ATTRIBUTE_NORETURN */
22918 +
22919 +/* Attribute `nonnull' was valid as of gcc 3.3.  */
22920 +#ifndef ATTRIBUTE_NONNULL
22921 +# if (GCC_VERSION >= 3003)
22922 +#  define ATTRIBUTE_NONNULL(m) __attribute__ ((__nonnull__ (m)))
22923 +# else
22924 +#  define ATTRIBUTE_NONNULL(m)
22925 +# endif /* GNUC >= 3.3 */
22926 +#endif /* ATTRIBUTE_NONNULL */
22927 +
22928 +/* Attribute `pure' was valid as of gcc 3.0.  */
22929 +#ifndef ATTRIBUTE_PURE
22930 +# if (GCC_VERSION >= 3000)
22931 +#  define ATTRIBUTE_PURE __attribute__ ((__pure__))
22932 +# else
22933 +#  define ATTRIBUTE_PURE
22934 +# endif /* GNUC >= 3.0 */
22935 +#endif /* ATTRIBUTE_PURE */
22936 +
22937 +/* Use ATTRIBUTE_PRINTF when the format specifier must not be NULL.
22938 +   This was the case for the `printf' format attribute by itself
22939 +   before GCC 3.3, but as of 3.3 we need to add the `nonnull'
22940 +   attribute to retain this behavior.  */
22941 +#ifndef ATTRIBUTE_PRINTF
22942 +#define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n))) ATTRIBUTE_NONNULL(m)
22943 +#define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
22944 +#define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
22945 +#define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
22946 +#define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
22947 +#define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
22948 +#endif /* ATTRIBUTE_PRINTF */
22949 +
22950 +/* Use ATTRIBUTE_FPTR_PRINTF when the format attribute is to be set on
22951 +   a function pointer.  Format attributes were allowed on function
22952 +   pointers as of gcc 3.1.  */
22953 +#ifndef ATTRIBUTE_FPTR_PRINTF
22954 +# if (GCC_VERSION >= 3001)
22955 +#  define ATTRIBUTE_FPTR_PRINTF(m, n) ATTRIBUTE_PRINTF(m, n)
22956 +# else
22957 +#  define ATTRIBUTE_FPTR_PRINTF(m, n)
22958 +# endif /* GNUC >= 3.1 */
22959 +# define ATTRIBUTE_FPTR_PRINTF_1 ATTRIBUTE_FPTR_PRINTF(1, 2)
22960 +# define ATTRIBUTE_FPTR_PRINTF_2 ATTRIBUTE_FPTR_PRINTF(2, 3)
22961 +# define ATTRIBUTE_FPTR_PRINTF_3 ATTRIBUTE_FPTR_PRINTF(3, 4)
22962 +# define ATTRIBUTE_FPTR_PRINTF_4 ATTRIBUTE_FPTR_PRINTF(4, 5)
22963 +# define ATTRIBUTE_FPTR_PRINTF_5 ATTRIBUTE_FPTR_PRINTF(5, 6)
22964 +#endif /* ATTRIBUTE_FPTR_PRINTF */
22965 +
22966 +/* Use ATTRIBUTE_NULL_PRINTF when the format specifier may be NULL.  A
22967 +   NULL format specifier was allowed as of gcc 3.3.  */
22968 +#ifndef ATTRIBUTE_NULL_PRINTF
22969 +# if (GCC_VERSION >= 3003)
22970 +#  define ATTRIBUTE_NULL_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n)))
22971 +# else
22972 +#  define ATTRIBUTE_NULL_PRINTF(m, n)
22973 +# endif /* GNUC >= 3.3 */
22974 +# define ATTRIBUTE_NULL_PRINTF_1 ATTRIBUTE_NULL_PRINTF(1, 2)
22975 +# define ATTRIBUTE_NULL_PRINTF_2 ATTRIBUTE_NULL_PRINTF(2, 3)
22976 +# define ATTRIBUTE_NULL_PRINTF_3 ATTRIBUTE_NULL_PRINTF(3, 4)
22977 +# define ATTRIBUTE_NULL_PRINTF_4 ATTRIBUTE_NULL_PRINTF(4, 5)
22978 +# define ATTRIBUTE_NULL_PRINTF_5 ATTRIBUTE_NULL_PRINTF(5, 6)
22979 +#endif /* ATTRIBUTE_NULL_PRINTF */
22980 +
22981 +/* Attribute `sentinel' was valid as of gcc 3.5.  */
22982 +#ifndef ATTRIBUTE_SENTINEL
22983 +# if (GCC_VERSION >= 3005)
22984 +#  define ATTRIBUTE_SENTINEL __attribute__ ((__sentinel__))
22985 +# else
22986 +#  define ATTRIBUTE_SENTINEL
22987 +# endif /* GNUC >= 3.5 */
22988 +#endif /* ATTRIBUTE_SENTINEL */
22989 +
22990 +
22991 +#ifndef ATTRIBUTE_ALIGNED_ALIGNOF
22992 +# if (GCC_VERSION >= 3000)
22993 +#  define ATTRIBUTE_ALIGNED_ALIGNOF(m) __attribute__ ((__aligned__ (__alignof__ (m))))
22994 +# else
22995 +#  define ATTRIBUTE_ALIGNED_ALIGNOF(m)
22996 +# endif /* GNUC >= 3.0 */
22997 +#endif /* ATTRIBUTE_ALIGNED_ALIGNOF */
22998 +
22999 +/* We use __extension__ in some places to suppress -pedantic warnings
23000 +   about GCC extensions.  This feature didn't work properly before
23001 +   gcc 2.8.  */
23002 +#if GCC_VERSION < 2008
23003 +#define __extension__
23004 +#endif
23005 +
23006 +#endif /* ansidecl.h   */
23007 --- /dev/null
23008 +++ b/include/asm-x86/ansidecl.h
23009 @@ -0,0 +1,5 @@
23010 +#ifdef CONFIG_X86_32
23011 +# include "ansidecl_32.h"
23012 +#else
23013 +# include "ansidecl_64.h"
23014 +#endif
23015 --- /dev/null
23016 +++ b/include/asm-x86/bfd_32.h
23017 @@ -0,0 +1,4921 @@
23018 +/* DO NOT EDIT!  -*- buffer-read-only: t -*-  This file is automatically
23019 +   generated from "bfd-in.h", "init.c", "opncls.c", "libbfd.c",
23020 +   "bfdio.c", "bfdwin.c", "section.c", "archures.c", "reloc.c",
23021 +   "syms.c", "bfd.c", "archive.c", "corefile.c", "targets.c", "format.c",
23022 +   "linker.c" and "simple.c".
23023 +   Run "make headers" in your build bfd/ to regenerate.  */
23024 +
23025 +/* Main header file for the bfd library -- portable access to object files.
23026 +
23027 +   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
23028 +   1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
23029 +
23030 +   Contributed by Cygnus Support.
23031 +
23032 +   This file is part of BFD, the Binary File Descriptor library.
23033 +
23034 +   This program is free software; you can redistribute it and/or modify
23035 +   it under the terms of the GNU General Public License as published by
23036 +   the Free Software Foundation; either version 2 of the License, or
23037 +   (at your option) any later version.
23038 +
23039 +   This program is distributed in the hope that it will be useful,
23040 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
23041 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23042 +   GNU General Public License for more details.
23043 +
23044 +   You should have received a copy of the GNU General Public License
23045 +   along with this program; if not, write to the Free Software
23046 +   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
23047 +
23048 +/* Extracted from binutils 2.16.91.0.2 (OpenSUSE 10.0) and modified for kdb use.
23049 + * Any trailing whitespace was removed and #ifdef/ifndef __KERNEL__ added as
23050 + * required.
23051 + * Keith Owens <kaos@sgi.com> 15 May 2006
23052 + */
23053 +
23054 +#ifndef __BFD_H_SEEN__
23055 +#define __BFD_H_SEEN__
23056 +
23057 +#ifdef __cplusplus
23058 +extern "C" {
23059 +#endif
23060 +
23061 +#ifdef __KERNEL__
23062 +#include <asm/ansidecl.h>
23063 +#else  /* __KERNEL__ */
23064 +#include "ansidecl.h"
23065 +#include "symcat.h"
23066 +#endif /* __KERNEL__ */
23067 +#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
23068 +#ifndef SABER
23069 +/* This hack is to avoid a problem with some strict ANSI C preprocessors.
23070 +   The problem is, "32_" is not a valid preprocessing token, and we don't
23071 +   want extra underscores (e.g., "nlm_32_").  The XCONCAT2 macro will
23072 +   cause the inner CONCAT2 macros to be evaluated first, producing
23073 +   still-valid pp-tokens.  Then the final concatenation can be done.  */
23074 +#undef CONCAT4
23075 +#define CONCAT4(a,b,c,d) XCONCAT2(CONCAT2(a,b),CONCAT2(c,d))
23076 +#endif
23077 +#endif
23078 +
23079 +/* The word size used by BFD on the host.  This may be 64 with a 32
23080 +   bit target if the host is 64 bit, or if other 64 bit targets have
23081 +   been selected with --enable-targets, or if --enable-64-bit-bfd.  */
23082 +#ifdef __KERNEL__
23083 +#define BFD_ARCH_SIZE 32
23084 +#else  /* __KERNEL__ */
23085 +#define BFD_ARCH_SIZE 64
23086 +#endif /* __KERNEL__ */
23087 +
23088 +/* The word size of the default bfd target.  */
23089 +#define BFD_DEFAULT_TARGET_SIZE 32
23090 +
23091 +#define BFD_HOST_64BIT_LONG 0
23092 +#define BFD_HOST_LONG_LONG 1
23093 +#if 1
23094 +#define BFD_HOST_64_BIT long long
23095 +#define BFD_HOST_U_64_BIT unsigned long long
23096 +typedef BFD_HOST_64_BIT bfd_int64_t;
23097 +typedef BFD_HOST_U_64_BIT bfd_uint64_t;
23098 +#endif
23099 +
23100 +#if BFD_ARCH_SIZE >= 64
23101 +#define BFD64
23102 +#endif
23103 +
23104 +#ifndef INLINE
23105 +#if __GNUC__ >= 2
23106 +#define INLINE __inline__
23107 +#else
23108 +#define INLINE
23109 +#endif
23110 +#endif
23111 +
23112 +/* Forward declaration.  */
23113 +typedef struct bfd bfd;
23114 +
23115 +/* Boolean type used in bfd.  Too many systems define their own
23116 +   versions of "boolean" for us to safely typedef a "boolean" of
23117 +   our own.  Using an enum for "bfd_boolean" has its own set of
23118 +   problems, with strange looking casts required to avoid warnings
23119 +   on some older compilers.  Thus we just use an int.
23120 +
23121 +   General rule: Functions which are bfd_boolean return TRUE on
23122 +   success and FALSE on failure (unless they're a predicate).  */
23123 +
23124 +typedef int bfd_boolean;
23125 +#undef FALSE
23126 +#undef TRUE
23127 +#define FALSE 0
23128 +#define TRUE 1
23129 +
23130 +#ifdef BFD64
23131 +
23132 +#ifndef BFD_HOST_64_BIT
23133 + #error No 64 bit integer type available
23134 +#endif /* ! defined (BFD_HOST_64_BIT) */
23135 +
23136 +typedef BFD_HOST_U_64_BIT bfd_vma;
23137 +typedef BFD_HOST_64_BIT bfd_signed_vma;
23138 +typedef BFD_HOST_U_64_BIT bfd_size_type;
23139 +typedef BFD_HOST_U_64_BIT symvalue;
23140 +
23141 +#ifndef fprintf_vma
23142 +#if BFD_HOST_64BIT_LONG
23143 +#define sprintf_vma(s,x) sprintf (s, "%016lx", x)
23144 +#define fprintf_vma(f,x) fprintf (f, "%016lx", x)
23145 +#else
23146 +#define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff)))
23147 +#define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff))
23148 +#define fprintf_vma(s,x) \
23149 +  fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
23150 +#define sprintf_vma(s,x) \
23151 +  sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
23152 +#endif
23153 +#endif
23154 +
23155 +#else /* not BFD64  */
23156 +
23157 +/* Represent a target address.  Also used as a generic unsigned type
23158 +   which is guaranteed to be big enough to hold any arithmetic types
23159 +   we need to deal with.  */
23160 +typedef unsigned long bfd_vma;
23161 +
23162 +/* A generic signed type which is guaranteed to be big enough to hold any
23163 +   arithmetic types we need to deal with.  Can be assumed to be compatible
23164 +   with bfd_vma in the same way that signed and unsigned ints are compatible
23165 +   (as parameters, in assignment, etc).  */
23166 +typedef long bfd_signed_vma;
23167 +
23168 +typedef unsigned long symvalue;
23169 +typedef unsigned long bfd_size_type;
23170 +
23171 +/* Print a bfd_vma x on stream s.  */
23172 +#define fprintf_vma(s,x) fprintf (s, "%08lx", x)
23173 +#define sprintf_vma(s,x) sprintf (s, "%08lx", x)
23174 +
23175 +#endif /* not BFD64  */
23176 +
23177 +#define HALF_BFD_SIZE_TYPE \
23178 +  (((bfd_size_type) 1) << (8 * sizeof (bfd_size_type) / 2))
23179 +
23180 +#ifndef BFD_HOST_64_BIT
23181 +/* Fall back on a 32 bit type.  The idea is to make these types always
23182 +   available for function return types, but in the case that
23183 +   BFD_HOST_64_BIT is undefined such a function should abort or
23184 +   otherwise signal an error.  */
23185 +typedef bfd_signed_vma bfd_int64_t;
23186 +typedef bfd_vma bfd_uint64_t;
23187 +#endif
23188 +
23189 +/* An offset into a file.  BFD always uses the largest possible offset
23190 +   based on the build time availability of fseek, fseeko, or fseeko64.  */
23191 +typedef BFD_HOST_64_BIT file_ptr;
23192 +typedef unsigned BFD_HOST_64_BIT ufile_ptr;
23193 +
23194 +extern void bfd_sprintf_vma (bfd *, char *, bfd_vma);
23195 +extern void bfd_fprintf_vma (bfd *, void *, bfd_vma);
23196 +
23197 +#define printf_vma(x) fprintf_vma(stdout,x)
23198 +#define bfd_printf_vma(abfd,x) bfd_fprintf_vma (abfd,stdout,x)
23199 +
23200 +typedef unsigned int flagword; /* 32 bits of flags */
23201 +typedef unsigned char bfd_byte;
23202 +\f
23203 +/* File formats.  */
23204 +
23205 +typedef enum bfd_format
23206 +{
23207 +  bfd_unknown = 0,     /* File format is unknown.  */
23208 +  bfd_object,          /* Linker/assembler/compiler output.  */
23209 +  bfd_archive,         /* Object archive file.  */
23210 +  bfd_core,            /* Core dump.  */
23211 +  bfd_type_end         /* Marks the end; don't use it!  */
23212 +}
23213 +bfd_format;
23214 +
23215 +/* Values that may appear in the flags field of a BFD.  These also
23216 +   appear in the object_flags field of the bfd_target structure, where
23217 +   they indicate the set of flags used by that backend (not all flags
23218 +   are meaningful for all object file formats) (FIXME: at the moment,
23219 +   the object_flags values have mostly just been copied from backend
23220 +   to another, and are not necessarily correct).  */
23221 +
23222 +/* No flags.  */
23223 +#define BFD_NO_FLAGS           0x00
23224 +
23225 +/* BFD contains relocation entries.  */
23226 +#define HAS_RELOC      0x01
23227 +
23228 +/* BFD is directly executable.  */
23229 +#define EXEC_P         0x02
23230 +
23231 +/* BFD has line number information (basically used for F_LNNO in a
23232 +   COFF header).  */
23233 +#define HAS_LINENO     0x04
23234 +
23235 +/* BFD has debugging information.  */
23236 +#define HAS_DEBUG      0x08
23237 +
23238 +/* BFD has symbols.  */
23239 +#define HAS_SYMS       0x10
23240 +
23241 +/* BFD has local symbols (basically used for F_LSYMS in a COFF
23242 +   header).  */
23243 +#define HAS_LOCALS     0x20
23244 +
23245 +/* BFD is a dynamic object.  */
23246 +#define DYNAMIC        0x40
23247 +
23248 +/* Text section is write protected (if D_PAGED is not set, this is
23249 +   like an a.out NMAGIC file) (the linker sets this by default, but
23250 +   clears it for -r or -N).  */
23251 +#define WP_TEXT        0x80
23252 +
23253 +/* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
23254 +   linker sets this by default, but clears it for -r or -n or -N).  */
23255 +#define D_PAGED        0x100
23256 +
23257 +/* BFD is relaxable (this means that bfd_relax_section may be able to
23258 +   do something) (sometimes bfd_relax_section can do something even if
23259 +   this is not set).  */
23260 +#define BFD_IS_RELAXABLE 0x200
23261 +
23262 +/* This may be set before writing out a BFD to request using a
23263 +   traditional format.  For example, this is used to request that when
23264 +   writing out an a.out object the symbols not be hashed to eliminate
23265 +   duplicates.  */
23266 +#define BFD_TRADITIONAL_FORMAT 0x400
23267 +
23268 +/* This flag indicates that the BFD contents are actually cached in
23269 +   memory.  If this is set, iostream points to a bfd_in_memory struct.  */
23270 +#define BFD_IN_MEMORY 0x800
23271 +
23272 +/* The sections in this BFD specify a memory page.  */
23273 +#define HAS_LOAD_PAGE 0x1000
23274 +
23275 +/* This BFD has been created by the linker and doesn't correspond
23276 +   to any input file.  */
23277 +#define BFD_LINKER_CREATED 0x2000
23278 +\f
23279 +/* Symbols and relocation.  */
23280 +
23281 +/* A count of carsyms (canonical archive symbols).  */
23282 +typedef unsigned long symindex;
23283 +
23284 +/* How to perform a relocation.  */
23285 +typedef const struct reloc_howto_struct reloc_howto_type;
23286 +
23287 +#define BFD_NO_MORE_SYMBOLS ((symindex) ~0)
23288 +
23289 +/* General purpose part of a symbol X;
23290 +   target specific parts are in libcoff.h, libaout.h, etc.  */
23291 +
23292 +#define bfd_get_section(x) ((x)->section)
23293 +#define bfd_get_output_section(x) ((x)->section->output_section)
23294 +#define bfd_set_section(x,y) ((x)->section) = (y)
23295 +#define bfd_asymbol_base(x) ((x)->section->vma)
23296 +#define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value)
23297 +#define bfd_asymbol_name(x) ((x)->name)
23298 +/*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/
23299 +#define bfd_asymbol_bfd(x) ((x)->the_bfd)
23300 +#define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour)
23301 +
23302 +/* A canonical archive symbol.  */
23303 +/* This is a type pun with struct ranlib on purpose!  */
23304 +typedef struct carsym
23305 +{
23306 +  char *name;
23307 +  file_ptr file_offset;        /* Look here to find the file.  */
23308 +}
23309 +carsym;                        /* To make these you call a carsymogen.  */
23310 +
23311 +/* Used in generating armaps (archive tables of contents).
23312 +   Perhaps just a forward definition would do?  */
23313 +struct orl                     /* Output ranlib.  */
23314 +{
23315 +  char **name;         /* Symbol name.  */
23316 +  union
23317 +  {
23318 +    file_ptr pos;
23319 +    bfd *abfd;
23320 +  } u;                 /* bfd* or file position.  */
23321 +  int namidx;          /* Index into string table.  */
23322 +};
23323 +\f
23324 +/* Linenumber stuff.  */
23325 +typedef struct lineno_cache_entry
23326 +{
23327 +  unsigned int line_number;    /* Linenumber from start of function.  */
23328 +  union
23329 +  {
23330 +    struct bfd_symbol *sym;    /* Function name.  */
23331 +    bfd_vma offset;                    /* Offset into section.  */
23332 +  } u;
23333 +}
23334 +alent;
23335 +\f
23336 +/* Object and core file sections.  */
23337 +
23338 +#define        align_power(addr, align)        \
23339 +  (((addr) + ((bfd_vma) 1 << (align)) - 1) & ((bfd_vma) -1 << (align)))
23340 +
23341 +typedef struct bfd_section *sec_ptr;
23342 +
23343 +#define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0)
23344 +#define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0)
23345 +#define bfd_get_section_lma(bfd, ptr) ((ptr)->lma + 0)
23346 +#define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0)
23347 +#define bfd_section_name(bfd, ptr) ((ptr)->name)
23348 +#define bfd_section_size(bfd, ptr) ((ptr)->size)
23349 +#define bfd_get_section_size(ptr) ((ptr)->size)
23350 +#define bfd_section_vma(bfd, ptr) ((ptr)->vma)
23351 +#define bfd_section_lma(bfd, ptr) ((ptr)->lma)
23352 +#define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)
23353 +#define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0)
23354 +#define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)
23355 +
23356 +#define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
23357 +
23358 +#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = TRUE), TRUE)
23359 +#define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),TRUE)
23360 +#define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),TRUE)
23361 +/* Find the address one past the end of SEC.  */
23362 +#define bfd_get_section_limit(bfd, sec) \
23363 +  (((sec)->rawsize ? (sec)->rawsize : (sec)->size) \
23364 +   / bfd_octets_per_byte (bfd))
23365 +
23366 +typedef struct stat stat_type;
23367 +\f
23368 +typedef enum bfd_print_symbol
23369 +{
23370 +  bfd_print_symbol_name,
23371 +  bfd_print_symbol_more,
23372 +  bfd_print_symbol_all
23373 +} bfd_print_symbol_type;
23374 +
23375 +/* Information about a symbol that nm needs.  */
23376 +
23377 +typedef struct _symbol_info
23378 +{
23379 +  symvalue value;
23380 +  char type;
23381 +  const char *name;            /* Symbol name.  */
23382 +  unsigned char stab_type;     /* Stab type.  */
23383 +  char stab_other;             /* Stab other.  */
23384 +  short stab_desc;             /* Stab desc.  */
23385 +  const char *stab_name;       /* String for stab type.  */
23386 +} symbol_info;
23387 +
23388 +/* Get the name of a stabs type code.  */
23389 +
23390 +extern const char *bfd_get_stab_name (int);
23391 +\f
23392 +/* Hash table routines.  There is no way to free up a hash table.  */
23393 +
23394 +/* An element in the hash table.  Most uses will actually use a larger
23395 +   structure, and an instance of this will be the first field.  */
23396 +
23397 +struct bfd_hash_entry
23398 +{
23399 +  /* Next entry for this hash code.  */
23400 +  struct bfd_hash_entry *next;
23401 +  /* String being hashed.  */
23402 +  const char *string;
23403 +  /* Hash code.  This is the full hash code, not the index into the
23404 +     table.  */
23405 +  unsigned long hash;
23406 +};
23407 +
23408 +/* A hash table.  */
23409 +
23410 +struct bfd_hash_table
23411 +{
23412 +  /* The hash array.  */
23413 +  struct bfd_hash_entry **table;
23414 +  /* The number of slots in the hash table.  */
23415 +  unsigned int size;
23416 +  /* A function used to create new elements in the hash table.  The
23417 +     first entry is itself a pointer to an element.  When this
23418 +     function is first invoked, this pointer will be NULL.  However,
23419 +     having the pointer permits a hierarchy of method functions to be
23420 +     built each of which calls the function in the superclass.  Thus
23421 +     each function should be written to allocate a new block of memory
23422 +     only if the argument is NULL.  */
23423 +  struct bfd_hash_entry *(*newfunc)
23424 +    (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
23425 +   /* An objalloc for this hash table.  This is a struct objalloc *,
23426 +     but we use void * to avoid requiring the inclusion of objalloc.h.  */
23427 +  void *memory;
23428 +};
23429 +
23430 +/* Initialize a hash table.  */
23431 +extern bfd_boolean bfd_hash_table_init
23432 +  (struct bfd_hash_table *,
23433 +   struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
23434 +                              struct bfd_hash_table *,
23435 +                              const char *));
23436 +
23437 +/* Initialize a hash table specifying a size.  */
23438 +extern bfd_boolean bfd_hash_table_init_n
23439 +  (struct bfd_hash_table *,
23440 +   struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
23441 +                              struct bfd_hash_table *,
23442 +                              const char *),
23443 +   unsigned int size);
23444 +
23445 +/* Free up a hash table.  */
23446 +extern void bfd_hash_table_free
23447 +  (struct bfd_hash_table *);
23448 +
23449 +/* Look up a string in a hash table.  If CREATE is TRUE, a new entry
23450 +   will be created for this string if one does not already exist.  The
23451 +   COPY argument must be TRUE if this routine should copy the string
23452 +   into newly allocated memory when adding an entry.  */
23453 +extern struct bfd_hash_entry *bfd_hash_lookup
23454 +  (struct bfd_hash_table *, const char *, bfd_boolean create,
23455 +   bfd_boolean copy);
23456 +
23457 +/* Replace an entry in a hash table.  */
23458 +extern void bfd_hash_replace
23459 +  (struct bfd_hash_table *, struct bfd_hash_entry *old,
23460 +   struct bfd_hash_entry *nw);
23461 +
23462 +/* Base method for creating a hash table entry.  */
23463 +extern struct bfd_hash_entry *bfd_hash_newfunc
23464 +  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
23465 +
23466 +/* Grab some space for a hash table entry.  */
23467 +extern void *bfd_hash_allocate
23468 +  (struct bfd_hash_table *, unsigned int);
23469 +
23470 +/* Traverse a hash table in a random order, calling a function on each
23471 +   element.  If the function returns FALSE, the traversal stops.  The
23472 +   INFO argument is passed to the function.  */
23473 +extern void bfd_hash_traverse
23474 +  (struct bfd_hash_table *,
23475 +   bfd_boolean (*) (struct bfd_hash_entry *, void *),
23476 +   void *info);
23477 +
23478 +/* Allows the default size of a hash table to be configured. New hash
23479 +   tables allocated using bfd_hash_table_init will be created with
23480 +   this size.  */
23481 +extern void bfd_hash_set_default_size (bfd_size_type);
23482 +
23483 +/* This structure is used to keep track of stabs in sections
23484 +   information while linking.  */
23485 +
23486 +struct stab_info
23487 +{
23488 +  /* A hash table used to hold stabs strings.  */
23489 +  struct bfd_strtab_hash *strings;
23490 +  /* The header file hash table.  */
23491 +  struct bfd_hash_table includes;
23492 +  /* The first .stabstr section.  */
23493 +  struct bfd_section *stabstr;
23494 +};
23495 +
23496 +#define COFF_SWAP_TABLE (void *) &bfd_coff_std_swap_table
23497 +
23498 +/* User program access to BFD facilities.  */
23499 +
23500 +/* Direct I/O routines, for programs which know more about the object
23501 +   file than BFD does.  Use higher level routines if possible.  */
23502 +
23503 +extern bfd_size_type bfd_bread (void *, bfd_size_type, bfd *);
23504 +extern bfd_size_type bfd_bwrite (const void *, bfd_size_type, bfd *);
23505 +extern int bfd_seek (bfd *, file_ptr, int);
23506 +extern file_ptr bfd_tell (bfd *);
23507 +extern int bfd_flush (bfd *);
23508 +extern int bfd_stat (bfd *, struct stat *);
23509 +
23510 +/* Deprecated old routines.  */
23511 +#if __GNUC__
23512 +#define bfd_read(BUF, ELTSIZE, NITEMS, ABFD)                           \
23513 +  (warn_deprecated ("bfd_read", __FILE__, __LINE__, __FUNCTION__),     \
23514 +   bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))
23515 +#define bfd_write(BUF, ELTSIZE, NITEMS, ABFD)                          \
23516 +  (warn_deprecated ("bfd_write", __FILE__, __LINE__, __FUNCTION__),    \
23517 +   bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))
23518 +#else
23519 +#define bfd_read(BUF, ELTSIZE, NITEMS, ABFD)                           \
23520 +  (warn_deprecated ("bfd_read", (const char *) 0, 0, (const char *) 0), \
23521 +   bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))
23522 +#define bfd_write(BUF, ELTSIZE, NITEMS, ABFD)                          \
23523 +  (warn_deprecated ("bfd_write", (const char *) 0, 0, (const char *) 0),\
23524 +   bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))
23525 +#endif
23526 +extern void warn_deprecated (const char *, const char *, int, const char *);
23527 +
23528 +/* Cast from const char * to char * so that caller can assign to
23529 +   a char * without a warning.  */
23530 +#define bfd_get_filename(abfd) ((char *) (abfd)->filename)
23531 +#define bfd_get_cacheable(abfd) ((abfd)->cacheable)
23532 +#define bfd_get_format(abfd) ((abfd)->format)
23533 +#define bfd_get_target(abfd) ((abfd)->xvec->name)
23534 +#define bfd_get_flavour(abfd) ((abfd)->xvec->flavour)
23535 +#define bfd_family_coff(abfd) \
23536 +  (bfd_get_flavour (abfd) == bfd_target_coff_flavour || \
23537 +   bfd_get_flavour (abfd) == bfd_target_xcoff_flavour)
23538 +#define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)
23539 +#define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE)
23540 +#define bfd_header_big_endian(abfd) \
23541 +  ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG)
23542 +#define bfd_header_little_endian(abfd) \
23543 +  ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
23544 +#define bfd_get_file_flags(abfd) ((abfd)->flags)
23545 +#define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)
23546 +#define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)
23547 +#define bfd_my_archive(abfd) ((abfd)->my_archive)
23548 +#define bfd_has_map(abfd) ((abfd)->has_armap)
23549 +
23550 +#define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)
23551 +#define bfd_usrdata(abfd) ((abfd)->usrdata)
23552 +
23553 +#define bfd_get_start_address(abfd) ((abfd)->start_address)
23554 +#define bfd_get_symcount(abfd) ((abfd)->symcount)
23555 +#define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)
23556 +#define bfd_count_sections(abfd) ((abfd)->section_count)
23557 +
23558 +#define bfd_get_dynamic_symcount(abfd) ((abfd)->dynsymcount)
23559 +
23560 +#define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char)
23561 +
23562 +#define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = bool), TRUE)
23563 +
23564 +extern bfd_boolean bfd_cache_close
23565 +  (bfd *abfd);
23566 +/* NB: This declaration should match the autogenerated one in libbfd.h.  */
23567 +
23568 +extern bfd_boolean bfd_cache_close_all (void);
23569 +
23570 +extern bfd_boolean bfd_record_phdr
23571 +  (bfd *, unsigned long, bfd_boolean, flagword, bfd_boolean, bfd_vma,
23572 +   bfd_boolean, bfd_boolean, unsigned int, struct bfd_section **);
23573 +
23574 +/* Byte swapping routines.  */
23575 +
23576 +bfd_uint64_t bfd_getb64 (const void *);
23577 +bfd_uint64_t bfd_getl64 (const void *);
23578 +bfd_int64_t bfd_getb_signed_64 (const void *);
23579 +bfd_int64_t bfd_getl_signed_64 (const void *);
23580 +bfd_vma bfd_getb32 (const void *);
23581 +bfd_vma bfd_getl32 (const void *);
23582 +bfd_signed_vma bfd_getb_signed_32 (const void *);
23583 +bfd_signed_vma bfd_getl_signed_32 (const void *);
23584 +bfd_vma bfd_getb16 (const void *);
23585 +bfd_vma bfd_getl16 (const void *);
23586 +bfd_signed_vma bfd_getb_signed_16 (const void *);
23587 +bfd_signed_vma bfd_getl_signed_16 (const void *);
23588 +void bfd_putb64 (bfd_uint64_t, void *);
23589 +void bfd_putl64 (bfd_uint64_t, void *);
23590 +void bfd_putb32 (bfd_vma, void *);
23591 +void bfd_putl32 (bfd_vma, void *);
23592 +void bfd_putb16 (bfd_vma, void *);
23593 +void bfd_putl16 (bfd_vma, void *);
23594 +
23595 +/* Byte swapping routines which take size and endiannes as arguments.  */
23596 +
23597 +bfd_uint64_t bfd_get_bits (const void *, int, bfd_boolean);
23598 +void bfd_put_bits (bfd_uint64_t, void *, int, bfd_boolean);
23599 +
23600 +extern bfd_boolean bfd_section_already_linked_table_init (void);
23601 +extern void bfd_section_already_linked_table_free (void);
23602 +\f
23603 +/* Externally visible ECOFF routines.  */
23604 +
23605 +#if defined(__STDC__) || defined(ALMOST_STDC)
23606 +struct ecoff_debug_info;
23607 +struct ecoff_debug_swap;
23608 +struct ecoff_extr;
23609 +struct bfd_symbol;
23610 +struct bfd_link_info;
23611 +struct bfd_link_hash_entry;
23612 +struct bfd_elf_version_tree;
23613 +#endif
23614 +extern bfd_vma bfd_ecoff_get_gp_value
23615 +  (bfd * abfd);
23616 +extern bfd_boolean bfd_ecoff_set_gp_value
23617 +  (bfd *abfd, bfd_vma gp_value);
23618 +extern bfd_boolean bfd_ecoff_set_regmasks
23619 +  (bfd *abfd, unsigned long gprmask, unsigned long fprmask,
23620 +   unsigned long *cprmask);
23621 +extern void *bfd_ecoff_debug_init
23622 +  (bfd *output_bfd, struct ecoff_debug_info *output_debug,
23623 +   const struct ecoff_debug_swap *output_swap, struct bfd_link_info *);
23624 +extern void bfd_ecoff_debug_free
23625 +  (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
23626 +   const struct ecoff_debug_swap *output_swap, struct bfd_link_info *);
23627 +extern bfd_boolean bfd_ecoff_debug_accumulate
23628 +  (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
23629 +   const struct ecoff_debug_swap *output_swap, bfd *input_bfd,
23630 +   struct ecoff_debug_info *input_debug,
23631 +   const struct ecoff_debug_swap *input_swap, struct bfd_link_info *);
23632 +extern bfd_boolean bfd_ecoff_debug_accumulate_other
23633 +  (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
23634 +   const struct ecoff_debug_swap *output_swap, bfd *input_bfd,
23635 +   struct bfd_link_info *);
23636 +extern bfd_boolean bfd_ecoff_debug_externals
23637 +  (bfd *abfd, struct ecoff_debug_info *debug,
23638 +   const struct ecoff_debug_swap *swap, bfd_boolean relocatable,
23639 +   bfd_boolean (*get_extr) (struct bfd_symbol *, struct ecoff_extr *),
23640 +   void (*set_index) (struct bfd_symbol *, bfd_size_type));
23641 +extern bfd_boolean bfd_ecoff_debug_one_external
23642 +  (bfd *abfd, struct ecoff_debug_info *debug,
23643 +   const struct ecoff_debug_swap *swap, const char *name,
23644 +   struct ecoff_extr *esym);
23645 +extern bfd_size_type bfd_ecoff_debug_size
23646 +  (bfd *abfd, struct ecoff_debug_info *debug,
23647 +   const struct ecoff_debug_swap *swap);
23648 +extern bfd_boolean bfd_ecoff_write_debug
23649 +  (bfd *abfd, struct ecoff_debug_info *debug,
23650 +   const struct ecoff_debug_swap *swap, file_ptr where);
23651 +extern bfd_boolean bfd_ecoff_write_accumulated_debug
23652 +  (void *handle, bfd *abfd, struct ecoff_debug_info *debug,
23653 +   const struct ecoff_debug_swap *swap,
23654 +   struct bfd_link_info *info, file_ptr where);
23655 +
23656 +/* Externally visible ELF routines.  */
23657 +
23658 +struct bfd_link_needed_list
23659 +{
23660 +  struct bfd_link_needed_list *next;
23661 +  bfd *by;
23662 +  const char *name;
23663 +};
23664 +
23665 +enum dynamic_lib_link_class {
23666 +  DYN_NORMAL = 0,
23667 +  DYN_AS_NEEDED = 1,
23668 +  DYN_DT_NEEDED = 2,
23669 +  DYN_NO_ADD_NEEDED = 4,
23670 +  DYN_NO_NEEDED = 8
23671 +};
23672 +
23673 +extern bfd_boolean bfd_elf_record_link_assignment
23674 +  (struct bfd_link_info *, const char *, bfd_boolean);
23675 +extern struct bfd_link_needed_list *bfd_elf_get_needed_list
23676 +  (bfd *, struct bfd_link_info *);
23677 +extern bfd_boolean bfd_elf_get_bfd_needed_list
23678 +  (bfd *, struct bfd_link_needed_list **);
23679 +extern bfd_boolean bfd_elf_size_dynamic_sections
23680 +  (bfd *, const char *, const char *, const char *, const char * const *,
23681 +   struct bfd_link_info *, struct bfd_section **,
23682 +   struct bfd_elf_version_tree *);
23683 +extern bfd_boolean bfd_elf_size_dynsym_hash_dynstr
23684 +  (bfd *, struct bfd_link_info *);
23685 +extern void bfd_elf_set_dt_needed_name
23686 +  (bfd *, const char *);
23687 +extern const char *bfd_elf_get_dt_soname
23688 +  (bfd *);
23689 +extern void bfd_elf_set_dyn_lib_class
23690 +  (bfd *, int);
23691 +extern int bfd_elf_get_dyn_lib_class
23692 +  (bfd *);
23693 +extern struct bfd_link_needed_list *bfd_elf_get_runpath_list
23694 +  (bfd *, struct bfd_link_info *);
23695 +extern bfd_boolean bfd_elf_discard_info
23696 +  (bfd *, struct bfd_link_info *);
23697 +extern unsigned int _bfd_elf_default_action_discarded
23698 +  (struct bfd_section *);
23699 +
23700 +/* Return an upper bound on the number of bytes required to store a
23701 +   copy of ABFD's program header table entries.  Return -1 if an error
23702 +   occurs; bfd_get_error will return an appropriate code.  */
23703 +extern long bfd_get_elf_phdr_upper_bound
23704 +  (bfd *abfd);
23705 +
23706 +/* Copy ABFD's program header table entries to *PHDRS.  The entries
23707 +   will be stored as an array of Elf_Internal_Phdr structures, as
23708 +   defined in include/elf/internal.h.  To find out how large the
23709 +   buffer needs to be, call bfd_get_elf_phdr_upper_bound.
23710 +
23711 +   Return the number of program header table entries read, or -1 if an
23712 +   error occurs; bfd_get_error will return an appropriate code.  */
23713 +extern int bfd_get_elf_phdrs
23714 +  (bfd *abfd, void *phdrs);
23715 +
23716 +/* Create a new BFD as if by bfd_openr.  Rather than opening a file,
23717 +   reconstruct an ELF file by reading the segments out of remote memory
23718 +   based on the ELF file header at EHDR_VMA and the ELF program headers it
23719 +   points to.  If not null, *LOADBASEP is filled in with the difference
23720 +   between the VMAs from which the segments were read, and the VMAs the
23721 +   file headers (and hence BFD's idea of each section's VMA) put them at.
23722 +
23723 +   The function TARGET_READ_MEMORY is called to copy LEN bytes from the
23724 +   remote memory at target address VMA into the local buffer at MYADDR; it
23725 +   should return zero on success or an `errno' code on failure.  TEMPL must
23726 +   be a BFD for an ELF target with the word size and byte order found in
23727 +   the remote memory.  */
23728 +extern bfd *bfd_elf_bfd_from_remote_memory
23729 +  (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
23730 +   int (*target_read_memory) (bfd_vma vma, bfd_byte *myaddr, int len));
23731 +
23732 +/* Return the arch_size field of an elf bfd, or -1 if not elf.  */
23733 +extern int bfd_get_arch_size
23734 +  (bfd *);
23735 +
23736 +/* Return TRUE if address "naturally" sign extends, or -1 if not elf.  */
23737 +extern int bfd_get_sign_extend_vma
23738 +  (bfd *);
23739 +
23740 +extern struct bfd_section *_bfd_elf_tls_setup
23741 +  (bfd *, struct bfd_link_info *);
23742 +
23743 +extern void _bfd_elf_provide_symbol
23744 +  (struct bfd_link_info *, const char *, bfd_vma, struct bfd_section *);
23745 +
23746 +extern void _bfd_elf_provide_section_bound_symbols
23747 +  (struct bfd_link_info *, struct bfd_section *, const char *, const char *);
23748 +
23749 +extern void _bfd_elf_fix_excluded_sec_syms
23750 +  (bfd *, struct bfd_link_info *);
23751 +
23752 +extern bfd_boolean bfd_m68k_elf32_create_embedded_relocs
23753 +  (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *,
23754 +   char **);
23755 +
23756 +/* SunOS shared library support routines for the linker.  */
23757 +
23758 +extern struct bfd_link_needed_list *bfd_sunos_get_needed_list
23759 +  (bfd *, struct bfd_link_info *);
23760 +extern bfd_boolean bfd_sunos_record_link_assignment
23761 +  (bfd *, struct bfd_link_info *, const char *);
23762 +extern bfd_boolean bfd_sunos_size_dynamic_sections
23763 +  (bfd *, struct bfd_link_info *, struct bfd_section **,
23764 +   struct bfd_section **, struct bfd_section **);
23765 +
23766 +/* Linux shared library support routines for the linker.  */
23767 +
23768 +extern bfd_boolean bfd_i386linux_size_dynamic_sections
23769 +  (bfd *, struct bfd_link_info *);
23770 +extern bfd_boolean bfd_m68klinux_size_dynamic_sections
23771 +  (bfd *, struct bfd_link_info *);
23772 +extern bfd_boolean bfd_sparclinux_size_dynamic_sections
23773 +  (bfd *, struct bfd_link_info *);
23774 +
23775 +/* mmap hacks */
23776 +
23777 +struct _bfd_window_internal;
23778 +typedef struct _bfd_window_internal bfd_window_internal;
23779 +
23780 +typedef struct _bfd_window
23781 +{
23782 +  /* What the user asked for.  */
23783 +  void *data;
23784 +  bfd_size_type size;
23785 +  /* The actual window used by BFD.  Small user-requested read-only
23786 +     regions sharing a page may share a single window into the object
23787 +     file.  Read-write versions shouldn't until I've fixed things to
23788 +     keep track of which portions have been claimed by the
23789 +     application; don't want to give the same region back when the
23790 +     application wants two writable copies!  */
23791 +  struct _bfd_window_internal *i;
23792 +}
23793 +bfd_window;
23794 +
23795 +extern void bfd_init_window
23796 +  (bfd_window *);
23797 +extern void bfd_free_window
23798 +  (bfd_window *);
23799 +extern bfd_boolean bfd_get_file_window
23800 +  (bfd *, file_ptr, bfd_size_type, bfd_window *, bfd_boolean);
23801 +
23802 +/* XCOFF support routines for the linker.  */
23803 +
23804 +extern bfd_boolean bfd_xcoff_link_record_set
23805 +  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_size_type);
23806 +extern bfd_boolean bfd_xcoff_import_symbol
23807 +  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_vma,
23808 +   const char *, const char *, const char *, unsigned int);
23809 +extern bfd_boolean bfd_xcoff_export_symbol
23810 +  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *);
23811 +extern bfd_boolean bfd_xcoff_link_count_reloc
23812 +  (bfd *, struct bfd_link_info *, const char *);
23813 +extern bfd_boolean bfd_xcoff_record_link_assignment
23814 +  (bfd *, struct bfd_link_info *, const char *);
23815 +extern bfd_boolean bfd_xcoff_size_dynamic_sections
23816 +  (bfd *, struct bfd_link_info *, const char *, const char *,
23817 +   unsigned long, unsigned long, unsigned long, bfd_boolean,
23818 +   int, bfd_boolean, bfd_boolean, struct bfd_section **, bfd_boolean);
23819 +extern bfd_boolean bfd_xcoff_link_generate_rtinit
23820 +  (bfd *, const char *, const char *, bfd_boolean);
23821 +
23822 +/* XCOFF support routines for ar.  */
23823 +extern bfd_boolean bfd_xcoff_ar_archive_set_magic
23824 +  (bfd *, char *);
23825 +
23826 +/* Externally visible COFF routines.  */
23827 +
23828 +#if defined(__STDC__) || defined(ALMOST_STDC)
23829 +struct internal_syment;
23830 +union internal_auxent;
23831 +#endif
23832 +
23833 +extern bfd_boolean bfd_coff_get_syment
23834 +  (bfd *, struct bfd_symbol *, struct internal_syment *);
23835 +
23836 +extern bfd_boolean bfd_coff_get_auxent
23837 +  (bfd *, struct bfd_symbol *, int, union internal_auxent *);
23838 +
23839 +extern bfd_boolean bfd_coff_set_symbol_class
23840 +  (bfd *, struct bfd_symbol *, unsigned int);
23841 +
23842 +extern bfd_boolean bfd_m68k_coff_create_embedded_relocs
23843 +  (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, char **);
23844 +
23845 +/* ARM Interworking support.  Called from linker.  */
23846 +extern bfd_boolean bfd_arm_allocate_interworking_sections
23847 +  (struct bfd_link_info *);
23848 +
23849 +extern bfd_boolean bfd_arm_process_before_allocation
23850 +  (bfd *, struct bfd_link_info *, int);
23851 +
23852 +extern bfd_boolean bfd_arm_get_bfd_for_interworking
23853 +  (bfd *, struct bfd_link_info *);
23854 +
23855 +/* PE ARM Interworking support.  Called from linker.  */
23856 +extern bfd_boolean bfd_arm_pe_allocate_interworking_sections
23857 +  (struct bfd_link_info *);
23858 +
23859 +extern bfd_boolean bfd_arm_pe_process_before_allocation
23860 +  (bfd *, struct bfd_link_info *, int);
23861 +
23862 +extern bfd_boolean bfd_arm_pe_get_bfd_for_interworking
23863 +  (bfd *, struct bfd_link_info *);
23864 +
23865 +/* ELF ARM Interworking support.  Called from linker.  */
23866 +extern bfd_boolean bfd_elf32_arm_allocate_interworking_sections
23867 +  (struct bfd_link_info *);
23868 +
23869 +extern bfd_boolean bfd_elf32_arm_process_before_allocation
23870 +  (bfd *, struct bfd_link_info *, int);
23871 +
23872 +void bfd_elf32_arm_set_target_relocs
23873 +  (struct bfd_link_info *, int, char *, int, int);
23874 +
23875 +extern bfd_boolean bfd_elf32_arm_get_bfd_for_interworking
23876 +  (bfd *, struct bfd_link_info *);
23877 +
23878 +extern bfd_boolean bfd_elf32_arm_add_glue_sections_to_bfd
23879 +  (bfd *, struct bfd_link_info *);
23880 +
23881 +/* ELF ARM mapping symbol support */
23882 +extern bfd_boolean bfd_is_arm_mapping_symbol_name
23883 +  (const char * name);
23884 +
23885 +/* ARM Note section processing.  */
23886 +extern bfd_boolean bfd_arm_merge_machines
23887 +  (bfd *, bfd *);
23888 +
23889 +extern bfd_boolean bfd_arm_update_notes
23890 +  (bfd *, const char *);
23891 +
23892 +extern unsigned int bfd_arm_get_mach_from_notes
23893 +  (bfd *, const char *);
23894 +
23895 +/* TI COFF load page support.  */
23896 +extern void bfd_ticoff_set_section_load_page
23897 +  (struct bfd_section *, int);
23898 +
23899 +extern int bfd_ticoff_get_section_load_page
23900 +  (struct bfd_section *);
23901 +
23902 +/* H8/300 functions.  */
23903 +extern bfd_vma bfd_h8300_pad_address
23904 +  (bfd *, bfd_vma);
23905 +
23906 +/* IA64 Itanium code generation.  Called from linker.  */
23907 +extern void bfd_elf32_ia64_after_parse
23908 +  (int);
23909 +
23910 +extern void bfd_elf64_ia64_after_parse
23911 +  (int);
23912 +
23913 +/* This structure is used for a comdat section, as in PE.  A comdat
23914 +   section is associated with a particular symbol.  When the linker
23915 +   sees a comdat section, it keeps only one of the sections with a
23916 +   given name and associated with a given symbol.  */
23917 +
23918 +struct coff_comdat_info
23919 +{
23920 +  /* The name of the symbol associated with a comdat section.  */
23921 +  const char *name;
23922 +
23923 +  /* The local symbol table index of the symbol associated with a
23924 +     comdat section.  This is only meaningful to the object file format
23925 +     specific code; it is not an index into the list returned by
23926 +     bfd_canonicalize_symtab.  */
23927 +  long symbol;
23928 +};
23929 +
23930 +extern struct coff_comdat_info *bfd_coff_get_comdat_section
23931 +  (bfd *, struct bfd_section *);
23932 +
23933 +/* Extracted from init.c.  */
23934 +void bfd_init (void);
23935 +
23936 +/* Extracted from opncls.c.  */
23937 +bfd *bfd_fopen (const char *filename, const char *target,
23938 +    const char *mode, int fd);
23939 +
23940 +bfd *bfd_openr (const char *filename, const char *target);
23941 +
23942 +bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
23943 +
23944 +bfd *bfd_openstreamr (const char *, const char *, void *);
23945 +
23946 +bfd *bfd_openr_iovec (const char *filename, const char *target,
23947 +    void *(*open) (struct bfd *nbfd,
23948 +    void *open_closure),
23949 +    void *open_closure,
23950 +    file_ptr (*pread) (struct bfd *nbfd,
23951 +    void *stream,
23952 +    void *buf,
23953 +    file_ptr nbytes,
23954 +    file_ptr offset),
23955 +    int (*close) (struct bfd *nbfd,
23956 +    void *stream));
23957 +
23958 +bfd *bfd_openw (const char *filename, const char *target);
23959 +
23960 +bfd_boolean bfd_close (bfd *abfd);
23961 +
23962 +bfd_boolean bfd_close_all_done (bfd *);
23963 +
23964 +bfd *bfd_create (const char *filename, bfd *templ);
23965 +
23966 +bfd_boolean bfd_make_writable (bfd *abfd);
23967 +
23968 +bfd_boolean bfd_make_readable (bfd *abfd);
23969 +
23970 +unsigned long bfd_calc_gnu_debuglink_crc32
23971 +   (unsigned long crc, const unsigned char *buf, bfd_size_type len);
23972 +
23973 +char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
23974 +
23975 +struct bfd_section *bfd_create_gnu_debuglink_section
23976 +   (bfd *abfd, const char *filename);
23977 +
23978 +bfd_boolean bfd_fill_in_gnu_debuglink_section
23979 +   (bfd *abfd, struct bfd_section *sect, const char *filename);
23980 +
23981 +/* Extracted from libbfd.c.  */
23982 +
23983 +/* Byte swapping macros for user section data.  */
23984 +
23985 +#define bfd_put_8(abfd, val, ptr) \
23986 +  ((void) (*((unsigned char *) (ptr)) = (val) & 0xff))
23987 +#define bfd_put_signed_8 \
23988 +  bfd_put_8
23989 +#define bfd_get_8(abfd, ptr) \
23990 +  (*(unsigned char *) (ptr) & 0xff)
23991 +#define bfd_get_signed_8(abfd, ptr) \
23992 +  (((*(unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)
23993 +
23994 +#define bfd_put_16(abfd, val, ptr) \
23995 +  BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
23996 +#define bfd_put_signed_16 \
23997 +  bfd_put_16
23998 +#define bfd_get_16(abfd, ptr) \
23999 +  BFD_SEND (abfd, bfd_getx16, (ptr))
24000 +#define bfd_get_signed_16(abfd, ptr) \
24001 +  BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
24002 +
24003 +#define bfd_put_32(abfd, val, ptr) \
24004 +  BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))
24005 +#define bfd_put_signed_32 \
24006 +  bfd_put_32
24007 +#define bfd_get_32(abfd, ptr) \
24008 +  BFD_SEND (abfd, bfd_getx32, (ptr))
24009 +#define bfd_get_signed_32(abfd, ptr) \
24010 +  BFD_SEND (abfd, bfd_getx_signed_32, (ptr))
24011 +
24012 +#define bfd_put_64(abfd, val, ptr) \
24013 +  BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))
24014 +#define bfd_put_signed_64 \
24015 +  bfd_put_64
24016 +#define bfd_get_64(abfd, ptr) \
24017 +  BFD_SEND (abfd, bfd_getx64, (ptr))
24018 +#define bfd_get_signed_64(abfd, ptr) \
24019 +  BFD_SEND (abfd, bfd_getx_signed_64, (ptr))
24020 +
24021 +#define bfd_get(bits, abfd, ptr)                       \
24022 +  ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr)       \
24023 +   : (bits) == 16 ? bfd_get_16 (abfd, ptr)             \
24024 +   : (bits) == 32 ? bfd_get_32 (abfd, ptr)             \
24025 +   : (bits) == 64 ? bfd_get_64 (abfd, ptr)             \
24026 +   : (abort (), (bfd_vma) - 1))
24027 +
24028 +#define bfd_put(bits, abfd, val, ptr)                  \
24029 +  ((bits) == 8 ? bfd_put_8  (abfd, val, ptr)           \
24030 +   : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)                \
24031 +   : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)                \
24032 +   : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)                \
24033 +   : (abort (), (void) 0))
24034 +
24035 +
24036 +/* Byte swapping macros for file header data.  */
24037 +
24038 +#define bfd_h_put_8(abfd, val, ptr) \
24039 +  bfd_put_8 (abfd, val, ptr)
24040 +#define bfd_h_put_signed_8(abfd, val, ptr) \
24041 +  bfd_put_8 (abfd, val, ptr)
24042 +#define bfd_h_get_8(abfd, ptr) \
24043 +  bfd_get_8 (abfd, ptr)
24044 +#define bfd_h_get_signed_8(abfd, ptr) \
24045 +  bfd_get_signed_8 (abfd, ptr)
24046 +
24047 +#define bfd_h_put_16(abfd, val, ptr) \
24048 +  BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
24049 +#define bfd_h_put_signed_16 \
24050 +  bfd_h_put_16
24051 +#define bfd_h_get_16(abfd, ptr) \
24052 +  BFD_SEND (abfd, bfd_h_getx16, (ptr))
24053 +#define bfd_h_get_signed_16(abfd, ptr) \
24054 +  BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
24055 +
24056 +#define bfd_h_put_32(abfd, val, ptr) \
24057 +  BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
24058 +#define bfd_h_put_signed_32 \
24059 +  bfd_h_put_32
24060 +#define bfd_h_get_32(abfd, ptr) \
24061 +  BFD_SEND (abfd, bfd_h_getx32, (ptr))
24062 +#define bfd_h_get_signed_32(abfd, ptr) \
24063 +  BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
24064 +
24065 +#define bfd_h_put_64(abfd, val, ptr) \
24066 +  BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
24067 +#define bfd_h_put_signed_64 \
24068 +  bfd_h_put_64
24069 +#define bfd_h_get_64(abfd, ptr) \
24070 +  BFD_SEND (abfd, bfd_h_getx64, (ptr))
24071 +#define bfd_h_get_signed_64(abfd, ptr) \
24072 +  BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
24073 +
24074 +/* Aliases for the above, which should eventually go away.  */
24075 +
24076 +#define H_PUT_64  bfd_h_put_64
24077 +#define H_PUT_32  bfd_h_put_32
24078 +#define H_PUT_16  bfd_h_put_16
24079 +#define H_PUT_8   bfd_h_put_8
24080 +#define H_PUT_S64 bfd_h_put_signed_64
24081 +#define H_PUT_S32 bfd_h_put_signed_32
24082 +#define H_PUT_S16 bfd_h_put_signed_16
24083 +#define H_PUT_S8  bfd_h_put_signed_8
24084 +#define H_GET_64  bfd_h_get_64
24085 +#define H_GET_32  bfd_h_get_32
24086 +#define H_GET_16  bfd_h_get_16
24087 +#define H_GET_8   bfd_h_get_8
24088 +#define H_GET_S64 bfd_h_get_signed_64
24089 +#define H_GET_S32 bfd_h_get_signed_32
24090 +#define H_GET_S16 bfd_h_get_signed_16
24091 +#define H_GET_S8  bfd_h_get_signed_8
24092 +
24093 +
24094 +/* Extracted from bfdio.c.  */
24095 +long bfd_get_mtime (bfd *abfd);
24096 +
24097 +long bfd_get_size (bfd *abfd);
24098 +
24099 +/* Extracted from bfdwin.c.  */
24100 +/* Extracted from section.c.  */
24101 +typedef struct bfd_section
24102 +{
24103 +  /* The name of the section; the name isn't a copy, the pointer is
24104 +     the same as that passed to bfd_make_section.  */
24105 +  const char *name;
24106 +
24107 +  /* A unique sequence number.  */
24108 +  int id;
24109 +
24110 +  /* Which section in the bfd; 0..n-1 as sections are created in a bfd.  */
24111 +  int index;
24112 +
24113 +  /* The next section in the list belonging to the BFD, or NULL.  */
24114 +  struct bfd_section *next;
24115 +
24116 +  /* The previous section in the list belonging to the BFD, or NULL.  */
24117 +  struct bfd_section *prev;
24118 +
24119 +  /* The field flags contains attributes of the section. Some
24120 +     flags are read in from the object file, and some are
24121 +     synthesized from other information.  */
24122 +  flagword flags;
24123 +
24124 +#define SEC_NO_FLAGS   0x000
24125 +
24126 +  /* Tells the OS to allocate space for this section when loading.
24127 +     This is clear for a section containing debug information only.  */
24128 +#define SEC_ALLOC      0x001
24129 +
24130 +  /* Tells the OS to load the section from the file when loading.
24131 +     This is clear for a .bss section.  */
24132 +#define SEC_LOAD       0x002
24133 +
24134 +  /* The section contains data still to be relocated, so there is
24135 +     some relocation information too.  */
24136 +#define SEC_RELOC      0x004
24137 +
24138 +  /* A signal to the OS that the section contains read only data.  */
24139 +#define SEC_READONLY   0x008
24140 +
24141 +  /* The section contains code only.  */
24142 +#define SEC_CODE       0x010
24143 +
24144 +  /* The section contains data only.  */
24145 +#define SEC_DATA       0x020
24146 +
24147 +  /* The section will reside in ROM.  */
24148 +#define SEC_ROM        0x040
24149 +
24150 +  /* The section contains constructor information. This section
24151 +     type is used by the linker to create lists of constructors and
24152 +     destructors used by <<g++>>. When a back end sees a symbol
24153 +     which should be used in a constructor list, it creates a new
24154 +     section for the type of name (e.g., <<__CTOR_LIST__>>), attaches
24155 +     the symbol to it, and builds a relocation. To build the lists
24156 +     of constructors, all the linker has to do is catenate all the
24157 +     sections called <<__CTOR_LIST__>> and relocate the data
24158 +     contained within - exactly the operations it would peform on
24159 +     standard data.  */
24160 +#define SEC_CONSTRUCTOR 0x080
24161 +
24162 +  /* The section has contents - a data section could be
24163 +     <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>; a debug section could be
24164 +     <<SEC_HAS_CONTENTS>>  */
24165 +#define SEC_HAS_CONTENTS 0x100
24166 +
24167 +  /* An instruction to the linker to not output the section
24168 +     even if it has information which would normally be written.  */
24169 +#define SEC_NEVER_LOAD 0x200
24170 +
24171 +  /* The section contains thread local data.  */
24172 +#define SEC_THREAD_LOCAL 0x400
24173 +
24174 +  /* The section has GOT references.  This flag is only for the
24175 +     linker, and is currently only used by the elf32-hppa back end.
24176 +     It will be set if global offset table references were detected
24177 +     in this section, which indicate to the linker that the section
24178 +     contains PIC code, and must be handled specially when doing a
24179 +     static link.  */
24180 +#define SEC_HAS_GOT_REF 0x800
24181 +
24182 +  /* The section contains common symbols (symbols may be defined
24183 +     multiple times, the value of a symbol is the amount of
24184 +     space it requires, and the largest symbol value is the one
24185 +     used).  Most targets have exactly one of these (which we
24186 +     translate to bfd_com_section_ptr), but ECOFF has two.  */
24187 +#define SEC_IS_COMMON 0x1000
24188 +
24189 +  /* The section contains only debugging information.  For
24190 +     example, this is set for ELF .debug and .stab sections.
24191 +     strip tests this flag to see if a section can be
24192 +     discarded.  */
24193 +#define SEC_DEBUGGING 0x2000
24194 +
24195 +  /* The contents of this section are held in memory pointed to
24196 +     by the contents field.  This is checked by bfd_get_section_contents,
24197 +     and the data is retrieved from memory if appropriate.  */
24198 +#define SEC_IN_MEMORY 0x4000
24199 +
24200 +  /* The contents of this section are to be excluded by the
24201 +     linker for executable and shared objects unless those
24202 +     objects are to be further relocated.  */
24203 +#define SEC_EXCLUDE 0x8000
24204 +
24205 +  /* The contents of this section are to be sorted based on the sum of
24206 +     the symbol and addend values specified by the associated relocation
24207 +     entries.  Entries without associated relocation entries will be
24208 +     appended to the end of the section in an unspecified order.  */
24209 +#define SEC_SORT_ENTRIES 0x10000
24210 +
24211 +  /* When linking, duplicate sections of the same name should be
24212 +     discarded, rather than being combined into a single section as
24213 +     is usually done.  This is similar to how common symbols are
24214 +     handled.  See SEC_LINK_DUPLICATES below.  */
24215 +#define SEC_LINK_ONCE 0x20000
24216 +
24217 +  /* If SEC_LINK_ONCE is set, this bitfield describes how the linker
24218 +     should handle duplicate sections.  */
24219 +#define SEC_LINK_DUPLICATES 0x40000
24220 +
24221 +  /* This value for SEC_LINK_DUPLICATES means that duplicate
24222 +     sections with the same name should simply be discarded.  */
24223 +#define SEC_LINK_DUPLICATES_DISCARD 0x0
24224 +
24225 +  /* This value for SEC_LINK_DUPLICATES means that the linker
24226 +     should warn if there are any duplicate sections, although
24227 +     it should still only link one copy.  */
24228 +#define SEC_LINK_DUPLICATES_ONE_ONLY 0x80000
24229 +
24230 +  /* This value for SEC_LINK_DUPLICATES means that the linker
24231 +     should warn if any duplicate sections are a different size.  */
24232 +#define SEC_LINK_DUPLICATES_SAME_SIZE 0x100000
24233 +
24234 +  /* This value for SEC_LINK_DUPLICATES means that the linker
24235 +     should warn if any duplicate sections contain different
24236 +     contents.  */
24237 +#define SEC_LINK_DUPLICATES_SAME_CONTENTS \
24238 +  (SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE)
24239 +
24240 +  /* This section was created by the linker as part of dynamic
24241 +     relocation or other arcane processing.  It is skipped when
24242 +     going through the first-pass output, trusting that someone
24243 +     else up the line will take care of it later.  */
24244 +#define SEC_LINKER_CREATED 0x200000
24245 +
24246 +  /* This section should not be subject to garbage collection.  */
24247 +#define SEC_KEEP 0x400000
24248 +
24249 +  /* This section contains "short" data, and should be placed
24250 +     "near" the GP.  */
24251 +#define SEC_SMALL_DATA 0x800000
24252 +
24253 +  /* Attempt to merge identical entities in the section.
24254 +     Entity size is given in the entsize field.  */
24255 +#define SEC_MERGE 0x1000000
24256 +
24257 +  /* If given with SEC_MERGE, entities to merge are zero terminated
24258 +     strings where entsize specifies character size instead of fixed
24259 +     size entries.  */
24260 +#define SEC_STRINGS 0x2000000
24261 +
24262 +  /* This section contains data about section groups.  */
24263 +#define SEC_GROUP 0x4000000
24264 +
24265 +  /* The section is a COFF shared library section.  This flag is
24266 +     only for the linker.  If this type of section appears in
24267 +     the input file, the linker must copy it to the output file
24268 +     without changing the vma or size.  FIXME: Although this
24269 +     was originally intended to be general, it really is COFF
24270 +     specific (and the flag was renamed to indicate this).  It
24271 +     might be cleaner to have some more general mechanism to
24272 +     allow the back end to control what the linker does with
24273 +     sections.  */
24274 +#define SEC_COFF_SHARED_LIBRARY 0x10000000
24275 +
24276 +  /* This section contains data which may be shared with other
24277 +     executables or shared objects. This is for COFF only.  */
24278 +#define SEC_COFF_SHARED 0x20000000
24279 +
24280 +  /* When a section with this flag is being linked, then if the size of
24281 +     the input section is less than a page, it should not cross a page
24282 +     boundary.  If the size of the input section is one page or more,
24283 +     it should be aligned on a page boundary.  This is for TI
24284 +     TMS320C54X only.  */
24285 +#define SEC_TIC54X_BLOCK 0x40000000
24286 +
24287 +  /* Conditionally link this section; do not link if there are no
24288 +     references found to any symbol in the section.  This is for TI
24289 +     TMS320C54X only.  */
24290 +#define SEC_TIC54X_CLINK 0x80000000
24291 +
24292 +  /*  End of section flags.  */
24293 +
24294 +  /* Some internal packed boolean fields.  */
24295 +
24296 +  /* See the vma field.  */
24297 +  unsigned int user_set_vma : 1;
24298 +
24299 +  /* A mark flag used by some of the linker backends.  */
24300 +  unsigned int linker_mark : 1;
24301 +
24302 +  /* Another mark flag used by some of the linker backends.  Set for
24303 +     output sections that have an input section.  */
24304 +  unsigned int linker_has_input : 1;
24305 +
24306 +  /* Mark flags used by some linker backends for garbage collection.  */
24307 +  unsigned int gc_mark : 1;
24308 +  unsigned int gc_mark_from_eh : 1;
24309 +
24310 +  /* The following flags are used by the ELF linker. */
24311 +
24312 +  /* Mark sections which have been allocated to segments.  */
24313 +  unsigned int segment_mark : 1;
24314 +
24315 +  /* Type of sec_info information.  */
24316 +  unsigned int sec_info_type:3;
24317 +#define ELF_INFO_TYPE_NONE      0
24318 +#define ELF_INFO_TYPE_STABS     1
24319 +#define ELF_INFO_TYPE_MERGE     2
24320 +#define ELF_INFO_TYPE_EH_FRAME  3
24321 +#define ELF_INFO_TYPE_JUST_SYMS 4
24322 +
24323 +  /* Nonzero if this section uses RELA relocations, rather than REL.  */
24324 +  unsigned int use_rela_p:1;
24325 +
24326 +  /* Bits used by various backends.  The generic code doesn't touch
24327 +     these fields.  */
24328 +
24329 +  /* Nonzero if this section has TLS related relocations.  */
24330 +  unsigned int has_tls_reloc:1;
24331 +
24332 +  /* Nonzero if this section has a gp reloc.  */
24333 +  unsigned int has_gp_reloc:1;
24334 +
24335 +  /* Nonzero if this section needs the relax finalize pass.  */
24336 +  unsigned int need_finalize_relax:1;
24337 +
24338 +  /* Whether relocations have been processed.  */
24339 +  unsigned int reloc_done : 1;
24340 +
24341 +  /* End of internal packed boolean fields.  */
24342 +
24343 +  /*  The virtual memory address of the section - where it will be
24344 +      at run time.  The symbols are relocated against this.  The
24345 +      user_set_vma flag is maintained by bfd; if it's not set, the
24346 +      backend can assign addresses (for example, in <<a.out>>, where
24347 +      the default address for <<.data>> is dependent on the specific
24348 +      target and various flags).  */
24349 +  bfd_vma vma;
24350 +
24351 +  /*  The load address of the section - where it would be in a
24352 +      rom image; really only used for writing section header
24353 +      information.  */
24354 +  bfd_vma lma;
24355 +
24356 +  /* The size of the section in octets, as it will be output.
24357 +     Contains a value even if the section has no contents (e.g., the
24358 +     size of <<.bss>>).  */
24359 +  bfd_size_type size;
24360 +
24361 +  /* For input sections, the original size on disk of the section, in
24362 +     octets.  This field is used by the linker relaxation code.  It is
24363 +     currently only set for sections where the linker relaxation scheme
24364 +     doesn't cache altered section and reloc contents (stabs, eh_frame,
24365 +     SEC_MERGE, some coff relaxing targets), and thus the original size
24366 +     needs to be kept to read the section multiple times.
24367 +     For output sections, rawsize holds the section size calculated on
24368 +     a previous linker relaxation pass.  */
24369 +  bfd_size_type rawsize;
24370 +
24371 +  /* If this section is going to be output, then this value is the
24372 +     offset in *bytes* into the output section of the first byte in the
24373 +     input section (byte ==> smallest addressable unit on the
24374 +     target).  In most cases, if this was going to start at the
24375 +     100th octet (8-bit quantity) in the output section, this value
24376 +     would be 100.  However, if the target byte size is 16 bits
24377 +     (bfd_octets_per_byte is "2"), this value would be 50.  */
24378 +  bfd_vma output_offset;
24379 +
24380 +  /* The output section through which to map on output.  */
24381 +  struct bfd_section *output_section;
24382 +
24383 +  /* The alignment requirement of the section, as an exponent of 2 -
24384 +     e.g., 3 aligns to 2^3 (or 8).  */
24385 +  unsigned int alignment_power;
24386 +
24387 +  /* If an input section, a pointer to a vector of relocation
24388 +     records for the data in this section.  */
24389 +  struct reloc_cache_entry *relocation;
24390 +
24391 +  /* If an output section, a pointer to a vector of pointers to
24392 +     relocation records for the data in this section.  */
24393 +  struct reloc_cache_entry **orelocation;
24394 +
24395 +  /* The number of relocation records in one of the above.  */
24396 +  unsigned reloc_count;
24397 +
24398 +  /* Information below is back end specific - and not always used
24399 +     or updated.  */
24400 +
24401 +  /* File position of section data.  */
24402 +  file_ptr filepos;
24403 +
24404 +  /* File position of relocation info.  */
24405 +  file_ptr rel_filepos;
24406 +
24407 +  /* File position of line data.  */
24408 +  file_ptr line_filepos;
24409 +
24410 +  /* Pointer to data for applications.  */
24411 +  void *userdata;
24412 +
24413 +  /* If the SEC_IN_MEMORY flag is set, this points to the actual
24414 +     contents.  */
24415 +  unsigned char *contents;
24416 +
24417 +  /* Attached line number information.  */
24418 +  alent *lineno;
24419 +
24420 +  /* Number of line number records.  */
24421 +  unsigned int lineno_count;
24422 +
24423 +  /* Entity size for merging purposes.  */
24424 +  unsigned int entsize;
24425 +
24426 +  /* Points to the kept section if this section is a link-once section,
24427 +     and is discarded.  */
24428 +  struct bfd_section *kept_section;
24429 +
24430 +  /* When a section is being output, this value changes as more
24431 +     linenumbers are written out.  */
24432 +  file_ptr moving_line_filepos;
24433 +
24434 +  /* What the section number is in the target world.  */
24435 +  int target_index;
24436 +
24437 +  void *used_by_bfd;
24438 +
24439 +  /* If this is a constructor section then here is a list of the
24440 +     relocations created to relocate items within it.  */
24441 +  struct relent_chain *constructor_chain;
24442 +
24443 +  /* The BFD which owns the section.  */
24444 +  bfd *owner;
24445 +
24446 +  /* A symbol which points at this section only.  */
24447 +  struct bfd_symbol *symbol;
24448 +  struct bfd_symbol **symbol_ptr_ptr;
24449 +
24450 +  /* Early in the link process, map_head and map_tail are used to build
24451 +     a list of input sections attached to an output section.  Later,
24452 +     output sections use these fields for a list of bfd_link_order
24453 +     structs.  */
24454 +  union {
24455 +    struct bfd_link_order *link_order;
24456 +    struct bfd_section *s;
24457 +  } map_head, map_tail;
24458 +} asection;
24459 +
24460 +/* These sections are global, and are managed by BFD.  The application
24461 +   and target back end are not permitted to change the values in
24462 +   these sections.  New code should use the section_ptr macros rather
24463 +   than referring directly to the const sections.  The const sections
24464 +   may eventually vanish.  */
24465 +#define BFD_ABS_SECTION_NAME "*ABS*"
24466 +#define BFD_UND_SECTION_NAME "*UND*"
24467 +#define BFD_COM_SECTION_NAME "*COM*"
24468 +#define BFD_IND_SECTION_NAME "*IND*"
24469 +
24470 +/* The absolute section.  */
24471 +extern asection bfd_abs_section;
24472 +#define bfd_abs_section_ptr ((asection *) &bfd_abs_section)
24473 +#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr)
24474 +/* Pointer to the undefined section.  */
24475 +extern asection bfd_und_section;
24476 +#define bfd_und_section_ptr ((asection *) &bfd_und_section)
24477 +#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr)
24478 +/* Pointer to the common section.  */
24479 +extern asection bfd_com_section;
24480 +#define bfd_com_section_ptr ((asection *) &bfd_com_section)
24481 +/* Pointer to the indirect section.  */
24482 +extern asection bfd_ind_section;
24483 +#define bfd_ind_section_ptr ((asection *) &bfd_ind_section)
24484 +#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr)
24485 +
24486 +#define bfd_is_const_section(SEC)              \
24487 + (   ((SEC) == bfd_abs_section_ptr)            \
24488 +  || ((SEC) == bfd_und_section_ptr)            \
24489 +  || ((SEC) == bfd_com_section_ptr)            \
24490 +  || ((SEC) == bfd_ind_section_ptr))
24491 +
24492 +extern const struct bfd_symbol * const bfd_abs_symbol;
24493 +extern const struct bfd_symbol * const bfd_com_symbol;
24494 +extern const struct bfd_symbol * const bfd_und_symbol;
24495 +extern const struct bfd_symbol * const bfd_ind_symbol;
24496 +
24497 +/* Macros to handle insertion and deletion of a bfd's sections.  These
24498 +   only handle the list pointers, ie. do not adjust section_count,
24499 +   target_index etc.  */
24500 +#define bfd_section_list_remove(ABFD, S) \
24501 +  do                                                   \
24502 +    {                                                  \
24503 +      asection *_s = S;                                \
24504 +      asection *_next = _s->next;                      \
24505 +      asection *_prev = _s->prev;                      \
24506 +      if (_prev)                                       \
24507 +        _prev->next = _next;                           \
24508 +      else                                             \
24509 +        (ABFD)->sections = _next;                      \
24510 +      if (_next)                                       \
24511 +        _next->prev = _prev;                           \
24512 +      else                                             \
24513 +        (ABFD)->section_last = _prev;                  \
24514 +    }                                                  \
24515 +  while (0)
24516 +#define bfd_section_list_append(ABFD, S) \
24517 +  do                                                   \
24518 +    {                                                  \
24519 +      asection *_s = S;                                \
24520 +      bfd *_abfd = ABFD;                               \
24521 +      _s->next = NULL;                                 \
24522 +      if (_abfd->section_last)                         \
24523 +        {                                              \
24524 +          _s->prev = _abfd->section_last;              \
24525 +          _abfd->section_last->next = _s;              \
24526 +        }                                              \
24527 +      else                                             \
24528 +        {                                              \
24529 +          _s->prev = NULL;                             \
24530 +          _abfd->sections = _s;                        \
24531 +        }                                              \
24532 +      _abfd->section_last = _s;                        \
24533 +    }                                                  \
24534 +  while (0)
24535 +#define bfd_section_list_prepend(ABFD, S) \
24536 +  do                                                   \
24537 +    {                                                  \
24538 +      asection *_s = S;                                \
24539 +      bfd *_abfd = ABFD;                               \
24540 +      _s->prev = NULL;                                 \
24541 +      if (_abfd->sections)                             \
24542 +        {                                              \
24543 +          _s->next = _abfd->sections;                  \
24544 +          _abfd->sections->prev = _s;                  \
24545 +        }                                              \
24546 +      else                                             \
24547 +        {                                              \
24548 +          _s->next = NULL;                             \
24549 +          _abfd->section_last = _s;                    \
24550 +        }                                              \
24551 +      _abfd->sections = _s;                            \
24552 +    }                                                  \
24553 +  while (0)
24554 +#define bfd_section_list_insert_after(ABFD, A, S) \
24555 +  do                                                   \
24556 +    {                                                  \
24557 +      asection *_a = A;                                \
24558 +      asection *_s = S;                                \
24559 +      asection *_next = _a->next;                      \
24560 +      _s->next = _next;                                \
24561 +      _s->prev = _a;                                   \
24562 +      _a->next = _s;                                   \
24563 +      if (_next)                                       \
24564 +        _next->prev = _s;                              \
24565 +      else                                             \
24566 +        (ABFD)->section_last = _s;                     \
24567 +    }                                                  \
24568 +  while (0)
24569 +#define bfd_section_list_insert_before(ABFD, B, S) \
24570 +  do                                                   \
24571 +    {                                                  \
24572 +      asection *_b = B;                                \
24573 +      asection *_s = S;                                \
24574 +      asection *_prev = _b->prev;                      \
24575 +      _s->prev = _prev;                                \
24576 +      _s->next = _b;                                   \
24577 +      _b->prev = _s;                                   \
24578 +      if (_prev)                                       \
24579 +        _prev->next = _s;                              \
24580 +      else                                             \
24581 +        (ABFD)->sections = _s;                         \
24582 +    }                                                  \
24583 +  while (0)
24584 +#define bfd_section_removed_from_list(ABFD, S) \
24585 +  ((S)->next == NULL ? (ABFD)->section_last != (S) : (S)->next->prev != (S))
24586 +
24587 +void bfd_section_list_clear (bfd *);
24588 +
24589 +asection *bfd_get_section_by_name (bfd *abfd, const char *name);
24590 +
24591 +asection *bfd_get_section_by_name_if
24592 +   (bfd *abfd,
24593 +    const char *name,
24594 +    bfd_boolean (*func) (bfd *abfd, asection *sect, void *obj),
24595 +    void *obj);
24596 +
24597 +char *bfd_get_unique_section_name
24598 +   (bfd *abfd, const char *templat, int *count);
24599 +
24600 +asection *bfd_make_section_old_way (bfd *abfd, const char *name);
24601 +
24602 +asection *bfd_make_section_anyway_with_flags
24603 +   (bfd *abfd, const char *name, flagword flags);
24604 +
24605 +asection *bfd_make_section_anyway (bfd *abfd, const char *name);
24606 +
24607 +asection *bfd_make_section_with_flags
24608 +   (bfd *, const char *name, flagword flags);
24609 +
24610 +asection *bfd_make_section (bfd *, const char *name);
24611 +
24612 +bfd_boolean bfd_set_section_flags
24613 +   (bfd *abfd, asection *sec, flagword flags);
24614 +
24615 +void bfd_map_over_sections
24616 +   (bfd *abfd,
24617 +    void (*func) (bfd *abfd, asection *sect, void *obj),
24618 +    void *obj);
24619 +
24620 +asection *bfd_sections_find_if
24621 +   (bfd *abfd,
24622 +    bfd_boolean (*operation) (bfd *abfd, asection *sect, void *obj),
24623 +    void *obj);
24624 +
24625 +bfd_boolean bfd_set_section_size
24626 +   (bfd *abfd, asection *sec, bfd_size_type val);
24627 +
24628 +bfd_boolean bfd_set_section_contents
24629 +   (bfd *abfd, asection *section, const void *data,
24630 +    file_ptr offset, bfd_size_type count);
24631 +
24632 +bfd_boolean bfd_get_section_contents
24633 +   (bfd *abfd, asection *section, void *location, file_ptr offset,
24634 +    bfd_size_type count);
24635 +
24636 +bfd_boolean bfd_malloc_and_get_section
24637 +   (bfd *abfd, asection *section, bfd_byte **buf);
24638 +
24639 +bfd_boolean bfd_copy_private_section_data
24640 +   (bfd *ibfd, asection *isec, bfd *obfd, asection *osec);
24641 +
24642 +#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \
24643 +     BFD_SEND (obfd, _bfd_copy_private_section_data, \
24644 +               (ibfd, isection, obfd, osection))
24645 +bfd_boolean bfd_generic_is_group_section (bfd *, const asection *sec);
24646 +
24647 +bfd_boolean bfd_generic_discard_group (bfd *abfd, asection *group);
24648 +
24649 +/* Extracted from archures.c.  */
24650 +enum bfd_architecture
24651 +{
24652 +  bfd_arch_unknown,   /* File arch not known.  */
24653 +  bfd_arch_obscure,   /* Arch known, not one of these.  */
24654 +  bfd_arch_m68k,      /* Motorola 68xxx */
24655 +#define bfd_mach_m68000 1
24656 +#define bfd_mach_m68008 2
24657 +#define bfd_mach_m68010 3
24658 +#define bfd_mach_m68020 4
24659 +#define bfd_mach_m68030 5
24660 +#define bfd_mach_m68040 6
24661 +#define bfd_mach_m68060 7
24662 +#define bfd_mach_cpu32  8
24663 +#define bfd_mach_mcf5200  9
24664 +#define bfd_mach_mcf5206e 10
24665 +#define bfd_mach_mcf5307  11
24666 +#define bfd_mach_mcf5407  12
24667 +#define bfd_mach_mcf528x  13
24668 +#define bfd_mach_mcfv4e   14
24669 +#define bfd_mach_mcf521x   15
24670 +#define bfd_mach_mcf5249   16
24671 +#define bfd_mach_mcf547x   17
24672 +#define bfd_mach_mcf548x   18
24673 +  bfd_arch_vax,       /* DEC Vax */
24674 +  bfd_arch_i960,      /* Intel 960 */
24675 +    /* The order of the following is important.
24676 +       lower number indicates a machine type that
24677 +       only accepts a subset of the instructions
24678 +       available to machines with higher numbers.
24679 +       The exception is the "ca", which is
24680 +       incompatible with all other machines except
24681 +       "core".  */
24682 +
24683 +#define bfd_mach_i960_core      1
24684 +#define bfd_mach_i960_ka_sa     2
24685 +#define bfd_mach_i960_kb_sb     3
24686 +#define bfd_mach_i960_mc        4
24687 +#define bfd_mach_i960_xa        5
24688 +#define bfd_mach_i960_ca        6
24689 +#define bfd_mach_i960_jx        7
24690 +#define bfd_mach_i960_hx        8
24691 +
24692 +  bfd_arch_or32,      /* OpenRISC 32 */
24693 +
24694 +  bfd_arch_a29k,      /* AMD 29000 */
24695 +  bfd_arch_sparc,     /* SPARC */
24696 +#define bfd_mach_sparc                 1
24697 +/* The difference between v8plus and v9 is that v9 is a true 64 bit env.  */
24698 +#define bfd_mach_sparc_sparclet        2
24699 +#define bfd_mach_sparc_sparclite       3
24700 +#define bfd_mach_sparc_v8plus          4
24701 +#define bfd_mach_sparc_v8plusa         5 /* with ultrasparc add'ns.  */
24702 +#define bfd_mach_sparc_sparclite_le    6
24703 +#define bfd_mach_sparc_v9              7
24704 +#define bfd_mach_sparc_v9a             8 /* with ultrasparc add'ns.  */
24705 +#define bfd_mach_sparc_v8plusb         9 /* with cheetah add'ns.  */
24706 +#define bfd_mach_sparc_v9b             10 /* with cheetah add'ns.  */
24707 +/* Nonzero if MACH has the v9 instruction set.  */
24708 +#define bfd_mach_sparc_v9_p(mach) \
24709 +  ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9b \
24710 +   && (mach) != bfd_mach_sparc_sparclite_le)
24711 +/* Nonzero if MACH is a 64 bit sparc architecture.  */
24712 +#define bfd_mach_sparc_64bit_p(mach) \
24713 +  ((mach) >= bfd_mach_sparc_v9 && (mach) != bfd_mach_sparc_v8plusb)
24714 +  bfd_arch_mips,      /* MIPS Rxxxx */
24715 +#define bfd_mach_mips3000              3000
24716 +#define bfd_mach_mips3900              3900
24717 +#define bfd_mach_mips4000              4000
24718 +#define bfd_mach_mips4010              4010
24719 +#define bfd_mach_mips4100              4100
24720 +#define bfd_mach_mips4111              4111
24721 +#define bfd_mach_mips4120              4120
24722 +#define bfd_mach_mips4300              4300
24723 +#define bfd_mach_mips4400              4400
24724 +#define bfd_mach_mips4600              4600
24725 +#define bfd_mach_mips4650              4650
24726 +#define bfd_mach_mips5000              5000
24727 +#define bfd_mach_mips5400              5400
24728 +#define bfd_mach_mips5500              5500
24729 +#define bfd_mach_mips6000              6000
24730 +#define bfd_mach_mips7000              7000
24731 +#define bfd_mach_mips8000              8000
24732 +#define bfd_mach_mips9000              9000
24733 +#define bfd_mach_mips10000             10000
24734 +#define bfd_mach_mips12000             12000
24735 +#define bfd_mach_mips16                16
24736 +#define bfd_mach_mips5                 5
24737 +#define bfd_mach_mips_sb1              12310201 /* octal 'SB', 01 */
24738 +#define bfd_mach_mipsisa32             32
24739 +#define bfd_mach_mipsisa32r2           33
24740 +#define bfd_mach_mipsisa64             64
24741 +#define bfd_mach_mipsisa64r2           65
24742 +  bfd_arch_i386,      /* Intel 386 */
24743 +#define bfd_mach_i386_i386 1
24744 +#define bfd_mach_i386_i8086 2
24745 +#define bfd_mach_i386_i386_intel_syntax 3
24746 +#define bfd_mach_x86_64 64
24747 +#define bfd_mach_x86_64_intel_syntax 65
24748 +  bfd_arch_we32k,     /* AT&T WE32xxx */
24749 +  bfd_arch_tahoe,     /* CCI/Harris Tahoe */
24750 +  bfd_arch_i860,      /* Intel 860 */
24751 +  bfd_arch_i370,      /* IBM 360/370 Mainframes */
24752 +  bfd_arch_romp,      /* IBM ROMP PC/RT */
24753 +  bfd_arch_alliant,   /* Alliant */
24754 +  bfd_arch_convex,    /* Convex */
24755 +  bfd_arch_m88k,      /* Motorola 88xxx */
24756 +  bfd_arch_m98k,      /* Motorola 98xxx */
24757 +  bfd_arch_pyramid,   /* Pyramid Technology */
24758 +  bfd_arch_h8300,     /* Renesas H8/300 (formerly Hitachi H8/300) */
24759 +#define bfd_mach_h8300    1
24760 +#define bfd_mach_h8300h   2
24761 +#define bfd_mach_h8300s   3
24762 +#define bfd_mach_h8300hn  4
24763 +#define bfd_mach_h8300sn  5
24764 +#define bfd_mach_h8300sx  6
24765 +#define bfd_mach_h8300sxn 7
24766 +  bfd_arch_pdp11,     /* DEC PDP-11 */
24767 +  bfd_arch_powerpc,   /* PowerPC */
24768 +#define bfd_mach_ppc           32
24769 +#define bfd_mach_ppc64         64
24770 +#define bfd_mach_ppc_403       403
24771 +#define bfd_mach_ppc_403gc     4030
24772 +#define bfd_mach_ppc_505       505
24773 +#define bfd_mach_ppc_601       601
24774 +#define bfd_mach_ppc_602       602
24775 +#define bfd_mach_ppc_603       603
24776 +#define bfd_mach_ppc_ec603e    6031
24777 +#define bfd_mach_ppc_604       604
24778 +#define bfd_mach_ppc_620       620
24779 +#define bfd_mach_ppc_630       630
24780 +#define bfd_mach_ppc_750       750
24781 +#define bfd_mach_ppc_860       860
24782 +#define bfd_mach_ppc_a35       35
24783 +#define bfd_mach_ppc_rs64ii    642
24784 +#define bfd_mach_ppc_rs64iii   643
24785 +#define bfd_mach_ppc_7400      7400
24786 +#define bfd_mach_ppc_e500      500
24787 +  bfd_arch_rs6000,    /* IBM RS/6000 */
24788 +#define bfd_mach_rs6k          6000
24789 +#define bfd_mach_rs6k_rs1      6001
24790 +#define bfd_mach_rs6k_rsc      6003
24791 +#define bfd_mach_rs6k_rs2      6002
24792 +  bfd_arch_hppa,      /* HP PA RISC */
24793 +#define bfd_mach_hppa10        10
24794 +#define bfd_mach_hppa11        11
24795 +#define bfd_mach_hppa20        20
24796 +#define bfd_mach_hppa20w       25
24797 +  bfd_arch_d10v,      /* Mitsubishi D10V */
24798 +#define bfd_mach_d10v          1
24799 +#define bfd_mach_d10v_ts2      2
24800 +#define bfd_mach_d10v_ts3      3
24801 +  bfd_arch_d30v,      /* Mitsubishi D30V */
24802 +  bfd_arch_dlx,       /* DLX */
24803 +  bfd_arch_m68hc11,   /* Motorola 68HC11 */
24804 +  bfd_arch_m68hc12,   /* Motorola 68HC12 */
24805 +#define bfd_mach_m6812_default 0
24806 +#define bfd_mach_m6812         1
24807 +#define bfd_mach_m6812s        2
24808 +  bfd_arch_z8k,       /* Zilog Z8000 */
24809 +#define bfd_mach_z8001         1
24810 +#define bfd_mach_z8002         2
24811 +  bfd_arch_h8500,     /* Renesas H8/500 (formerly Hitachi H8/500) */
24812 +  bfd_arch_sh,        /* Renesas / SuperH SH (formerly Hitachi SH) */
24813 +#define bfd_mach_sh            1
24814 +#define bfd_mach_sh2        0x20
24815 +#define bfd_mach_sh_dsp     0x2d
24816 +#define bfd_mach_sh2a       0x2a
24817 +#define bfd_mach_sh2a_nofpu 0x2b
24818 +#define bfd_mach_sh2a_nofpu_or_sh4_nommu_nofpu 0x2a1
24819 +#define bfd_mach_sh2a_nofpu_or_sh3_nommu 0x2a2
24820 +#define bfd_mach_sh2a_or_sh4  0x2a3
24821 +#define bfd_mach_sh2a_or_sh3e 0x2a4
24822 +#define bfd_mach_sh2e       0x2e
24823 +#define bfd_mach_sh3        0x30
24824 +#define bfd_mach_sh3_nommu  0x31
24825 +#define bfd_mach_sh3_dsp    0x3d
24826 +#define bfd_mach_sh3e       0x3e
24827 +#define bfd_mach_sh4        0x40
24828 +#define bfd_mach_sh4_nofpu  0x41
24829 +#define bfd_mach_sh4_nommu_nofpu  0x42
24830 +#define bfd_mach_sh4a       0x4a
24831 +#define bfd_mach_sh4a_nofpu 0x4b
24832 +#define bfd_mach_sh4al_dsp  0x4d
24833 +#define bfd_mach_sh5        0x50
24834 +  bfd_arch_alpha,     /* Dec Alpha */
24835 +#define bfd_mach_alpha_ev4  0x10
24836 +#define bfd_mach_alpha_ev5  0x20
24837 +#define bfd_mach_alpha_ev6  0x30
24838 +  bfd_arch_arm,       /* Advanced Risc Machines ARM.  */
24839 +#define bfd_mach_arm_unknown   0
24840 +#define bfd_mach_arm_2         1
24841 +#define bfd_mach_arm_2a        2
24842 +#define bfd_mach_arm_3         3
24843 +#define bfd_mach_arm_3M        4
24844 +#define bfd_mach_arm_4         5
24845 +#define bfd_mach_arm_4T        6
24846 +#define bfd_mach_arm_5         7
24847 +#define bfd_mach_arm_5T        8
24848 +#define bfd_mach_arm_5TE       9
24849 +#define bfd_mach_arm_XScale    10
24850 +#define bfd_mach_arm_ep9312    11
24851 +#define bfd_mach_arm_iWMMXt    12
24852 +  bfd_arch_ns32k,     /* National Semiconductors ns32000 */
24853 +  bfd_arch_w65,       /* WDC 65816 */
24854 +  bfd_arch_tic30,     /* Texas Instruments TMS320C30 */
24855 +  bfd_arch_tic4x,     /* Texas Instruments TMS320C3X/4X */
24856 +#define bfd_mach_tic3x         30
24857 +#define bfd_mach_tic4x         40
24858 +  bfd_arch_tic54x,    /* Texas Instruments TMS320C54X */
24859 +  bfd_arch_tic80,     /* TI TMS320c80 (MVP) */
24860 +  bfd_arch_v850,      /* NEC V850 */
24861 +#define bfd_mach_v850          1
24862 +#define bfd_mach_v850e         'E'
24863 +#define bfd_mach_v850e1        '1'
24864 +  bfd_arch_arc,       /* ARC Cores */
24865 +#define bfd_mach_arc_5         5
24866 +#define bfd_mach_arc_6         6
24867 +#define bfd_mach_arc_7         7
24868 +#define bfd_mach_arc_8         8
24869 + bfd_arch_m32c,     /* Renesas M16C/M32C.  */
24870 +#define bfd_mach_m16c        0x75
24871 +#define bfd_mach_m32c        0x78
24872 +  bfd_arch_m32r,      /* Renesas M32R (formerly Mitsubishi M32R/D) */
24873 +#define bfd_mach_m32r          1 /* For backwards compatibility.  */
24874 +#define bfd_mach_m32rx         'x'
24875 +#define bfd_mach_m32r2         '2'
24876 +  bfd_arch_mn10200,   /* Matsushita MN10200 */
24877 +  bfd_arch_mn10300,   /* Matsushita MN10300 */
24878 +#define bfd_mach_mn10300               300
24879 +#define bfd_mach_am33          330
24880 +#define bfd_mach_am33_2        332
24881 +  bfd_arch_fr30,
24882 +#define bfd_mach_fr30          0x46523330
24883 +  bfd_arch_frv,
24884 +#define bfd_mach_frv           1
24885 +#define bfd_mach_frvsimple     2
24886 +#define bfd_mach_fr300         300
24887 +#define bfd_mach_fr400         400
24888 +#define bfd_mach_fr450         450
24889 +#define bfd_mach_frvtomcat     499     /* fr500 prototype */
24890 +#define bfd_mach_fr500         500
24891 +#define bfd_mach_fr550         550
24892 +  bfd_arch_mcore,
24893 +  bfd_arch_ia64,      /* HP/Intel ia64 */
24894 +#define bfd_mach_ia64_elf64    64
24895 +#define bfd_mach_ia64_elf32    32
24896 +  bfd_arch_ip2k,      /* Ubicom IP2K microcontrollers. */
24897 +#define bfd_mach_ip2022        1
24898 +#define bfd_mach_ip2022ext     2
24899 + bfd_arch_iq2000,     /* Vitesse IQ2000.  */
24900 +#define bfd_mach_iq2000        1
24901 +#define bfd_mach_iq10          2
24902 +  bfd_arch_ms1,
24903 +#define bfd_mach_ms1           1
24904 +#define bfd_mach_mrisc2        2
24905 +  bfd_arch_pj,
24906 +  bfd_arch_avr,       /* Atmel AVR microcontrollers.  */
24907 +#define bfd_mach_avr1          1
24908 +#define bfd_mach_avr2          2
24909 +#define bfd_mach_avr3          3
24910 +#define bfd_mach_avr4          4
24911 +#define bfd_mach_avr5          5
24912 +  bfd_arch_cr16c,       /* National Semiconductor CompactRISC. */
24913 +#define bfd_mach_cr16c         1
24914 +  bfd_arch_crx,       /*  National Semiconductor CRX.  */
24915 +#define bfd_mach_crx           1
24916 +  bfd_arch_cris,      /* Axis CRIS */
24917 +#define bfd_mach_cris_v0_v10   255
24918 +#define bfd_mach_cris_v32      32
24919 +#define bfd_mach_cris_v10_v32  1032
24920 +  bfd_arch_s390,      /* IBM s390 */
24921 +#define bfd_mach_s390_31       31
24922 +#define bfd_mach_s390_64       64
24923 +  bfd_arch_openrisc,  /* OpenRISC */
24924 +  bfd_arch_mmix,      /* Donald Knuth's educational processor.  */
24925 +  bfd_arch_xstormy16,
24926 +#define bfd_mach_xstormy16     1
24927 +  bfd_arch_msp430,    /* Texas Instruments MSP430 architecture.  */
24928 +#define bfd_mach_msp11          11
24929 +#define bfd_mach_msp110         110
24930 +#define bfd_mach_msp12          12
24931 +#define bfd_mach_msp13          13
24932 +#define bfd_mach_msp14          14
24933 +#define bfd_mach_msp15          15
24934 +#define bfd_mach_msp16          16
24935 +#define bfd_mach_msp31          31
24936 +#define bfd_mach_msp32          32
24937 +#define bfd_mach_msp33          33
24938 +#define bfd_mach_msp41          41
24939 +#define bfd_mach_msp42          42
24940 +#define bfd_mach_msp43          43
24941 +#define bfd_mach_msp44          44
24942 +  bfd_arch_xtensa,    /* Tensilica's Xtensa cores.  */
24943 +#define bfd_mach_xtensa        1
24944 +   bfd_arch_maxq,     /* Dallas MAXQ 10/20 */
24945 +#define bfd_mach_maxq10    10
24946 +#define bfd_mach_maxq20    20
24947 +  bfd_arch_last
24948 +  };
24949 +
24950 +typedef struct bfd_arch_info
24951 +{
24952 +  int bits_per_word;
24953 +  int bits_per_address;
24954 +  int bits_per_byte;
24955 +  enum bfd_architecture arch;
24956 +  unsigned long mach;
24957 +  const char *arch_name;
24958 +  const char *printable_name;
24959 +  unsigned int section_align_power;
24960 +  /* TRUE if this is the default machine for the architecture.
24961 +     The default arch should be the first entry for an arch so that
24962 +     all the entries for that arch can be accessed via <<next>>.  */
24963 +  bfd_boolean the_default;
24964 +  const struct bfd_arch_info * (*compatible)
24965 +    (const struct bfd_arch_info *a, const struct bfd_arch_info *b);
24966 +
24967 +  bfd_boolean (*scan) (const struct bfd_arch_info *, const char *);
24968 +
24969 +  const struct bfd_arch_info *next;
24970 +}
24971 +bfd_arch_info_type;
24972 +
24973 +const char *bfd_printable_name (bfd *abfd);
24974 +
24975 +const bfd_arch_info_type *bfd_scan_arch (const char *string);
24976 +
24977 +const char **bfd_arch_list (void);
24978 +
24979 +const bfd_arch_info_type *bfd_arch_get_compatible
24980 +   (const bfd *abfd, const bfd *bbfd, bfd_boolean accept_unknowns);
24981 +
24982 +void bfd_set_arch_info (bfd *abfd, const bfd_arch_info_type *arg);
24983 +
24984 +enum bfd_architecture bfd_get_arch (bfd *abfd);
24985 +
24986 +unsigned long bfd_get_mach (bfd *abfd);
24987 +
24988 +unsigned int bfd_arch_bits_per_byte (bfd *abfd);
24989 +
24990 +unsigned int bfd_arch_bits_per_address (bfd *abfd);
24991 +
24992 +const bfd_arch_info_type *bfd_get_arch_info (bfd *abfd);
24993 +
24994 +const bfd_arch_info_type *bfd_lookup_arch
24995 +   (enum bfd_architecture arch, unsigned long machine);
24996 +
24997 +const char *bfd_printable_arch_mach
24998 +   (enum bfd_architecture arch, unsigned long machine);
24999 +
25000 +unsigned int bfd_octets_per_byte (bfd *abfd);
25001 +
25002 +unsigned int bfd_arch_mach_octets_per_byte
25003 +   (enum bfd_architecture arch, unsigned long machine);
25004 +
25005 +/* Extracted from reloc.c.  */
25006 +typedef enum bfd_reloc_status
25007 +{
25008 +  /* No errors detected.  */
25009 +  bfd_reloc_ok,
25010 +
25011 +  /* The relocation was performed, but there was an overflow.  */
25012 +  bfd_reloc_overflow,
25013 +
25014 +  /* The address to relocate was not within the section supplied.  */
25015 +  bfd_reloc_outofrange,
25016 +
25017 +  /* Used by special functions.  */
25018 +  bfd_reloc_continue,
25019 +
25020 +  /* Unsupported relocation size requested.  */
25021 +  bfd_reloc_notsupported,
25022 +
25023 +  /* Unused.  */
25024 +  bfd_reloc_other,
25025 +
25026 +  /* The symbol to relocate against was undefined.  */
25027 +  bfd_reloc_undefined,
25028 +
25029 +  /* The relocation was performed, but may not be ok - presently
25030 +     generated only when linking i960 coff files with i960 b.out
25031 +     symbols.  If this type is returned, the error_message argument
25032 +     to bfd_perform_relocation will be set.  */
25033 +  bfd_reloc_dangerous
25034 + }
25035 + bfd_reloc_status_type;
25036 +
25037 +
25038 +typedef struct reloc_cache_entry
25039 +{
25040 +  /* A pointer into the canonical table of pointers.  */
25041 +  struct bfd_symbol **sym_ptr_ptr;
25042 +
25043 +  /* offset in section.  */
25044 +  bfd_size_type address;
25045 +
25046 +  /* addend for relocation value.  */
25047 +  bfd_vma addend;
25048 +
25049 +  /* Pointer to how to perform the required relocation.  */
25050 +  reloc_howto_type *howto;
25051 +
25052 +}
25053 +arelent;
25054 +
25055 +enum complain_overflow
25056 +{
25057 +  /* Do not complain on overflow.  */
25058 +  complain_overflow_dont,
25059 +
25060 +  /* Complain if the bitfield overflows, whether it is considered
25061 +     as signed or unsigned.  */
25062 +  complain_overflow_bitfield,
25063 +
25064 +  /* Complain if the value overflows when considered as signed
25065 +     number.  */
25066 +  complain_overflow_signed,
25067 +
25068 +  /* Complain if the value overflows when considered as an
25069 +     unsigned number.  */
25070 +  complain_overflow_unsigned
25071 +};
25072 +
25073 +struct reloc_howto_struct
25074 +{
25075 +  /*  The type field has mainly a documentary use - the back end can
25076 +      do what it wants with it, though normally the back end's
25077 +      external idea of what a reloc number is stored
25078 +      in this field.  For example, a PC relative word relocation
25079 +      in a coff environment has the type 023 - because that's
25080 +      what the outside world calls a R_PCRWORD reloc.  */
25081 +  unsigned int type;
25082 +
25083 +  /*  The value the final relocation is shifted right by.  This drops
25084 +      unwanted data from the relocation.  */
25085 +  unsigned int rightshift;
25086 +
25087 +  /*  The size of the item to be relocated.  This is *not* a
25088 +      power-of-two measure.  To get the number of bytes operated
25089 +      on by a type of relocation, use bfd_get_reloc_size.  */
25090 +  int size;
25091 +
25092 +  /*  The number of bits in the item to be relocated.  This is used
25093 +      when doing overflow checking.  */
25094 +  unsigned int bitsize;
25095 +
25096 +  /*  Notes that the relocation is relative to the location in the
25097 +      data section of the addend.  The relocation function will
25098 +      subtract from the relocation value the address of the location
25099 +      being relocated.  */
25100 +  bfd_boolean pc_relative;
25101 +
25102 +  /*  The bit position of the reloc value in the destination.
25103 +      The relocated value is left shifted by this amount.  */
25104 +  unsigned int bitpos;
25105 +
25106 +  /* What type of overflow error should be checked for when
25107 +     relocating.  */
25108 +  enum complain_overflow complain_on_overflow;
25109 +
25110 +  /* If this field is non null, then the supplied function is
25111 +     called rather than the normal function.  This allows really
25112 +     strange relocation methods to be accommodated (e.g., i960 callj
25113 +     instructions).  */
25114 +  bfd_reloc_status_type (*special_function)
25115 +    (bfd *, arelent *, struct bfd_symbol *, void *, asection *,
25116 +     bfd *, char **);
25117 +
25118 +  /* The textual name of the relocation type.  */
25119 +  char *name;
25120 +
25121 +  /* Some formats record a relocation addend in the section contents
25122 +     rather than with the relocation.  For ELF formats this is the
25123 +     distinction between USE_REL and USE_RELA (though the code checks
25124 +     for USE_REL == 1/0).  The value of this field is TRUE if the
25125 +     addend is recorded with the section contents; when performing a
25126 +     partial link (ld -r) the section contents (the data) will be
25127 +     modified.  The value of this field is FALSE if addends are
25128 +     recorded with the relocation (in arelent.addend); when performing
25129 +     a partial link the relocation will be modified.
25130 +     All relocations for all ELF USE_RELA targets should set this field
25131 +     to FALSE (values of TRUE should be looked on with suspicion).
25132 +     However, the converse is not true: not all relocations of all ELF
25133 +     USE_REL targets set this field to TRUE.  Why this is so is peculiar
25134 +     to each particular target.  For relocs that aren't used in partial
25135 +     links (e.g. GOT stuff) it doesn't matter what this is set to.  */
25136 +  bfd_boolean partial_inplace;
25137 +
25138 +  /* src_mask selects the part of the instruction (or data) to be used
25139 +     in the relocation sum.  If the target relocations don't have an
25140 +     addend in the reloc, eg. ELF USE_REL, src_mask will normally equal
25141 +     dst_mask to extract the addend from the section contents.  If
25142 +     relocations do have an addend in the reloc, eg. ELF USE_RELA, this
25143 +     field should be zero.  Non-zero values for ELF USE_RELA targets are
25144 +     bogus as in those cases the value in the dst_mask part of the
25145 +     section contents should be treated as garbage.  */
25146 +  bfd_vma src_mask;
25147 +
25148 +  /* dst_mask selects which parts of the instruction (or data) are
25149 +     replaced with a relocated value.  */
25150 +  bfd_vma dst_mask;
25151 +
25152 +  /* When some formats create PC relative instructions, they leave
25153 +     the value of the pc of the place being relocated in the offset
25154 +     slot of the instruction, so that a PC relative relocation can
25155 +     be made just by adding in an ordinary offset (e.g., sun3 a.out).
25156 +     Some formats leave the displacement part of an instruction
25157 +     empty (e.g., m88k bcs); this flag signals the fact.  */
25158 +  bfd_boolean pcrel_offset;
25159 +};
25160 +
25161 +#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
25162 +  { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC }
25163 +#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \
25164 +  HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \
25165 +         NAME, FALSE, 0, 0, IN)
25166 +
25167 +#define EMPTY_HOWTO(C) \
25168 +  HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \
25169 +         NULL, FALSE, 0, 0, FALSE)
25170 +
25171 +#define HOWTO_PREPARE(relocation, symbol)               \
25172 +  {                                                     \
25173 +    if (symbol != NULL)                                 \
25174 +      {                                                 \
25175 +        if (bfd_is_com_section (symbol->section))       \
25176 +          {                                             \
25177 +            relocation = 0;                             \
25178 +          }                                             \
25179 +        else                                            \
25180 +          {                                             \
25181 +            relocation = symbol->value;                 \
25182 +          }                                             \
25183 +      }                                                 \
25184 +  }
25185 +
25186 +unsigned int bfd_get_reloc_size (reloc_howto_type *);
25187 +
25188 +typedef struct relent_chain
25189 +{
25190 +  arelent relent;
25191 +  struct relent_chain *next;
25192 +}
25193 +arelent_chain;
25194 +
25195 +bfd_reloc_status_type bfd_check_overflow
25196 +   (enum complain_overflow how,
25197 +    unsigned int bitsize,
25198 +    unsigned int rightshift,
25199 +    unsigned int addrsize,
25200 +    bfd_vma relocation);
25201 +
25202 +bfd_reloc_status_type bfd_perform_relocation
25203 +   (bfd *abfd,
25204 +    arelent *reloc_entry,
25205 +    void *data,
25206 +    asection *input_section,
25207 +    bfd *output_bfd,
25208 +    char **error_message);
25209 +
25210 +bfd_reloc_status_type bfd_install_relocation
25211 +   (bfd *abfd,
25212 +    arelent *reloc_entry,
25213 +    void *data, bfd_vma data_start,
25214 +    asection *input_section,
25215 +    char **error_message);
25216 +
25217 +enum bfd_reloc_code_real {
25218 +  _dummy_first_bfd_reloc_code_real,
25219 +
25220 +
25221 +/* Basic absolute relocations of N bits.  */
25222 +  BFD_RELOC_64,
25223 +  BFD_RELOC_32,
25224 +  BFD_RELOC_26,
25225 +  BFD_RELOC_24,
25226 +  BFD_RELOC_16,
25227 +  BFD_RELOC_14,
25228 +  BFD_RELOC_8,
25229 +
25230 +/* PC-relative relocations.  Sometimes these are relative to the address
25231 +of the relocation itself; sometimes they are relative to the start of
25232 +the section containing the relocation.  It depends on the specific target.
25233 +
25234 +The 24-bit relocation is used in some Intel 960 configurations.  */
25235 +  BFD_RELOC_64_PCREL,
25236 +  BFD_RELOC_32_PCREL,
25237 +  BFD_RELOC_24_PCREL,
25238 +  BFD_RELOC_16_PCREL,
25239 +  BFD_RELOC_12_PCREL,
25240 +  BFD_RELOC_8_PCREL,
25241 +
25242 +/* Section relative relocations.  Some targets need this for DWARF2.  */
25243 +  BFD_RELOC_32_SECREL,
25244 +
25245 +/* For ELF.  */
25246 +  BFD_RELOC_32_GOT_PCREL,
25247 +  BFD_RELOC_16_GOT_PCREL,
25248 +  BFD_RELOC_8_GOT_PCREL,
25249 +  BFD_RELOC_32_GOTOFF,
25250 +  BFD_RELOC_16_GOTOFF,
25251 +  BFD_RELOC_LO16_GOTOFF,
25252 +  BFD_RELOC_HI16_GOTOFF,
25253 +  BFD_RELOC_HI16_S_GOTOFF,
25254 +  BFD_RELOC_8_GOTOFF,
25255 +  BFD_RELOC_64_PLT_PCREL,
25256 +  BFD_RELOC_32_PLT_PCREL,
25257 +  BFD_RELOC_24_PLT_PCREL,
25258 +  BFD_RELOC_16_PLT_PCREL,
25259 +  BFD_RELOC_8_PLT_PCREL,
25260 +  BFD_RELOC_64_PLTOFF,
25261 +  BFD_RELOC_32_PLTOFF,
25262 +  BFD_RELOC_16_PLTOFF,
25263 +  BFD_RELOC_LO16_PLTOFF,
25264 +  BFD_RELOC_HI16_PLTOFF,
25265 +  BFD_RELOC_HI16_S_PLTOFF,
25266 +  BFD_RELOC_8_PLTOFF,
25267 +
25268 +/* Relocations used by 68K ELF.  */
25269 +  BFD_RELOC_68K_GLOB_DAT,
25270 +  BFD_RELOC_68K_JMP_SLOT,
25271 +  BFD_RELOC_68K_RELATIVE,
25272 +
25273 +/* Linkage-table relative.  */
25274 +  BFD_RELOC_32_BASEREL,
25275 +  BFD_RELOC_16_BASEREL,
25276 +  BFD_RELOC_LO16_BASEREL,
25277 +  BFD_RELOC_HI16_BASEREL,
25278 +  BFD_RELOC_HI16_S_BASEREL,
25279 +  BFD_RELOC_8_BASEREL,
25280 +  BFD_RELOC_RVA,
25281 +
25282 +/* Absolute 8-bit relocation, but used to form an address like 0xFFnn.  */
25283 +  BFD_RELOC_8_FFnn,
25284 +
25285 +/* These PC-relative relocations are stored as word displacements --
25286 +i.e., byte displacements shifted right two bits.  The 30-bit word
25287 +displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
25288 +SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The
25289 +signed 16-bit displacement is used on the MIPS, and the 23-bit
25290 +displacement is used on the Alpha.  */
25291 +  BFD_RELOC_32_PCREL_S2,
25292 +  BFD_RELOC_16_PCREL_S2,
25293 +  BFD_RELOC_23_PCREL_S2,
25294 +
25295 +/* High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
25296 +the target word.  These are used on the SPARC.  */
25297 +  BFD_RELOC_HI22,
25298 +  BFD_RELOC_LO10,
25299 +
25300 +/* For systems that allocate a Global Pointer register, these are
25301 +displacements off that register.  These relocation types are
25302 +handled specially, because the value the register will have is
25303 +decided relatively late.  */
25304 +  BFD_RELOC_GPREL16,
25305 +  BFD_RELOC_GPREL32,
25306 +
25307 +/* Reloc types used for i960/b.out.  */
25308 +  BFD_RELOC_I960_CALLJ,
25309 +
25310 +/* SPARC ELF relocations.  There is probably some overlap with other
25311 +relocation types already defined.  */
25312 +  BFD_RELOC_NONE,
25313 +  BFD_RELOC_SPARC_WDISP22,
25314 +  BFD_RELOC_SPARC22,
25315 +  BFD_RELOC_SPARC13,
25316 +  BFD_RELOC_SPARC_GOT10,
25317 +  BFD_RELOC_SPARC_GOT13,
25318 +  BFD_RELOC_SPARC_GOT22,
25319 +  BFD_RELOC_SPARC_PC10,
25320 +  BFD_RELOC_SPARC_PC22,
25321 +  BFD_RELOC_SPARC_WPLT30,
25322 +  BFD_RELOC_SPARC_COPY,
25323 +  BFD_RELOC_SPARC_GLOB_DAT,
25324 +  BFD_RELOC_SPARC_JMP_SLOT,
25325 +  BFD_RELOC_SPARC_RELATIVE,
25326 +  BFD_RELOC_SPARC_UA16,
25327 +  BFD_RELOC_SPARC_UA32,
25328 +  BFD_RELOC_SPARC_UA64,
25329 +
25330 +/* I think these are specific to SPARC a.out (e.g., Sun 4).  */
25331 +  BFD_RELOC_SPARC_BASE13,
25332 +  BFD_RELOC_SPARC_BASE22,
25333 +
25334 +/* SPARC64 relocations  */
25335 +#define BFD_RELOC_SPARC_64 BFD_RELOC_64
25336 +  BFD_RELOC_SPARC_10,
25337 +  BFD_RELOC_SPARC_11,
25338 +  BFD_RELOC_SPARC_OLO10,
25339 +  BFD_RELOC_SPARC_HH22,
25340 +  BFD_RELOC_SPARC_HM10,
25341 +  BFD_RELOC_SPARC_LM22,
25342 +  BFD_RELOC_SPARC_PC_HH22,
25343 +  BFD_RELOC_SPARC_PC_HM10,
25344 +  BFD_RELOC_SPARC_PC_LM22,
25345 +  BFD_RELOC_SPARC_WDISP16,
25346 +  BFD_RELOC_SPARC_WDISP19,
25347 +  BFD_RELOC_SPARC_7,
25348 +  BFD_RELOC_SPARC_6,
25349 +  BFD_RELOC_SPARC_5,
25350 +#define BFD_RELOC_SPARC_DISP64 BFD_RELOC_64_PCREL
25351 +  BFD_RELOC_SPARC_PLT32,
25352 +  BFD_RELOC_SPARC_PLT64,
25353 +  BFD_RELOC_SPARC_HIX22,
25354 +  BFD_RELOC_SPARC_LOX10,
25355 +  BFD_RELOC_SPARC_H44,
25356 +  BFD_RELOC_SPARC_M44,
25357 +  BFD_RELOC_SPARC_L44,
25358 +  BFD_RELOC_SPARC_REGISTER,
25359 +
25360 +/* SPARC little endian relocation  */
25361 +  BFD_RELOC_SPARC_REV32,
25362 +
25363 +/* SPARC TLS relocations  */
25364 +  BFD_RELOC_SPARC_TLS_GD_HI22,
25365 +  BFD_RELOC_SPARC_TLS_GD_LO10,
25366 +  BFD_RELOC_SPARC_TLS_GD_ADD,
25367 +  BFD_RELOC_SPARC_TLS_GD_CALL,
25368 +  BFD_RELOC_SPARC_TLS_LDM_HI22,
25369 +  BFD_RELOC_SPARC_TLS_LDM_LO10,
25370 +  BFD_RELOC_SPARC_TLS_LDM_ADD,
25371 +  BFD_RELOC_SPARC_TLS_LDM_CALL,
25372 +  BFD_RELOC_SPARC_TLS_LDO_HIX22,
25373 +  BFD_RELOC_SPARC_TLS_LDO_LOX10,
25374 +  BFD_RELOC_SPARC_TLS_LDO_ADD,
25375 +  BFD_RELOC_SPARC_TLS_IE_HI22,
25376 +  BFD_RELOC_SPARC_TLS_IE_LO10,
25377 +  BFD_RELOC_SPARC_TLS_IE_LD,
25378 +  BFD_RELOC_SPARC_TLS_IE_LDX,
25379 +  BFD_RELOC_SPARC_TLS_IE_ADD,
25380 +  BFD_RELOC_SPARC_TLS_LE_HIX22,
25381 +  BFD_RELOC_SPARC_TLS_LE_LOX10,
25382 +  BFD_RELOC_SPARC_TLS_DTPMOD32,
25383 +  BFD_RELOC_SPARC_TLS_DTPMOD64,
25384 +  BFD_RELOC_SPARC_TLS_DTPOFF32,
25385 +  BFD_RELOC_SPARC_TLS_DTPOFF64,
25386 +  BFD_RELOC_SPARC_TLS_TPOFF32,
25387 +  BFD_RELOC_SPARC_TLS_TPOFF64,
25388 +
25389 +/* Alpha ECOFF and ELF relocations.  Some of these treat the symbol or
25390 +"addend" in some special way.
25391 +For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
25392 +writing; when reading, it will be the absolute section symbol.  The
25393 +addend is the displacement in bytes of the "lda" instruction from
25394 +the "ldah" instruction (which is at the address of this reloc).  */
25395 +  BFD_RELOC_ALPHA_GPDISP_HI16,
25396 +
25397 +/* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
25398 +with GPDISP_HI16 relocs.  The addend is ignored when writing the
25399 +relocations out, and is filled in with the file's GP value on
25400 +reading, for convenience.  */
25401 +  BFD_RELOC_ALPHA_GPDISP_LO16,
25402 +
25403 +/* The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
25404 +relocation except that there is no accompanying GPDISP_LO16
25405 +relocation.  */
25406 +  BFD_RELOC_ALPHA_GPDISP,
25407 +
25408 +/* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
25409 +the assembler turns it into a LDQ instruction to load the address of
25410 +the symbol, and then fills in a register in the real instruction.
25411 +
25412 +The LITERAL reloc, at the LDQ instruction, refers to the .lita
25413 +section symbol.  The addend is ignored when writing, but is filled
25414 +in with the file's GP value on reading, for convenience, as with the
25415 +GPDISP_LO16 reloc.
25416 +
25417 +The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
25418 +It should refer to the symbol to be referenced, as with 16_GOTOFF,
25419 +but it generates output not based on the position within the .got
25420 +section, but relative to the GP value chosen for the file during the
25421 +final link stage.
25422 +
25423 +The LITUSE reloc, on the instruction using the loaded address, gives
25424 +information to the linker that it might be able to use to optimize
25425 +away some literal section references.  The symbol is ignored (read
25426 +as the absolute section symbol), and the "addend" indicates the type
25427 +of instruction using the register:
25428 +1 - "memory" fmt insn
25429 +2 - byte-manipulation (byte offset reg)
25430 +3 - jsr (target of branch)  */
25431 +  BFD_RELOC_ALPHA_LITERAL,
25432 +  BFD_RELOC_ALPHA_ELF_LITERAL,
25433 +  BFD_RELOC_ALPHA_LITUSE,
25434 +
25435 +/* The HINT relocation indicates a value that should be filled into the
25436 +"hint" field of a jmp/jsr/ret instruction, for possible branch-
25437 +prediction logic which may be provided on some processors.  */
25438 +  BFD_RELOC_ALPHA_HINT,
25439 +
25440 +/* The LINKAGE relocation outputs a linkage pair in the object file,
25441 +which is filled by the linker.  */
25442 +  BFD_RELOC_ALPHA_LINKAGE,
25443 +
25444 +/* The CODEADDR relocation outputs a STO_CA in the object file,
25445 +which is filled by the linker.  */
25446 +  BFD_RELOC_ALPHA_CODEADDR,
25447 +
25448 +/* The GPREL_HI/LO relocations together form a 32-bit offset from the
25449 +GP register.  */
25450 +  BFD_RELOC_ALPHA_GPREL_HI16,
25451 +  BFD_RELOC_ALPHA_GPREL_LO16,
25452 +
25453 +/* Like BFD_RELOC_23_PCREL_S2, except that the source and target must
25454 +share a common GP, and the target address is adjusted for
25455 +STO_ALPHA_STD_GPLOAD.  */
25456 +  BFD_RELOC_ALPHA_BRSGP,
25457 +
25458 +/* Alpha thread-local storage relocations.  */
25459 +  BFD_RELOC_ALPHA_TLSGD,
25460 +  BFD_RELOC_ALPHA_TLSLDM,
25461 +  BFD_RELOC_ALPHA_DTPMOD64,
25462 +  BFD_RELOC_ALPHA_GOTDTPREL16,
25463 +  BFD_RELOC_ALPHA_DTPREL64,
25464 +  BFD_RELOC_ALPHA_DTPREL_HI16,
25465 +  BFD_RELOC_ALPHA_DTPREL_LO16,
25466 +  BFD_RELOC_ALPHA_DTPREL16,
25467 +  BFD_RELOC_ALPHA_GOTTPREL16,
25468 +  BFD_RELOC_ALPHA_TPREL64,
25469 +  BFD_RELOC_ALPHA_TPREL_HI16,
25470 +  BFD_RELOC_ALPHA_TPREL_LO16,
25471 +  BFD_RELOC_ALPHA_TPREL16,
25472 +
25473 +/* Bits 27..2 of the relocation address shifted right 2 bits;
25474 +simple reloc otherwise.  */
25475 +  BFD_RELOC_MIPS_JMP,
25476 +
25477 +/* The MIPS16 jump instruction.  */
25478 +  BFD_RELOC_MIPS16_JMP,
25479 +
25480 +/* MIPS16 GP relative reloc.  */
25481 +  BFD_RELOC_MIPS16_GPREL,
25482 +
25483 +/* High 16 bits of 32-bit value; simple reloc.  */
25484 +  BFD_RELOC_HI16,
25485 +
25486 +/* High 16 bits of 32-bit value but the low 16 bits will be sign
25487 +extended and added to form the final result.  If the low 16
25488 +bits form a negative number, we need to add one to the high value
25489 +to compensate for the borrow when the low bits are added.  */
25490 +  BFD_RELOC_HI16_S,
25491 +
25492 +/* Low 16 bits.  */
25493 +  BFD_RELOC_LO16,
25494 +
25495 +/* High 16 bits of 32-bit pc-relative value  */
25496 +  BFD_RELOC_HI16_PCREL,
25497 +
25498 +/* High 16 bits of 32-bit pc-relative value, adjusted  */
25499 +  BFD_RELOC_HI16_S_PCREL,
25500 +
25501 +/* Low 16 bits of pc-relative value  */
25502 +  BFD_RELOC_LO16_PCREL,
25503 +
25504 +/* MIPS16 high 16 bits of 32-bit value.  */
25505 +  BFD_RELOC_MIPS16_HI16,
25506 +
25507 +/* MIPS16 high 16 bits of 32-bit value but the low 16 bits will be sign
25508 +extended and added to form the final result.  If the low 16
25509 +bits form a negative number, we need to add one to the high value
25510 +to compensate for the borrow when the low bits are added.  */
25511 +  BFD_RELOC_MIPS16_HI16_S,
25512 +
25513 +/* MIPS16 low 16 bits.  */
25514 +  BFD_RELOC_MIPS16_LO16,
25515 +
25516 +/* Relocation against a MIPS literal section.  */
25517 +  BFD_RELOC_MIPS_LITERAL,
25518 +
25519 +/* MIPS ELF relocations.  */
25520 +  BFD_RELOC_MIPS_GOT16,
25521 +  BFD_RELOC_MIPS_CALL16,
25522 +  BFD_RELOC_MIPS_GOT_HI16,
25523 +  BFD_RELOC_MIPS_GOT_LO16,
25524 +  BFD_RELOC_MIPS_CALL_HI16,
25525 +  BFD_RELOC_MIPS_CALL_LO16,
25526 +  BFD_RELOC_MIPS_SUB,
25527 +  BFD_RELOC_MIPS_GOT_PAGE,
25528 +  BFD_RELOC_MIPS_GOT_OFST,
25529 +  BFD_RELOC_MIPS_GOT_DISP,
25530 +  BFD_RELOC_MIPS_SHIFT5,
25531 +  BFD_RELOC_MIPS_SHIFT6,
25532 +  BFD_RELOC_MIPS_INSERT_A,
25533 +  BFD_RELOC_MIPS_INSERT_B,
25534 +  BFD_RELOC_MIPS_DELETE,
25535 +  BFD_RELOC_MIPS_HIGHEST,
25536 +  BFD_RELOC_MIPS_HIGHER,
25537 +  BFD_RELOC_MIPS_SCN_DISP,
25538 +  BFD_RELOC_MIPS_REL16,
25539 +  BFD_RELOC_MIPS_RELGOT,
25540 +  BFD_RELOC_MIPS_JALR,
25541 +  BFD_RELOC_MIPS_TLS_DTPMOD32,
25542 +  BFD_RELOC_MIPS_TLS_DTPREL32,
25543 +  BFD_RELOC_MIPS_TLS_DTPMOD64,
25544 +  BFD_RELOC_MIPS_TLS_DTPREL64,
25545 +  BFD_RELOC_MIPS_TLS_GD,
25546 +  BFD_RELOC_MIPS_TLS_LDM,
25547 +  BFD_RELOC_MIPS_TLS_DTPREL_HI16,
25548 +  BFD_RELOC_MIPS_TLS_DTPREL_LO16,
25549 +  BFD_RELOC_MIPS_TLS_GOTTPREL,
25550 +  BFD_RELOC_MIPS_TLS_TPREL32,
25551 +  BFD_RELOC_MIPS_TLS_TPREL64,
25552 +  BFD_RELOC_MIPS_TLS_TPREL_HI16,
25553 +  BFD_RELOC_MIPS_TLS_TPREL_LO16,
25554 +
25555 +
25556 +/* Fujitsu Frv Relocations.  */
25557 +  BFD_RELOC_FRV_LABEL16,
25558 +  BFD_RELOC_FRV_LABEL24,
25559 +  BFD_RELOC_FRV_LO16,
25560 +  BFD_RELOC_FRV_HI16,
25561 +  BFD_RELOC_FRV_GPREL12,
25562 +  BFD_RELOC_FRV_GPRELU12,
25563 +  BFD_RELOC_FRV_GPREL32,
25564 +  BFD_RELOC_FRV_GPRELHI,
25565 +  BFD_RELOC_FRV_GPRELLO,
25566 +  BFD_RELOC_FRV_GOT12,
25567 +  BFD_RELOC_FRV_GOTHI,
25568 +  BFD_RELOC_FRV_GOTLO,
25569 +  BFD_RELOC_FRV_FUNCDESC,
25570 +  BFD_RELOC_FRV_FUNCDESC_GOT12,
25571 +  BFD_RELOC_FRV_FUNCDESC_GOTHI,
25572 +  BFD_RELOC_FRV_FUNCDESC_GOTLO,
25573 +  BFD_RELOC_FRV_FUNCDESC_VALUE,
25574 +  BFD_RELOC_FRV_FUNCDESC_GOTOFF12,
25575 +  BFD_RELOC_FRV_FUNCDESC_GOTOFFHI,
25576 +  BFD_RELOC_FRV_FUNCDESC_GOTOFFLO,
25577 +  BFD_RELOC_FRV_GOTOFF12,
25578 +  BFD_RELOC_FRV_GOTOFFHI,
25579 +  BFD_RELOC_FRV_GOTOFFLO,
25580 +  BFD_RELOC_FRV_GETTLSOFF,
25581 +  BFD_RELOC_FRV_TLSDESC_VALUE,
25582 +  BFD_RELOC_FRV_GOTTLSDESC12,
25583 +  BFD_RELOC_FRV_GOTTLSDESCHI,
25584 +  BFD_RELOC_FRV_GOTTLSDESCLO,
25585 +  BFD_RELOC_FRV_TLSMOFF12,
25586 +  BFD_RELOC_FRV_TLSMOFFHI,
25587 +  BFD_RELOC_FRV_TLSMOFFLO,
25588 +  BFD_RELOC_FRV_GOTTLSOFF12,
25589 +  BFD_RELOC_FRV_GOTTLSOFFHI,
25590 +  BFD_RELOC_FRV_GOTTLSOFFLO,
25591 +  BFD_RELOC_FRV_TLSOFF,
25592 +  BFD_RELOC_FRV_TLSDESC_RELAX,
25593 +  BFD_RELOC_FRV_GETTLSOFF_RELAX,
25594 +  BFD_RELOC_FRV_TLSOFF_RELAX,
25595 +  BFD_RELOC_FRV_TLSMOFF,
25596 +
25597 +
25598 +/* This is a 24bit GOT-relative reloc for the mn10300.  */
25599 +  BFD_RELOC_MN10300_GOTOFF24,
25600 +
25601 +/* This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes
25602 +in the instruction.  */
25603 +  BFD_RELOC_MN10300_GOT32,
25604 +
25605 +/* This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes
25606 +in the instruction.  */
25607 +  BFD_RELOC_MN10300_GOT24,
25608 +
25609 +/* This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes
25610 +in the instruction.  */
25611 +  BFD_RELOC_MN10300_GOT16,
25612 +
25613 +/* Copy symbol at runtime.  */
25614 +  BFD_RELOC_MN10300_COPY,
25615 +
25616 +/* Create GOT entry.  */
25617 +  BFD_RELOC_MN10300_GLOB_DAT,
25618 +
25619 +/* Create PLT entry.  */
25620 +  BFD_RELOC_MN10300_JMP_SLOT,
25621 +
25622 +/* Adjust by program base.  */
25623 +  BFD_RELOC_MN10300_RELATIVE,
25624 +
25625 +
25626 +/* i386/elf relocations  */
25627 +  BFD_RELOC_386_GOT32,
25628 +  BFD_RELOC_386_PLT32,
25629 +  BFD_RELOC_386_COPY,
25630 +  BFD_RELOC_386_GLOB_DAT,
25631 +  BFD_RELOC_386_JUMP_SLOT,
25632 +  BFD_RELOC_386_RELATIVE,
25633 +  BFD_RELOC_386_GOTOFF,
25634 +  BFD_RELOC_386_GOTPC,
25635 +  BFD_RELOC_386_TLS_TPOFF,
25636 +  BFD_RELOC_386_TLS_IE,
25637 +  BFD_RELOC_386_TLS_GOTIE,
25638 +  BFD_RELOC_386_TLS_LE,
25639 +  BFD_RELOC_386_TLS_GD,
25640 +  BFD_RELOC_386_TLS_LDM,
25641 +  BFD_RELOC_386_TLS_LDO_32,
25642 +  BFD_RELOC_386_TLS_IE_32,
25643 +  BFD_RELOC_386_TLS_LE_32,
25644 +  BFD_RELOC_386_TLS_DTPMOD32,
25645 +  BFD_RELOC_386_TLS_DTPOFF32,
25646 +  BFD_RELOC_386_TLS_TPOFF32,
25647 +
25648 +/* x86-64/elf relocations  */
25649 +  BFD_RELOC_X86_64_GOT32,
25650 +  BFD_RELOC_X86_64_PLT32,
25651 +  BFD_RELOC_X86_64_COPY,
25652 +  BFD_RELOC_X86_64_GLOB_DAT,
25653 +  BFD_RELOC_X86_64_JUMP_SLOT,
25654 +  BFD_RELOC_X86_64_RELATIVE,
25655 +  BFD_RELOC_X86_64_GOTPCREL,
25656 +  BFD_RELOC_X86_64_32S,
25657 +  BFD_RELOC_X86_64_DTPMOD64,
25658 +  BFD_RELOC_X86_64_DTPOFF64,
25659 +  BFD_RELOC_X86_64_TPOFF64,
25660 +  BFD_RELOC_X86_64_TLSGD,
25661 +  BFD_RELOC_X86_64_TLSLD,
25662 +  BFD_RELOC_X86_64_DTPOFF32,
25663 +  BFD_RELOC_X86_64_GOTTPOFF,
25664 +  BFD_RELOC_X86_64_TPOFF32,
25665 +  BFD_RELOC_X86_64_GOTOFF64,
25666 +  BFD_RELOC_X86_64_GOTPC32,
25667 +
25668 +/* ns32k relocations  */
25669 +  BFD_RELOC_NS32K_IMM_8,
25670 +  BFD_RELOC_NS32K_IMM_16,
25671 +  BFD_RELOC_NS32K_IMM_32,
25672 +  BFD_RELOC_NS32K_IMM_8_PCREL,
25673 +  BFD_RELOC_NS32K_IMM_16_PCREL,
25674 +  BFD_RELOC_NS32K_IMM_32_PCREL,
25675 +  BFD_RELOC_NS32K_DISP_8,
25676 +  BFD_RELOC_NS32K_DISP_16,
25677 +  BFD_RELOC_NS32K_DISP_32,
25678 +  BFD_RELOC_NS32K_DISP_8_PCREL,
25679 +  BFD_RELOC_NS32K_DISP_16_PCREL,
25680 +  BFD_RELOC_NS32K_DISP_32_PCREL,
25681 +
25682 +/* PDP11 relocations  */
25683 +  BFD_RELOC_PDP11_DISP_8_PCREL,
25684 +  BFD_RELOC_PDP11_DISP_6_PCREL,
25685 +
25686 +/* Picojava relocs.  Not all of these appear in object files.  */
25687 +  BFD_RELOC_PJ_CODE_HI16,
25688 +  BFD_RELOC_PJ_CODE_LO16,
25689 +  BFD_RELOC_PJ_CODE_DIR16,
25690 +  BFD_RELOC_PJ_CODE_DIR32,
25691 +  BFD_RELOC_PJ_CODE_REL16,
25692 +  BFD_RELOC_PJ_CODE_REL32,
25693 +
25694 +/* Power(rs6000) and PowerPC relocations.  */
25695 +  BFD_RELOC_PPC_B26,
25696 +  BFD_RELOC_PPC_BA26,
25697 +  BFD_RELOC_PPC_TOC16,
25698 +  BFD_RELOC_PPC_B16,
25699 +  BFD_RELOC_PPC_B16_BRTAKEN,
25700 +  BFD_RELOC_PPC_B16_BRNTAKEN,
25701 +  BFD_RELOC_PPC_BA16,
25702 +  BFD_RELOC_PPC_BA16_BRTAKEN,
25703 +  BFD_RELOC_PPC_BA16_BRNTAKEN,
25704 +  BFD_RELOC_PPC_COPY,
25705 +  BFD_RELOC_PPC_GLOB_DAT,
25706 +  BFD_RELOC_PPC_JMP_SLOT,
25707 +  BFD_RELOC_PPC_RELATIVE,
25708 +  BFD_RELOC_PPC_LOCAL24PC,
25709 +  BFD_RELOC_PPC_EMB_NADDR32,
25710 +  BFD_RELOC_PPC_EMB_NADDR16,
25711 +  BFD_RELOC_PPC_EMB_NADDR16_LO,
25712 +  BFD_RELOC_PPC_EMB_NADDR16_HI,
25713 +  BFD_RELOC_PPC_EMB_NADDR16_HA,
25714 +  BFD_RELOC_PPC_EMB_SDAI16,
25715 +  BFD_RELOC_PPC_EMB_SDA2I16,
25716 +  BFD_RELOC_PPC_EMB_SDA2REL,
25717 +  BFD_RELOC_PPC_EMB_SDA21,
25718 +  BFD_RELOC_PPC_EMB_MRKREF,
25719 +  BFD_RELOC_PPC_EMB_RELSEC16,
25720 +  BFD_RELOC_PPC_EMB_RELST_LO,
25721 +  BFD_RELOC_PPC_EMB_RELST_HI,
25722 +  BFD_RELOC_PPC_EMB_RELST_HA,
25723 +  BFD_RELOC_PPC_EMB_BIT_FLD,
25724 +  BFD_RELOC_PPC_EMB_RELSDA,
25725 +  BFD_RELOC_PPC64_HIGHER,
25726 +  BFD_RELOC_PPC64_HIGHER_S,
25727 +  BFD_RELOC_PPC64_HIGHEST,
25728 +  BFD_RELOC_PPC64_HIGHEST_S,
25729 +  BFD_RELOC_PPC64_TOC16_LO,
25730 +  BFD_RELOC_PPC64_TOC16_HI,
25731 +  BFD_RELOC_PPC64_TOC16_HA,
25732 +  BFD_RELOC_PPC64_TOC,
25733 +  BFD_RELOC_PPC64_PLTGOT16,
25734 +  BFD_RELOC_PPC64_PLTGOT16_LO,
25735 +  BFD_RELOC_PPC64_PLTGOT16_HI,
25736 +  BFD_RELOC_PPC64_PLTGOT16_HA,
25737 +  BFD_RELOC_PPC64_ADDR16_DS,
25738 +  BFD_RELOC_PPC64_ADDR16_LO_DS,
25739 +  BFD_RELOC_PPC64_GOT16_DS,
25740 +  BFD_RELOC_PPC64_GOT16_LO_DS,
25741 +  BFD_RELOC_PPC64_PLT16_LO_DS,
25742 +  BFD_RELOC_PPC64_SECTOFF_DS,
25743 +  BFD_RELOC_PPC64_SECTOFF_LO_DS,
25744 +  BFD_RELOC_PPC64_TOC16_DS,
25745 +  BFD_RELOC_PPC64_TOC16_LO_DS,
25746 +  BFD_RELOC_PPC64_PLTGOT16_DS,
25747 +  BFD_RELOC_PPC64_PLTGOT16_LO_DS,
25748 +
25749 +/* PowerPC and PowerPC64 thread-local storage relocations.  */
25750 +  BFD_RELOC_PPC_TLS,
25751 +  BFD_RELOC_PPC_DTPMOD,
25752 +  BFD_RELOC_PPC_TPREL16,
25753 +  BFD_RELOC_PPC_TPREL16_LO,
25754 +  BFD_RELOC_PPC_TPREL16_HI,
25755 +  BFD_RELOC_PPC_TPREL16_HA,
25756 +  BFD_RELOC_PPC_TPREL,
25757 +  BFD_RELOC_PPC_DTPREL16,
25758 +  BFD_RELOC_PPC_DTPREL16_LO,
25759 +  BFD_RELOC_PPC_DTPREL16_HI,
25760 +  BFD_RELOC_PPC_DTPREL16_HA,
25761 +  BFD_RELOC_PPC_DTPREL,
25762 +  BFD_RELOC_PPC_GOT_TLSGD16,
25763 +  BFD_RELOC_PPC_GOT_TLSGD16_LO,
25764 +  BFD_RELOC_PPC_GOT_TLSGD16_HI,
25765 +  BFD_RELOC_PPC_GOT_TLSGD16_HA,
25766 +  BFD_RELOC_PPC_GOT_TLSLD16,
25767 +  BFD_RELOC_PPC_GOT_TLSLD16_LO,
25768 +  BFD_RELOC_PPC_GOT_TLSLD16_HI,
25769 +  BFD_RELOC_PPC_GOT_TLSLD16_HA,
25770 +  BFD_RELOC_PPC_GOT_TPREL16,
25771 +  BFD_RELOC_PPC_GOT_TPREL16_LO,
25772 +  BFD_RELOC_PPC_GOT_TPREL16_HI,
25773 +  BFD_RELOC_PPC_GOT_TPREL16_HA,
25774 +  BFD_RELOC_PPC_GOT_DTPREL16,
25775 +  BFD_RELOC_PPC_GOT_DTPREL16_LO,
25776 +  BFD_RELOC_PPC_GOT_DTPREL16_HI,
25777 +  BFD_RELOC_PPC_GOT_DTPREL16_HA,
25778 +  BFD_RELOC_PPC64_TPREL16_DS,
25779 +  BFD_RELOC_PPC64_TPREL16_LO_DS,
25780 +  BFD_RELOC_PPC64_TPREL16_HIGHER,
25781 +  BFD_RELOC_PPC64_TPREL16_HIGHERA,
25782 +  BFD_RELOC_PPC64_TPREL16_HIGHEST,
25783 +  BFD_RELOC_PPC64_TPREL16_HIGHESTA,
25784 +  BFD_RELOC_PPC64_DTPREL16_DS,
25785 +  BFD_RELOC_PPC64_DTPREL16_LO_DS,
25786 +  BFD_RELOC_PPC64_DTPREL16_HIGHER,
25787 +  BFD_RELOC_PPC64_DTPREL16_HIGHERA,
25788 +  BFD_RELOC_PPC64_DTPREL16_HIGHEST,
25789 +  BFD_RELOC_PPC64_DTPREL16_HIGHESTA,
25790 +
25791 +/* IBM 370/390 relocations  */
25792 +  BFD_RELOC_I370_D12,
25793 +
25794 +/* The type of reloc used to build a constructor table - at the moment
25795 +probably a 32 bit wide absolute relocation, but the target can choose.
25796 +It generally does map to one of the other relocation types.  */
25797 +  BFD_RELOC_CTOR,
25798 +
25799 +/* ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
25800 +not stored in the instruction.  */
25801 +  BFD_RELOC_ARM_PCREL_BRANCH,
25802 +
25803 +/* ARM 26 bit pc-relative branch.  The lowest bit must be zero and is
25804 +not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
25805 +field in the instruction.  */
25806 +  BFD_RELOC_ARM_PCREL_BLX,
25807 +
25808 +/* Thumb 22 bit pc-relative branch.  The lowest bit must be zero and is
25809 +not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
25810 +field in the instruction.  */
25811 +  BFD_RELOC_THUMB_PCREL_BLX,
25812 +
25813 +/* Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches.
25814 +The lowest bit must be zero and is not stored in the instruction.
25815 +Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an
25816 +"nn" one smaller in all cases.  Note further that BRANCH23
25817 +corresponds to R_ARM_THM_CALL.  */
25818 +  BFD_RELOC_THUMB_PCREL_BRANCH7,
25819 +  BFD_RELOC_THUMB_PCREL_BRANCH9,
25820 +  BFD_RELOC_THUMB_PCREL_BRANCH12,
25821 +  BFD_RELOC_THUMB_PCREL_BRANCH20,
25822 +  BFD_RELOC_THUMB_PCREL_BRANCH23,
25823 +  BFD_RELOC_THUMB_PCREL_BRANCH25,
25824 +
25825 +/* 12-bit immediate offset, used in ARM-format ldr and str instructions.  */
25826 +  BFD_RELOC_ARM_OFFSET_IMM,
25827 +
25828 +/* 5-bit immediate offset, used in Thumb-format ldr and str instructions.  */
25829 +  BFD_RELOC_ARM_THUMB_OFFSET,
25830 +
25831 +/* Pc-relative or absolute relocation depending on target.  Used for
25832 +entries in .init_array sections.  */
25833 +  BFD_RELOC_ARM_TARGET1,
25834 +
25835 +/* Read-only segment base relative address.  */
25836 +  BFD_RELOC_ARM_ROSEGREL32,
25837 +
25838 +/* Data segment base relative address.  */
25839 +  BFD_RELOC_ARM_SBREL32,
25840 +
25841 +/* This reloc is used for references to RTTI data from exception handling
25842 +tables.  The actual definition depends on the target.  It may be a
25843 +pc-relative or some form of GOT-indirect relocation.  */
25844 +  BFD_RELOC_ARM_TARGET2,
25845 +
25846 +/* 31-bit PC relative address.  */
25847 +  BFD_RELOC_ARM_PREL31,
25848 +
25849 +/* Relocations for setting up GOTs and PLTs for shared libraries.  */
25850 +  BFD_RELOC_ARM_JUMP_SLOT,
25851 +  BFD_RELOC_ARM_GLOB_DAT,
25852 +  BFD_RELOC_ARM_GOT32,
25853 +  BFD_RELOC_ARM_PLT32,
25854 +  BFD_RELOC_ARM_RELATIVE,
25855 +  BFD_RELOC_ARM_GOTOFF,
25856 +  BFD_RELOC_ARM_GOTPC,
25857 +
25858 +/* ARM thread-local storage relocations.  */
25859 +  BFD_RELOC_ARM_TLS_GD32,
25860 +  BFD_RELOC_ARM_TLS_LDO32,
25861 +  BFD_RELOC_ARM_TLS_LDM32,
25862 +  BFD_RELOC_ARM_TLS_DTPOFF32,
25863 +  BFD_RELOC_ARM_TLS_DTPMOD32,
25864 +  BFD_RELOC_ARM_TLS_TPOFF32,
25865 +  BFD_RELOC_ARM_TLS_IE32,
25866 +  BFD_RELOC_ARM_TLS_LE32,
25867 +
25868 +/* These relocs are only used within the ARM assembler.  They are not
25869 +(at present) written to any object files.  */
25870 +  BFD_RELOC_ARM_IMMEDIATE,
25871 +  BFD_RELOC_ARM_ADRL_IMMEDIATE,
25872 +  BFD_RELOC_ARM_T32_IMMEDIATE,
25873 +  BFD_RELOC_ARM_SHIFT_IMM,
25874 +  BFD_RELOC_ARM_SMI,
25875 +  BFD_RELOC_ARM_SWI,
25876 +  BFD_RELOC_ARM_MULTI,
25877 +  BFD_RELOC_ARM_CP_OFF_IMM,
25878 +  BFD_RELOC_ARM_CP_OFF_IMM_S2,
25879 +  BFD_RELOC_ARM_ADR_IMM,
25880 +  BFD_RELOC_ARM_LDR_IMM,
25881 +  BFD_RELOC_ARM_LITERAL,
25882 +  BFD_RELOC_ARM_IN_POOL,
25883 +  BFD_RELOC_ARM_OFFSET_IMM8,
25884 +  BFD_RELOC_ARM_T32_OFFSET_U8,
25885 +  BFD_RELOC_ARM_T32_OFFSET_IMM,
25886 +  BFD_RELOC_ARM_HWLITERAL,
25887 +  BFD_RELOC_ARM_THUMB_ADD,
25888 +  BFD_RELOC_ARM_THUMB_IMM,
25889 +  BFD_RELOC_ARM_THUMB_SHIFT,
25890 +
25891 +/* Renesas / SuperH SH relocs.  Not all of these appear in object files.  */
25892 +  BFD_RELOC_SH_PCDISP8BY2,
25893 +  BFD_RELOC_SH_PCDISP12BY2,
25894 +  BFD_RELOC_SH_IMM3,
25895 +  BFD_RELOC_SH_IMM3U,
25896 +  BFD_RELOC_SH_DISP12,
25897 +  BFD_RELOC_SH_DISP12BY2,
25898 +  BFD_RELOC_SH_DISP12BY4,
25899 +  BFD_RELOC_SH_DISP12BY8,
25900 +  BFD_RELOC_SH_DISP20,
25901 +  BFD_RELOC_SH_DISP20BY8,
25902 +  BFD_RELOC_SH_IMM4,
25903 +  BFD_RELOC_SH_IMM4BY2,
25904 +  BFD_RELOC_SH_IMM4BY4,
25905 +  BFD_RELOC_SH_IMM8,
25906 +  BFD_RELOC_SH_IMM8BY2,
25907 +  BFD_RELOC_SH_IMM8BY4,
25908 +  BFD_RELOC_SH_PCRELIMM8BY2,
25909 +  BFD_RELOC_SH_PCRELIMM8BY4,
25910 +  BFD_RELOC_SH_SWITCH16,
25911 +  BFD_RELOC_SH_SWITCH32,
25912 +  BFD_RELOC_SH_USES,
25913 +  BFD_RELOC_SH_COUNT,
25914 +  BFD_RELOC_SH_ALIGN,
25915 +  BFD_RELOC_SH_CODE,
25916 +  BFD_RELOC_SH_DATA,
25917 +  BFD_RELOC_SH_LABEL,
25918 +  BFD_RELOC_SH_LOOP_START,
25919 +  BFD_RELOC_SH_LOOP_END,
25920 +  BFD_RELOC_SH_COPY,
25921 +  BFD_RELOC_SH_GLOB_DAT,
25922 +  BFD_RELOC_SH_JMP_SLOT,
25923 +  BFD_RELOC_SH_RELATIVE,
25924 +  BFD_RELOC_SH_GOTPC,
25925 +  BFD_RELOC_SH_GOT_LOW16,
25926 +  BFD_RELOC_SH_GOT_MEDLOW16,
25927 +  BFD_RELOC_SH_GOT_MEDHI16,
25928 +  BFD_RELOC_SH_GOT_HI16,
25929 +  BFD_RELOC_SH_GOTPLT_LOW16,
25930 +  BFD_RELOC_SH_GOTPLT_MEDLOW16,
25931 +  BFD_RELOC_SH_GOTPLT_MEDHI16,
25932 +  BFD_RELOC_SH_GOTPLT_HI16,
25933 +  BFD_RELOC_SH_PLT_LOW16,
25934 +  BFD_RELOC_SH_PLT_MEDLOW16,
25935 +  BFD_RELOC_SH_PLT_MEDHI16,
25936 +  BFD_RELOC_SH_PLT_HI16,
25937 +  BFD_RELOC_SH_GOTOFF_LOW16,
25938 +  BFD_RELOC_SH_GOTOFF_MEDLOW16,
25939 +  BFD_RELOC_SH_GOTOFF_MEDHI16,
25940 +  BFD_RELOC_SH_GOTOFF_HI16,
25941 +  BFD_RELOC_SH_GOTPC_LOW16,
25942 +  BFD_RELOC_SH_GOTPC_MEDLOW16,
25943 +  BFD_RELOC_SH_GOTPC_MEDHI16,
25944 +  BFD_RELOC_SH_GOTPC_HI16,
25945 +  BFD_RELOC_SH_COPY64,
25946 +  BFD_RELOC_SH_GLOB_DAT64,
25947 +  BFD_RELOC_SH_JMP_SLOT64,
25948 +  BFD_RELOC_SH_RELATIVE64,
25949 +  BFD_RELOC_SH_GOT10BY4,
25950 +  BFD_RELOC_SH_GOT10BY8,
25951 +  BFD_RELOC_SH_GOTPLT10BY4,
25952 +  BFD_RELOC_SH_GOTPLT10BY8,
25953 +  BFD_RELOC_SH_GOTPLT32,
25954 +  BFD_RELOC_SH_SHMEDIA_CODE,
25955 +  BFD_RELOC_SH_IMMU5,
25956 +  BFD_RELOC_SH_IMMS6,
25957 +  BFD_RELOC_SH_IMMS6BY32,
25958 +  BFD_RELOC_SH_IMMU6,
25959 +  BFD_RELOC_SH_IMMS10,
25960 +  BFD_RELOC_SH_IMMS10BY2,
25961 +  BFD_RELOC_SH_IMMS10BY4,
25962 +  BFD_RELOC_SH_IMMS10BY8,
25963 +  BFD_RELOC_SH_IMMS16,
25964 +  BFD_RELOC_SH_IMMU16,
25965 +  BFD_RELOC_SH_IMM_LOW16,
25966 +  BFD_RELOC_SH_IMM_LOW16_PCREL,
25967 +  BFD_RELOC_SH_IMM_MEDLOW16,
25968 +  BFD_RELOC_SH_IMM_MEDLOW16_PCREL,
25969 +  BFD_RELOC_SH_IMM_MEDHI16,
25970 +  BFD_RELOC_SH_IMM_MEDHI16_PCREL,
25971 +  BFD_RELOC_SH_IMM_HI16,
25972 +  BFD_RELOC_SH_IMM_HI16_PCREL,
25973 +  BFD_RELOC_SH_PT_16,
25974 +  BFD_RELOC_SH_TLS_GD_32,
25975 +  BFD_RELOC_SH_TLS_LD_32,
25976 +  BFD_RELOC_SH_TLS_LDO_32,
25977 +  BFD_RELOC_SH_TLS_IE_32,
25978 +  BFD_RELOC_SH_TLS_LE_32,
25979 +  BFD_RELOC_SH_TLS_DTPMOD32,
25980 +  BFD_RELOC_SH_TLS_DTPOFF32,
25981 +  BFD_RELOC_SH_TLS_TPOFF32,
25982 +
25983 +/* ARC Cores relocs.
25984 +ARC 22 bit pc-relative branch.  The lowest two bits must be zero and are
25985 +not stored in the instruction.  The high 20 bits are installed in bits 26
25986 +through 7 of the instruction.  */
25987 +  BFD_RELOC_ARC_B22_PCREL,
25988 +
25989 +/* ARC 26 bit absolute branch.  The lowest two bits must be zero and are not
25990 +stored in the instruction.  The high 24 bits are installed in bits 23
25991 +through 0.  */
25992 +  BFD_RELOC_ARC_B26,
25993 +
25994 +/* Mitsubishi D10V relocs.
25995 +This is a 10-bit reloc with the right 2 bits
25996 +assumed to be 0.  */
25997 +  BFD_RELOC_D10V_10_PCREL_R,
25998 +
25999 +/* Mitsubishi D10V relocs.
26000 +This is a 10-bit reloc with the right 2 bits
26001 +assumed to be 0.  This is the same as the previous reloc
26002 +except it is in the left container, i.e.,
26003 +shifted left 15 bits.  */
26004 +  BFD_RELOC_D10V_10_PCREL_L,
26005 +
26006 +/* This is an 18-bit reloc with the right 2 bits
26007 +assumed to be 0.  */
26008 +  BFD_RELOC_D10V_18,
26009 +
26010 +/* This is an 18-bit reloc with the right 2 bits
26011 +assumed to be 0.  */
26012 +  BFD_RELOC_D10V_18_PCREL,
26013 +
26014 +/* Mitsubishi D30V relocs.
26015 +This is a 6-bit absolute reloc.  */
26016 +  BFD_RELOC_D30V_6,
26017 +
26018 +/* This is a 6-bit pc-relative reloc with
26019 +the right 3 bits assumed to be 0.  */
26020 +  BFD_RELOC_D30V_9_PCREL,
26021 +
26022 +/* This is a 6-bit pc-relative reloc with
26023 +the right 3 bits assumed to be 0. Same
26024 +as the previous reloc but on the right side
26025 +of the container.  */
26026 +  BFD_RELOC_D30V_9_PCREL_R,
26027 +
26028 +/* This is a 12-bit absolute reloc with the
26029 +right 3 bitsassumed to be 0.  */
26030 +  BFD_RELOC_D30V_15,
26031 +
26032 +/* This is a 12-bit pc-relative reloc with
26033 +the right 3 bits assumed to be 0.  */
26034 +  BFD_RELOC_D30V_15_PCREL,
26035 +
26036 +/* This is a 12-bit pc-relative reloc with
26037 +the right 3 bits assumed to be 0. Same
26038 +as the previous reloc but on the right side
26039 +of the container.  */
26040 +  BFD_RELOC_D30V_15_PCREL_R,
26041 +
26042 +/* This is an 18-bit absolute reloc with
26043 +the right 3 bits assumed to be 0.  */
26044 +  BFD_RELOC_D30V_21,
26045 +
26046 +/* This is an 18-bit pc-relative reloc with
26047 +the right 3 bits assumed to be 0.  */
26048 +  BFD_RELOC_D30V_21_PCREL,
26049 +
26050 +/* This is an 18-bit pc-relative reloc with
26051 +the right 3 bits assumed to be 0. Same
26052 +as the previous reloc but on the right side
26053 +of the container.  */
26054 +  BFD_RELOC_D30V_21_PCREL_R,
26055 +
26056 +/* This is a 32-bit absolute reloc.  */
26057 +  BFD_RELOC_D30V_32,
26058 +
26059 +/* This is a 32-bit pc-relative reloc.  */
26060 +  BFD_RELOC_D30V_32_PCREL,
26061 +
26062 +/* DLX relocs  */
26063 +  BFD_RELOC_DLX_HI16_S,
26064 +
26065 +/* DLX relocs  */
26066 +  BFD_RELOC_DLX_LO16,
26067 +
26068 +/* DLX relocs  */
26069 +  BFD_RELOC_DLX_JMP26,
26070 +
26071 +/* Renesas M16C/M32C Relocations.  */
26072 +  BFD_RELOC_M16C_8_PCREL8,
26073 +  BFD_RELOC_M16C_16_PCREL8,
26074 +  BFD_RELOC_M16C_8_PCREL16,
26075 +  BFD_RELOC_M16C_8_ELABEL24,
26076 +  BFD_RELOC_M16C_8_ABS16,
26077 +  BFD_RELOC_M16C_16_ABS16,
26078 +  BFD_RELOC_M16C_16_ABS24,
26079 +  BFD_RELOC_M16C_16_ABS32,
26080 +  BFD_RELOC_M16C_24_ABS16,
26081 +  BFD_RELOC_M16C_24_ABS24,
26082 +  BFD_RELOC_M16C_24_ABS32,
26083 +  BFD_RELOC_M16C_32_ABS16,
26084 +  BFD_RELOC_M16C_32_ABS24,
26085 +  BFD_RELOC_M16C_32_ABS32,
26086 +  BFD_RELOC_M16C_40_ABS16,
26087 +  BFD_RELOC_M16C_40_ABS24,
26088 +  BFD_RELOC_M16C_40_ABS32,
26089 +
26090 +/* Renesas M32R (formerly Mitsubishi M32R) relocs.
26091 +This is a 24 bit absolute address.  */
26092 +  BFD_RELOC_M32R_24,
26093 +
26094 +/* This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.  */
26095 +  BFD_RELOC_M32R_10_PCREL,
26096 +
26097 +/* This is an 18-bit reloc with the right 2 bits assumed to be 0.  */
26098 +  BFD_RELOC_M32R_18_PCREL,
26099 +
26100 +/* This is a 26-bit reloc with the right 2 bits assumed to be 0.  */
26101 +  BFD_RELOC_M32R_26_PCREL,
26102 +
26103 +/* This is a 16-bit reloc containing the high 16 bits of an address
26104 +used when the lower 16 bits are treated as unsigned.  */
26105 +  BFD_RELOC_M32R_HI16_ULO,
26106 +
26107 +/* This is a 16-bit reloc containing the high 16 bits of an address
26108 +used when the lower 16 bits are treated as signed.  */
26109 +  BFD_RELOC_M32R_HI16_SLO,
26110 +
26111 +/* This is a 16-bit reloc containing the lower 16 bits of an address.  */
26112 +  BFD_RELOC_M32R_LO16,
26113 +
26114 +/* This is a 16-bit reloc containing the small data area offset for use in
26115 +add3, load, and store instructions.  */
26116 +  BFD_RELOC_M32R_SDA16,
26117 +
26118 +/* For PIC.  */
26119 +  BFD_RELOC_M32R_GOT24,
26120 +  BFD_RELOC_M32R_26_PLTREL,
26121 +  BFD_RELOC_M32R_COPY,
26122 +  BFD_RELOC_M32R_GLOB_DAT,
26123 +  BFD_RELOC_M32R_JMP_SLOT,
26124 +  BFD_RELOC_M32R_RELATIVE,
26125 +  BFD_RELOC_M32R_GOTOFF,
26126 +  BFD_RELOC_M32R_GOTOFF_HI_ULO,
26127 +  BFD_RELOC_M32R_GOTOFF_HI_SLO,
26128 +  BFD_RELOC_M32R_GOTOFF_LO,
26129 +  BFD_RELOC_M32R_GOTPC24,
26130 +  BFD_RELOC_M32R_GOT16_HI_ULO,
26131 +  BFD_RELOC_M32R_GOT16_HI_SLO,
26132 +  BFD_RELOC_M32R_GOT16_LO,
26133 +  BFD_RELOC_M32R_GOTPC_HI_ULO,
26134 +  BFD_RELOC_M32R_GOTPC_HI_SLO,
26135 +  BFD_RELOC_M32R_GOTPC_LO,
26136 +
26137 +/* This is a 9-bit reloc  */
26138 +  BFD_RELOC_V850_9_PCREL,
26139 +
26140 +/* This is a 22-bit reloc  */
26141 +  BFD_RELOC_V850_22_PCREL,
26142 +
26143 +/* This is a 16 bit offset from the short data area pointer.  */
26144 +  BFD_RELOC_V850_SDA_16_16_OFFSET,
26145 +
26146 +/* This is a 16 bit offset (of which only 15 bits are used) from the
26147 +short data area pointer.  */
26148 +  BFD_RELOC_V850_SDA_15_16_OFFSET,
26149 +
26150 +/* This is a 16 bit offset from the zero data area pointer.  */
26151 +  BFD_RELOC_V850_ZDA_16_16_OFFSET,
26152 +
26153 +/* This is a 16 bit offset (of which only 15 bits are used) from the
26154 +zero data area pointer.  */
26155 +  BFD_RELOC_V850_ZDA_15_16_OFFSET,
26156 +
26157 +/* This is an 8 bit offset (of which only 6 bits are used) from the
26158 +tiny data area pointer.  */
26159 +  BFD_RELOC_V850_TDA_6_8_OFFSET,
26160 +
26161 +/* This is an 8bit offset (of which only 7 bits are used) from the tiny
26162 +data area pointer.  */
26163 +  BFD_RELOC_V850_TDA_7_8_OFFSET,
26164 +
26165 +/* This is a 7 bit offset from the tiny data area pointer.  */
26166 +  BFD_RELOC_V850_TDA_7_7_OFFSET,
26167 +
26168 +/* This is a 16 bit offset from the tiny data area pointer.  */
26169 +  BFD_RELOC_V850_TDA_16_16_OFFSET,
26170 +
26171 +/* This is a 5 bit offset (of which only 4 bits are used) from the tiny
26172 +data area pointer.  */
26173 +  BFD_RELOC_V850_TDA_4_5_OFFSET,
26174 +
26175 +/* This is a 4 bit offset from the tiny data area pointer.  */
26176 +  BFD_RELOC_V850_TDA_4_4_OFFSET,
26177 +
26178 +/* This is a 16 bit offset from the short data area pointer, with the
26179 +bits placed non-contiguously in the instruction.  */
26180 +  BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET,
26181 +
26182 +/* This is a 16 bit offset from the zero data area pointer, with the
26183 +bits placed non-contiguously in the instruction.  */
26184 +  BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET,
26185 +
26186 +/* This is a 6 bit offset from the call table base pointer.  */
26187 +  BFD_RELOC_V850_CALLT_6_7_OFFSET,
26188 +
26189 +/* This is a 16 bit offset from the call table base pointer.  */
26190 +  BFD_RELOC_V850_CALLT_16_16_OFFSET,
26191 +
26192 +/* Used for relaxing indirect function calls.  */
26193 +  BFD_RELOC_V850_LONGCALL,
26194 +
26195 +/* Used for relaxing indirect jumps.  */
26196 +  BFD_RELOC_V850_LONGJUMP,
26197 +
26198 +/* Used to maintain alignment whilst relaxing.  */
26199 +  BFD_RELOC_V850_ALIGN,
26200 +
26201 +/* This is a variation of BFD_RELOC_LO16 that can be used in v850e ld.bu
26202 +instructions.  */
26203 +  BFD_RELOC_V850_LO16_SPLIT_OFFSET,
26204 +
26205 +/* This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
26206 +instruction.  */
26207 +  BFD_RELOC_MN10300_32_PCREL,
26208 +
26209 +/* This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
26210 +instruction.  */
26211 +  BFD_RELOC_MN10300_16_PCREL,
26212 +
26213 +/* This is a 8bit DP reloc for the tms320c30, where the most
26214 +significant 8 bits of a 24 bit word are placed into the least
26215 +significant 8 bits of the opcode.  */
26216 +  BFD_RELOC_TIC30_LDP,
26217 +
26218 +/* This is a 7bit reloc for the tms320c54x, where the least
26219 +significant 7 bits of a 16 bit word are placed into the least
26220 +significant 7 bits of the opcode.  */
26221 +  BFD_RELOC_TIC54X_PARTLS7,
26222 +
26223 +/* This is a 9bit DP reloc for the tms320c54x, where the most
26224 +significant 9 bits of a 16 bit word are placed into the least
26225 +significant 9 bits of the opcode.  */
26226 +  BFD_RELOC_TIC54X_PARTMS9,
26227 +
26228 +/* This is an extended address 23-bit reloc for the tms320c54x.  */
26229 +  BFD_RELOC_TIC54X_23,
26230 +
26231 +/* This is a 16-bit reloc for the tms320c54x, where the least
26232 +significant 16 bits of a 23-bit extended address are placed into
26233 +the opcode.  */
26234 +  BFD_RELOC_TIC54X_16_OF_23,
26235 +
26236 +/* This is a reloc for the tms320c54x, where the most
26237 +significant 7 bits of a 23-bit extended address are placed into
26238 +the opcode.  */
26239 +  BFD_RELOC_TIC54X_MS7_OF_23,
26240 +
26241 +/* This is a 48 bit reloc for the FR30 that stores 32 bits.  */
26242 +  BFD_RELOC_FR30_48,
26243 +
26244 +/* This is a 32 bit reloc for the FR30 that stores 20 bits split up into
26245 +two sections.  */
26246 +  BFD_RELOC_FR30_20,
26247 +
26248 +/* This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
26249 +4 bits.  */
26250 +  BFD_RELOC_FR30_6_IN_4,
26251 +
26252 +/* This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
26253 +into 8 bits.  */
26254 +  BFD_RELOC_FR30_8_IN_8,
26255 +
26256 +/* This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
26257 +into 8 bits.  */
26258 +  BFD_RELOC_FR30_9_IN_8,
26259 +
26260 +/* This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
26261 +into 8 bits.  */
26262 +  BFD_RELOC_FR30_10_IN_8,
26263 +
26264 +/* This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
26265 +short offset into 8 bits.  */
26266 +  BFD_RELOC_FR30_9_PCREL,
26267 +
26268 +/* This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
26269 +short offset into 11 bits.  */
26270 +  BFD_RELOC_FR30_12_PCREL,
26271 +
26272 +/* Motorola Mcore relocations.  */
26273 +  BFD_RELOC_MCORE_PCREL_IMM8BY4,
26274 +  BFD_RELOC_MCORE_PCREL_IMM11BY2,
26275 +  BFD_RELOC_MCORE_PCREL_IMM4BY2,
26276 +  BFD_RELOC_MCORE_PCREL_32,
26277 +  BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2,
26278 +  BFD_RELOC_MCORE_RVA,
26279 +
26280 +/* These are relocations for the GETA instruction.  */
26281 +  BFD_RELOC_MMIX_GETA,
26282 +  BFD_RELOC_MMIX_GETA_1,
26283 +  BFD_RELOC_MMIX_GETA_2,
26284 +  BFD_RELOC_MMIX_GETA_3,
26285 +
26286 +/* These are relocations for a conditional branch instruction.  */
26287 +  BFD_RELOC_MMIX_CBRANCH,
26288 +  BFD_RELOC_MMIX_CBRANCH_J,
26289 +  BFD_RELOC_MMIX_CBRANCH_1,
26290 +  BFD_RELOC_MMIX_CBRANCH_2,
26291 +  BFD_RELOC_MMIX_CBRANCH_3,
26292 +
26293 +/* These are relocations for the PUSHJ instruction.  */
26294 +  BFD_RELOC_MMIX_PUSHJ,
26295 +  BFD_RELOC_MMIX_PUSHJ_1,
26296 +  BFD_RELOC_MMIX_PUSHJ_2,
26297 +  BFD_RELOC_MMIX_PUSHJ_3,
26298 +  BFD_RELOC_MMIX_PUSHJ_STUBBABLE,
26299 +
26300 +/* These are relocations for the JMP instruction.  */
26301 +  BFD_RELOC_MMIX_JMP,
26302 +  BFD_RELOC_MMIX_JMP_1,
26303 +  BFD_RELOC_MMIX_JMP_2,
26304 +  BFD_RELOC_MMIX_JMP_3,
26305 +
26306 +/* This is a relocation for a relative address as in a GETA instruction or
26307 +a branch.  */
26308 +  BFD_RELOC_MMIX_ADDR19,
26309 +
26310 +/* This is a relocation for a relative address as in a JMP instruction.  */
26311 +  BFD_RELOC_MMIX_ADDR27,
26312 +
26313 +/* This is a relocation for an instruction field that may be a general
26314 +register or a value 0..255.  */
26315 +  BFD_RELOC_MMIX_REG_OR_BYTE,
26316 +
26317 +/* This is a relocation for an instruction field that may be a general
26318 +register.  */
26319 +  BFD_RELOC_MMIX_REG,
26320 +
26321 +/* This is a relocation for two instruction fields holding a register and
26322 +an offset, the equivalent of the relocation.  */
26323 +  BFD_RELOC_MMIX_BASE_PLUS_OFFSET,
26324 +
26325 +/* This relocation is an assertion that the expression is not allocated as
26326 +a global register.  It does not modify contents.  */
26327 +  BFD_RELOC_MMIX_LOCAL,
26328 +
26329 +/* This is a 16 bit reloc for the AVR that stores 8 bit pc relative
26330 +short offset into 7 bits.  */
26331 +  BFD_RELOC_AVR_7_PCREL,
26332 +
26333 +/* This is a 16 bit reloc for the AVR that stores 13 bit pc relative
26334 +short offset into 12 bits.  */
26335 +  BFD_RELOC_AVR_13_PCREL,
26336 +
26337 +/* This is a 16 bit reloc for the AVR that stores 17 bit value (usually
26338 +program memory address) into 16 bits.  */
26339 +  BFD_RELOC_AVR_16_PM,
26340 +
26341 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually
26342 +data memory address) into 8 bit immediate value of LDI insn.  */
26343 +  BFD_RELOC_AVR_LO8_LDI,
26344 +
26345 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
26346 +of data memory address) into 8 bit immediate value of LDI insn.  */
26347 +  BFD_RELOC_AVR_HI8_LDI,
26348 +
26349 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
26350 +of program memory address) into 8 bit immediate value of LDI insn.  */
26351 +  BFD_RELOC_AVR_HH8_LDI,
26352 +
26353 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
26354 +(usually data memory address) into 8 bit immediate value of SUBI insn.  */
26355 +  BFD_RELOC_AVR_LO8_LDI_NEG,
26356 +
26357 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
26358 +(high 8 bit of data memory address) into 8 bit immediate value of
26359 +SUBI insn.  */
26360 +  BFD_RELOC_AVR_HI8_LDI_NEG,
26361 +
26362 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
26363 +(most high 8 bit of program memory address) into 8 bit immediate value
26364 +of LDI or SUBI insn.  */
26365 +  BFD_RELOC_AVR_HH8_LDI_NEG,
26366 +
26367 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually
26368 +command address) into 8 bit immediate value of LDI insn.  */
26369 +  BFD_RELOC_AVR_LO8_LDI_PM,
26370 +
26371 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
26372 +of command address) into 8 bit immediate value of LDI insn.  */
26373 +  BFD_RELOC_AVR_HI8_LDI_PM,
26374 +
26375 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
26376 +of command address) into 8 bit immediate value of LDI insn.  */
26377 +  BFD_RELOC_AVR_HH8_LDI_PM,
26378 +
26379 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
26380 +(usually command address) into 8 bit immediate value of SUBI insn.  */
26381 +  BFD_RELOC_AVR_LO8_LDI_PM_NEG,
26382 +
26383 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
26384 +(high 8 bit of 16 bit command address) into 8 bit immediate value
26385 +of SUBI insn.  */
26386 +  BFD_RELOC_AVR_HI8_LDI_PM_NEG,
26387 +
26388 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
26389 +(high 6 bit of 22 bit command address) into 8 bit immediate
26390 +value of SUBI insn.  */
26391 +  BFD_RELOC_AVR_HH8_LDI_PM_NEG,
26392 +
26393 +/* This is a 32 bit reloc for the AVR that stores 23 bit value
26394 +into 22 bits.  */
26395 +  BFD_RELOC_AVR_CALL,
26396 +
26397 +/* This is a 16 bit reloc for the AVR that stores all needed bits
26398 +for absolute addressing with ldi with overflow check to linktime  */
26399 +  BFD_RELOC_AVR_LDI,
26400 +
26401 +/* This is a 6 bit reloc for the AVR that stores offset for ldd/std
26402 +instructions  */
26403 +  BFD_RELOC_AVR_6,
26404 +
26405 +/* This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw
26406 +instructions  */
26407 +  BFD_RELOC_AVR_6_ADIW,
26408 +
26409 +/* Direct 12 bit.  */
26410 +  BFD_RELOC_390_12,
26411 +
26412 +/* 12 bit GOT offset.  */
26413 +  BFD_RELOC_390_GOT12,
26414 +
26415 +/* 32 bit PC relative PLT address.  */
26416 +  BFD_RELOC_390_PLT32,
26417 +
26418 +/* Copy symbol at runtime.  */
26419 +  BFD_RELOC_390_COPY,
26420 +
26421 +/* Create GOT entry.  */
26422 +  BFD_RELOC_390_GLOB_DAT,
26423 +
26424 +/* Create PLT entry.  */
26425 +  BFD_RELOC_390_JMP_SLOT,
26426 +
26427 +/* Adjust by program base.  */
26428 +  BFD_RELOC_390_RELATIVE,
26429 +
26430 +/* 32 bit PC relative offset to GOT.  */
26431 +  BFD_RELOC_390_GOTPC,
26432 +
26433 +/* 16 bit GOT offset.  */
26434 +  BFD_RELOC_390_GOT16,
26435 +
26436 +/* PC relative 16 bit shifted by 1.  */
26437 +  BFD_RELOC_390_PC16DBL,
26438 +
26439 +/* 16 bit PC rel. PLT shifted by 1.  */
26440 +  BFD_RELOC_390_PLT16DBL,
26441 +
26442 +/* PC relative 32 bit shifted by 1.  */
26443 +  BFD_RELOC_390_PC32DBL,
26444 +
26445 +/* 32 bit PC rel. PLT shifted by 1.  */
26446 +  BFD_RELOC_390_PLT32DBL,
26447 +
26448 +/* 32 bit PC rel. GOT shifted by 1.  */
26449 +  BFD_RELOC_390_GOTPCDBL,
26450 +
26451 +/* 64 bit GOT offset.  */
26452 +  BFD_RELOC_390_GOT64,
26453 +
26454 +/* 64 bit PC relative PLT address.  */
26455 +  BFD_RELOC_390_PLT64,
26456 +
26457 +/* 32 bit rel. offset to GOT entry.  */
26458 +  BFD_RELOC_390_GOTENT,
26459 +
26460 +/* 64 bit offset to GOT.  */
26461 +  BFD_RELOC_390_GOTOFF64,
26462 +
26463 +/* 12-bit offset to symbol-entry within GOT, with PLT handling.  */
26464 +  BFD_RELOC_390_GOTPLT12,
26465 +
26466 +/* 16-bit offset to symbol-entry within GOT, with PLT handling.  */
26467 +  BFD_RELOC_390_GOTPLT16,
26468 +
26469 +/* 32-bit offset to symbol-entry within GOT, with PLT handling.  */
26470 +  BFD_RELOC_390_GOTPLT32,
26471 +
26472 +/* 64-bit offset to symbol-entry within GOT, with PLT handling.  */
26473 +  BFD_RELOC_390_GOTPLT64,
26474 +
26475 +/* 32-bit rel. offset to symbol-entry within GOT, with PLT handling.  */
26476 +  BFD_RELOC_390_GOTPLTENT,
26477 +
26478 +/* 16-bit rel. offset from the GOT to a PLT entry.  */
26479 +  BFD_RELOC_390_PLTOFF16,
26480 +
26481 +/* 32-bit rel. offset from the GOT to a PLT entry.  */
26482 +  BFD_RELOC_390_PLTOFF32,
26483 +
26484 +/* 64-bit rel. offset from the GOT to a PLT entry.  */
26485 +  BFD_RELOC_390_PLTOFF64,
26486 +
26487 +/* s390 tls relocations.  */
26488 +  BFD_RELOC_390_TLS_LOAD,
26489 +  BFD_RELOC_390_TLS_GDCALL,
26490 +  BFD_RELOC_390_TLS_LDCALL,
26491 +  BFD_RELOC_390_TLS_GD32,
26492 +  BFD_RELOC_390_TLS_GD64,
26493 +  BFD_RELOC_390_TLS_GOTIE12,
26494 +  BFD_RELOC_390_TLS_GOTIE32,
26495 +  BFD_RELOC_390_TLS_GOTIE64,
26496 +  BFD_RELOC_390_TLS_LDM32,
26497 +  BFD_RELOC_390_TLS_LDM64,
26498 +  BFD_RELOC_390_TLS_IE32,
26499 +  BFD_RELOC_390_TLS_IE64,
26500 +  BFD_RELOC_390_TLS_IEENT,
26501 +  BFD_RELOC_390_TLS_LE32,
26502 +  BFD_RELOC_390_TLS_LE64,
26503 +  BFD_RELOC_390_TLS_LDO32,
26504 +  BFD_RELOC_390_TLS_LDO64,
26505 +  BFD_RELOC_390_TLS_DTPMOD,
26506 +  BFD_RELOC_390_TLS_DTPOFF,
26507 +  BFD_RELOC_390_TLS_TPOFF,
26508 +
26509 +/* Long displacement extension.  */
26510 +  BFD_RELOC_390_20,
26511 +  BFD_RELOC_390_GOT20,
26512 +  BFD_RELOC_390_GOTPLT20,
26513 +  BFD_RELOC_390_TLS_GOTIE20,
26514 +
26515 +/* Scenix IP2K - 9-bit register number / data address  */
26516 +  BFD_RELOC_IP2K_FR9,
26517 +
26518 +/* Scenix IP2K - 4-bit register/data bank number  */
26519 +  BFD_RELOC_IP2K_BANK,
26520 +
26521 +/* Scenix IP2K - low 13 bits of instruction word address  */
26522 +  BFD_RELOC_IP2K_ADDR16CJP,
26523 +
26524 +/* Scenix IP2K - high 3 bits of instruction word address  */
26525 +  BFD_RELOC_IP2K_PAGE3,
26526 +
26527 +/* Scenix IP2K - ext/low/high 8 bits of data address  */
26528 +  BFD_RELOC_IP2K_LO8DATA,
26529 +  BFD_RELOC_IP2K_HI8DATA,
26530 +  BFD_RELOC_IP2K_EX8DATA,
26531 +
26532 +/* Scenix IP2K - low/high 8 bits of instruction word address  */
26533 +  BFD_RELOC_IP2K_LO8INSN,
26534 +  BFD_RELOC_IP2K_HI8INSN,
26535 +
26536 +/* Scenix IP2K - even/odd PC modifier to modify snb pcl.0  */
26537 +  BFD_RELOC_IP2K_PC_SKIP,
26538 +
26539 +/* Scenix IP2K - 16 bit word address in text section.  */
26540 +  BFD_RELOC_IP2K_TEXT,
26541 +
26542 +/* Scenix IP2K - 7-bit sp or dp offset  */
26543 +  BFD_RELOC_IP2K_FR_OFFSET,
26544 +
26545 +/* Scenix VPE4K coprocessor - data/insn-space addressing  */
26546 +  BFD_RELOC_VPE4KMATH_DATA,
26547 +  BFD_RELOC_VPE4KMATH_INSN,
26548 +
26549 +/* These two relocations are used by the linker to determine which of
26550 +the entries in a C++ virtual function table are actually used.  When
26551 +the --gc-sections option is given, the linker will zero out the entries
26552 +that are not used, so that the code for those functions need not be
26553 +included in the output.
26554 +
26555 +VTABLE_INHERIT is a zero-space relocation used to describe to the
26556 +linker the inheritance tree of a C++ virtual function table.  The
26557 +relocation's symbol should be the parent class' vtable, and the
26558 +relocation should be located at the child vtable.
26559 +
26560 +VTABLE_ENTRY is a zero-space relocation that describes the use of a
26561 +virtual function table entry.  The reloc's symbol should refer to the
26562 +table of the class mentioned in the code.  Off of that base, an offset
26563 +describes the entry that is being used.  For Rela hosts, this offset
26564 +is stored in the reloc's addend.  For Rel hosts, we are forced to put
26565 +this offset in the reloc's section offset.  */
26566 +  BFD_RELOC_VTABLE_INHERIT,
26567 +  BFD_RELOC_VTABLE_ENTRY,
26568 +
26569 +/* Intel IA64 Relocations.  */
26570 +  BFD_RELOC_IA64_IMM14,
26571 +  BFD_RELOC_IA64_IMM22,
26572 +  BFD_RELOC_IA64_IMM64,
26573 +  BFD_RELOC_IA64_DIR32MSB,
26574 +  BFD_RELOC_IA64_DIR32LSB,
26575 +  BFD_RELOC_IA64_DIR64MSB,
26576 +  BFD_RELOC_IA64_DIR64LSB,
26577 +  BFD_RELOC_IA64_GPREL22,
26578 +  BFD_RELOC_IA64_GPREL64I,
26579 +  BFD_RELOC_IA64_GPREL32MSB,
26580 +  BFD_RELOC_IA64_GPREL32LSB,
26581 +  BFD_RELOC_IA64_GPREL64MSB,
26582 +  BFD_RELOC_IA64_GPREL64LSB,
26583 +  BFD_RELOC_IA64_LTOFF22,
26584 +  BFD_RELOC_IA64_LTOFF64I,
26585 +  BFD_RELOC_IA64_PLTOFF22,
26586 +  BFD_RELOC_IA64_PLTOFF64I,
26587 +  BFD_RELOC_IA64_PLTOFF64MSB,
26588 +  BFD_RELOC_IA64_PLTOFF64LSB,
26589 +  BFD_RELOC_IA64_FPTR64I,
26590 +  BFD_RELOC_IA64_FPTR32MSB,
26591 +  BFD_RELOC_IA64_FPTR32LSB,
26592 +  BFD_RELOC_IA64_FPTR64MSB,
26593 +  BFD_RELOC_IA64_FPTR64LSB,
26594 +  BFD_RELOC_IA64_PCREL21B,
26595 +  BFD_RELOC_IA64_PCREL21BI,
26596 +  BFD_RELOC_IA64_PCREL21M,
26597 +  BFD_RELOC_IA64_PCREL21F,
26598 +  BFD_RELOC_IA64_PCREL22,
26599 +  BFD_RELOC_IA64_PCREL60B,
26600 +  BFD_RELOC_IA64_PCREL64I,
26601 +  BFD_RELOC_IA64_PCREL32MSB,
26602 +  BFD_RELOC_IA64_PCREL32LSB,
26603 +  BFD_RELOC_IA64_PCREL64MSB,
26604 +  BFD_RELOC_IA64_PCREL64LSB,
26605 +  BFD_RELOC_IA64_LTOFF_FPTR22,
26606 +  BFD_RELOC_IA64_LTOFF_FPTR64I,
26607 +  BFD_RELOC_IA64_LTOFF_FPTR32MSB,
26608 +  BFD_RELOC_IA64_LTOFF_FPTR32LSB,
26609 +  BFD_RELOC_IA64_LTOFF_FPTR64MSB,
26610 +  BFD_RELOC_IA64_LTOFF_FPTR64LSB,
26611 +  BFD_RELOC_IA64_SEGREL32MSB,
26612 +  BFD_RELOC_IA64_SEGREL32LSB,
26613 +  BFD_RELOC_IA64_SEGREL64MSB,
26614 +  BFD_RELOC_IA64_SEGREL64LSB,
26615 +  BFD_RELOC_IA64_SECREL32MSB,
26616 +  BFD_RELOC_IA64_SECREL32LSB,
26617 +  BFD_RELOC_IA64_SECREL64MSB,
26618 +  BFD_RELOC_IA64_SECREL64LSB,
26619 +  BFD_RELOC_IA64_REL32MSB,
26620 +  BFD_RELOC_IA64_REL32LSB,
26621 +  BFD_RELOC_IA64_REL64MSB,
26622 +  BFD_RELOC_IA64_REL64LSB,
26623 +  BFD_RELOC_IA64_LTV32MSB,
26624 +  BFD_RELOC_IA64_LTV32LSB,
26625 +  BFD_RELOC_IA64_LTV64MSB,
26626 +  BFD_RELOC_IA64_LTV64LSB,
26627 +  BFD_RELOC_IA64_IPLTMSB,
26628 +  BFD_RELOC_IA64_IPLTLSB,
26629 +  BFD_RELOC_IA64_COPY,
26630 +  BFD_RELOC_IA64_LTOFF22X,
26631 +  BFD_RELOC_IA64_LDXMOV,
26632 +  BFD_RELOC_IA64_TPREL14,
26633 +  BFD_RELOC_IA64_TPREL22,
26634 +  BFD_RELOC_IA64_TPREL64I,
26635 +  BFD_RELOC_IA64_TPREL64MSB,
26636 +  BFD_RELOC_IA64_TPREL64LSB,
26637 +  BFD_RELOC_IA64_LTOFF_TPREL22,
26638 +  BFD_RELOC_IA64_DTPMOD64MSB,
26639 +  BFD_RELOC_IA64_DTPMOD64LSB,
26640 +  BFD_RELOC_IA64_LTOFF_DTPMOD22,
26641 +  BFD_RELOC_IA64_DTPREL14,
26642 +  BFD_RELOC_IA64_DTPREL22,
26643 +  BFD_RELOC_IA64_DTPREL64I,
26644 +  BFD_RELOC_IA64_DTPREL32MSB,
26645 +  BFD_RELOC_IA64_DTPREL32LSB,
26646 +  BFD_RELOC_IA64_DTPREL64MSB,
26647 +  BFD_RELOC_IA64_DTPREL64LSB,
26648 +  BFD_RELOC_IA64_LTOFF_DTPREL22,
26649 +
26650 +/* Motorola 68HC11 reloc.
26651 +This is the 8 bit high part of an absolute address.  */
26652 +  BFD_RELOC_M68HC11_HI8,
26653 +
26654 +/* Motorola 68HC11 reloc.
26655 +This is the 8 bit low part of an absolute address.  */
26656 +  BFD_RELOC_M68HC11_LO8,
26657 +
26658 +/* Motorola 68HC11 reloc.
26659 +This is the 3 bit of a value.  */
26660 +  BFD_RELOC_M68HC11_3B,
26661 +
26662 +/* Motorola 68HC11 reloc.
26663 +This reloc marks the beginning of a jump/call instruction.
26664 +It is used for linker relaxation to correctly identify beginning
26665 +of instruction and change some branches to use PC-relative
26666 +addressing mode.  */
26667 +  BFD_RELOC_M68HC11_RL_JUMP,
26668 +
26669 +/* Motorola 68HC11 reloc.
26670 +This reloc marks a group of several instructions that gcc generates
26671 +and for which the linker relaxation pass can modify and/or remove
26672 +some of them.  */
26673 +  BFD_RELOC_M68HC11_RL_GROUP,
26674 +
26675 +/* Motorola 68HC11 reloc.
26676 +This is the 16-bit lower part of an address.  It is used for 'call'
26677 +instruction to specify the symbol address without any special
26678 +transformation (due to memory bank window).  */
26679 +  BFD_RELOC_M68HC11_LO16,
26680 +
26681 +/* Motorola 68HC11 reloc.
26682 +This is a 8-bit reloc that specifies the page number of an address.
26683 +It is used by 'call' instruction to specify the page number of
26684 +the symbol.  */
26685 +  BFD_RELOC_M68HC11_PAGE,
26686 +
26687 +/* Motorola 68HC11 reloc.
26688 +This is a 24-bit reloc that represents the address with a 16-bit
26689 +value and a 8-bit page number.  The symbol address is transformed
26690 +to follow the 16K memory bank of 68HC12 (seen as mapped in the window).  */
26691 +  BFD_RELOC_M68HC11_24,
26692 +
26693 +/* Motorola 68HC12 reloc.
26694 +This is the 5 bits of a value.  */
26695 +  BFD_RELOC_M68HC12_5B,
26696 +
26697 +/* NS CR16C Relocations.  */
26698 +  BFD_RELOC_16C_NUM08,
26699 +  BFD_RELOC_16C_NUM08_C,
26700 +  BFD_RELOC_16C_NUM16,
26701 +  BFD_RELOC_16C_NUM16_C,
26702 +  BFD_RELOC_16C_NUM32,
26703 +  BFD_RELOC_16C_NUM32_C,
26704 +  BFD_RELOC_16C_DISP04,
26705 +  BFD_RELOC_16C_DISP04_C,
26706 +  BFD_RELOC_16C_DISP08,
26707 +  BFD_RELOC_16C_DISP08_C,
26708 +  BFD_RELOC_16C_DISP16,
26709 +  BFD_RELOC_16C_DISP16_C,
26710 +  BFD_RELOC_16C_DISP24,
26711 +  BFD_RELOC_16C_DISP24_C,
26712 +  BFD_RELOC_16C_DISP24a,
26713 +  BFD_RELOC_16C_DISP24a_C,
26714 +  BFD_RELOC_16C_REG04,
26715 +  BFD_RELOC_16C_REG04_C,
26716 +  BFD_RELOC_16C_REG04a,
26717 +  BFD_RELOC_16C_REG04a_C,
26718 +  BFD_RELOC_16C_REG14,
26719 +  BFD_RELOC_16C_REG14_C,
26720 +  BFD_RELOC_16C_REG16,
26721 +  BFD_RELOC_16C_REG16_C,
26722 +  BFD_RELOC_16C_REG20,
26723 +  BFD_RELOC_16C_REG20_C,
26724 +  BFD_RELOC_16C_ABS20,
26725 +  BFD_RELOC_16C_ABS20_C,
26726 +  BFD_RELOC_16C_ABS24,
26727 +  BFD_RELOC_16C_ABS24_C,
26728 +  BFD_RELOC_16C_IMM04,
26729 +  BFD_RELOC_16C_IMM04_C,
26730 +  BFD_RELOC_16C_IMM16,
26731 +  BFD_RELOC_16C_IMM16_C,
26732 +  BFD_RELOC_16C_IMM20,
26733 +  BFD_RELOC_16C_IMM20_C,
26734 +  BFD_RELOC_16C_IMM24,
26735 +  BFD_RELOC_16C_IMM24_C,
26736 +  BFD_RELOC_16C_IMM32,
26737 +  BFD_RELOC_16C_IMM32_C,
26738 +
26739 +/* NS CRX Relocations.  */
26740 +  BFD_RELOC_CRX_REL4,
26741 +  BFD_RELOC_CRX_REL8,
26742 +  BFD_RELOC_CRX_REL8_CMP,
26743 +  BFD_RELOC_CRX_REL16,
26744 +  BFD_RELOC_CRX_REL24,
26745 +  BFD_RELOC_CRX_REL32,
26746 +  BFD_RELOC_CRX_REGREL12,
26747 +  BFD_RELOC_CRX_REGREL22,
26748 +  BFD_RELOC_CRX_REGREL28,
26749 +  BFD_RELOC_CRX_REGREL32,
26750 +  BFD_RELOC_CRX_ABS16,
26751 +  BFD_RELOC_CRX_ABS32,
26752 +  BFD_RELOC_CRX_NUM8,
26753 +  BFD_RELOC_CRX_NUM16,
26754 +  BFD_RELOC_CRX_NUM32,
26755 +  BFD_RELOC_CRX_IMM16,
26756 +  BFD_RELOC_CRX_IMM32,
26757 +  BFD_RELOC_CRX_SWITCH8,
26758 +  BFD_RELOC_CRX_SWITCH16,
26759 +  BFD_RELOC_CRX_SWITCH32,
26760 +
26761 +/* These relocs are only used within the CRIS assembler.  They are not
26762 +(at present) written to any object files.  */
26763 +  BFD_RELOC_CRIS_BDISP8,
26764 +  BFD_RELOC_CRIS_UNSIGNED_5,
26765 +  BFD_RELOC_CRIS_SIGNED_6,
26766 +  BFD_RELOC_CRIS_UNSIGNED_6,
26767 +  BFD_RELOC_CRIS_SIGNED_8,
26768 +  BFD_RELOC_CRIS_UNSIGNED_8,
26769 +  BFD_RELOC_CRIS_SIGNED_16,
26770 +  BFD_RELOC_CRIS_UNSIGNED_16,
26771 +  BFD_RELOC_CRIS_LAPCQ_OFFSET,
26772 +  BFD_RELOC_CRIS_UNSIGNED_4,
26773 +
26774 +/* Relocs used in ELF shared libraries for CRIS.  */
26775 +  BFD_RELOC_CRIS_COPY,
26776 +  BFD_RELOC_CRIS_GLOB_DAT,
26777 +  BFD_RELOC_CRIS_JUMP_SLOT,
26778 +  BFD_RELOC_CRIS_RELATIVE,
26779 +
26780 +/* 32-bit offset to symbol-entry within GOT.  */
26781 +  BFD_RELOC_CRIS_32_GOT,
26782 +
26783 +/* 16-bit offset to symbol-entry within GOT.  */
26784 +  BFD_RELOC_CRIS_16_GOT,
26785 +
26786 +/* 32-bit offset to symbol-entry within GOT, with PLT handling.  */
26787 +  BFD_RELOC_CRIS_32_GOTPLT,
26788 +
26789 +/* 16-bit offset to symbol-entry within GOT, with PLT handling.  */
26790 +  BFD_RELOC_CRIS_16_GOTPLT,
26791 +
26792 +/* 32-bit offset to symbol, relative to GOT.  */
26793 +  BFD_RELOC_CRIS_32_GOTREL,
26794 +
26795 +/* 32-bit offset to symbol with PLT entry, relative to GOT.  */
26796 +  BFD_RELOC_CRIS_32_PLT_GOTREL,
26797 +
26798 +/* 32-bit offset to symbol with PLT entry, relative to this relocation.  */
26799 +  BFD_RELOC_CRIS_32_PLT_PCREL,
26800 +
26801 +/* Intel i860 Relocations.  */
26802 +  BFD_RELOC_860_COPY,
26803 +  BFD_RELOC_860_GLOB_DAT,
26804 +  BFD_RELOC_860_JUMP_SLOT,
26805 +  BFD_RELOC_860_RELATIVE,
26806 +  BFD_RELOC_860_PC26,
26807 +  BFD_RELOC_860_PLT26,
26808 +  BFD_RELOC_860_PC16,
26809 +  BFD_RELOC_860_LOW0,
26810 +  BFD_RELOC_860_SPLIT0,
26811 +  BFD_RELOC_860_LOW1,
26812 +  BFD_RELOC_860_SPLIT1,
26813 +  BFD_RELOC_860_LOW2,
26814 +  BFD_RELOC_860_SPLIT2,
26815 +  BFD_RELOC_860_LOW3,
26816 +  BFD_RELOC_860_LOGOT0,
26817 +  BFD_RELOC_860_SPGOT0,
26818 +  BFD_RELOC_860_LOGOT1,
26819 +  BFD_RELOC_860_SPGOT1,
26820 +  BFD_RELOC_860_LOGOTOFF0,
26821 +  BFD_RELOC_860_SPGOTOFF0,
26822 +  BFD_RELOC_860_LOGOTOFF1,
26823 +  BFD_RELOC_860_SPGOTOFF1,
26824 +  BFD_RELOC_860_LOGOTOFF2,
26825 +  BFD_RELOC_860_LOGOTOFF3,
26826 +  BFD_RELOC_860_LOPC,
26827 +  BFD_RELOC_860_HIGHADJ,
26828 +  BFD_RELOC_860_HAGOT,
26829 +  BFD_RELOC_860_HAGOTOFF,
26830 +  BFD_RELOC_860_HAPC,
26831 +  BFD_RELOC_860_HIGH,
26832 +  BFD_RELOC_860_HIGOT,
26833 +  BFD_RELOC_860_HIGOTOFF,
26834 +
26835 +/* OpenRISC Relocations.  */
26836 +  BFD_RELOC_OPENRISC_ABS_26,
26837 +  BFD_RELOC_OPENRISC_REL_26,
26838 +
26839 +/* H8 elf Relocations.  */
26840 +  BFD_RELOC_H8_DIR16A8,
26841 +  BFD_RELOC_H8_DIR16R8,
26842 +  BFD_RELOC_H8_DIR24A8,
26843 +  BFD_RELOC_H8_DIR24R8,
26844 +  BFD_RELOC_H8_DIR32A16,
26845 +
26846 +/* Sony Xstormy16 Relocations.  */
26847 +  BFD_RELOC_XSTORMY16_REL_12,
26848 +  BFD_RELOC_XSTORMY16_12,
26849 +  BFD_RELOC_XSTORMY16_24,
26850 +  BFD_RELOC_XSTORMY16_FPTR16,
26851 +
26852 +/* Relocations used by VAX ELF.  */
26853 +  BFD_RELOC_VAX_GLOB_DAT,
26854 +  BFD_RELOC_VAX_JMP_SLOT,
26855 +  BFD_RELOC_VAX_RELATIVE,
26856 +
26857 +/* Morpho MS1 - 16 bit immediate relocation.  */
26858 +  BFD_RELOC_MS1_PC16,
26859 +
26860 +/* Morpho MS1 - Hi 16 bits of an address.  */
26861 +  BFD_RELOC_MS1_HI16,
26862 +
26863 +/* Morpho MS1 - Low 16 bits of an address.  */
26864 +  BFD_RELOC_MS1_LO16,
26865 +
26866 +/* Morpho MS1 - Used to tell the linker which vtable entries are used.  */
26867 +  BFD_RELOC_MS1_GNU_VTINHERIT,
26868 +
26869 +/* Morpho MS1 - Used to tell the linker which vtable entries are used.  */
26870 +  BFD_RELOC_MS1_GNU_VTENTRY,
26871 +
26872 +/* msp430 specific relocation codes  */
26873 +  BFD_RELOC_MSP430_10_PCREL,
26874 +  BFD_RELOC_MSP430_16_PCREL,
26875 +  BFD_RELOC_MSP430_16,
26876 +  BFD_RELOC_MSP430_16_PCREL_BYTE,
26877 +  BFD_RELOC_MSP430_16_BYTE,
26878 +  BFD_RELOC_MSP430_2X_PCREL,
26879 +  BFD_RELOC_MSP430_RL_PCREL,
26880 +
26881 +/* IQ2000 Relocations.  */
26882 +  BFD_RELOC_IQ2000_OFFSET_16,
26883 +  BFD_RELOC_IQ2000_OFFSET_21,
26884 +  BFD_RELOC_IQ2000_UHI16,
26885 +
26886 +/* Special Xtensa relocation used only by PLT entries in ELF shared
26887 +objects to indicate that the runtime linker should set the value
26888 +to one of its own internal functions or data structures.  */
26889 +  BFD_RELOC_XTENSA_RTLD,
26890 +
26891 +/* Xtensa relocations for ELF shared objects.  */
26892 +  BFD_RELOC_XTENSA_GLOB_DAT,
26893 +  BFD_RELOC_XTENSA_JMP_SLOT,
26894 +  BFD_RELOC_XTENSA_RELATIVE,
26895 +
26896 +/* Xtensa relocation used in ELF object files for symbols that may require
26897 +PLT entries.  Otherwise, this is just a generic 32-bit relocation.  */
26898 +  BFD_RELOC_XTENSA_PLT,
26899 +
26900 +/* Xtensa relocations to mark the difference of two local symbols.
26901 +These are only needed to support linker relaxation and can be ignored
26902 +when not relaxing.  The field is set to the value of the difference
26903 +assuming no relaxation.  The relocation encodes the position of the
26904 +first symbol so the linker can determine whether to adjust the field
26905 +value.  */
26906 +  BFD_RELOC_XTENSA_DIFF8,
26907 +  BFD_RELOC_XTENSA_DIFF16,
26908 +  BFD_RELOC_XTENSA_DIFF32,
26909 +
26910 +/* Generic Xtensa relocations for instruction operands.  Only the slot
26911 +number is encoded in the relocation.  The relocation applies to the
26912 +last PC-relative immediate operand, or if there are no PC-relative
26913 +immediates, to the last immediate operand.  */
26914 +  BFD_RELOC_XTENSA_SLOT0_OP,
26915 +  BFD_RELOC_XTENSA_SLOT1_OP,
26916 +  BFD_RELOC_XTENSA_SLOT2_OP,
26917 +  BFD_RELOC_XTENSA_SLOT3_OP,
26918 +  BFD_RELOC_XTENSA_SLOT4_OP,
26919 +  BFD_RELOC_XTENSA_SLOT5_OP,
26920 +  BFD_RELOC_XTENSA_SLOT6_OP,
26921 +  BFD_RELOC_XTENSA_SLOT7_OP,
26922 +  BFD_RELOC_XTENSA_SLOT8_OP,
26923 +  BFD_RELOC_XTENSA_SLOT9_OP,
26924 +  BFD_RELOC_XTENSA_SLOT10_OP,
26925 +  BFD_RELOC_XTENSA_SLOT11_OP,
26926 +  BFD_RELOC_XTENSA_SLOT12_OP,
26927 +  BFD_RELOC_XTENSA_SLOT13_OP,
26928 +  BFD_RELOC_XTENSA_SLOT14_OP,
26929 +
26930 +/* Alternate Xtensa relocations.  Only the slot is encoded in the
26931 +relocation.  The meaning of these relocations is opcode-specific.  */
26932 +  BFD_RELOC_XTENSA_SLOT0_ALT,
26933 +  BFD_RELOC_XTENSA_SLOT1_ALT,
26934 +  BFD_RELOC_XTENSA_SLOT2_ALT,
26935 +  BFD_RELOC_XTENSA_SLOT3_ALT,
26936 +  BFD_RELOC_XTENSA_SLOT4_ALT,
26937 +  BFD_RELOC_XTENSA_SLOT5_ALT,
26938 +  BFD_RELOC_XTENSA_SLOT6_ALT,
26939 +  BFD_RELOC_XTENSA_SLOT7_ALT,
26940 +  BFD_RELOC_XTENSA_SLOT8_ALT,
26941 +  BFD_RELOC_XTENSA_SLOT9_ALT,
26942 +  BFD_RELOC_XTENSA_SLOT10_ALT,
26943 +  BFD_RELOC_XTENSA_SLOT11_ALT,
26944 +  BFD_RELOC_XTENSA_SLOT12_ALT,
26945 +  BFD_RELOC_XTENSA_SLOT13_ALT,
26946 +  BFD_RELOC_XTENSA_SLOT14_ALT,
26947 +
26948 +/* Xtensa relocations for backward compatibility.  These have all been
26949 +replaced by BFD_RELOC_XTENSA_SLOT0_OP.  */
26950 +  BFD_RELOC_XTENSA_OP0,
26951 +  BFD_RELOC_XTENSA_OP1,
26952 +  BFD_RELOC_XTENSA_OP2,
26953 +
26954 +/* Xtensa relocation to mark that the assembler expanded the
26955 +instructions from an original target.  The expansion size is
26956 +encoded in the reloc size.  */
26957 +  BFD_RELOC_XTENSA_ASM_EXPAND,
26958 +
26959 +/* Xtensa relocation to mark that the linker should simplify
26960 +assembler-expanded instructions.  This is commonly used
26961 +internally by the linker after analysis of a
26962 +BFD_RELOC_XTENSA_ASM_EXPAND.  */
26963 +  BFD_RELOC_XTENSA_ASM_SIMPLIFY,
26964 +  BFD_RELOC_UNUSED };
26965 +typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
26966 +reloc_howto_type *bfd_reloc_type_lookup
26967 +   (bfd *abfd, bfd_reloc_code_real_type code);
26968 +
26969 +const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
26970 +
26971 +/* Extracted from syms.c.  */
26972 +
26973 +typedef struct bfd_symbol
26974 +{
26975 +  /* A pointer to the BFD which owns the symbol. This information
26976 +     is necessary so that a back end can work out what additional
26977 +     information (invisible to the application writer) is carried
26978 +     with the symbol.
26979 +
26980 +     This field is *almost* redundant, since you can use section->owner
26981 +     instead, except that some symbols point to the global sections
26982 +     bfd_{abs,com,und}_section.  This could be fixed by making
26983 +     these globals be per-bfd (or per-target-flavor).  FIXME.  */
26984 +  struct bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field.  */
26985 +
26986 +  /* The text of the symbol. The name is left alone, and not copied; the
26987 +     application may not alter it.  */
26988 +  const char *name;
26989 +
26990 +  /* The value of the symbol.  This really should be a union of a
26991 +     numeric value with a pointer, since some flags indicate that
26992 +     a pointer to another symbol is stored here.  */
26993 +  symvalue value;
26994 +
26995 +  /* Attributes of a symbol.  */
26996 +#define BSF_NO_FLAGS    0x00
26997 +
26998 +  /* The symbol has local scope; <<static>> in <<C>>. The value
26999 +     is the offset into the section of the data.  */
27000 +#define BSF_LOCAL      0x01
27001 +
27002 +  /* The symbol has global scope; initialized data in <<C>>. The
27003 +     value is the offset into the section of the data.  */
27004 +#define BSF_GLOBAL     0x02
27005 +
27006 +  /* The symbol has global scope and is exported. The value is
27007 +     the offset into the section of the data.  */
27008 +#define BSF_EXPORT     BSF_GLOBAL /* No real difference.  */
27009 +
27010 +  /* A normal C symbol would be one of:
27011 +     <<BSF_LOCAL>>, <<BSF_FORT_COMM>>,  <<BSF_UNDEFINED>> or
27012 +     <<BSF_GLOBAL>>.  */
27013 +
27014 +  /* The symbol is a debugging record. The value has an arbitrary
27015 +     meaning, unless BSF_DEBUGGING_RELOC is also set.  */
27016 +#define BSF_DEBUGGING  0x08
27017 +
27018 +  /* The symbol denotes a function entry point.  Used in ELF,
27019 +     perhaps others someday.  */
27020 +#define BSF_FUNCTION    0x10
27021 +
27022 +  /* Used by the linker.  */
27023 +#define BSF_KEEP        0x20
27024 +#define BSF_KEEP_G      0x40
27025 +
27026 +  /* A weak global symbol, overridable without warnings by
27027 +     a regular global symbol of the same name.  */
27028 +#define BSF_WEAK        0x80
27029 +
27030 +  /* This symbol was created to point to a section, e.g. ELF's
27031 +     STT_SECTION symbols.  */
27032 +#define BSF_SECTION_SYM 0x100
27033 +
27034 +  /* The symbol used to be a common symbol, but now it is
27035 +     allocated.  */
27036 +#define BSF_OLD_COMMON  0x200
27037 +
27038 +  /* The default value for common data.  */
27039 +#define BFD_FORT_COMM_DEFAULT_VALUE 0
27040 +
27041 +  /* In some files the type of a symbol sometimes alters its
27042 +     location in an output file - ie in coff a <<ISFCN>> symbol
27043 +     which is also <<C_EXT>> symbol appears where it was
27044 +     declared and not at the end of a section.  This bit is set
27045 +     by the target BFD part to convey this information.  */
27046 +#define BSF_NOT_AT_END    0x400
27047 +
27048 +  /* Signal that the symbol is the label of constructor section.  */
27049 +#define BSF_CONSTRUCTOR   0x800
27050 +
27051 +  /* Signal that the symbol is a warning symbol.  The name is a
27052 +     warning.  The name of the next symbol is the one to warn about;
27053 +     if a reference is made to a symbol with the same name as the next
27054 +     symbol, a warning is issued by the linker.  */
27055 +#define BSF_WARNING       0x1000
27056 +
27057 +  /* Signal that the symbol is indirect.  This symbol is an indirect
27058 +     pointer to the symbol with the same name as the next symbol.  */
27059 +#define BSF_INDIRECT      0x2000
27060 +
27061 +  /* BSF_FILE marks symbols that contain a file name.  This is used
27062 +     for ELF STT_FILE symbols.  */
27063 +#define BSF_FILE          0x4000
27064 +
27065 +  /* Symbol is from dynamic linking information.  */
27066 +#define BSF_DYNAMIC       0x8000
27067 +
27068 +  /* The symbol denotes a data object.  Used in ELF, and perhaps
27069 +     others someday.  */
27070 +#define BSF_OBJECT        0x10000
27071 +
27072 +  /* This symbol is a debugging symbol.  The value is the offset
27073 +     into the section of the data.  BSF_DEBUGGING should be set
27074 +     as well.  */
27075 +#define BSF_DEBUGGING_RELOC 0x20000
27076 +
27077 +  /* This symbol is thread local.  Used in ELF.  */
27078 +#define BSF_THREAD_LOCAL  0x40000
27079 +
27080 +  flagword flags;
27081 +
27082 +  /* A pointer to the section to which this symbol is
27083 +     relative.  This will always be non NULL, there are special
27084 +     sections for undefined and absolute symbols.  */
27085 +  struct bfd_section *section;
27086 +
27087 +  /* Back end special data.  */
27088 +  union
27089 +    {
27090 +      void *p;
27091 +      bfd_vma i;
27092 +    }
27093 +  udata;
27094 +}
27095 +asymbol;
27096 +
27097 +#define bfd_get_symtab_upper_bound(abfd) \
27098 +     BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
27099 +
27100 +bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);
27101 +
27102 +bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);
27103 +
27104 +#define bfd_is_local_label_name(abfd, name) \
27105 +  BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
27106 +
27107 +bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
27108 +
27109 +#define bfd_is_target_special_symbol(abfd, sym) \
27110 +  BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))
27111 +
27112 +#define bfd_canonicalize_symtab(abfd, location) \
27113 +  BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
27114 +
27115 +bfd_boolean bfd_set_symtab
27116 +   (bfd *abfd, asymbol **location, unsigned int count);
27117 +
27118 +void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
27119 +
27120 +#define bfd_make_empty_symbol(abfd) \
27121 +  BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
27122 +
27123 +asymbol *_bfd_generic_make_empty_symbol (bfd *);
27124 +
27125 +#define bfd_make_debug_symbol(abfd,ptr,size) \
27126 +  BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
27127 +
27128 +int bfd_decode_symclass (asymbol *symbol);
27129 +
27130 +bfd_boolean bfd_is_undefined_symclass (int symclass);
27131 +
27132 +void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
27133 +
27134 +bfd_boolean bfd_copy_private_symbol_data
27135 +   (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
27136 +
27137 +#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
27138 +  BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
27139 +            (ibfd, isymbol, obfd, osymbol))
27140 +
27141 +/* Extracted from bfd.c.  */
27142 +struct bfd
27143 +{
27144 +  /* A unique identifier of the BFD  */
27145 +  unsigned int id;
27146 +
27147 +  /* The filename the application opened the BFD with.  */
27148 +  const char *filename;
27149 +
27150 +  /* A pointer to the target jump table.  */
27151 +  const struct bfd_target *xvec;
27152 +
27153 +  /* The IOSTREAM, and corresponding IO vector that provide access
27154 +     to the file backing the BFD.  */
27155 +  void *iostream;
27156 +  const struct bfd_iovec *iovec;
27157 +
27158 +  /* Is the file descriptor being cached?  That is, can it be closed as
27159 +     needed, and re-opened when accessed later?  */
27160 +  bfd_boolean cacheable;
27161 +
27162 +  /* Marks whether there was a default target specified when the
27163 +     BFD was opened. This is used to select which matching algorithm
27164 +     to use to choose the back end.  */
27165 +  bfd_boolean target_defaulted;
27166 +
27167 +  /* The caching routines use these to maintain a
27168 +     least-recently-used list of BFDs.  */
27169 +  struct bfd *lru_prev, *lru_next;
27170 +
27171 +  /* When a file is closed by the caching routines, BFD retains
27172 +     state information on the file here...  */
27173 +  ufile_ptr where;
27174 +
27175 +  /* ... and here: (``once'' means at least once).  */
27176 +  bfd_boolean opened_once;
27177 +
27178 +  /* Set if we have a locally maintained mtime value, rather than
27179 +     getting it from the file each time.  */
27180 +  bfd_boolean mtime_set;
27181 +
27182 +  /* File modified time, if mtime_set is TRUE.  */
27183 +  long mtime;
27184 +
27185 +  /* Reserved for an unimplemented file locking extension.  */
27186 +  int ifd;
27187 +
27188 +  /* The format which belongs to the BFD. (object, core, etc.)  */
27189 +  bfd_format format;
27190 +
27191 +  /* The direction with which the BFD was opened.  */
27192 +  enum bfd_direction
27193 +    {
27194 +      no_direction = 0,
27195 +      read_direction = 1,
27196 +      write_direction = 2,
27197 +      both_direction = 3
27198 +    }
27199 +  direction;
27200 +
27201 +  /* Format_specific flags.  */
27202 +  flagword flags;
27203 +
27204 +  /* Currently my_archive is tested before adding origin to
27205 +     anything. I believe that this can become always an add of
27206 +     origin, with origin set to 0 for non archive files.  */
27207 +  ufile_ptr origin;
27208 +
27209 +  /* Remember when output has begun, to stop strange things
27210 +     from happening.  */
27211 +  bfd_boolean output_has_begun;
27212 +
27213 +  /* A hash table for section names.  */
27214 +  struct bfd_hash_table section_htab;
27215 +
27216 +  /* Pointer to linked list of sections.  */
27217 +  struct bfd_section *sections;
27218 +
27219 +  /* The last section on the section list.  */
27220 +  struct bfd_section *section_last;
27221 +
27222 +  /* The number of sections.  */
27223 +  unsigned int section_count;
27224 +
27225 +  /* Stuff only useful for object files:
27226 +     The start address.  */
27227 +  bfd_vma start_address;
27228 +
27229 +  /* Used for input and output.  */
27230 +  unsigned int symcount;
27231 +
27232 +  /* Symbol table for output BFD (with symcount entries).  */
27233 +  struct bfd_symbol  **outsymbols;
27234 +
27235 +  /* Used for slurped dynamic symbol tables.  */
27236 +  unsigned int dynsymcount;
27237 +
27238 +  /* Pointer to structure which contains architecture information.  */
27239 +  const struct bfd_arch_info *arch_info;
27240 +
27241 +  /* Flag set if symbols from this BFD should not be exported.  */
27242 +  bfd_boolean no_export;
27243 +
27244 +  /* Stuff only useful for archives.  */
27245 +  void *arelt_data;
27246 +  struct bfd *my_archive;      /* The containing archive BFD.  */
27247 +  struct bfd *next;            /* The next BFD in the archive.  */
27248 +  struct bfd *archive_head;    /* The first BFD in the archive.  */
27249 +  bfd_boolean has_armap;
27250 +
27251 +  /* A chain of BFD structures involved in a link.  */
27252 +  struct bfd *link_next;
27253 +
27254 +  /* A field used by _bfd_generic_link_add_archive_symbols.  This will
27255 +     be used only for archive elements.  */
27256 +  int archive_pass;
27257 +
27258 +  /* Used by the back end to hold private data.  */
27259 +  union
27260 +    {
27261 +      struct aout_data_struct *aout_data;
27262 +      struct artdata *aout_ar_data;
27263 +      struct _oasys_data *oasys_obj_data;
27264 +      struct _oasys_ar_data *oasys_ar_data;
27265 +      struct coff_tdata *coff_obj_data;
27266 +      struct pe_tdata *pe_obj_data;
27267 +      struct xcoff_tdata *xcoff_obj_data;
27268 +      struct ecoff_tdata *ecoff_obj_data;
27269 +      struct ieee_data_struct *ieee_data;
27270 +      struct ieee_ar_data_struct *ieee_ar_data;
27271 +      struct srec_data_struct *srec_data;
27272 +      struct ihex_data_struct *ihex_data;
27273 +      struct tekhex_data_struct *tekhex_data;
27274 +      struct elf_obj_tdata *elf_obj_data;
27275 +      struct nlm_obj_tdata *nlm_obj_data;
27276 +      struct bout_data_struct *bout_data;
27277 +      struct mmo_data_struct *mmo_data;
27278 +      struct sun_core_struct *sun_core_data;
27279 +      struct sco5_core_struct *sco5_core_data;
27280 +      struct trad_core_struct *trad_core_data;
27281 +      struct som_data_struct *som_data;
27282 +      struct hpux_core_struct *hpux_core_data;
27283 +      struct hppabsd_core_struct *hppabsd_core_data;
27284 +      struct sgi_core_struct *sgi_core_data;
27285 +      struct lynx_core_struct *lynx_core_data;
27286 +      struct osf_core_struct *osf_core_data;
27287 +      struct cisco_core_struct *cisco_core_data;
27288 +      struct versados_data_struct *versados_data;
27289 +      struct netbsd_core_struct *netbsd_core_data;
27290 +      struct mach_o_data_struct *mach_o_data;
27291 +      struct mach_o_fat_data_struct *mach_o_fat_data;
27292 +      struct bfd_pef_data_struct *pef_data;
27293 +      struct bfd_pef_xlib_data_struct *pef_xlib_data;
27294 +      struct bfd_sym_data_struct *sym_data;
27295 +      void *any;
27296 +    }
27297 +  tdata;
27298 +
27299 +  /* Used by the application to hold private data.  */
27300 +  void *usrdata;
27301 +
27302 +  /* Where all the allocated stuff under this BFD goes.  This is a
27303 +     struct objalloc *, but we use void * to avoid requiring the inclusion
27304 +     of objalloc.h.  */
27305 +  void *memory;
27306 +};
27307 +
27308 +typedef enum bfd_error
27309 +{
27310 +  bfd_error_no_error = 0,
27311 +  bfd_error_system_call,
27312 +  bfd_error_invalid_target,
27313 +  bfd_error_wrong_format,
27314 +  bfd_error_wrong_object_format,
27315 +  bfd_error_invalid_operation,
27316 +  bfd_error_no_memory,
27317 +  bfd_error_no_symbols,
27318 +  bfd_error_no_armap,
27319 +  bfd_error_no_more_archived_files,
27320 +  bfd_error_malformed_archive,
27321 +  bfd_error_file_not_recognized,
27322 +  bfd_error_file_ambiguously_recognized,
27323 +  bfd_error_no_contents,
27324 +  bfd_error_nonrepresentable_section,
27325 +  bfd_error_no_debug_section,
27326 +  bfd_error_bad_value,
27327 +  bfd_error_file_truncated,
27328 +  bfd_error_file_too_big,
27329 +  bfd_error_invalid_error_code
27330 +}
27331 +bfd_error_type;
27332 +
27333 +bfd_error_type bfd_get_error (void);
27334 +
27335 +void bfd_set_error (bfd_error_type error_tag);
27336 +
27337 +const char *bfd_errmsg (bfd_error_type error_tag);
27338 +
27339 +void bfd_perror (const char *message);
27340 +
27341 +typedef void (*bfd_error_handler_type) (const char *, ...);
27342 +
27343 +bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);
27344 +
27345 +void bfd_set_error_program_name (const char *);
27346 +
27347 +bfd_error_handler_type bfd_get_error_handler (void);
27348 +
27349 +long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);
27350 +
27351 +long bfd_canonicalize_reloc
27352 +   (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);
27353 +
27354 +void bfd_set_reloc
27355 +   (bfd *abfd, asection *sec, arelent **rel, unsigned int count);
27356 +
27357 +bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);
27358 +
27359 +int bfd_get_arch_size (bfd *abfd);
27360 +
27361 +int bfd_get_sign_extend_vma (bfd *abfd);
27362 +
27363 +bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
27364 +
27365 +unsigned int bfd_get_gp_size (bfd *abfd);
27366 +
27367 +void bfd_set_gp_size (bfd *abfd, unsigned int i);
27368 +
27369 +bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
27370 +
27371 +bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
27372 +
27373 +#define bfd_copy_private_header_data(ibfd, obfd) \
27374 +     BFD_SEND (obfd, _bfd_copy_private_header_data, \
27375 +               (ibfd, obfd))
27376 +bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
27377 +
27378 +#define bfd_copy_private_bfd_data(ibfd, obfd) \
27379 +     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
27380 +               (ibfd, obfd))
27381 +bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);
27382 +
27383 +#define bfd_merge_private_bfd_data(ibfd, obfd) \
27384 +     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
27385 +               (ibfd, obfd))
27386 +bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
27387 +
27388 +#define bfd_set_private_flags(abfd, flags) \
27389 +     BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
27390 +#define bfd_sizeof_headers(abfd, reloc) \
27391 +       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
27392 +
27393 +#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
27394 +       BFD_SEND (abfd, _bfd_find_nearest_line, \
27395 +                 (abfd, sec, syms, off, file, func, line))
27396 +
27397 +#define bfd_find_line(abfd, syms, sym, file, line) \
27398 +       BFD_SEND (abfd, _bfd_find_line, \
27399 +                 (abfd, syms, sym, file, line))
27400 +
27401 +#define bfd_find_inliner_info(abfd, file, func, line) \
27402 +       BFD_SEND (abfd, _bfd_find_inliner_info, \
27403 +                 (abfd, file, func, line))
27404 +
27405 +#define bfd_debug_info_start(abfd) \
27406 +       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
27407 +
27408 +#define bfd_debug_info_end(abfd) \
27409 +       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
27410 +
27411 +#define bfd_debug_info_accumulate(abfd, section) \
27412 +       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
27413 +
27414 +#define bfd_stat_arch_elt(abfd, stat) \
27415 +       BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
27416 +
27417 +#define bfd_update_armap_timestamp(abfd) \
27418 +       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
27419 +
27420 +#define bfd_set_arch_mach(abfd, arch, mach)\
27421 +       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
27422 +
27423 +#define bfd_relax_section(abfd, section, link_info, again) \
27424 +       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
27425 +
27426 +#define bfd_gc_sections(abfd, link_info) \
27427 +       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
27428 +
27429 +#define bfd_merge_sections(abfd, link_info) \
27430 +       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
27431 +
27432 +#define bfd_is_group_section(abfd, sec) \
27433 +       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
27434 +
27435 +#define bfd_discard_group(abfd, sec) \
27436 +       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
27437 +
27438 +#define bfd_link_hash_table_create(abfd) \
27439 +       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
27440 +
27441 +#define bfd_link_hash_table_free(abfd, hash) \
27442 +       BFD_SEND (abfd, _bfd_link_hash_table_free, (hash))
27443 +
27444 +#define bfd_link_add_symbols(abfd, info) \
27445 +       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
27446 +
27447 +#define bfd_link_just_syms(abfd, sec, info) \
27448 +       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
27449 +
27450 +#define bfd_final_link(abfd, info) \
27451 +       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
27452 +
27453 +#define bfd_free_cached_info(abfd) \
27454 +       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
27455 +
27456 +#define bfd_get_dynamic_symtab_upper_bound(abfd) \
27457 +       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
27458 +
27459 +#define bfd_print_private_bfd_data(abfd, file)\
27460 +       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
27461 +
27462 +#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
27463 +       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
27464 +
27465 +#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
27466 +       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
27467 +                                                   dyncount, dynsyms, ret))
27468 +
27469 +#define bfd_get_dynamic_reloc_upper_bound(abfd) \
27470 +       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
27471 +
27472 +#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
27473 +       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
27474 +
27475 +extern bfd_byte *bfd_get_relocated_section_contents
27476 +  (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
27477 +   bfd_boolean, asymbol **);
27478 +
27479 +bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
27480 +
27481 +struct bfd_preserve
27482 +{
27483 +  void *marker;
27484 +  void *tdata;
27485 +  flagword flags;
27486 +  const struct bfd_arch_info *arch_info;
27487 +  struct bfd_section *sections;
27488 +  struct bfd_section *section_last;
27489 +  unsigned int section_count;
27490 +  struct bfd_hash_table section_htab;
27491 +};
27492 +
27493 +bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *);
27494 +
27495 +void bfd_preserve_restore (bfd *, struct bfd_preserve *);
27496 +
27497 +void bfd_preserve_finish (bfd *, struct bfd_preserve *);
27498 +
27499 +/* Extracted from archive.c.  */
27500 +symindex bfd_get_next_mapent
27501 +   (bfd *abfd, symindex previous, carsym **sym);
27502 +
27503 +bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
27504 +
27505 +bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
27506 +
27507 +/* Extracted from corefile.c.  */
27508 +const char *bfd_core_file_failing_command (bfd *abfd);
27509 +
27510 +int bfd_core_file_failing_signal (bfd *abfd);
27511 +
27512 +bfd_boolean core_file_matches_executable_p
27513 +   (bfd *core_bfd, bfd *exec_bfd);
27514 +
27515 +/* Extracted from targets.c.  */
27516 +#define BFD_SEND(bfd, message, arglist) \
27517 +  ((*((bfd)->xvec->message)) arglist)
27518 +
27519 +#ifdef DEBUG_BFD_SEND
27520 +#undef BFD_SEND
27521 +#define BFD_SEND(bfd, message, arglist) \
27522 +  (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
27523 +    ((*((bfd)->xvec->message)) arglist) : \
27524 +    (bfd_assert (__FILE__,__LINE__), NULL))
27525 +#endif
27526 +#define BFD_SEND_FMT(bfd, message, arglist) \
27527 +  (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist)
27528 +
27529 +#ifdef DEBUG_BFD_SEND
27530 +#undef BFD_SEND_FMT
27531 +#define BFD_SEND_FMT(bfd, message, arglist) \
27532 +  (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
27533 +   (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) : \
27534 +   (bfd_assert (__FILE__,__LINE__), NULL))
27535 +#endif
27536 +
27537 +enum bfd_flavour
27538 +{
27539 +  bfd_target_unknown_flavour,
27540 +  bfd_target_aout_flavour,
27541 +  bfd_target_coff_flavour,
27542 +  bfd_target_ecoff_flavour,
27543 +  bfd_target_xcoff_flavour,
27544 +  bfd_target_elf_flavour,
27545 +  bfd_target_ieee_flavour,
27546 +  bfd_target_nlm_flavour,
27547 +  bfd_target_oasys_flavour,
27548 +  bfd_target_tekhex_flavour,
27549 +  bfd_target_srec_flavour,
27550 +  bfd_target_ihex_flavour,
27551 +  bfd_target_som_flavour,
27552 +  bfd_target_os9k_flavour,
27553 +  bfd_target_versados_flavour,
27554 +  bfd_target_msdos_flavour,
27555 +  bfd_target_ovax_flavour,
27556 +  bfd_target_evax_flavour,
27557 +  bfd_target_mmo_flavour,
27558 +  bfd_target_mach_o_flavour,
27559 +  bfd_target_pef_flavour,
27560 +  bfd_target_pef_xlib_flavour,
27561 +  bfd_target_sym_flavour
27562 +};
27563 +
27564 +enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN };
27565 +
27566 +/* Forward declaration.  */
27567 +typedef struct bfd_link_info _bfd_link_info;
27568 +
27569 +typedef struct bfd_target
27570 +{
27571 +  /* Identifies the kind of target, e.g., SunOS4, Ultrix, etc.  */
27572 +  char *name;
27573 +
27574 + /* The "flavour" of a back end is a general indication about
27575 +    the contents of a file.  */
27576 +  enum bfd_flavour flavour;
27577 +
27578 +  /* The order of bytes within the data area of a file.  */
27579 +  enum bfd_endian byteorder;
27580 +
27581 + /* The order of bytes within the header parts of a file.  */
27582 +  enum bfd_endian header_byteorder;
27583 +
27584 +  /* A mask of all the flags which an executable may have set -
27585 +     from the set <<BFD_NO_FLAGS>>, <<HAS_RELOC>>, ...<<D_PAGED>>.  */
27586 +  flagword object_flags;
27587 +
27588 + /* A mask of all the flags which a section may have set - from
27589 +    the set <<SEC_NO_FLAGS>>, <<SEC_ALLOC>>, ...<<SET_NEVER_LOAD>>.  */
27590 +  flagword section_flags;
27591 +
27592 + /* The character normally found at the front of a symbol.
27593 +    (if any), perhaps `_'.  */
27594 +  char symbol_leading_char;
27595 +
27596 + /* The pad character for file names within an archive header.  */
27597 +  char ar_pad_char;
27598 +
27599 +  /* The maximum number of characters in an archive header.  */
27600 +  unsigned short ar_max_namelen;
27601 +
27602 +  /* Entries for byte swapping for data. These are different from the
27603 +     other entry points, since they don't take a BFD as the first argument.
27604 +     Certain other handlers could do the same.  */
27605 +  bfd_uint64_t   (*bfd_getx64) (const void *);
27606 +  bfd_int64_t    (*bfd_getx_signed_64) (const void *);
27607 +  void           (*bfd_putx64) (bfd_uint64_t, void *);
27608 +  bfd_vma        (*bfd_getx32) (const void *);
27609 +  bfd_signed_vma (*bfd_getx_signed_32) (const void *);
27610 +  void           (*bfd_putx32) (bfd_vma, void *);
27611 +  bfd_vma        (*bfd_getx16) (const void *);
27612 +  bfd_signed_vma (*bfd_getx_signed_16) (const void *);
27613 +  void           (*bfd_putx16) (bfd_vma, void *);
27614 +
27615 +  /* Byte swapping for the headers.  */
27616 +  bfd_uint64_t   (*bfd_h_getx64) (const void *);
27617 +  bfd_int64_t    (*bfd_h_getx_signed_64) (const void *);
27618 +  void           (*bfd_h_putx64) (bfd_uint64_t, void *);
27619 +  bfd_vma        (*bfd_h_getx32) (const void *);
27620 +  bfd_signed_vma (*bfd_h_getx_signed_32) (const void *);
27621 +  void           (*bfd_h_putx32) (bfd_vma, void *);
27622 +  bfd_vma        (*bfd_h_getx16) (const void *);
27623 +  bfd_signed_vma (*bfd_h_getx_signed_16) (const void *);
27624 +  void           (*bfd_h_putx16) (bfd_vma, void *);
27625 +
27626 +  /* Format dependent routines: these are vectors of entry points
27627 +     within the target vector structure, one for each format to check.  */
27628 +
27629 +  /* Check the format of a file being read.  Return a <<bfd_target *>> or zero.  */
27630 +  const struct bfd_target *(*_bfd_check_format[bfd_type_end]) (bfd *);
27631 +
27632 +  /* Set the format of a file being written.  */
27633 +  bfd_boolean (*_bfd_set_format[bfd_type_end]) (bfd *);
27634 +
27635 +  /* Write cached information into a file being written, at <<bfd_close>>.  */
27636 +  bfd_boolean (*_bfd_write_contents[bfd_type_end]) (bfd *);
27637 +
27638 +
27639 +  /* Generic entry points.  */
27640 +#define BFD_JUMP_TABLE_GENERIC(NAME) \
27641 +  NAME##_close_and_cleanup, \
27642 +  NAME##_bfd_free_cached_info, \
27643 +  NAME##_new_section_hook, \
27644 +  NAME##_get_section_contents, \
27645 +  NAME##_get_section_contents_in_window
27646 +
27647 +  /* Called when the BFD is being closed to do any necessary cleanup.  */
27648 +  bfd_boolean (*_close_and_cleanup) (bfd *);
27649 +  /* Ask the BFD to free all cached information.  */
27650 +  bfd_boolean (*_bfd_free_cached_info) (bfd *);
27651 +  /* Called when a new section is created.  */
27652 +  bfd_boolean (*_new_section_hook) (bfd *, sec_ptr);
27653 +  /* Read the contents of a section.  */
27654 +  bfd_boolean (*_bfd_get_section_contents)
27655 +    (bfd *, sec_ptr, void *, file_ptr, bfd_size_type);
27656 +  bfd_boolean (*_bfd_get_section_contents_in_window)
27657 +    (bfd *, sec_ptr, bfd_window *, file_ptr, bfd_size_type);
27658 +
27659 +  /* Entry points to copy private data.  */
27660 +#define BFD_JUMP_TABLE_COPY(NAME) \
27661 +  NAME##_bfd_copy_private_bfd_data, \
27662 +  NAME##_bfd_merge_private_bfd_data, \
27663 +  NAME##_bfd_copy_private_section_data, \
27664 +  NAME##_bfd_copy_private_symbol_data, \
27665 +  NAME##_bfd_copy_private_header_data, \
27666 +  NAME##_bfd_set_private_flags, \
27667 +  NAME##_bfd_print_private_bfd_data
27668 +
27669 +  /* Called to copy BFD general private data from one object file
27670 +     to another.  */
27671 +  bfd_boolean (*_bfd_copy_private_bfd_data) (bfd *, bfd *);
27672 +  /* Called to merge BFD general private data from one object file
27673 +     to a common output file when linking.  */
27674 +  bfd_boolean (*_bfd_merge_private_bfd_data) (bfd *, bfd *);
27675 +  /* Called to copy BFD private section data from one object file
27676 +     to another.  */
27677 +  bfd_boolean (*_bfd_copy_private_section_data)
27678 +    (bfd *, sec_ptr, bfd *, sec_ptr);
27679 +  /* Called to copy BFD private symbol data from one symbol
27680 +     to another.  */
27681 +  bfd_boolean (*_bfd_copy_private_symbol_data)
27682 +    (bfd *, asymbol *, bfd *, asymbol *);
27683 +  /* Called to copy BFD private header data from one object file
27684 +     to another.  */
27685 +  bfd_boolean (*_bfd_copy_private_header_data)
27686 +    (bfd *, bfd *);
27687 +  /* Called to set private backend flags.  */
27688 +  bfd_boolean (*_bfd_set_private_flags) (bfd *, flagword);
27689 +
27690 +  /* Called to print private BFD data.  */
27691 +  bfd_boolean (*_bfd_print_private_bfd_data) (bfd *, void *);
27692 +
27693 +  /* Core file entry points.  */
27694 +#define BFD_JUMP_TABLE_CORE(NAME) \
27695 +  NAME##_core_file_failing_command, \
27696 +  NAME##_core_file_failing_signal, \
27697 +  NAME##_core_file_matches_executable_p
27698 +
27699 +  char *      (*_core_file_failing_command) (bfd *);
27700 +  int         (*_core_file_failing_signal) (bfd *);
27701 +  bfd_boolean (*_core_file_matches_executable_p) (bfd *, bfd *);
27702 +
27703 +  /* Archive entry points.  */
27704 +#define BFD_JUMP_TABLE_ARCHIVE(NAME) \
27705 +  NAME##_slurp_armap, \
27706 +  NAME##_slurp_extended_name_table, \
27707 +  NAME##_construct_extended_name_table, \
27708 +  NAME##_truncate_arname, \
27709 +  NAME##_write_armap, \
27710 +  NAME##_read_ar_hdr, \
27711 +  NAME##_openr_next_archived_file, \
27712 +  NAME##_get_elt_at_index, \
27713 +  NAME##_generic_stat_arch_elt, \
27714 +  NAME##_update_armap_timestamp
27715 +
27716 +  bfd_boolean (*_bfd_slurp_armap) (bfd *);
27717 +  bfd_boolean (*_bfd_slurp_extended_name_table) (bfd *);
27718 +  bfd_boolean (*_bfd_construct_extended_name_table)
27719 +    (bfd *, char **, bfd_size_type *, const char **);
27720 +  void        (*_bfd_truncate_arname) (bfd *, const char *, char *);
27721 +  bfd_boolean (*write_armap)
27722 +    (bfd *, unsigned int, struct orl *, unsigned int, int);
27723 +  void *      (*_bfd_read_ar_hdr_fn) (bfd *);
27724 +  bfd *       (*openr_next_archived_file) (bfd *, bfd *);
27725 +#define bfd_get_elt_at_index(b,i) BFD_SEND (b, _bfd_get_elt_at_index, (b,i))
27726 +  bfd *       (*_bfd_get_elt_at_index) (bfd *, symindex);
27727 +  int         (*_bfd_stat_arch_elt) (bfd *, struct stat *);
27728 +  bfd_boolean (*_bfd_update_armap_timestamp) (bfd *);
27729 +
27730 +  /* Entry points used for symbols.  */
27731 +#define BFD_JUMP_TABLE_SYMBOLS(NAME) \
27732 +  NAME##_get_symtab_upper_bound, \
27733 +  NAME##_canonicalize_symtab, \
27734 +  NAME##_make_empty_symbol, \
27735 +  NAME##_print_symbol, \
27736 +  NAME##_get_symbol_info, \
27737 +  NAME##_bfd_is_local_label_name, \
27738 +  NAME##_bfd_is_target_special_symbol, \
27739 +  NAME##_get_lineno, \
27740 +  NAME##_find_nearest_line, \
27741 +  _bfd_generic_find_line, \
27742 +  NAME##_find_inliner_info, \
27743 +  NAME##_bfd_make_debug_symbol, \
27744 +  NAME##_read_minisymbols, \
27745 +  NAME##_minisymbol_to_symbol
27746 +
27747 +  long        (*_bfd_get_symtab_upper_bound) (bfd *);
27748 +  long        (*_bfd_canonicalize_symtab)
27749 +    (bfd *, struct bfd_symbol **);
27750 +  struct bfd_symbol *
27751 +              (*_bfd_make_empty_symbol) (bfd *);
27752 +  void        (*_bfd_print_symbol)
27753 +    (bfd *, void *, struct bfd_symbol *, bfd_print_symbol_type);
27754 +#define bfd_print_symbol(b,p,s,e) BFD_SEND (b, _bfd_print_symbol, (b,p,s,e))
27755 +  void        (*_bfd_get_symbol_info)
27756 +    (bfd *, struct bfd_symbol *, symbol_info *);
27757 +#define bfd_get_symbol_info(b,p,e) BFD_SEND (b, _bfd_get_symbol_info, (b,p,e))
27758 +  bfd_boolean (*_bfd_is_local_label_name) (bfd *, const char *);
27759 +  bfd_boolean (*_bfd_is_target_special_symbol) (bfd *, asymbol *);
27760 +  alent *     (*_get_lineno) (bfd *, struct bfd_symbol *);
27761 +  bfd_boolean (*_bfd_find_nearest_line)
27762 +    (bfd *, struct bfd_section *, struct bfd_symbol **, bfd_vma,
27763 +     const char **, const char **, unsigned int *);
27764 +  bfd_boolean (*_bfd_find_line)
27765 +    (bfd *, struct bfd_symbol **, struct bfd_symbol *,
27766 +     const char **, unsigned int *);
27767 +  bfd_boolean (*_bfd_find_inliner_info)
27768 +    (bfd *, const char **, const char **, unsigned int *);
27769 + /* Back-door to allow format-aware applications to create debug symbols
27770 +    while using BFD for everything else.  Currently used by the assembler
27771 +    when creating COFF files.  */
27772 +  asymbol *   (*_bfd_make_debug_symbol)
27773 +    (bfd *, void *, unsigned long size);
27774 +#define bfd_read_minisymbols(b, d, m, s) \
27775 +  BFD_SEND (b, _read_minisymbols, (b, d, m, s))
27776 +  long        (*_read_minisymbols)
27777 +    (bfd *, bfd_boolean, void **, unsigned int *);
27778 +#define bfd_minisymbol_to_symbol(b, d, m, f) \
27779 +  BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f))
27780 +  asymbol *   (*_minisymbol_to_symbol)
27781 +    (bfd *, bfd_boolean, const void *, asymbol *);
27782 +
27783 +  /* Routines for relocs.  */
27784 +#define BFD_JUMP_TABLE_RELOCS(NAME) \
27785 +  NAME##_get_reloc_upper_bound, \
27786 +  NAME##_canonicalize_reloc, \
27787 +  NAME##_bfd_reloc_type_lookup
27788 +
27789 +  long        (*_get_reloc_upper_bound) (bfd *, sec_ptr);
27790 +  long        (*_bfd_canonicalize_reloc)
27791 +    (bfd *, sec_ptr, arelent **, struct bfd_symbol **);
27792 +  /* See documentation on reloc types.  */
27793 +  reloc_howto_type *
27794 +              (*reloc_type_lookup) (bfd *, bfd_reloc_code_real_type);
27795 +
27796 +  /* Routines used when writing an object file.  */
27797 +#define BFD_JUMP_TABLE_WRITE(NAME) \
27798 +  NAME##_set_arch_mach, \
27799 +  NAME##_set_section_contents
27800 +
27801 +  bfd_boolean (*_bfd_set_arch_mach)
27802 +    (bfd *, enum bfd_architecture, unsigned long);
27803 +  bfd_boolean (*_bfd_set_section_contents)
27804 +    (bfd *, sec_ptr, const void *, file_ptr, bfd_size_type);
27805 +
27806 +  /* Routines used by the linker.  */
27807 +#define BFD_JUMP_TABLE_LINK(NAME) \
27808 +  NAME##_sizeof_headers, \
27809 +  NAME##_bfd_get_relocated_section_contents, \
27810 +  NAME##_bfd_relax_section, \
27811 +  NAME##_bfd_link_hash_table_create, \
27812 +  NAME##_bfd_link_hash_table_free, \
27813 +  NAME##_bfd_link_add_symbols, \
27814 +  NAME##_bfd_link_just_syms, \
27815 +  NAME##_bfd_final_link, \
27816 +  NAME##_bfd_link_split_section, \
27817 +  NAME##_bfd_gc_sections, \
27818 +  NAME##_bfd_merge_sections, \
27819 +  NAME##_bfd_is_group_section, \
27820 +  NAME##_bfd_discard_group, \
27821 +  NAME##_section_already_linked \
27822 +
27823 +  int         (*_bfd_sizeof_headers) (bfd *, bfd_boolean);
27824 +  bfd_byte *  (*_bfd_get_relocated_section_contents)
27825 +    (bfd *, struct bfd_link_info *, struct bfd_link_order *,
27826 +     bfd_byte *, bfd_boolean, struct bfd_symbol **);
27827 +
27828 +  bfd_boolean (*_bfd_relax_section)
27829 +    (bfd *, struct bfd_section *, struct bfd_link_info *, bfd_boolean *);
27830 +
27831 +  /* Create a hash table for the linker.  Different backends store
27832 +     different information in this table.  */
27833 +  struct bfd_link_hash_table *
27834 +              (*_bfd_link_hash_table_create) (bfd *);
27835 +
27836 +  /* Release the memory associated with the linker hash table.  */
27837 +  void        (*_bfd_link_hash_table_free) (struct bfd_link_hash_table *);
27838 +
27839 +  /* Add symbols from this object file into the hash table.  */
27840 +  bfd_boolean (*_bfd_link_add_symbols) (bfd *, struct bfd_link_info *);
27841 +
27842 +  /* Indicate that we are only retrieving symbol values from this section.  */
27843 +  void        (*_bfd_link_just_syms) (asection *, struct bfd_link_info *);
27844 +
27845 +  /* Do a link based on the link_order structures attached to each
27846 +     section of the BFD.  */
27847 +  bfd_boolean (*_bfd_final_link) (bfd *, struct bfd_link_info *);
27848 +
27849 +  /* Should this section be split up into smaller pieces during linking.  */
27850 +  bfd_boolean (*_bfd_link_split_section) (bfd *, struct bfd_section *);
27851 +
27852 +  /* Remove sections that are not referenced from the output.  */
27853 +  bfd_boolean (*_bfd_gc_sections) (bfd *, struct bfd_link_info *);
27854 +
27855 +  /* Attempt to merge SEC_MERGE sections.  */
27856 +  bfd_boolean (*_bfd_merge_sections) (bfd *, struct bfd_link_info *);
27857 +
27858 +  /* Is this section a member of a group?  */
27859 +  bfd_boolean (*_bfd_is_group_section) (bfd *, const struct bfd_section *);
27860 +
27861 +  /* Discard members of a group.  */
27862 +  bfd_boolean (*_bfd_discard_group) (bfd *, struct bfd_section *);
27863 +
27864 +  /* Check if SEC has been already linked during a reloceatable or
27865 +     final link.  */
27866 +  void (*_section_already_linked) (bfd *, struct bfd_section *);
27867 +
27868 +  /* Routines to handle dynamic symbols and relocs.  */
27869 +#define BFD_JUMP_TABLE_DYNAMIC(NAME) \
27870 +  NAME##_get_dynamic_symtab_upper_bound, \
27871 +  NAME##_canonicalize_dynamic_symtab, \
27872 +  NAME##_get_synthetic_symtab, \
27873 +  NAME##_get_dynamic_reloc_upper_bound, \
27874 +  NAME##_canonicalize_dynamic_reloc
27875 +
27876 +  /* Get the amount of memory required to hold the dynamic symbols.  */
27877 +  long        (*_bfd_get_dynamic_symtab_upper_bound) (bfd *);
27878 +  /* Read in the dynamic symbols.  */
27879 +  long        (*_bfd_canonicalize_dynamic_symtab)
27880 +    (bfd *, struct bfd_symbol **);
27881 +  /* Create synthetized symbols.  */
27882 +  long        (*_bfd_get_synthetic_symtab)
27883 +    (bfd *, long, struct bfd_symbol **, long, struct bfd_symbol **,
27884 +     struct bfd_symbol **);
27885 +  /* Get the amount of memory required to hold the dynamic relocs.  */
27886 +  long        (*_bfd_get_dynamic_reloc_upper_bound) (bfd *);
27887 +  /* Read in the dynamic relocs.  */
27888 +  long        (*_bfd_canonicalize_dynamic_reloc)
27889 +    (bfd *, arelent **, struct bfd_symbol **);
27890 +
27891 +  /* Opposite endian version of this target.  */
27892 +  const struct bfd_target * alternative_target;
27893 +
27894 +  /* Data for use by back-end routines, which isn't
27895 +     generic enough to belong in this structure.  */
27896 +  const void *backend_data;
27897 +
27898 +} bfd_target;
27899 +
27900 +bfd_boolean bfd_set_default_target (const char *name);
27901 +
27902 +const bfd_target *bfd_find_target (const char *target_name, bfd *abfd);
27903 +
27904 +const char ** bfd_target_list (void);
27905 +
27906 +const bfd_target *bfd_search_for_target
27907 +   (int (*search_func) (const bfd_target *, void *),
27908 +    void *);
27909 +
27910 +/* Extracted from format.c.  */
27911 +bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);
27912 +
27913 +bfd_boolean bfd_check_format_matches
27914 +   (bfd *abfd, bfd_format format, char ***matching);
27915 +
27916 +bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
27917 +
27918 +const char *bfd_format_string (bfd_format format);
27919 +
27920 +/* Extracted from linker.c.  */
27921 +bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec);
27922 +
27923 +#define bfd_link_split_section(abfd, sec) \
27924 +       BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec))
27925 +
27926 +void bfd_section_already_linked (bfd *abfd, asection *sec);
27927 +
27928 +#define bfd_section_already_linked(abfd, sec) \
27929 +       BFD_SEND (abfd, _section_already_linked, (abfd, sec))
27930 +
27931 +/* Extracted from simple.c.  */
27932 +bfd_byte *bfd_simple_get_relocated_section_contents
27933 +   (bfd *abfd, asection *sec, bfd_byte *outbuf, asymbol **symbol_table);
27934 +
27935 +#ifdef __cplusplus
27936 +}
27937 +#endif
27938 +#endif
27939 --- /dev/null
27940 +++ b/include/asm-x86/bfd_64.h
27941 @@ -0,0 +1,4917 @@
27942 +/* DO NOT EDIT!  -*- buffer-read-only: t -*-  This file is automatically
27943 +   generated from "bfd-in.h", "init.c", "opncls.c", "libbfd.c",
27944 +   "bfdio.c", "bfdwin.c", "section.c", "archures.c", "reloc.c",
27945 +   "syms.c", "bfd.c", "archive.c", "corefile.c", "targets.c", "format.c",
27946 +   "linker.c" and "simple.c".
27947 +   Run "make headers" in your build bfd/ to regenerate.  */
27948 +
27949 +/* Main header file for the bfd library -- portable access to object files.
27950 +
27951 +   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
27952 +   1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
27953 +
27954 +   Contributed by Cygnus Support.
27955 +
27956 +   This file is part of BFD, the Binary File Descriptor library.
27957 +
27958 +   This program is free software; you can redistribute it and/or modify
27959 +   it under the terms of the GNU General Public License as published by
27960 +   the Free Software Foundation; either version 2 of the License, or
27961 +   (at your option) any later version.
27962 +
27963 +   This program is distributed in the hope that it will be useful,
27964 +   but WITHOUT ANY WARRANTY; without even the implied warranty of
27965 +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27966 +   GNU General Public License for more details.
27967 +
27968 +   You should have received a copy of the GNU General Public License
27969 +   along with this program; if not, write to the Free Software
27970 +   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
27971 +
27972 +/* Extracted from binutils 2.16.91.0.2 (OpenSUSE 10.0) and modified for kdb use.
27973 + * Any trailing whitespace was removed and #ifdef/ifndef __KERNEL__ added as
27974 + * required.
27975 + * Keith Owens <kaos@sgi.com> 15 May 2006
27976 + */
27977 +
27978 +#ifndef __BFD_H_SEEN__
27979 +#define __BFD_H_SEEN__
27980 +
27981 +#ifdef __cplusplus
27982 +extern "C" {
27983 +#endif
27984 +
27985 +#ifdef __KERNEL__
27986 +#include <asm/ansidecl.h>
27987 +#else  /* __KERNEL__ */
27988 +#include "ansidecl.h"
27989 +#include "symcat.h"
27990 +#endif /* __KERNEL__ */
27991 +#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
27992 +#ifndef SABER
27993 +/* This hack is to avoid a problem with some strict ANSI C preprocessors.
27994 +   The problem is, "32_" is not a valid preprocessing token, and we don't
27995 +   want extra underscores (e.g., "nlm_32_").  The XCONCAT2 macro will
27996 +   cause the inner CONCAT2 macros to be evaluated first, producing
27997 +   still-valid pp-tokens.  Then the final concatenation can be done.  */
27998 +#undef CONCAT4
27999 +#define CONCAT4(a,b,c,d) XCONCAT2(CONCAT2(a,b),CONCAT2(c,d))
28000 +#endif
28001 +#endif
28002 +
28003 +/* The word size used by BFD on the host.  This may be 64 with a 32
28004 +   bit target if the host is 64 bit, or if other 64 bit targets have
28005 +   been selected with --enable-targets, or if --enable-64-bit-bfd.  */
28006 +#define BFD_ARCH_SIZE 64
28007 +
28008 +/* The word size of the default bfd target.  */
28009 +#define BFD_DEFAULT_TARGET_SIZE 64
28010 +
28011 +#define BFD_HOST_64BIT_LONG 1
28012 +#define BFD_HOST_LONG_LONG 1
28013 +#if 1
28014 +#define BFD_HOST_64_BIT long
28015 +#define BFD_HOST_U_64_BIT unsigned long
28016 +typedef BFD_HOST_64_BIT bfd_int64_t;
28017 +typedef BFD_HOST_U_64_BIT bfd_uint64_t;
28018 +#endif
28019 +
28020 +#if BFD_ARCH_SIZE >= 64
28021 +#define BFD64
28022 +#endif
28023 +
28024 +#ifndef INLINE
28025 +#if __GNUC__ >= 2
28026 +#define INLINE __inline__
28027 +#else
28028 +#define INLINE
28029 +#endif
28030 +#endif
28031 +
28032 +/* Forward declaration.  */
28033 +typedef struct bfd bfd;
28034 +
28035 +/* Boolean type used in bfd.  Too many systems define their own
28036 +   versions of "boolean" for us to safely typedef a "boolean" of
28037 +   our own.  Using an enum for "bfd_boolean" has its own set of
28038 +   problems, with strange looking casts required to avoid warnings
28039 +   on some older compilers.  Thus we just use an int.
28040 +
28041 +   General rule: Functions which are bfd_boolean return TRUE on
28042 +   success and FALSE on failure (unless they're a predicate).  */
28043 +
28044 +typedef int bfd_boolean;
28045 +#undef FALSE
28046 +#undef TRUE
28047 +#define FALSE 0
28048 +#define TRUE 1
28049 +
28050 +#ifdef BFD64
28051 +
28052 +#ifndef BFD_HOST_64_BIT
28053 + #error No 64 bit integer type available
28054 +#endif /* ! defined (BFD_HOST_64_BIT) */
28055 +
28056 +typedef BFD_HOST_U_64_BIT bfd_vma;
28057 +typedef BFD_HOST_64_BIT bfd_signed_vma;
28058 +typedef BFD_HOST_U_64_BIT bfd_size_type;
28059 +typedef BFD_HOST_U_64_BIT symvalue;
28060 +
28061 +#ifndef fprintf_vma
28062 +#if BFD_HOST_64BIT_LONG
28063 +#define sprintf_vma(s,x) sprintf (s, "%016lx", x)
28064 +#define fprintf_vma(f,x) fprintf (f, "%016lx", x)
28065 +#else
28066 +#define _bfd_int64_low(x) ((unsigned long) (((x) & 0xffffffff)))
28067 +#define _bfd_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff))
28068 +#define fprintf_vma(s,x) \
28069 +  fprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
28070 +#define sprintf_vma(s,x) \
28071 +  sprintf ((s), "%08lx%08lx", _bfd_int64_high (x), _bfd_int64_low (x))
28072 +#endif
28073 +#endif
28074 +
28075 +#else /* not BFD64  */
28076 +
28077 +/* Represent a target address.  Also used as a generic unsigned type
28078 +   which is guaranteed to be big enough to hold any arithmetic types
28079 +   we need to deal with.  */
28080 +typedef unsigned long bfd_vma;
28081 +
28082 +/* A generic signed type which is guaranteed to be big enough to hold any
28083 +   arithmetic types we need to deal with.  Can be assumed to be compatible
28084 +   with bfd_vma in the same way that signed and unsigned ints are compatible
28085 +   (as parameters, in assignment, etc).  */
28086 +typedef long bfd_signed_vma;
28087 +
28088 +typedef unsigned long symvalue;
28089 +typedef unsigned long bfd_size_type;
28090 +
28091 +/* Print a bfd_vma x on stream s.  */
28092 +#define fprintf_vma(s,x) fprintf (s, "%08lx", x)
28093 +#define sprintf_vma(s,x) sprintf (s, "%08lx", x)
28094 +
28095 +#endif /* not BFD64  */
28096 +
28097 +#define HALF_BFD_SIZE_TYPE \
28098 +  (((bfd_size_type) 1) << (8 * sizeof (bfd_size_type) / 2))
28099 +
28100 +#ifndef BFD_HOST_64_BIT
28101 +/* Fall back on a 32 bit type.  The idea is to make these types always
28102 +   available for function return types, but in the case that
28103 +   BFD_HOST_64_BIT is undefined such a function should abort or
28104 +   otherwise signal an error.  */
28105 +typedef bfd_signed_vma bfd_int64_t;
28106 +typedef bfd_vma bfd_uint64_t;
28107 +#endif
28108 +
28109 +/* An offset into a file.  BFD always uses the largest possible offset
28110 +   based on the build time availability of fseek, fseeko, or fseeko64.  */
28111 +typedef BFD_HOST_64_BIT file_ptr;
28112 +typedef unsigned BFD_HOST_64_BIT ufile_ptr;
28113 +
28114 +extern void bfd_sprintf_vma (bfd *, char *, bfd_vma);
28115 +extern void bfd_fprintf_vma (bfd *, void *, bfd_vma);
28116 +
28117 +#define printf_vma(x) fprintf_vma(stdout,x)
28118 +#define bfd_printf_vma(abfd,x) bfd_fprintf_vma (abfd,stdout,x)
28119 +
28120 +typedef unsigned int flagword; /* 32 bits of flags */
28121 +typedef unsigned char bfd_byte;
28122 +\f
28123 +/* File formats.  */
28124 +
28125 +typedef enum bfd_format
28126 +{
28127 +  bfd_unknown = 0,     /* File format is unknown.  */
28128 +  bfd_object,          /* Linker/assembler/compiler output.  */
28129 +  bfd_archive,         /* Object archive file.  */
28130 +  bfd_core,            /* Core dump.  */
28131 +  bfd_type_end         /* Marks the end; don't use it!  */
28132 +}
28133 +bfd_format;
28134 +
28135 +/* Values that may appear in the flags field of a BFD.  These also
28136 +   appear in the object_flags field of the bfd_target structure, where
28137 +   they indicate the set of flags used by that backend (not all flags
28138 +   are meaningful for all object file formats) (FIXME: at the moment,
28139 +   the object_flags values have mostly just been copied from backend
28140 +   to another, and are not necessarily correct).  */
28141 +
28142 +/* No flags.  */
28143 +#define BFD_NO_FLAGS           0x00
28144 +
28145 +/* BFD contains relocation entries.  */
28146 +#define HAS_RELOC      0x01
28147 +
28148 +/* BFD is directly executable.  */
28149 +#define EXEC_P         0x02
28150 +
28151 +/* BFD has line number information (basically used for F_LNNO in a
28152 +   COFF header).  */
28153 +#define HAS_LINENO     0x04
28154 +
28155 +/* BFD has debugging information.  */
28156 +#define HAS_DEBUG      0x08
28157 +
28158 +/* BFD has symbols.  */
28159 +#define HAS_SYMS       0x10
28160 +
28161 +/* BFD has local symbols (basically used for F_LSYMS in a COFF
28162 +   header).  */
28163 +#define HAS_LOCALS     0x20
28164 +
28165 +/* BFD is a dynamic object.  */
28166 +#define DYNAMIC        0x40
28167 +
28168 +/* Text section is write protected (if D_PAGED is not set, this is
28169 +   like an a.out NMAGIC file) (the linker sets this by default, but
28170 +   clears it for -r or -N).  */
28171 +#define WP_TEXT        0x80
28172 +
28173 +/* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the
28174 +   linker sets this by default, but clears it for -r or -n or -N).  */
28175 +#define D_PAGED        0x100
28176 +
28177 +/* BFD is relaxable (this means that bfd_relax_section may be able to
28178 +   do something) (sometimes bfd_relax_section can do something even if
28179 +   this is not set).  */
28180 +#define BFD_IS_RELAXABLE 0x200
28181 +
28182 +/* This may be set before writing out a BFD to request using a
28183 +   traditional format.  For example, this is used to request that when
28184 +   writing out an a.out object the symbols not be hashed to eliminate
28185 +   duplicates.  */
28186 +#define BFD_TRADITIONAL_FORMAT 0x400
28187 +
28188 +/* This flag indicates that the BFD contents are actually cached in
28189 +   memory.  If this is set, iostream points to a bfd_in_memory struct.  */
28190 +#define BFD_IN_MEMORY 0x800
28191 +
28192 +/* The sections in this BFD specify a memory page.  */
28193 +#define HAS_LOAD_PAGE 0x1000
28194 +
28195 +/* This BFD has been created by the linker and doesn't correspond
28196 +   to any input file.  */
28197 +#define BFD_LINKER_CREATED 0x2000
28198 +\f
28199 +/* Symbols and relocation.  */
28200 +
28201 +/* A count of carsyms (canonical archive symbols).  */
28202 +typedef unsigned long symindex;
28203 +
28204 +/* How to perform a relocation.  */
28205 +typedef const struct reloc_howto_struct reloc_howto_type;
28206 +
28207 +#define BFD_NO_MORE_SYMBOLS ((symindex) ~0)
28208 +
28209 +/* General purpose part of a symbol X;
28210 +   target specific parts are in libcoff.h, libaout.h, etc.  */
28211 +
28212 +#define bfd_get_section(x) ((x)->section)
28213 +#define bfd_get_output_section(x) ((x)->section->output_section)
28214 +#define bfd_set_section(x,y) ((x)->section) = (y)
28215 +#define bfd_asymbol_base(x) ((x)->section->vma)
28216 +#define bfd_asymbol_value(x) (bfd_asymbol_base(x) + (x)->value)
28217 +#define bfd_asymbol_name(x) ((x)->name)
28218 +/*Perhaps future: #define bfd_asymbol_bfd(x) ((x)->section->owner)*/
28219 +#define bfd_asymbol_bfd(x) ((x)->the_bfd)
28220 +#define bfd_asymbol_flavour(x) (bfd_asymbol_bfd(x)->xvec->flavour)
28221 +
28222 +/* A canonical archive symbol.  */
28223 +/* This is a type pun with struct ranlib on purpose!  */
28224 +typedef struct carsym
28225 +{
28226 +  char *name;
28227 +  file_ptr file_offset;        /* Look here to find the file.  */
28228 +}
28229 +carsym;                        /* To make these you call a carsymogen.  */
28230 +
28231 +/* Used in generating armaps (archive tables of contents).
28232 +   Perhaps just a forward definition would do?  */
28233 +struct orl                     /* Output ranlib.  */
28234 +{
28235 +  char **name;         /* Symbol name.  */
28236 +  union
28237 +  {
28238 +    file_ptr pos;
28239 +    bfd *abfd;
28240 +  } u;                 /* bfd* or file position.  */
28241 +  int namidx;          /* Index into string table.  */
28242 +};
28243 +\f
28244 +/* Linenumber stuff.  */
28245 +typedef struct lineno_cache_entry
28246 +{
28247 +  unsigned int line_number;    /* Linenumber from start of function.  */
28248 +  union
28249 +  {
28250 +    struct bfd_symbol *sym;    /* Function name.  */
28251 +    bfd_vma offset;                    /* Offset into section.  */
28252 +  } u;
28253 +}
28254 +alent;
28255 +\f
28256 +/* Object and core file sections.  */
28257 +
28258 +#define        align_power(addr, align)        \
28259 +  (((addr) + ((bfd_vma) 1 << (align)) - 1) & ((bfd_vma) -1 << (align)))
28260 +
28261 +typedef struct bfd_section *sec_ptr;
28262 +
28263 +#define bfd_get_section_name(bfd, ptr) ((ptr)->name + 0)
28264 +#define bfd_get_section_vma(bfd, ptr) ((ptr)->vma + 0)
28265 +#define bfd_get_section_lma(bfd, ptr) ((ptr)->lma + 0)
28266 +#define bfd_get_section_alignment(bfd, ptr) ((ptr)->alignment_power + 0)
28267 +#define bfd_section_name(bfd, ptr) ((ptr)->name)
28268 +#define bfd_section_size(bfd, ptr) ((ptr)->size)
28269 +#define bfd_get_section_size(ptr) ((ptr)->size)
28270 +#define bfd_section_vma(bfd, ptr) ((ptr)->vma)
28271 +#define bfd_section_lma(bfd, ptr) ((ptr)->lma)
28272 +#define bfd_section_alignment(bfd, ptr) ((ptr)->alignment_power)
28273 +#define bfd_get_section_flags(bfd, ptr) ((ptr)->flags + 0)
28274 +#define bfd_get_section_userdata(bfd, ptr) ((ptr)->userdata)
28275 +
28276 +#define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
28277 +
28278 +#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = TRUE), TRUE)
28279 +#define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),TRUE)
28280 +#define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),TRUE)
28281 +/* Find the address one past the end of SEC.  */
28282 +#define bfd_get_section_limit(bfd, sec) \
28283 +  (((sec)->rawsize ? (sec)->rawsize : (sec)->size) \
28284 +   / bfd_octets_per_byte (bfd))
28285 +
28286 +typedef struct stat stat_type;
28287 +\f
28288 +typedef enum bfd_print_symbol
28289 +{
28290 +  bfd_print_symbol_name,
28291 +  bfd_print_symbol_more,
28292 +  bfd_print_symbol_all
28293 +} bfd_print_symbol_type;
28294 +
28295 +/* Information about a symbol that nm needs.  */
28296 +
28297 +typedef struct _symbol_info
28298 +{
28299 +  symvalue value;
28300 +  char type;
28301 +  const char *name;            /* Symbol name.  */
28302 +  unsigned char stab_type;     /* Stab type.  */
28303 +  char stab_other;             /* Stab other.  */
28304 +  short stab_desc;             /* Stab desc.  */
28305 +  const char *stab_name;       /* String for stab type.  */
28306 +} symbol_info;
28307 +
28308 +/* Get the name of a stabs type code.  */
28309 +
28310 +extern const char *bfd_get_stab_name (int);
28311 +\f
28312 +/* Hash table routines.  There is no way to free up a hash table.  */
28313 +
28314 +/* An element in the hash table.  Most uses will actually use a larger
28315 +   structure, and an instance of this will be the first field.  */
28316 +
28317 +struct bfd_hash_entry
28318 +{
28319 +  /* Next entry for this hash code.  */
28320 +  struct bfd_hash_entry *next;
28321 +  /* String being hashed.  */
28322 +  const char *string;
28323 +  /* Hash code.  This is the full hash code, not the index into the
28324 +     table.  */
28325 +  unsigned long hash;
28326 +};
28327 +
28328 +/* A hash table.  */
28329 +
28330 +struct bfd_hash_table
28331 +{
28332 +  /* The hash array.  */
28333 +  struct bfd_hash_entry **table;
28334 +  /* The number of slots in the hash table.  */
28335 +  unsigned int size;
28336 +  /* A function used to create new elements in the hash table.  The
28337 +     first entry is itself a pointer to an element.  When this
28338 +     function is first invoked, this pointer will be NULL.  However,
28339 +     having the pointer permits a hierarchy of method functions to be
28340 +     built each of which calls the function in the superclass.  Thus
28341 +     each function should be written to allocate a new block of memory
28342 +     only if the argument is NULL.  */
28343 +  struct bfd_hash_entry *(*newfunc)
28344 +    (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
28345 +   /* An objalloc for this hash table.  This is a struct objalloc *,
28346 +     but we use void * to avoid requiring the inclusion of objalloc.h.  */
28347 +  void *memory;
28348 +};
28349 +
28350 +/* Initialize a hash table.  */
28351 +extern bfd_boolean bfd_hash_table_init
28352 +  (struct bfd_hash_table *,
28353 +   struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
28354 +                              struct bfd_hash_table *,
28355 +                              const char *));
28356 +
28357 +/* Initialize a hash table specifying a size.  */
28358 +extern bfd_boolean bfd_hash_table_init_n
28359 +  (struct bfd_hash_table *,
28360 +   struct bfd_hash_entry *(*) (struct bfd_hash_entry *,
28361 +                              struct bfd_hash_table *,
28362 +                              const char *),
28363 +   unsigned int size);
28364 +
28365 +/* Free up a hash table.  */
28366 +extern void bfd_hash_table_free
28367 +  (struct bfd_hash_table *);
28368 +
28369 +/* Look up a string in a hash table.  If CREATE is TRUE, a new entry
28370 +   will be created for this string if one does not already exist.  The
28371 +   COPY argument must be TRUE if this routine should copy the string
28372 +   into newly allocated memory when adding an entry.  */
28373 +extern struct bfd_hash_entry *bfd_hash_lookup
28374 +  (struct bfd_hash_table *, const char *, bfd_boolean create,
28375 +   bfd_boolean copy);
28376 +
28377 +/* Replace an entry in a hash table.  */
28378 +extern void bfd_hash_replace
28379 +  (struct bfd_hash_table *, struct bfd_hash_entry *old,
28380 +   struct bfd_hash_entry *nw);
28381 +
28382 +/* Base method for creating a hash table entry.  */
28383 +extern struct bfd_hash_entry *bfd_hash_newfunc
28384 +  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
28385 +
28386 +/* Grab some space for a hash table entry.  */
28387 +extern void *bfd_hash_allocate
28388 +  (struct bfd_hash_table *, unsigned int);
28389 +
28390 +/* Traverse a hash table in a random order, calling a function on each
28391 +   element.  If the function returns FALSE, the traversal stops.  The
28392 +   INFO argument is passed to the function.  */
28393 +extern void bfd_hash_traverse
28394 +  (struct bfd_hash_table *,
28395 +   bfd_boolean (*) (struct bfd_hash_entry *, void *),
28396 +   void *info);
28397 +
28398 +/* Allows the default size of a hash table to be configured. New hash
28399 +   tables allocated using bfd_hash_table_init will be created with
28400 +   this size.  */
28401 +extern void bfd_hash_set_default_size (bfd_size_type);
28402 +
28403 +/* This structure is used to keep track of stabs in sections
28404 +   information while linking.  */
28405 +
28406 +struct stab_info
28407 +{
28408 +  /* A hash table used to hold stabs strings.  */
28409 +  struct bfd_strtab_hash *strings;
28410 +  /* The header file hash table.  */
28411 +  struct bfd_hash_table includes;
28412 +  /* The first .stabstr section.  */
28413 +  struct bfd_section *stabstr;
28414 +};
28415 +
28416 +#define COFF_SWAP_TABLE (void *) &bfd_coff_std_swap_table
28417 +
28418 +/* User program access to BFD facilities.  */
28419 +
28420 +/* Direct I/O routines, for programs which know more about the object
28421 +   file than BFD does.  Use higher level routines if possible.  */
28422 +
28423 +extern bfd_size_type bfd_bread (void *, bfd_size_type, bfd *);
28424 +extern bfd_size_type bfd_bwrite (const void *, bfd_size_type, bfd *);
28425 +extern int bfd_seek (bfd *, file_ptr, int);
28426 +extern file_ptr bfd_tell (bfd *);
28427 +extern int bfd_flush (bfd *);
28428 +extern int bfd_stat (bfd *, struct stat *);
28429 +
28430 +/* Deprecated old routines.  */
28431 +#if __GNUC__
28432 +#define bfd_read(BUF, ELTSIZE, NITEMS, ABFD)                           \
28433 +  (warn_deprecated ("bfd_read", __FILE__, __LINE__, __FUNCTION__),     \
28434 +   bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))
28435 +#define bfd_write(BUF, ELTSIZE, NITEMS, ABFD)                          \
28436 +  (warn_deprecated ("bfd_write", __FILE__, __LINE__, __FUNCTION__),    \
28437 +   bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))
28438 +#else
28439 +#define bfd_read(BUF, ELTSIZE, NITEMS, ABFD)                           \
28440 +  (warn_deprecated ("bfd_read", (const char *) 0, 0, (const char *) 0), \
28441 +   bfd_bread ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))
28442 +#define bfd_write(BUF, ELTSIZE, NITEMS, ABFD)                          \
28443 +  (warn_deprecated ("bfd_write", (const char *) 0, 0, (const char *) 0),\
28444 +   bfd_bwrite ((BUF), (ELTSIZE) * (NITEMS), (ABFD)))
28445 +#endif
28446 +extern void warn_deprecated (const char *, const char *, int, const char *);
28447 +
28448 +/* Cast from const char * to char * so that caller can assign to
28449 +   a char * without a warning.  */
28450 +#define bfd_get_filename(abfd) ((char *) (abfd)->filename)
28451 +#define bfd_get_cacheable(abfd) ((abfd)->cacheable)
28452 +#define bfd_get_format(abfd) ((abfd)->format)
28453 +#define bfd_get_target(abfd) ((abfd)->xvec->name)
28454 +#define bfd_get_flavour(abfd) ((abfd)->xvec->flavour)
28455 +#define bfd_family_coff(abfd) \
28456 +  (bfd_get_flavour (abfd) == bfd_target_coff_flavour || \
28457 +   bfd_get_flavour (abfd) == bfd_target_xcoff_flavour)
28458 +#define bfd_big_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)
28459 +#define bfd_little_endian(abfd) ((abfd)->xvec->byteorder == BFD_ENDIAN_LITTLE)
28460 +#define bfd_header_big_endian(abfd) \
28461 +  ((abfd)->xvec->header_byteorder == BFD_ENDIAN_BIG)
28462 +#define bfd_header_little_endian(abfd) \
28463 +  ((abfd)->xvec->header_byteorder == BFD_ENDIAN_LITTLE)
28464 +#define bfd_get_file_flags(abfd) ((abfd)->flags)
28465 +#define bfd_applicable_file_flags(abfd) ((abfd)->xvec->object_flags)
28466 +#define bfd_applicable_section_flags(abfd) ((abfd)->xvec->section_flags)
28467 +#define bfd_my_archive(abfd) ((abfd)->my_archive)
28468 +#define bfd_has_map(abfd) ((abfd)->has_armap)
28469 +
28470 +#define bfd_valid_reloc_types(abfd) ((abfd)->xvec->valid_reloc_types)
28471 +#define bfd_usrdata(abfd) ((abfd)->usrdata)
28472 +
28473 +#define bfd_get_start_address(abfd) ((abfd)->start_address)
28474 +#define bfd_get_symcount(abfd) ((abfd)->symcount)
28475 +#define bfd_get_outsymbols(abfd) ((abfd)->outsymbols)
28476 +#define bfd_count_sections(abfd) ((abfd)->section_count)
28477 +
28478 +#define bfd_get_dynamic_symcount(abfd) ((abfd)->dynsymcount)
28479 +
28480 +#define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char)
28481 +
28482 +#define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = bool), TRUE)
28483 +
28484 +extern bfd_boolean bfd_cache_close
28485 +  (bfd *abfd);
28486 +/* NB: This declaration should match the autogenerated one in libbfd.h.  */
28487 +
28488 +extern bfd_boolean bfd_cache_close_all (void);
28489 +
28490 +extern bfd_boolean bfd_record_phdr
28491 +  (bfd *, unsigned long, bfd_boolean, flagword, bfd_boolean, bfd_vma,
28492 +   bfd_boolean, bfd_boolean, unsigned int, struct bfd_section **);
28493 +
28494 +/* Byte swapping routines.  */
28495 +
28496 +bfd_uint64_t bfd_getb64 (const void *);
28497 +bfd_uint64_t bfd_getl64 (const void *);
28498 +bfd_int64_t bfd_getb_signed_64 (const void *);
28499 +bfd_int64_t bfd_getl_signed_64 (const void *);
28500 +bfd_vma bfd_getb32 (const void *);
28501 +bfd_vma bfd_getl32 (const void *);
28502 +bfd_signed_vma bfd_getb_signed_32 (const void *);
28503 +bfd_signed_vma bfd_getl_signed_32 (const void *);
28504 +bfd_vma bfd_getb16 (const void *);
28505 +bfd_vma bfd_getl16 (const void *);
28506 +bfd_signed_vma bfd_getb_signed_16 (const void *);
28507 +bfd_signed_vma bfd_getl_signed_16 (const void *);
28508 +void bfd_putb64 (bfd_uint64_t, void *);
28509 +void bfd_putl64 (bfd_uint64_t, void *);
28510 +void bfd_putb32 (bfd_vma, void *);
28511 +void bfd_putl32 (bfd_vma, void *);
28512 +void bfd_putb16 (bfd_vma, void *);
28513 +void bfd_putl16 (bfd_vma, void *);
28514 +
28515 +/* Byte swapping routines which take size and endiannes as arguments.  */
28516 +
28517 +bfd_uint64_t bfd_get_bits (const void *, int, bfd_boolean);
28518 +void bfd_put_bits (bfd_uint64_t, void *, int, bfd_boolean);
28519 +
28520 +extern bfd_boolean bfd_section_already_linked_table_init (void);
28521 +extern void bfd_section_already_linked_table_free (void);
28522 +\f
28523 +/* Externally visible ECOFF routines.  */
28524 +
28525 +#if defined(__STDC__) || defined(ALMOST_STDC)
28526 +struct ecoff_debug_info;
28527 +struct ecoff_debug_swap;
28528 +struct ecoff_extr;
28529 +struct bfd_symbol;
28530 +struct bfd_link_info;
28531 +struct bfd_link_hash_entry;
28532 +struct bfd_elf_version_tree;
28533 +#endif
28534 +extern bfd_vma bfd_ecoff_get_gp_value
28535 +  (bfd * abfd);
28536 +extern bfd_boolean bfd_ecoff_set_gp_value
28537 +  (bfd *abfd, bfd_vma gp_value);
28538 +extern bfd_boolean bfd_ecoff_set_regmasks
28539 +  (bfd *abfd, unsigned long gprmask, unsigned long fprmask,
28540 +   unsigned long *cprmask);
28541 +extern void *bfd_ecoff_debug_init
28542 +  (bfd *output_bfd, struct ecoff_debug_info *output_debug,
28543 +   const struct ecoff_debug_swap *output_swap, struct bfd_link_info *);
28544 +extern void bfd_ecoff_debug_free
28545 +  (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
28546 +   const struct ecoff_debug_swap *output_swap, struct bfd_link_info *);
28547 +extern bfd_boolean bfd_ecoff_debug_accumulate
28548 +  (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
28549 +   const struct ecoff_debug_swap *output_swap, bfd *input_bfd,
28550 +   struct ecoff_debug_info *input_debug,
28551 +   const struct ecoff_debug_swap *input_swap, struct bfd_link_info *);
28552 +extern bfd_boolean bfd_ecoff_debug_accumulate_other
28553 +  (void *handle, bfd *output_bfd, struct ecoff_debug_info *output_debug,
28554 +   const struct ecoff_debug_swap *output_swap, bfd *input_bfd,
28555 +   struct bfd_link_info *);
28556 +extern bfd_boolean bfd_ecoff_debug_externals
28557 +  (bfd *abfd, struct ecoff_debug_info *debug,
28558 +   const struct ecoff_debug_swap *swap, bfd_boolean relocatable,
28559 +   bfd_boolean (*get_extr) (struct bfd_symbol *, struct ecoff_extr *),
28560 +   void (*set_index) (struct bfd_symbol *, bfd_size_type));
28561 +extern bfd_boolean bfd_ecoff_debug_one_external
28562 +  (bfd *abfd, struct ecoff_debug_info *debug,
28563 +   const struct ecoff_debug_swap *swap, const char *name,
28564 +   struct ecoff_extr *esym);
28565 +extern bfd_size_type bfd_ecoff_debug_size
28566 +  (bfd *abfd, struct ecoff_debug_info *debug,
28567 +   const struct ecoff_debug_swap *swap);
28568 +extern bfd_boolean bfd_ecoff_write_debug
28569 +  (bfd *abfd, struct ecoff_debug_info *debug,
28570 +   const struct ecoff_debug_swap *swap, file_ptr where);
28571 +extern bfd_boolean bfd_ecoff_write_accumulated_debug
28572 +  (void *handle, bfd *abfd, struct ecoff_debug_info *debug,
28573 +   const struct ecoff_debug_swap *swap,
28574 +   struct bfd_link_info *info, file_ptr where);
28575 +
28576 +/* Externally visible ELF routines.  */
28577 +
28578 +struct bfd_link_needed_list
28579 +{
28580 +  struct bfd_link_needed_list *next;
28581 +  bfd *by;
28582 +  const char *name;
28583 +};
28584 +
28585 +enum dynamic_lib_link_class {
28586 +  DYN_NORMAL = 0,
28587 +  DYN_AS_NEEDED = 1,
28588 +  DYN_DT_NEEDED = 2,
28589 +  DYN_NO_ADD_NEEDED = 4,
28590 +  DYN_NO_NEEDED = 8
28591 +};
28592 +
28593 +extern bfd_boolean bfd_elf_record_link_assignment
28594 +  (struct bfd_link_info *, const char *, bfd_boolean);
28595 +extern struct bfd_link_needed_list *bfd_elf_get_needed_list
28596 +  (bfd *, struct bfd_link_info *);
28597 +extern bfd_boolean bfd_elf_get_bfd_needed_list
28598 +  (bfd *, struct bfd_link_needed_list **);
28599 +extern bfd_boolean bfd_elf_size_dynamic_sections
28600 +  (bfd *, const char *, const char *, const char *, const char * const *,
28601 +   struct bfd_link_info *, struct bfd_section **,
28602 +   struct bfd_elf_version_tree *);
28603 +extern bfd_boolean bfd_elf_size_dynsym_hash_dynstr
28604 +  (bfd *, struct bfd_link_info *);
28605 +extern void bfd_elf_set_dt_needed_name
28606 +  (bfd *, const char *);
28607 +extern const char *bfd_elf_get_dt_soname
28608 +  (bfd *);
28609 +extern void bfd_elf_set_dyn_lib_class
28610 +  (bfd *, int);
28611 +extern int bfd_elf_get_dyn_lib_class
28612 +  (bfd *);
28613 +extern struct bfd_link_needed_list *bfd_elf_get_runpath_list
28614 +  (bfd *, struct bfd_link_info *);
28615 +extern bfd_boolean bfd_elf_discard_info
28616 +  (bfd *, struct bfd_link_info *);
28617 +extern unsigned int _bfd_elf_default_action_discarded
28618 +  (struct bfd_section *);
28619 +
28620 +/* Return an upper bound on the number of bytes required to store a
28621 +   copy of ABFD's program header table entries.  Return -1 if an error
28622 +   occurs; bfd_get_error will return an appropriate code.  */
28623 +extern long bfd_get_elf_phdr_upper_bound
28624 +  (bfd *abfd);
28625 +
28626 +/* Copy ABFD's program header table entries to *PHDRS.  The entries
28627 +   will be stored as an array of Elf_Internal_Phdr structures, as
28628 +   defined in include/elf/internal.h.  To find out how large the
28629 +   buffer needs to be, call bfd_get_elf_phdr_upper_bound.
28630 +
28631 +   Return the number of program header table entries read, or -1 if an
28632 +   error occurs; bfd_get_error will return an appropriate code.  */
28633 +extern int bfd_get_elf_phdrs
28634 +  (bfd *abfd, void *phdrs);
28635 +
28636 +/* Create a new BFD as if by bfd_openr.  Rather than opening a file,
28637 +   reconstruct an ELF file by reading the segments out of remote memory
28638 +   based on the ELF file header at EHDR_VMA and the ELF program headers it
28639 +   points to.  If not null, *LOADBASEP is filled in with the difference
28640 +   between the VMAs from which the segments were read, and the VMAs the
28641 +   file headers (and hence BFD's idea of each section's VMA) put them at.
28642 +
28643 +   The function TARGET_READ_MEMORY is called to copy LEN bytes from the
28644 +   remote memory at target address VMA into the local buffer at MYADDR; it
28645 +   should return zero on success or an `errno' code on failure.  TEMPL must
28646 +   be a BFD for an ELF target with the word size and byte order found in
28647 +   the remote memory.  */
28648 +extern bfd *bfd_elf_bfd_from_remote_memory
28649 +  (bfd *templ, bfd_vma ehdr_vma, bfd_vma *loadbasep,
28650 +   int (*target_read_memory) (bfd_vma vma, bfd_byte *myaddr, int len));
28651 +
28652 +/* Return the arch_size field of an elf bfd, or -1 if not elf.  */
28653 +extern int bfd_get_arch_size
28654 +  (bfd *);
28655 +
28656 +/* Return TRUE if address "naturally" sign extends, or -1 if not elf.  */
28657 +extern int bfd_get_sign_extend_vma
28658 +  (bfd *);
28659 +
28660 +extern struct bfd_section *_bfd_elf_tls_setup
28661 +  (bfd *, struct bfd_link_info *);
28662 +
28663 +extern void _bfd_elf_provide_symbol
28664 +  (struct bfd_link_info *, const char *, bfd_vma, struct bfd_section *);
28665 +
28666 +extern void _bfd_elf_provide_section_bound_symbols
28667 +  (struct bfd_link_info *, struct bfd_section *, const char *, const char *);
28668 +
28669 +extern void _bfd_elf_fix_excluded_sec_syms
28670 +  (bfd *, struct bfd_link_info *);
28671 +
28672 +extern bfd_boolean bfd_m68k_elf32_create_embedded_relocs
28673 +  (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *,
28674 +   char **);
28675 +
28676 +/* SunOS shared library support routines for the linker.  */
28677 +
28678 +extern struct bfd_link_needed_list *bfd_sunos_get_needed_list
28679 +  (bfd *, struct bfd_link_info *);
28680 +extern bfd_boolean bfd_sunos_record_link_assignment
28681 +  (bfd *, struct bfd_link_info *, const char *);
28682 +extern bfd_boolean bfd_sunos_size_dynamic_sections
28683 +  (bfd *, struct bfd_link_info *, struct bfd_section **,
28684 +   struct bfd_section **, struct bfd_section **);
28685 +
28686 +/* Linux shared library support routines for the linker.  */
28687 +
28688 +extern bfd_boolean bfd_i386linux_size_dynamic_sections
28689 +  (bfd *, struct bfd_link_info *);
28690 +extern bfd_boolean bfd_m68klinux_size_dynamic_sections
28691 +  (bfd *, struct bfd_link_info *);
28692 +extern bfd_boolean bfd_sparclinux_size_dynamic_sections
28693 +  (bfd *, struct bfd_link_info *);
28694 +
28695 +/* mmap hacks */
28696 +
28697 +struct _bfd_window_internal;
28698 +typedef struct _bfd_window_internal bfd_window_internal;
28699 +
28700 +typedef struct _bfd_window
28701 +{
28702 +  /* What the user asked for.  */
28703 +  void *data;
28704 +  bfd_size_type size;
28705 +  /* The actual window used by BFD.  Small user-requested read-only
28706 +     regions sharing a page may share a single window into the object
28707 +     file.  Read-write versions shouldn't until I've fixed things to
28708 +     keep track of which portions have been claimed by the
28709 +     application; don't want to give the same region back when the
28710 +     application wants two writable copies!  */
28711 +  struct _bfd_window_internal *i;
28712 +}
28713 +bfd_window;
28714 +
28715 +extern void bfd_init_window
28716 +  (bfd_window *);
28717 +extern void bfd_free_window
28718 +  (bfd_window *);
28719 +extern bfd_boolean bfd_get_file_window
28720 +  (bfd *, file_ptr, bfd_size_type, bfd_window *, bfd_boolean);
28721 +
28722 +/* XCOFF support routines for the linker.  */
28723 +
28724 +extern bfd_boolean bfd_xcoff_link_record_set
28725 +  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_size_type);
28726 +extern bfd_boolean bfd_xcoff_import_symbol
28727 +  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *, bfd_vma,
28728 +   const char *, const char *, const char *, unsigned int);
28729 +extern bfd_boolean bfd_xcoff_export_symbol
28730 +  (bfd *, struct bfd_link_info *, struct bfd_link_hash_entry *);
28731 +extern bfd_boolean bfd_xcoff_link_count_reloc
28732 +  (bfd *, struct bfd_link_info *, const char *);
28733 +extern bfd_boolean bfd_xcoff_record_link_assignment
28734 +  (bfd *, struct bfd_link_info *, const char *);
28735 +extern bfd_boolean bfd_xcoff_size_dynamic_sections
28736 +  (bfd *, struct bfd_link_info *, const char *, const char *,
28737 +   unsigned long, unsigned long, unsigned long, bfd_boolean,
28738 +   int, bfd_boolean, bfd_boolean, struct bfd_section **, bfd_boolean);
28739 +extern bfd_boolean bfd_xcoff_link_generate_rtinit
28740 +  (bfd *, const char *, const char *, bfd_boolean);
28741 +
28742 +/* XCOFF support routines for ar.  */
28743 +extern bfd_boolean bfd_xcoff_ar_archive_set_magic
28744 +  (bfd *, char *);
28745 +
28746 +/* Externally visible COFF routines.  */
28747 +
28748 +#if defined(__STDC__) || defined(ALMOST_STDC)
28749 +struct internal_syment;
28750 +union internal_auxent;
28751 +#endif
28752 +
28753 +extern bfd_boolean bfd_coff_get_syment
28754 +  (bfd *, struct bfd_symbol *, struct internal_syment *);
28755 +
28756 +extern bfd_boolean bfd_coff_get_auxent
28757 +  (bfd *, struct bfd_symbol *, int, union internal_auxent *);
28758 +
28759 +extern bfd_boolean bfd_coff_set_symbol_class
28760 +  (bfd *, struct bfd_symbol *, unsigned int);
28761 +
28762 +extern bfd_boolean bfd_m68k_coff_create_embedded_relocs
28763 +  (bfd *, struct bfd_link_info *, struct bfd_section *, struct bfd_section *, char **);
28764 +
28765 +/* ARM Interworking support.  Called from linker.  */
28766 +extern bfd_boolean bfd_arm_allocate_interworking_sections
28767 +  (struct bfd_link_info *);
28768 +
28769 +extern bfd_boolean bfd_arm_process_before_allocation
28770 +  (bfd *, struct bfd_link_info *, int);
28771 +
28772 +extern bfd_boolean bfd_arm_get_bfd_for_interworking
28773 +  (bfd *, struct bfd_link_info *);
28774 +
28775 +/* PE ARM Interworking support.  Called from linker.  */
28776 +extern bfd_boolean bfd_arm_pe_allocate_interworking_sections
28777 +  (struct bfd_link_info *);
28778 +
28779 +extern bfd_boolean bfd_arm_pe_process_before_allocation
28780 +  (bfd *, struct bfd_link_info *, int);
28781 +
28782 +extern bfd_boolean bfd_arm_pe_get_bfd_for_interworking
28783 +  (bfd *, struct bfd_link_info *);
28784 +
28785 +/* ELF ARM Interworking support.  Called from linker.  */
28786 +extern bfd_boolean bfd_elf32_arm_allocate_interworking_sections
28787 +  (struct bfd_link_info *);
28788 +
28789 +extern bfd_boolean bfd_elf32_arm_process_before_allocation
28790 +  (bfd *, struct bfd_link_info *, int);
28791 +
28792 +void bfd_elf32_arm_set_target_relocs
28793 +  (struct bfd_link_info *, int, char *, int, int);
28794 +
28795 +extern bfd_boolean bfd_elf32_arm_get_bfd_for_interworking
28796 +  (bfd *, struct bfd_link_info *);
28797 +
28798 +extern bfd_boolean bfd_elf32_arm_add_glue_sections_to_bfd
28799 +  (bfd *, struct bfd_link_info *);
28800 +
28801 +/* ELF ARM mapping symbol support */
28802 +extern bfd_boolean bfd_is_arm_mapping_symbol_name
28803 +  (const char * name);
28804 +
28805 +/* ARM Note section processing.  */
28806 +extern bfd_boolean bfd_arm_merge_machines
28807 +  (bfd *, bfd *);
28808 +
28809 +extern bfd_boolean bfd_arm_update_notes
28810 +  (bfd *, const char *);
28811 +
28812 +extern unsigned int bfd_arm_get_mach_from_notes
28813 +  (bfd *, const char *);
28814 +
28815 +/* TI COFF load page support.  */
28816 +extern void bfd_ticoff_set_section_load_page
28817 +  (struct bfd_section *, int);
28818 +
28819 +extern int bfd_ticoff_get_section_load_page
28820 +  (struct bfd_section *);
28821 +
28822 +/* H8/300 functions.  */
28823 +extern bfd_vma bfd_h8300_pad_address
28824 +  (bfd *, bfd_vma);
28825 +
28826 +/* IA64 Itanium code generation.  Called from linker.  */
28827 +extern void bfd_elf32_ia64_after_parse
28828 +  (int);
28829 +
28830 +extern void bfd_elf64_ia64_after_parse
28831 +  (int);
28832 +
28833 +/* This structure is used for a comdat section, as in PE.  A comdat
28834 +   section is associated with a particular symbol.  When the linker
28835 +   sees a comdat section, it keeps only one of the sections with a
28836 +   given name and associated with a given symbol.  */
28837 +
28838 +struct coff_comdat_info
28839 +{
28840 +  /* The name of the symbol associated with a comdat section.  */
28841 +  const char *name;
28842 +
28843 +  /* The local symbol table index of the symbol associated with a
28844 +     comdat section.  This is only meaningful to the object file format
28845 +     specific code; it is not an index into the list returned by
28846 +     bfd_canonicalize_symtab.  */
28847 +  long symbol;
28848 +};
28849 +
28850 +extern struct coff_comdat_info *bfd_coff_get_comdat_section
28851 +  (bfd *, struct bfd_section *);
28852 +
28853 +/* Extracted from init.c.  */
28854 +void bfd_init (void);
28855 +
28856 +/* Extracted from opncls.c.  */
28857 +bfd *bfd_fopen (const char *filename, const char *target,
28858 +    const char *mode, int fd);
28859 +
28860 +bfd *bfd_openr (const char *filename, const char *target);
28861 +
28862 +bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
28863 +
28864 +bfd *bfd_openstreamr (const char *, const char *, void *);
28865 +
28866 +bfd *bfd_openr_iovec (const char *filename, const char *target,
28867 +    void *(*open) (struct bfd *nbfd,
28868 +    void *open_closure),
28869 +    void *open_closure,
28870 +    file_ptr (*pread) (struct bfd *nbfd,
28871 +    void *stream,
28872 +    void *buf,
28873 +    file_ptr nbytes,
28874 +    file_ptr offset),
28875 +    int (*close) (struct bfd *nbfd,
28876 +    void *stream));
28877 +
28878 +bfd *bfd_openw (const char *filename, const char *target);
28879 +
28880 +bfd_boolean bfd_close (bfd *abfd);
28881 +
28882 +bfd_boolean bfd_close_all_done (bfd *);
28883 +
28884 +bfd *bfd_create (const char *filename, bfd *templ);
28885 +
28886 +bfd_boolean bfd_make_writable (bfd *abfd);
28887 +
28888 +bfd_boolean bfd_make_readable (bfd *abfd);
28889 +
28890 +unsigned long bfd_calc_gnu_debuglink_crc32
28891 +   (unsigned long crc, const unsigned char *buf, bfd_size_type len);
28892 +
28893 +char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
28894 +
28895 +struct bfd_section *bfd_create_gnu_debuglink_section
28896 +   (bfd *abfd, const char *filename);
28897 +
28898 +bfd_boolean bfd_fill_in_gnu_debuglink_section
28899 +   (bfd *abfd, struct bfd_section *sect, const char *filename);
28900 +
28901 +/* Extracted from libbfd.c.  */
28902 +
28903 +/* Byte swapping macros for user section data.  */
28904 +
28905 +#define bfd_put_8(abfd, val, ptr) \
28906 +  ((void) (*((unsigned char *) (ptr)) = (val) & 0xff))
28907 +#define bfd_put_signed_8 \
28908 +  bfd_put_8
28909 +#define bfd_get_8(abfd, ptr) \
28910 +  (*(unsigned char *) (ptr) & 0xff)
28911 +#define bfd_get_signed_8(abfd, ptr) \
28912 +  (((*(unsigned char *) (ptr) & 0xff) ^ 0x80) - 0x80)
28913 +
28914 +#define bfd_put_16(abfd, val, ptr) \
28915 +  BFD_SEND (abfd, bfd_putx16, ((val),(ptr)))
28916 +#define bfd_put_signed_16 \
28917 +  bfd_put_16
28918 +#define bfd_get_16(abfd, ptr) \
28919 +  BFD_SEND (abfd, bfd_getx16, (ptr))
28920 +#define bfd_get_signed_16(abfd, ptr) \
28921 +  BFD_SEND (abfd, bfd_getx_signed_16, (ptr))
28922 +
28923 +#define bfd_put_32(abfd, val, ptr) \
28924 +  BFD_SEND (abfd, bfd_putx32, ((val),(ptr)))
28925 +#define bfd_put_signed_32 \
28926 +  bfd_put_32
28927 +#define bfd_get_32(abfd, ptr) \
28928 +  BFD_SEND (abfd, bfd_getx32, (ptr))
28929 +#define bfd_get_signed_32(abfd, ptr) \
28930 +  BFD_SEND (abfd, bfd_getx_signed_32, (ptr))
28931 +
28932 +#define bfd_put_64(abfd, val, ptr) \
28933 +  BFD_SEND (abfd, bfd_putx64, ((val), (ptr)))
28934 +#define bfd_put_signed_64 \
28935 +  bfd_put_64
28936 +#define bfd_get_64(abfd, ptr) \
28937 +  BFD_SEND (abfd, bfd_getx64, (ptr))
28938 +#define bfd_get_signed_64(abfd, ptr) \
28939 +  BFD_SEND (abfd, bfd_getx_signed_64, (ptr))
28940 +
28941 +#define bfd_get(bits, abfd, ptr)                       \
28942 +  ((bits) == 8 ? (bfd_vma) bfd_get_8 (abfd, ptr)       \
28943 +   : (bits) == 16 ? bfd_get_16 (abfd, ptr)             \
28944 +   : (bits) == 32 ? bfd_get_32 (abfd, ptr)             \
28945 +   : (bits) == 64 ? bfd_get_64 (abfd, ptr)             \
28946 +   : (abort (), (bfd_vma) - 1))
28947 +
28948 +#define bfd_put(bits, abfd, val, ptr)                  \
28949 +  ((bits) == 8 ? bfd_put_8  (abfd, val, ptr)           \
28950 +   : (bits) == 16 ? bfd_put_16 (abfd, val, ptr)                \
28951 +   : (bits) == 32 ? bfd_put_32 (abfd, val, ptr)                \
28952 +   : (bits) == 64 ? bfd_put_64 (abfd, val, ptr)                \
28953 +   : (abort (), (void) 0))
28954 +
28955 +
28956 +/* Byte swapping macros for file header data.  */
28957 +
28958 +#define bfd_h_put_8(abfd, val, ptr) \
28959 +  bfd_put_8 (abfd, val, ptr)
28960 +#define bfd_h_put_signed_8(abfd, val, ptr) \
28961 +  bfd_put_8 (abfd, val, ptr)
28962 +#define bfd_h_get_8(abfd, ptr) \
28963 +  bfd_get_8 (abfd, ptr)
28964 +#define bfd_h_get_signed_8(abfd, ptr) \
28965 +  bfd_get_signed_8 (abfd, ptr)
28966 +
28967 +#define bfd_h_put_16(abfd, val, ptr) \
28968 +  BFD_SEND (abfd, bfd_h_putx16, (val, ptr))
28969 +#define bfd_h_put_signed_16 \
28970 +  bfd_h_put_16
28971 +#define bfd_h_get_16(abfd, ptr) \
28972 +  BFD_SEND (abfd, bfd_h_getx16, (ptr))
28973 +#define bfd_h_get_signed_16(abfd, ptr) \
28974 +  BFD_SEND (abfd, bfd_h_getx_signed_16, (ptr))
28975 +
28976 +#define bfd_h_put_32(abfd, val, ptr) \
28977 +  BFD_SEND (abfd, bfd_h_putx32, (val, ptr))
28978 +#define bfd_h_put_signed_32 \
28979 +  bfd_h_put_32
28980 +#define bfd_h_get_32(abfd, ptr) \
28981 +  BFD_SEND (abfd, bfd_h_getx32, (ptr))
28982 +#define bfd_h_get_signed_32(abfd, ptr) \
28983 +  BFD_SEND (abfd, bfd_h_getx_signed_32, (ptr))
28984 +
28985 +#define bfd_h_put_64(abfd, val, ptr) \
28986 +  BFD_SEND (abfd, bfd_h_putx64, (val, ptr))
28987 +#define bfd_h_put_signed_64 \
28988 +  bfd_h_put_64
28989 +#define bfd_h_get_64(abfd, ptr) \
28990 +  BFD_SEND (abfd, bfd_h_getx64, (ptr))
28991 +#define bfd_h_get_signed_64(abfd, ptr) \
28992 +  BFD_SEND (abfd, bfd_h_getx_signed_64, (ptr))
28993 +
28994 +/* Aliases for the above, which should eventually go away.  */
28995 +
28996 +#define H_PUT_64  bfd_h_put_64
28997 +#define H_PUT_32  bfd_h_put_32
28998 +#define H_PUT_16  bfd_h_put_16
28999 +#define H_PUT_8   bfd_h_put_8
29000 +#define H_PUT_S64 bfd_h_put_signed_64
29001 +#define H_PUT_S32 bfd_h_put_signed_32
29002 +#define H_PUT_S16 bfd_h_put_signed_16
29003 +#define H_PUT_S8  bfd_h_put_signed_8
29004 +#define H_GET_64  bfd_h_get_64
29005 +#define H_GET_32  bfd_h_get_32
29006 +#define H_GET_16  bfd_h_get_16
29007 +#define H_GET_8   bfd_h_get_8
29008 +#define H_GET_S64 bfd_h_get_signed_64
29009 +#define H_GET_S32 bfd_h_get_signed_32
29010 +#define H_GET_S16 bfd_h_get_signed_16
29011 +#define H_GET_S8  bfd_h_get_signed_8
29012 +
29013 +
29014 +/* Extracted from bfdio.c.  */
29015 +long bfd_get_mtime (bfd *abfd);
29016 +
29017 +long bfd_get_size (bfd *abfd);
29018 +
29019 +/* Extracted from bfdwin.c.  */
29020 +/* Extracted from section.c.  */
29021 +typedef struct bfd_section
29022 +{
29023 +  /* The name of the section; the name isn't a copy, the pointer is
29024 +     the same as that passed to bfd_make_section.  */
29025 +  const char *name;
29026 +
29027 +  /* A unique sequence number.  */
29028 +  int id;
29029 +
29030 +  /* Which section in the bfd; 0..n-1 as sections are created in a bfd.  */
29031 +  int index;
29032 +
29033 +  /* The next section in the list belonging to the BFD, or NULL.  */
29034 +  struct bfd_section *next;
29035 +
29036 +  /* The previous section in the list belonging to the BFD, or NULL.  */
29037 +  struct bfd_section *prev;
29038 +
29039 +  /* The field flags contains attributes of the section. Some
29040 +     flags are read in from the object file, and some are
29041 +     synthesized from other information.  */
29042 +  flagword flags;
29043 +
29044 +#define SEC_NO_FLAGS   0x000
29045 +
29046 +  /* Tells the OS to allocate space for this section when loading.
29047 +     This is clear for a section containing debug information only.  */
29048 +#define SEC_ALLOC      0x001
29049 +
29050 +  /* Tells the OS to load the section from the file when loading.
29051 +     This is clear for a .bss section.  */
29052 +#define SEC_LOAD       0x002
29053 +
29054 +  /* The section contains data still to be relocated, so there is
29055 +     some relocation information too.  */
29056 +#define SEC_RELOC      0x004
29057 +
29058 +  /* A signal to the OS that the section contains read only data.  */
29059 +#define SEC_READONLY   0x008
29060 +
29061 +  /* The section contains code only.  */
29062 +#define SEC_CODE       0x010
29063 +
29064 +  /* The section contains data only.  */
29065 +#define SEC_DATA       0x020
29066 +
29067 +  /* The section will reside in ROM.  */
29068 +#define SEC_ROM        0x040
29069 +
29070 +  /* The section contains constructor information. This section
29071 +     type is used by the linker to create lists of constructors and
29072 +     destructors used by <<g++>>. When a back end sees a symbol
29073 +     which should be used in a constructor list, it creates a new
29074 +     section for the type of name (e.g., <<__CTOR_LIST__>>), attaches
29075 +     the symbol to it, and builds a relocation. To build the lists
29076 +     of constructors, all the linker has to do is catenate all the
29077 +     sections called <<__CTOR_LIST__>> and relocate the data
29078 +     contained within - exactly the operations it would peform on
29079 +     standard data.  */
29080 +#define SEC_CONSTRUCTOR 0x080
29081 +
29082 +  /* The section has contents - a data section could be
29083 +     <<SEC_ALLOC>> | <<SEC_HAS_CONTENTS>>; a debug section could be
29084 +     <<SEC_HAS_CONTENTS>>  */
29085 +#define SEC_HAS_CONTENTS 0x100
29086 +
29087 +  /* An instruction to the linker to not output the section
29088 +     even if it has information which would normally be written.  */
29089 +#define SEC_NEVER_LOAD 0x200
29090 +
29091 +  /* The section contains thread local data.  */
29092 +#define SEC_THREAD_LOCAL 0x400
29093 +
29094 +  /* The section has GOT references.  This flag is only for the
29095 +     linker, and is currently only used by the elf32-hppa back end.
29096 +     It will be set if global offset table references were detected
29097 +     in this section, which indicate to the linker that the section
29098 +     contains PIC code, and must be handled specially when doing a
29099 +     static link.  */
29100 +#define SEC_HAS_GOT_REF 0x800
29101 +
29102 +  /* The section contains common symbols (symbols may be defined
29103 +     multiple times, the value of a symbol is the amount of
29104 +     space it requires, and the largest symbol value is the one
29105 +     used).  Most targets have exactly one of these (which we
29106 +     translate to bfd_com_section_ptr), but ECOFF has two.  */
29107 +#define SEC_IS_COMMON 0x1000
29108 +
29109 +  /* The section contains only debugging information.  For
29110 +     example, this is set for ELF .debug and .stab sections.
29111 +     strip tests this flag to see if a section can be
29112 +     discarded.  */
29113 +#define SEC_DEBUGGING 0x2000
29114 +
29115 +  /* The contents of this section are held in memory pointed to
29116 +     by the contents field.  This is checked by bfd_get_section_contents,
29117 +     and the data is retrieved from memory if appropriate.  */
29118 +#define SEC_IN_MEMORY 0x4000
29119 +
29120 +  /* The contents of this section are to be excluded by the
29121 +     linker for executable and shared objects unless those
29122 +     objects are to be further relocated.  */
29123 +#define SEC_EXCLUDE 0x8000
29124 +
29125 +  /* The contents of this section are to be sorted based on the sum of
29126 +     the symbol and addend values specified by the associated relocation
29127 +     entries.  Entries without associated relocation entries will be
29128 +     appended to the end of the section in an unspecified order.  */
29129 +#define SEC_SORT_ENTRIES 0x10000
29130 +
29131 +  /* When linking, duplicate sections of the same name should be
29132 +     discarded, rather than being combined into a single section as
29133 +     is usually done.  This is similar to how common symbols are
29134 +     handled.  See SEC_LINK_DUPLICATES below.  */
29135 +#define SEC_LINK_ONCE 0x20000
29136 +
29137 +  /* If SEC_LINK_ONCE is set, this bitfield describes how the linker
29138 +     should handle duplicate sections.  */
29139 +#define SEC_LINK_DUPLICATES 0x40000
29140 +
29141 +  /* This value for SEC_LINK_DUPLICATES means that duplicate
29142 +     sections with the same name should simply be discarded.  */
29143 +#define SEC_LINK_DUPLICATES_DISCARD 0x0
29144 +
29145 +  /* This value for SEC_LINK_DUPLICATES means that the linker
29146 +     should warn if there are any duplicate sections, although
29147 +     it should still only link one copy.  */
29148 +#define SEC_LINK_DUPLICATES_ONE_ONLY 0x80000
29149 +
29150 +  /* This value for SEC_LINK_DUPLICATES means that the linker
29151 +     should warn if any duplicate sections are a different size.  */
29152 +#define SEC_LINK_DUPLICATES_SAME_SIZE 0x100000
29153 +
29154 +  /* This value for SEC_LINK_DUPLICATES means that the linker
29155 +     should warn if any duplicate sections contain different
29156 +     contents.  */
29157 +#define SEC_LINK_DUPLICATES_SAME_CONTENTS \
29158 +  (SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE)
29159 +
29160 +  /* This section was created by the linker as part of dynamic
29161 +     relocation or other arcane processing.  It is skipped when
29162 +     going through the first-pass output, trusting that someone
29163 +     else up the line will take care of it later.  */
29164 +#define SEC_LINKER_CREATED 0x200000
29165 +
29166 +  /* This section should not be subject to garbage collection.  */
29167 +#define SEC_KEEP 0x400000
29168 +
29169 +  /* This section contains "short" data, and should be placed
29170 +     "near" the GP.  */
29171 +#define SEC_SMALL_DATA 0x800000
29172 +
29173 +  /* Attempt to merge identical entities in the section.
29174 +     Entity size is given in the entsize field.  */
29175 +#define SEC_MERGE 0x1000000
29176 +
29177 +  /* If given with SEC_MERGE, entities to merge are zero terminated
29178 +     strings where entsize specifies character size instead of fixed
29179 +     size entries.  */
29180 +#define SEC_STRINGS 0x2000000
29181 +
29182 +  /* This section contains data about section groups.  */
29183 +#define SEC_GROUP 0x4000000
29184 +
29185 +  /* The section is a COFF shared library section.  This flag is
29186 +     only for the linker.  If this type of section appears in
29187 +     the input file, the linker must copy it to the output file
29188 +     without changing the vma or size.  FIXME: Although this
29189 +     was originally intended to be general, it really is COFF
29190 +     specific (and the flag was renamed to indicate this).  It
29191 +     might be cleaner to have some more general mechanism to
29192 +     allow the back end to control what the linker does with
29193 +     sections.  */
29194 +#define SEC_COFF_SHARED_LIBRARY 0x10000000
29195 +
29196 +  /* This section contains data which may be shared with other
29197 +     executables or shared objects. This is for COFF only.  */
29198 +#define SEC_COFF_SHARED 0x20000000
29199 +
29200 +  /* When a section with this flag is being linked, then if the size of
29201 +     the input section is less than a page, it should not cross a page
29202 +     boundary.  If the size of the input section is one page or more,
29203 +     it should be aligned on a page boundary.  This is for TI
29204 +     TMS320C54X only.  */
29205 +#define SEC_TIC54X_BLOCK 0x40000000
29206 +
29207 +  /* Conditionally link this section; do not link if there are no
29208 +     references found to any symbol in the section.  This is for TI
29209 +     TMS320C54X only.  */
29210 +#define SEC_TIC54X_CLINK 0x80000000
29211 +
29212 +  /*  End of section flags.  */
29213 +
29214 +  /* Some internal packed boolean fields.  */
29215 +
29216 +  /* See the vma field.  */
29217 +  unsigned int user_set_vma : 1;
29218 +
29219 +  /* A mark flag used by some of the linker backends.  */
29220 +  unsigned int linker_mark : 1;
29221 +
29222 +  /* Another mark flag used by some of the linker backends.  Set for
29223 +     output sections that have an input section.  */
29224 +  unsigned int linker_has_input : 1;
29225 +
29226 +  /* Mark flags used by some linker backends for garbage collection.  */
29227 +  unsigned int gc_mark : 1;
29228 +  unsigned int gc_mark_from_eh : 1;
29229 +
29230 +  /* The following flags are used by the ELF linker. */
29231 +
29232 +  /* Mark sections which have been allocated to segments.  */
29233 +  unsigned int segment_mark : 1;
29234 +
29235 +  /* Type of sec_info information.  */
29236 +  unsigned int sec_info_type:3;
29237 +#define ELF_INFO_TYPE_NONE      0
29238 +#define ELF_INFO_TYPE_STABS     1
29239 +#define ELF_INFO_TYPE_MERGE     2
29240 +#define ELF_INFO_TYPE_EH_FRAME  3
29241 +#define ELF_INFO_TYPE_JUST_SYMS 4
29242 +
29243 +  /* Nonzero if this section uses RELA relocations, rather than REL.  */
29244 +  unsigned int use_rela_p:1;
29245 +
29246 +  /* Bits used by various backends.  The generic code doesn't touch
29247 +     these fields.  */
29248 +
29249 +  /* Nonzero if this section has TLS related relocations.  */
29250 +  unsigned int has_tls_reloc:1;
29251 +
29252 +  /* Nonzero if this section has a gp reloc.  */
29253 +  unsigned int has_gp_reloc:1;
29254 +
29255 +  /* Nonzero if this section needs the relax finalize pass.  */
29256 +  unsigned int need_finalize_relax:1;
29257 +
29258 +  /* Whether relocations have been processed.  */
29259 +  unsigned int reloc_done : 1;
29260 +
29261 +  /* End of internal packed boolean fields.  */
29262 +
29263 +  /*  The virtual memory address of the section - where it will be
29264 +      at run time.  The symbols are relocated against this.  The
29265 +      user_set_vma flag is maintained by bfd; if it's not set, the
29266 +      backend can assign addresses (for example, in <<a.out>>, where
29267 +      the default address for <<.data>> is dependent on the specific
29268 +      target and various flags).  */
29269 +  bfd_vma vma;
29270 +
29271 +  /*  The load address of the section - where it would be in a
29272 +      rom image; really only used for writing section header
29273 +      information.  */
29274 +  bfd_vma lma;
29275 +
29276 +  /* The size of the section in octets, as it will be output.
29277 +     Contains a value even if the section has no contents (e.g., the
29278 +     size of <<.bss>>).  */
29279 +  bfd_size_type size;
29280 +
29281 +  /* For input sections, the original size on disk of the section, in
29282 +     octets.  This field is used by the linker relaxation code.  It is
29283 +     currently only set for sections where the linker relaxation scheme
29284 +     doesn't cache altered section and reloc contents (stabs, eh_frame,
29285 +     SEC_MERGE, some coff relaxing targets), and thus the original size
29286 +     needs to be kept to read the section multiple times.
29287 +     For output sections, rawsize holds the section size calculated on
29288 +     a previous linker relaxation pass.  */
29289 +  bfd_size_type rawsize;
29290 +
29291 +  /* If this section is going to be output, then this value is the
29292 +     offset in *bytes* into the output section of the first byte in the
29293 +     input section (byte ==> smallest addressable unit on the
29294 +     target).  In most cases, if this was going to start at the
29295 +     100th octet (8-bit quantity) in the output section, this value
29296 +     would be 100.  However, if the target byte size is 16 bits
29297 +     (bfd_octets_per_byte is "2"), this value would be 50.  */
29298 +  bfd_vma output_offset;
29299 +
29300 +  /* The output section through which to map on output.  */
29301 +  struct bfd_section *output_section;
29302 +
29303 +  /* The alignment requirement of the section, as an exponent of 2 -
29304 +     e.g., 3 aligns to 2^3 (or 8).  */
29305 +  unsigned int alignment_power;
29306 +
29307 +  /* If an input section, a pointer to a vector of relocation
29308 +     records for the data in this section.  */
29309 +  struct reloc_cache_entry *relocation;
29310 +
29311 +  /* If an output section, a pointer to a vector of pointers to
29312 +     relocation records for the data in this section.  */
29313 +  struct reloc_cache_entry **orelocation;
29314 +
29315 +  /* The number of relocation records in one of the above.  */
29316 +  unsigned reloc_count;
29317 +
29318 +  /* Information below is back end specific - and not always used
29319 +     or updated.  */
29320 +
29321 +  /* File position of section data.  */
29322 +  file_ptr filepos;
29323 +
29324 +  /* File position of relocation info.  */
29325 +  file_ptr rel_filepos;
29326 +
29327 +  /* File position of line data.  */
29328 +  file_ptr line_filepos;
29329 +
29330 +  /* Pointer to data for applications.  */
29331 +  void *userdata;
29332 +
29333 +  /* If the SEC_IN_MEMORY flag is set, this points to the actual
29334 +     contents.  */
29335 +  unsigned char *contents;
29336 +
29337 +  /* Attached line number information.  */
29338 +  alent *lineno;
29339 +
29340 +  /* Number of line number records.  */
29341 +  unsigned int lineno_count;
29342 +
29343 +  /* Entity size for merging purposes.  */
29344 +  unsigned int entsize;
29345 +
29346 +  /* Points to the kept section if this section is a link-once section,
29347 +     and is discarded.  */
29348 +  struct bfd_section *kept_section;
29349 +
29350 +  /* When a section is being output, this value changes as more
29351 +     linenumbers are written out.  */
29352 +  file_ptr moving_line_filepos;
29353 +
29354 +  /* What the section number is in the target world.  */
29355 +  int target_index;
29356 +
29357 +  void *used_by_bfd;
29358 +
29359 +  /* If this is a constructor section then here is a list of the
29360 +     relocations created to relocate items within it.  */
29361 +  struct relent_chain *constructor_chain;
29362 +
29363 +  /* The BFD which owns the section.  */
29364 +  bfd *owner;
29365 +
29366 +  /* A symbol which points at this section only.  */
29367 +  struct bfd_symbol *symbol;
29368 +  struct bfd_symbol **symbol_ptr_ptr;
29369 +
29370 +  /* Early in the link process, map_head and map_tail are used to build
29371 +     a list of input sections attached to an output section.  Later,
29372 +     output sections use these fields for a list of bfd_link_order
29373 +     structs.  */
29374 +  union {
29375 +    struct bfd_link_order *link_order;
29376 +    struct bfd_section *s;
29377 +  } map_head, map_tail;
29378 +} asection;
29379 +
29380 +/* These sections are global, and are managed by BFD.  The application
29381 +   and target back end are not permitted to change the values in
29382 +   these sections.  New code should use the section_ptr macros rather
29383 +   than referring directly to the const sections.  The const sections
29384 +   may eventually vanish.  */
29385 +#define BFD_ABS_SECTION_NAME "*ABS*"
29386 +#define BFD_UND_SECTION_NAME "*UND*"
29387 +#define BFD_COM_SECTION_NAME "*COM*"
29388 +#define BFD_IND_SECTION_NAME "*IND*"
29389 +
29390 +/* The absolute section.  */
29391 +extern asection bfd_abs_section;
29392 +#define bfd_abs_section_ptr ((asection *) &bfd_abs_section)
29393 +#define bfd_is_abs_section(sec) ((sec) == bfd_abs_section_ptr)
29394 +/* Pointer to the undefined section.  */
29395 +extern asection bfd_und_section;
29396 +#define bfd_und_section_ptr ((asection *) &bfd_und_section)
29397 +#define bfd_is_und_section(sec) ((sec) == bfd_und_section_ptr)
29398 +/* Pointer to the common section.  */
29399 +extern asection bfd_com_section;
29400 +#define bfd_com_section_ptr ((asection *) &bfd_com_section)
29401 +/* Pointer to the indirect section.  */
29402 +extern asection bfd_ind_section;
29403 +#define bfd_ind_section_ptr ((asection *) &bfd_ind_section)
29404 +#define bfd_is_ind_section(sec) ((sec) == bfd_ind_section_ptr)
29405 +
29406 +#define bfd_is_const_section(SEC)              \
29407 + (   ((SEC) == bfd_abs_section_ptr)            \
29408 +  || ((SEC) == bfd_und_section_ptr)            \
29409 +  || ((SEC) == bfd_com_section_ptr)            \
29410 +  || ((SEC) == bfd_ind_section_ptr))
29411 +
29412 +extern const struct bfd_symbol * const bfd_abs_symbol;
29413 +extern const struct bfd_symbol * const bfd_com_symbol;
29414 +extern const struct bfd_symbol * const bfd_und_symbol;
29415 +extern const struct bfd_symbol * const bfd_ind_symbol;
29416 +
29417 +/* Macros to handle insertion and deletion of a bfd's sections.  These
29418 +   only handle the list pointers, ie. do not adjust section_count,
29419 +   target_index etc.  */
29420 +#define bfd_section_list_remove(ABFD, S) \
29421 +  do                                                   \
29422 +    {                                                  \
29423 +      asection *_s = S;                                \
29424 +      asection *_next = _s->next;                      \
29425 +      asection *_prev = _s->prev;                      \
29426 +      if (_prev)                                       \
29427 +        _prev->next = _next;                           \
29428 +      else                                             \
29429 +        (ABFD)->sections = _next;                      \
29430 +      if (_next)                                       \
29431 +        _next->prev = _prev;                           \
29432 +      else                                             \
29433 +        (ABFD)->section_last = _prev;                  \
29434 +    }                                                  \
29435 +  while (0)
29436 +#define bfd_section_list_append(ABFD, S) \
29437 +  do                                                   \
29438 +    {                                                  \
29439 +      asection *_s = S;                                \
29440 +      bfd *_abfd = ABFD;                               \
29441 +      _s->next = NULL;                                 \
29442 +      if (_abfd->section_last)                         \
29443 +        {                                              \
29444 +          _s->prev = _abfd->section_last;              \
29445 +          _abfd->section_last->next = _s;              \
29446 +        }                                              \
29447 +      else                                             \
29448 +        {                                              \
29449 +          _s->prev = NULL;                             \
29450 +          _abfd->sections = _s;                        \
29451 +        }                                              \
29452 +      _abfd->section_last = _s;                        \
29453 +    }                                                  \
29454 +  while (0)
29455 +#define bfd_section_list_prepend(ABFD, S) \
29456 +  do                                                   \
29457 +    {                                                  \
29458 +      asection *_s = S;                                \
29459 +      bfd *_abfd = ABFD;                               \
29460 +      _s->prev = NULL;                                 \
29461 +      if (_abfd->sections)                             \
29462 +        {                                              \
29463 +          _s->next = _abfd->sections;                  \
29464 +          _abfd->sections->prev = _s;                  \
29465 +        }                                              \
29466 +      else                                             \
29467 +        {                                              \
29468 +          _s->next = NULL;                             \
29469 +          _abfd->section_last = _s;                    \
29470 +        }                                              \
29471 +      _abfd->sections = _s;                            \
29472 +    }                                                  \
29473 +  while (0)
29474 +#define bfd_section_list_insert_after(ABFD, A, S) \
29475 +  do                                                   \
29476 +    {                                                  \
29477 +      asection *_a = A;                                \
29478 +      asection *_s = S;                                \
29479 +      asection *_next = _a->next;                      \
29480 +      _s->next = _next;                                \
29481 +      _s->prev = _a;                                   \
29482 +      _a->next = _s;                                   \
29483 +      if (_next)                                       \
29484 +        _next->prev = _s;                              \
29485 +      else                                             \
29486 +        (ABFD)->section_last = _s;                     \
29487 +    }                                                  \
29488 +  while (0)
29489 +#define bfd_section_list_insert_before(ABFD, B, S) \
29490 +  do                                                   \
29491 +    {                                                  \
29492 +      asection *_b = B;                                \
29493 +      asection *_s = S;                                \
29494 +      asection *_prev = _b->prev;                      \
29495 +      _s->prev = _prev;                                \
29496 +      _s->next = _b;                                   \
29497 +      _b->prev = _s;                                   \
29498 +      if (_prev)                                       \
29499 +        _prev->next = _s;                              \
29500 +      else                                             \
29501 +        (ABFD)->sections = _s;                         \
29502 +    }                                                  \
29503 +  while (0)
29504 +#define bfd_section_removed_from_list(ABFD, S) \
29505 +  ((S)->next == NULL ? (ABFD)->section_last != (S) : (S)->next->prev != (S))
29506 +
29507 +void bfd_section_list_clear (bfd *);
29508 +
29509 +asection *bfd_get_section_by_name (bfd *abfd, const char *name);
29510 +
29511 +asection *bfd_get_section_by_name_if
29512 +   (bfd *abfd,
29513 +    const char *name,
29514 +    bfd_boolean (*func) (bfd *abfd, asection *sect, void *obj),
29515 +    void *obj);
29516 +
29517 +char *bfd_get_unique_section_name
29518 +   (bfd *abfd, const char *templat, int *count);
29519 +
29520 +asection *bfd_make_section_old_way (bfd *abfd, const char *name);
29521 +
29522 +asection *bfd_make_section_anyway_with_flags
29523 +   (bfd *abfd, const char *name, flagword flags);
29524 +
29525 +asection *bfd_make_section_anyway (bfd *abfd, const char *name);
29526 +
29527 +asection *bfd_make_section_with_flags
29528 +   (bfd *, const char *name, flagword flags);
29529 +
29530 +asection *bfd_make_section (bfd *, const char *name);
29531 +
29532 +bfd_boolean bfd_set_section_flags
29533 +   (bfd *abfd, asection *sec, flagword flags);
29534 +
29535 +void bfd_map_over_sections
29536 +   (bfd *abfd,
29537 +    void (*func) (bfd *abfd, asection *sect, void *obj),
29538 +    void *obj);
29539 +
29540 +asection *bfd_sections_find_if
29541 +   (bfd *abfd,
29542 +    bfd_boolean (*operation) (bfd *abfd, asection *sect, void *obj),
29543 +    void *obj);
29544 +
29545 +bfd_boolean bfd_set_section_size
29546 +   (bfd *abfd, asection *sec, bfd_size_type val);
29547 +
29548 +bfd_boolean bfd_set_section_contents
29549 +   (bfd *abfd, asection *section, const void *data,
29550 +    file_ptr offset, bfd_size_type count);
29551 +
29552 +bfd_boolean bfd_get_section_contents
29553 +   (bfd *abfd, asection *section, void *location, file_ptr offset,
29554 +    bfd_size_type count);
29555 +
29556 +bfd_boolean bfd_malloc_and_get_section
29557 +   (bfd *abfd, asection *section, bfd_byte **buf);
29558 +
29559 +bfd_boolean bfd_copy_private_section_data
29560 +   (bfd *ibfd, asection *isec, bfd *obfd, asection *osec);
29561 +
29562 +#define bfd_copy_private_section_data(ibfd, isection, obfd, osection) \
29563 +     BFD_SEND (obfd, _bfd_copy_private_section_data, \
29564 +               (ibfd, isection, obfd, osection))
29565 +bfd_boolean bfd_generic_is_group_section (bfd *, const asection *sec);
29566 +
29567 +bfd_boolean bfd_generic_discard_group (bfd *abfd, asection *group);
29568 +
29569 +/* Extracted from archures.c.  */
29570 +enum bfd_architecture
29571 +{
29572 +  bfd_arch_unknown,   /* File arch not known.  */
29573 +  bfd_arch_obscure,   /* Arch known, not one of these.  */
29574 +  bfd_arch_m68k,      /* Motorola 68xxx */
29575 +#define bfd_mach_m68000 1
29576 +#define bfd_mach_m68008 2
29577 +#define bfd_mach_m68010 3
29578 +#define bfd_mach_m68020 4
29579 +#define bfd_mach_m68030 5
29580 +#define bfd_mach_m68040 6
29581 +#define bfd_mach_m68060 7
29582 +#define bfd_mach_cpu32  8
29583 +#define bfd_mach_mcf5200  9
29584 +#define bfd_mach_mcf5206e 10
29585 +#define bfd_mach_mcf5307  11
29586 +#define bfd_mach_mcf5407  12
29587 +#define bfd_mach_mcf528x  13
29588 +#define bfd_mach_mcfv4e   14
29589 +#define bfd_mach_mcf521x   15
29590 +#define bfd_mach_mcf5249   16
29591 +#define bfd_mach_mcf547x   17
29592 +#define bfd_mach_mcf548x   18
29593 +  bfd_arch_vax,       /* DEC Vax */
29594 +  bfd_arch_i960,      /* Intel 960 */
29595 +    /* The order of the following is important.
29596 +       lower number indicates a machine type that
29597 +       only accepts a subset of the instructions
29598 +       available to machines with higher numbers.
29599 +       The exception is the "ca", which is
29600 +       incompatible with all other machines except
29601 +       "core".  */
29602 +
29603 +#define bfd_mach_i960_core      1
29604 +#define bfd_mach_i960_ka_sa     2
29605 +#define bfd_mach_i960_kb_sb     3
29606 +#define bfd_mach_i960_mc        4
29607 +#define bfd_mach_i960_xa        5
29608 +#define bfd_mach_i960_ca        6
29609 +#define bfd_mach_i960_jx        7
29610 +#define bfd_mach_i960_hx        8
29611 +
29612 +  bfd_arch_or32,      /* OpenRISC 32 */
29613 +
29614 +  bfd_arch_a29k,      /* AMD 29000 */
29615 +  bfd_arch_sparc,     /* SPARC */
29616 +#define bfd_mach_sparc                 1
29617 +/* The difference between v8plus and v9 is that v9 is a true 64 bit env.  */
29618 +#define bfd_mach_sparc_sparclet        2
29619 +#define bfd_mach_sparc_sparclite       3
29620 +#define bfd_mach_sparc_v8plus          4
29621 +#define bfd_mach_sparc_v8plusa         5 /* with ultrasparc add'ns.  */
29622 +#define bfd_mach_sparc_sparclite_le    6
29623 +#define bfd_mach_sparc_v9              7
29624 +#define bfd_mach_sparc_v9a             8 /* with ultrasparc add'ns.  */
29625 +#define bfd_mach_sparc_v8plusb         9 /* with cheetah add'ns.  */
29626 +#define bfd_mach_sparc_v9b             10 /* with cheetah add'ns.  */
29627 +/* Nonzero if MACH has the v9 instruction set.  */
29628 +#define bfd_mach_sparc_v9_p(mach) \
29629 +  ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9b \
29630 +   && (mach) != bfd_mach_sparc_sparclite_le)
29631 +/* Nonzero if MACH is a 64 bit sparc architecture.  */
29632 +#define bfd_mach_sparc_64bit_p(mach) \
29633 +  ((mach) >= bfd_mach_sparc_v9 && (mach) != bfd_mach_sparc_v8plusb)
29634 +  bfd_arch_mips,      /* MIPS Rxxxx */
29635 +#define bfd_mach_mips3000              3000
29636 +#define bfd_mach_mips3900              3900
29637 +#define bfd_mach_mips4000              4000
29638 +#define bfd_mach_mips4010              4010
29639 +#define bfd_mach_mips4100              4100
29640 +#define bfd_mach_mips4111              4111
29641 +#define bfd_mach_mips4120              4120
29642 +#define bfd_mach_mips4300              4300
29643 +#define bfd_mach_mips4400              4400
29644 +#define bfd_mach_mips4600              4600
29645 +#define bfd_mach_mips4650              4650
29646 +#define bfd_mach_mips5000              5000
29647 +#define bfd_mach_mips5400              5400
29648 +#define bfd_mach_mips5500              5500
29649 +#define bfd_mach_mips6000              6000
29650 +#define bfd_mach_mips7000              7000
29651 +#define bfd_mach_mips8000              8000
29652 +#define bfd_mach_mips9000              9000
29653 +#define bfd_mach_mips10000             10000
29654 +#define bfd_mach_mips12000             12000
29655 +#define bfd_mach_mips16                16
29656 +#define bfd_mach_mips5                 5
29657 +#define bfd_mach_mips_sb1              12310201 /* octal 'SB', 01 */
29658 +#define bfd_mach_mipsisa32             32
29659 +#define bfd_mach_mipsisa32r2           33
29660 +#define bfd_mach_mipsisa64             64
29661 +#define bfd_mach_mipsisa64r2           65
29662 +  bfd_arch_i386,      /* Intel 386 */
29663 +#define bfd_mach_i386_i386 1
29664 +#define bfd_mach_i386_i8086 2
29665 +#define bfd_mach_i386_i386_intel_syntax 3
29666 +#define bfd_mach_x86_64 64
29667 +#define bfd_mach_x86_64_intel_syntax 65
29668 +  bfd_arch_we32k,     /* AT&T WE32xxx */
29669 +  bfd_arch_tahoe,     /* CCI/Harris Tahoe */
29670 +  bfd_arch_i860,      /* Intel 860 */
29671 +  bfd_arch_i370,      /* IBM 360/370 Mainframes */
29672 +  bfd_arch_romp,      /* IBM ROMP PC/RT */
29673 +  bfd_arch_alliant,   /* Alliant */
29674 +  bfd_arch_convex,    /* Convex */
29675 +  bfd_arch_m88k,      /* Motorola 88xxx */
29676 +  bfd_arch_m98k,      /* Motorola 98xxx */
29677 +  bfd_arch_pyramid,   /* Pyramid Technology */
29678 +  bfd_arch_h8300,     /* Renesas H8/300 (formerly Hitachi H8/300) */
29679 +#define bfd_mach_h8300    1
29680 +#define bfd_mach_h8300h   2
29681 +#define bfd_mach_h8300s   3
29682 +#define bfd_mach_h8300hn  4
29683 +#define bfd_mach_h8300sn  5
29684 +#define bfd_mach_h8300sx  6
29685 +#define bfd_mach_h8300sxn 7
29686 +  bfd_arch_pdp11,     /* DEC PDP-11 */
29687 +  bfd_arch_powerpc,   /* PowerPC */
29688 +#define bfd_mach_ppc           32
29689 +#define bfd_mach_ppc64         64
29690 +#define bfd_mach_ppc_403       403
29691 +#define bfd_mach_ppc_403gc     4030
29692 +#define bfd_mach_ppc_505       505
29693 +#define bfd_mach_ppc_601       601
29694 +#define bfd_mach_ppc_602       602
29695 +#define bfd_mach_ppc_603       603
29696 +#define bfd_mach_ppc_ec603e    6031
29697 +#define bfd_mach_ppc_604       604
29698 +#define bfd_mach_ppc_620       620
29699 +#define bfd_mach_ppc_630       630
29700 +#define bfd_mach_ppc_750       750
29701 +#define bfd_mach_ppc_860       860
29702 +#define bfd_mach_ppc_a35       35
29703 +#define bfd_mach_ppc_rs64ii    642
29704 +#define bfd_mach_ppc_rs64iii   643
29705 +#define bfd_mach_ppc_7400      7400
29706 +#define bfd_mach_ppc_e500      500
29707 +  bfd_arch_rs6000,    /* IBM RS/6000 */
29708 +#define bfd_mach_rs6k          6000
29709 +#define bfd_mach_rs6k_rs1      6001
29710 +#define bfd_mach_rs6k_rsc      6003
29711 +#define bfd_mach_rs6k_rs2      6002
29712 +  bfd_arch_hppa,      /* HP PA RISC */
29713 +#define bfd_mach_hppa10        10
29714 +#define bfd_mach_hppa11        11
29715 +#define bfd_mach_hppa20        20
29716 +#define bfd_mach_hppa20w       25
29717 +  bfd_arch_d10v,      /* Mitsubishi D10V */
29718 +#define bfd_mach_d10v          1
29719 +#define bfd_mach_d10v_ts2      2
29720 +#define bfd_mach_d10v_ts3      3
29721 +  bfd_arch_d30v,      /* Mitsubishi D30V */
29722 +  bfd_arch_dlx,       /* DLX */
29723 +  bfd_arch_m68hc11,   /* Motorola 68HC11 */
29724 +  bfd_arch_m68hc12,   /* Motorola 68HC12 */
29725 +#define bfd_mach_m6812_default 0
29726 +#define bfd_mach_m6812         1
29727 +#define bfd_mach_m6812s        2
29728 +  bfd_arch_z8k,       /* Zilog Z8000 */
29729 +#define bfd_mach_z8001         1
29730 +#define bfd_mach_z8002         2
29731 +  bfd_arch_h8500,     /* Renesas H8/500 (formerly Hitachi H8/500) */
29732 +  bfd_arch_sh,        /* Renesas / SuperH SH (formerly Hitachi SH) */
29733 +#define bfd_mach_sh            1
29734 +#define bfd_mach_sh2        0x20
29735 +#define bfd_mach_sh_dsp     0x2d
29736 +#define bfd_mach_sh2a       0x2a
29737 +#define bfd_mach_sh2a_nofpu 0x2b
29738 +#define bfd_mach_sh2a_nofpu_or_sh4_nommu_nofpu 0x2a1
29739 +#define bfd_mach_sh2a_nofpu_or_sh3_nommu 0x2a2
29740 +#define bfd_mach_sh2a_or_sh4  0x2a3
29741 +#define bfd_mach_sh2a_or_sh3e 0x2a4
29742 +#define bfd_mach_sh2e       0x2e
29743 +#define bfd_mach_sh3        0x30
29744 +#define bfd_mach_sh3_nommu  0x31
29745 +#define bfd_mach_sh3_dsp    0x3d
29746 +#define bfd_mach_sh3e       0x3e
29747 +#define bfd_mach_sh4        0x40
29748 +#define bfd_mach_sh4_nofpu  0x41
29749 +#define bfd_mach_sh4_nommu_nofpu  0x42
29750 +#define bfd_mach_sh4a       0x4a
29751 +#define bfd_mach_sh4a_nofpu 0x4b
29752 +#define bfd_mach_sh4al_dsp  0x4d
29753 +#define bfd_mach_sh5        0x50
29754 +  bfd_arch_alpha,     /* Dec Alpha */
29755 +#define bfd_mach_alpha_ev4  0x10
29756 +#define bfd_mach_alpha_ev5  0x20
29757 +#define bfd_mach_alpha_ev6  0x30
29758 +  bfd_arch_arm,       /* Advanced Risc Machines ARM.  */
29759 +#define bfd_mach_arm_unknown   0
29760 +#define bfd_mach_arm_2         1
29761 +#define bfd_mach_arm_2a        2
29762 +#define bfd_mach_arm_3         3
29763 +#define bfd_mach_arm_3M        4
29764 +#define bfd_mach_arm_4         5
29765 +#define bfd_mach_arm_4T        6
29766 +#define bfd_mach_arm_5         7
29767 +#define bfd_mach_arm_5T        8
29768 +#define bfd_mach_arm_5TE       9
29769 +#define bfd_mach_arm_XScale    10
29770 +#define bfd_mach_arm_ep9312    11
29771 +#define bfd_mach_arm_iWMMXt    12
29772 +  bfd_arch_ns32k,     /* National Semiconductors ns32000 */
29773 +  bfd_arch_w65,       /* WDC 65816 */
29774 +  bfd_arch_tic30,     /* Texas Instruments TMS320C30 */
29775 +  bfd_arch_tic4x,     /* Texas Instruments TMS320C3X/4X */
29776 +#define bfd_mach_tic3x         30
29777 +#define bfd_mach_tic4x         40
29778 +  bfd_arch_tic54x,    /* Texas Instruments TMS320C54X */
29779 +  bfd_arch_tic80,     /* TI TMS320c80 (MVP) */
29780 +  bfd_arch_v850,      /* NEC V850 */
29781 +#define bfd_mach_v850          1
29782 +#define bfd_mach_v850e         'E'
29783 +#define bfd_mach_v850e1        '1'
29784 +  bfd_arch_arc,       /* ARC Cores */
29785 +#define bfd_mach_arc_5         5
29786 +#define bfd_mach_arc_6         6
29787 +#define bfd_mach_arc_7         7
29788 +#define bfd_mach_arc_8         8
29789 + bfd_arch_m32c,     /* Renesas M16C/M32C.  */
29790 +#define bfd_mach_m16c        0x75
29791 +#define bfd_mach_m32c        0x78
29792 +  bfd_arch_m32r,      /* Renesas M32R (formerly Mitsubishi M32R/D) */
29793 +#define bfd_mach_m32r          1 /* For backwards compatibility.  */
29794 +#define bfd_mach_m32rx         'x'
29795 +#define bfd_mach_m32r2         '2'
29796 +  bfd_arch_mn10200,   /* Matsushita MN10200 */
29797 +  bfd_arch_mn10300,   /* Matsushita MN10300 */
29798 +#define bfd_mach_mn10300               300
29799 +#define bfd_mach_am33          330
29800 +#define bfd_mach_am33_2        332
29801 +  bfd_arch_fr30,
29802 +#define bfd_mach_fr30          0x46523330
29803 +  bfd_arch_frv,
29804 +#define bfd_mach_frv           1
29805 +#define bfd_mach_frvsimple     2
29806 +#define bfd_mach_fr300         300
29807 +#define bfd_mach_fr400         400
29808 +#define bfd_mach_fr450         450
29809 +#define bfd_mach_frvtomcat     499     /* fr500 prototype */
29810 +#define bfd_mach_fr500         500
29811 +#define bfd_mach_fr550         550
29812 +  bfd_arch_mcore,
29813 +  bfd_arch_ia64,      /* HP/Intel ia64 */
29814 +#define bfd_mach_ia64_elf64    64
29815 +#define bfd_mach_ia64_elf32    32
29816 +  bfd_arch_ip2k,      /* Ubicom IP2K microcontrollers. */
29817 +#define bfd_mach_ip2022        1
29818 +#define bfd_mach_ip2022ext     2
29819 + bfd_arch_iq2000,     /* Vitesse IQ2000.  */
29820 +#define bfd_mach_iq2000        1
29821 +#define bfd_mach_iq10          2
29822 +  bfd_arch_ms1,
29823 +#define bfd_mach_ms1           1
29824 +#define bfd_mach_mrisc2        2
29825 +  bfd_arch_pj,
29826 +  bfd_arch_avr,       /* Atmel AVR microcontrollers.  */
29827 +#define bfd_mach_avr1          1
29828 +#define bfd_mach_avr2          2
29829 +#define bfd_mach_avr3          3
29830 +#define bfd_mach_avr4          4
29831 +#define bfd_mach_avr5          5
29832 +  bfd_arch_cr16c,       /* National Semiconductor CompactRISC. */
29833 +#define bfd_mach_cr16c         1
29834 +  bfd_arch_crx,       /*  National Semiconductor CRX.  */
29835 +#define bfd_mach_crx           1
29836 +  bfd_arch_cris,      /* Axis CRIS */
29837 +#define bfd_mach_cris_v0_v10   255
29838 +#define bfd_mach_cris_v32      32
29839 +#define bfd_mach_cris_v10_v32  1032
29840 +  bfd_arch_s390,      /* IBM s390 */
29841 +#define bfd_mach_s390_31       31
29842 +#define bfd_mach_s390_64       64
29843 +  bfd_arch_openrisc,  /* OpenRISC */
29844 +  bfd_arch_mmix,      /* Donald Knuth's educational processor.  */
29845 +  bfd_arch_xstormy16,
29846 +#define bfd_mach_xstormy16     1
29847 +  bfd_arch_msp430,    /* Texas Instruments MSP430 architecture.  */
29848 +#define bfd_mach_msp11          11
29849 +#define bfd_mach_msp110         110
29850 +#define bfd_mach_msp12          12
29851 +#define bfd_mach_msp13          13
29852 +#define bfd_mach_msp14          14
29853 +#define bfd_mach_msp15          15
29854 +#define bfd_mach_msp16          16
29855 +#define bfd_mach_msp31          31
29856 +#define bfd_mach_msp32          32
29857 +#define bfd_mach_msp33          33
29858 +#define bfd_mach_msp41          41
29859 +#define bfd_mach_msp42          42
29860 +#define bfd_mach_msp43          43
29861 +#define bfd_mach_msp44          44
29862 +  bfd_arch_xtensa,    /* Tensilica's Xtensa cores.  */
29863 +#define bfd_mach_xtensa        1
29864 +   bfd_arch_maxq,     /* Dallas MAXQ 10/20 */
29865 +#define bfd_mach_maxq10    10
29866 +#define bfd_mach_maxq20    20
29867 +  bfd_arch_last
29868 +  };
29869 +
29870 +typedef struct bfd_arch_info
29871 +{
29872 +  int bits_per_word;
29873 +  int bits_per_address;
29874 +  int bits_per_byte;
29875 +  enum bfd_architecture arch;
29876 +  unsigned long mach;
29877 +  const char *arch_name;
29878 +  const char *printable_name;
29879 +  unsigned int section_align_power;
29880 +  /* TRUE if this is the default machine for the architecture.
29881 +     The default arch should be the first entry for an arch so that
29882 +     all the entries for that arch can be accessed via <<next>>.  */
29883 +  bfd_boolean the_default;
29884 +  const struct bfd_arch_info * (*compatible)
29885 +    (const struct bfd_arch_info *a, const struct bfd_arch_info *b);
29886 +
29887 +  bfd_boolean (*scan) (const struct bfd_arch_info *, const char *);
29888 +
29889 +  const struct bfd_arch_info *next;
29890 +}
29891 +bfd_arch_info_type;
29892 +
29893 +const char *bfd_printable_name (bfd *abfd);
29894 +
29895 +const bfd_arch_info_type *bfd_scan_arch (const char *string);
29896 +
29897 +const char **bfd_arch_list (void);
29898 +
29899 +const bfd_arch_info_type *bfd_arch_get_compatible
29900 +   (const bfd *abfd, const bfd *bbfd, bfd_boolean accept_unknowns);
29901 +
29902 +void bfd_set_arch_info (bfd *abfd, const bfd_arch_info_type *arg);
29903 +
29904 +enum bfd_architecture bfd_get_arch (bfd *abfd);
29905 +
29906 +unsigned long bfd_get_mach (bfd *abfd);
29907 +
29908 +unsigned int bfd_arch_bits_per_byte (bfd *abfd);
29909 +
29910 +unsigned int bfd_arch_bits_per_address (bfd *abfd);
29911 +
29912 +const bfd_arch_info_type *bfd_get_arch_info (bfd *abfd);
29913 +
29914 +const bfd_arch_info_type *bfd_lookup_arch
29915 +   (enum bfd_architecture arch, unsigned long machine);
29916 +
29917 +const char *bfd_printable_arch_mach
29918 +   (enum bfd_architecture arch, unsigned long machine);
29919 +
29920 +unsigned int bfd_octets_per_byte (bfd *abfd);
29921 +
29922 +unsigned int bfd_arch_mach_octets_per_byte
29923 +   (enum bfd_architecture arch, unsigned long machine);
29924 +
29925 +/* Extracted from reloc.c.  */
29926 +typedef enum bfd_reloc_status
29927 +{
29928 +  /* No errors detected.  */
29929 +  bfd_reloc_ok,
29930 +
29931 +  /* The relocation was performed, but there was an overflow.  */
29932 +  bfd_reloc_overflow,
29933 +
29934 +  /* The address to relocate was not within the section supplied.  */
29935 +  bfd_reloc_outofrange,
29936 +
29937 +  /* Used by special functions.  */
29938 +  bfd_reloc_continue,
29939 +
29940 +  /* Unsupported relocation size requested.  */
29941 +  bfd_reloc_notsupported,
29942 +
29943 +  /* Unused.  */
29944 +  bfd_reloc_other,
29945 +
29946 +  /* The symbol to relocate against was undefined.  */
29947 +  bfd_reloc_undefined,
29948 +
29949 +  /* The relocation was performed, but may not be ok - presently
29950 +     generated only when linking i960 coff files with i960 b.out
29951 +     symbols.  If this type is returned, the error_message argument
29952 +     to bfd_perform_relocation will be set.  */
29953 +  bfd_reloc_dangerous
29954 + }
29955 + bfd_reloc_status_type;
29956 +
29957 +
29958 +typedef struct reloc_cache_entry
29959 +{
29960 +  /* A pointer into the canonical table of pointers.  */
29961 +  struct bfd_symbol **sym_ptr_ptr;
29962 +
29963 +  /* offset in section.  */
29964 +  bfd_size_type address;
29965 +
29966 +  /* addend for relocation value.  */
29967 +  bfd_vma addend;
29968 +
29969 +  /* Pointer to how to perform the required relocation.  */
29970 +  reloc_howto_type *howto;
29971 +
29972 +}
29973 +arelent;
29974 +
29975 +enum complain_overflow
29976 +{
29977 +  /* Do not complain on overflow.  */
29978 +  complain_overflow_dont,
29979 +
29980 +  /* Complain if the bitfield overflows, whether it is considered
29981 +     as signed or unsigned.  */
29982 +  complain_overflow_bitfield,
29983 +
29984 +  /* Complain if the value overflows when considered as signed
29985 +     number.  */
29986 +  complain_overflow_signed,
29987 +
29988 +  /* Complain if the value overflows when considered as an
29989 +     unsigned number.  */
29990 +  complain_overflow_unsigned
29991 +};
29992 +
29993 +struct reloc_howto_struct
29994 +{
29995 +  /*  The type field has mainly a documentary use - the back end can
29996 +      do what it wants with it, though normally the back end's
29997 +      external idea of what a reloc number is stored
29998 +      in this field.  For example, a PC relative word relocation
29999 +      in a coff environment has the type 023 - because that's
30000 +      what the outside world calls a R_PCRWORD reloc.  */
30001 +  unsigned int type;
30002 +
30003 +  /*  The value the final relocation is shifted right by.  This drops
30004 +      unwanted data from the relocation.  */
30005 +  unsigned int rightshift;
30006 +
30007 +  /*  The size of the item to be relocated.  This is *not* a
30008 +      power-of-two measure.  To get the number of bytes operated
30009 +      on by a type of relocation, use bfd_get_reloc_size.  */
30010 +  int size;
30011 +
30012 +  /*  The number of bits in the item to be relocated.  This is used
30013 +      when doing overflow checking.  */
30014 +  unsigned int bitsize;
30015 +
30016 +  /*  Notes that the relocation is relative to the location in the
30017 +      data section of the addend.  The relocation function will
30018 +      subtract from the relocation value the address of the location
30019 +      being relocated.  */
30020 +  bfd_boolean pc_relative;
30021 +
30022 +  /*  The bit position of the reloc value in the destination.
30023 +      The relocated value is left shifted by this amount.  */
30024 +  unsigned int bitpos;
30025 +
30026 +  /* What type of overflow error should be checked for when
30027 +     relocating.  */
30028 +  enum complain_overflow complain_on_overflow;
30029 +
30030 +  /* If this field is non null, then the supplied function is
30031 +     called rather than the normal function.  This allows really
30032 +     strange relocation methods to be accommodated (e.g., i960 callj
30033 +     instructions).  */
30034 +  bfd_reloc_status_type (*special_function)
30035 +    (bfd *, arelent *, struct bfd_symbol *, void *, asection *,
30036 +     bfd *, char **);
30037 +
30038 +  /* The textual name of the relocation type.  */
30039 +  char *name;
30040 +
30041 +  /* Some formats record a relocation addend in the section contents
30042 +     rather than with the relocation.  For ELF formats this is the
30043 +     distinction between USE_REL and USE_RELA (though the code checks
30044 +     for USE_REL == 1/0).  The value of this field is TRUE if the
30045 +     addend is recorded with the section contents; when performing a
30046 +     partial link (ld -r) the section contents (the data) will be
30047 +     modified.  The value of this field is FALSE if addends are
30048 +     recorded with the relocation (in arelent.addend); when performing
30049 +     a partial link the relocation will be modified.
30050 +     All relocations for all ELF USE_RELA targets should set this field
30051 +     to FALSE (values of TRUE should be looked on with suspicion).
30052 +     However, the converse is not true: not all relocations of all ELF
30053 +     USE_REL targets set this field to TRUE.  Why this is so is peculiar
30054 +     to each particular target.  For relocs that aren't used in partial
30055 +     links (e.g. GOT stuff) it doesn't matter what this is set to.  */
30056 +  bfd_boolean partial_inplace;
30057 +
30058 +  /* src_mask selects the part of the instruction (or data) to be used
30059 +     in the relocation sum.  If the target relocations don't have an
30060 +     addend in the reloc, eg. ELF USE_REL, src_mask will normally equal
30061 +     dst_mask to extract the addend from the section contents.  If
30062 +     relocations do have an addend in the reloc, eg. ELF USE_RELA, this
30063 +     field should be zero.  Non-zero values for ELF USE_RELA targets are
30064 +     bogus as in those cases the value in the dst_mask part of the
30065 +     section contents should be treated as garbage.  */
30066 +  bfd_vma src_mask;
30067 +
30068 +  /* dst_mask selects which parts of the instruction (or data) are
30069 +     replaced with a relocated value.  */
30070 +  bfd_vma dst_mask;
30071 +
30072 +  /* When some formats create PC relative instructions, they leave
30073 +     the value of the pc of the place being relocated in the offset
30074 +     slot of the instruction, so that a PC relative relocation can
30075 +     be made just by adding in an ordinary offset (e.g., sun3 a.out).
30076 +     Some formats leave the displacement part of an instruction
30077 +     empty (e.g., m88k bcs); this flag signals the fact.  */
30078 +  bfd_boolean pcrel_offset;
30079 +};
30080 +
30081 +#define HOWTO(C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC) \
30082 +  { (unsigned) C, R, S, B, P, BI, O, SF, NAME, INPLACE, MASKSRC, MASKDST, PC }
30083 +#define NEWHOWTO(FUNCTION, NAME, SIZE, REL, IN) \
30084 +  HOWTO (0, 0, SIZE, 0, REL, 0, complain_overflow_dont, FUNCTION, \
30085 +         NAME, FALSE, 0, 0, IN)
30086 +
30087 +#define EMPTY_HOWTO(C) \
30088 +  HOWTO ((C), 0, 0, 0, FALSE, 0, complain_overflow_dont, NULL, \
30089 +         NULL, FALSE, 0, 0, FALSE)
30090 +
30091 +#define HOWTO_PREPARE(relocation, symbol)               \
30092 +  {                                                     \
30093 +    if (symbol != NULL)                                 \
30094 +      {                                                 \
30095 +        if (bfd_is_com_section (symbol->section))       \
30096 +          {                                             \
30097 +            relocation = 0;                             \
30098 +          }                                             \
30099 +        else                                            \
30100 +          {                                             \
30101 +            relocation = symbol->value;                 \
30102 +          }                                             \
30103 +      }                                                 \
30104 +  }
30105 +
30106 +unsigned int bfd_get_reloc_size (reloc_howto_type *);
30107 +
30108 +typedef struct relent_chain
30109 +{
30110 +  arelent relent;
30111 +  struct relent_chain *next;
30112 +}
30113 +arelent_chain;
30114 +
30115 +bfd_reloc_status_type bfd_check_overflow
30116 +   (enum complain_overflow how,
30117 +    unsigned int bitsize,
30118 +    unsigned int rightshift,
30119 +    unsigned int addrsize,
30120 +    bfd_vma relocation);
30121 +
30122 +bfd_reloc_status_type bfd_perform_relocation
30123 +   (bfd *abfd,
30124 +    arelent *reloc_entry,
30125 +    void *data,
30126 +    asection *input_section,
30127 +    bfd *output_bfd,
30128 +    char **error_message);
30129 +
30130 +bfd_reloc_status_type bfd_install_relocation
30131 +   (bfd *abfd,
30132 +    arelent *reloc_entry,
30133 +    void *data, bfd_vma data_start,
30134 +    asection *input_section,
30135 +    char **error_message);
30136 +
30137 +enum bfd_reloc_code_real {
30138 +  _dummy_first_bfd_reloc_code_real,
30139 +
30140 +
30141 +/* Basic absolute relocations of N bits.  */
30142 +  BFD_RELOC_64,
30143 +  BFD_RELOC_32,
30144 +  BFD_RELOC_26,
30145 +  BFD_RELOC_24,
30146 +  BFD_RELOC_16,
30147 +  BFD_RELOC_14,
30148 +  BFD_RELOC_8,
30149 +
30150 +/* PC-relative relocations.  Sometimes these are relative to the address
30151 +of the relocation itself; sometimes they are relative to the start of
30152 +the section containing the relocation.  It depends on the specific target.
30153 +
30154 +The 24-bit relocation is used in some Intel 960 configurations.  */
30155 +  BFD_RELOC_64_PCREL,
30156 +  BFD_RELOC_32_PCREL,
30157 +  BFD_RELOC_24_PCREL,
30158 +  BFD_RELOC_16_PCREL,
30159 +  BFD_RELOC_12_PCREL,
30160 +  BFD_RELOC_8_PCREL,
30161 +
30162 +/* Section relative relocations.  Some targets need this for DWARF2.  */
30163 +  BFD_RELOC_32_SECREL,
30164 +
30165 +/* For ELF.  */
30166 +  BFD_RELOC_32_GOT_PCREL,
30167 +  BFD_RELOC_16_GOT_PCREL,
30168 +  BFD_RELOC_8_GOT_PCREL,
30169 +  BFD_RELOC_32_GOTOFF,
30170 +  BFD_RELOC_16_GOTOFF,
30171 +  BFD_RELOC_LO16_GOTOFF,
30172 +  BFD_RELOC_HI16_GOTOFF,
30173 +  BFD_RELOC_HI16_S_GOTOFF,
30174 +  BFD_RELOC_8_GOTOFF,
30175 +  BFD_RELOC_64_PLT_PCREL,
30176 +  BFD_RELOC_32_PLT_PCREL,
30177 +  BFD_RELOC_24_PLT_PCREL,
30178 +  BFD_RELOC_16_PLT_PCREL,
30179 +  BFD_RELOC_8_PLT_PCREL,
30180 +  BFD_RELOC_64_PLTOFF,
30181 +  BFD_RELOC_32_PLTOFF,
30182 +  BFD_RELOC_16_PLTOFF,
30183 +  BFD_RELOC_LO16_PLTOFF,
30184 +  BFD_RELOC_HI16_PLTOFF,
30185 +  BFD_RELOC_HI16_S_PLTOFF,
30186 +  BFD_RELOC_8_PLTOFF,
30187 +
30188 +/* Relocations used by 68K ELF.  */
30189 +  BFD_RELOC_68K_GLOB_DAT,
30190 +  BFD_RELOC_68K_JMP_SLOT,
30191 +  BFD_RELOC_68K_RELATIVE,
30192 +
30193 +/* Linkage-table relative.  */
30194 +  BFD_RELOC_32_BASEREL,
30195 +  BFD_RELOC_16_BASEREL,
30196 +  BFD_RELOC_LO16_BASEREL,
30197 +  BFD_RELOC_HI16_BASEREL,
30198 +  BFD_RELOC_HI16_S_BASEREL,
30199 +  BFD_RELOC_8_BASEREL,
30200 +  BFD_RELOC_RVA,
30201 +
30202 +/* Absolute 8-bit relocation, but used to form an address like 0xFFnn.  */
30203 +  BFD_RELOC_8_FFnn,
30204 +
30205 +/* These PC-relative relocations are stored as word displacements --
30206 +i.e., byte displacements shifted right two bits.  The 30-bit word
30207 +displacement (<<32_PCREL_S2>> -- 32 bits, shifted 2) is used on the
30208 +SPARC.  (SPARC tools generally refer to this as <<WDISP30>>.)  The
30209 +signed 16-bit displacement is used on the MIPS, and the 23-bit
30210 +displacement is used on the Alpha.  */
30211 +  BFD_RELOC_32_PCREL_S2,
30212 +  BFD_RELOC_16_PCREL_S2,
30213 +  BFD_RELOC_23_PCREL_S2,
30214 +
30215 +/* High 22 bits and low 10 bits of 32-bit value, placed into lower bits of
30216 +the target word.  These are used on the SPARC.  */
30217 +  BFD_RELOC_HI22,
30218 +  BFD_RELOC_LO10,
30219 +
30220 +/* For systems that allocate a Global Pointer register, these are
30221 +displacements off that register.  These relocation types are
30222 +handled specially, because the value the register will have is
30223 +decided relatively late.  */
30224 +  BFD_RELOC_GPREL16,
30225 +  BFD_RELOC_GPREL32,
30226 +
30227 +/* Reloc types used for i960/b.out.  */
30228 +  BFD_RELOC_I960_CALLJ,
30229 +
30230 +/* SPARC ELF relocations.  There is probably some overlap with other
30231 +relocation types already defined.  */
30232 +  BFD_RELOC_NONE,
30233 +  BFD_RELOC_SPARC_WDISP22,
30234 +  BFD_RELOC_SPARC22,
30235 +  BFD_RELOC_SPARC13,
30236 +  BFD_RELOC_SPARC_GOT10,
30237 +  BFD_RELOC_SPARC_GOT13,
30238 +  BFD_RELOC_SPARC_GOT22,
30239 +  BFD_RELOC_SPARC_PC10,
30240 +  BFD_RELOC_SPARC_PC22,
30241 +  BFD_RELOC_SPARC_WPLT30,
30242 +  BFD_RELOC_SPARC_COPY,
30243 +  BFD_RELOC_SPARC_GLOB_DAT,
30244 +  BFD_RELOC_SPARC_JMP_SLOT,
30245 +  BFD_RELOC_SPARC_RELATIVE,
30246 +  BFD_RELOC_SPARC_UA16,
30247 +  BFD_RELOC_SPARC_UA32,
30248 +  BFD_RELOC_SPARC_UA64,
30249 +
30250 +/* I think these are specific to SPARC a.out (e.g., Sun 4).  */
30251 +  BFD_RELOC_SPARC_BASE13,
30252 +  BFD_RELOC_SPARC_BASE22,
30253 +
30254 +/* SPARC64 relocations  */
30255 +#define BFD_RELOC_SPARC_64 BFD_RELOC_64
30256 +  BFD_RELOC_SPARC_10,
30257 +  BFD_RELOC_SPARC_11,
30258 +  BFD_RELOC_SPARC_OLO10,
30259 +  BFD_RELOC_SPARC_HH22,
30260 +  BFD_RELOC_SPARC_HM10,
30261 +  BFD_RELOC_SPARC_LM22,
30262 +  BFD_RELOC_SPARC_PC_HH22,
30263 +  BFD_RELOC_SPARC_PC_HM10,
30264 +  BFD_RELOC_SPARC_PC_LM22,
30265 +  BFD_RELOC_SPARC_WDISP16,
30266 +  BFD_RELOC_SPARC_WDISP19,
30267 +  BFD_RELOC_SPARC_7,
30268 +  BFD_RELOC_SPARC_6,
30269 +  BFD_RELOC_SPARC_5,
30270 +#define BFD_RELOC_SPARC_DISP64 BFD_RELOC_64_PCREL
30271 +  BFD_RELOC_SPARC_PLT32,
30272 +  BFD_RELOC_SPARC_PLT64,
30273 +  BFD_RELOC_SPARC_HIX22,
30274 +  BFD_RELOC_SPARC_LOX10,
30275 +  BFD_RELOC_SPARC_H44,
30276 +  BFD_RELOC_SPARC_M44,
30277 +  BFD_RELOC_SPARC_L44,
30278 +  BFD_RELOC_SPARC_REGISTER,
30279 +
30280 +/* SPARC little endian relocation  */
30281 +  BFD_RELOC_SPARC_REV32,
30282 +
30283 +/* SPARC TLS relocations  */
30284 +  BFD_RELOC_SPARC_TLS_GD_HI22,
30285 +  BFD_RELOC_SPARC_TLS_GD_LO10,
30286 +  BFD_RELOC_SPARC_TLS_GD_ADD,
30287 +  BFD_RELOC_SPARC_TLS_GD_CALL,
30288 +  BFD_RELOC_SPARC_TLS_LDM_HI22,
30289 +  BFD_RELOC_SPARC_TLS_LDM_LO10,
30290 +  BFD_RELOC_SPARC_TLS_LDM_ADD,
30291 +  BFD_RELOC_SPARC_TLS_LDM_CALL,
30292 +  BFD_RELOC_SPARC_TLS_LDO_HIX22,
30293 +  BFD_RELOC_SPARC_TLS_LDO_LOX10,
30294 +  BFD_RELOC_SPARC_TLS_LDO_ADD,
30295 +  BFD_RELOC_SPARC_TLS_IE_HI22,
30296 +  BFD_RELOC_SPARC_TLS_IE_LO10,
30297 +  BFD_RELOC_SPARC_TLS_IE_LD,
30298 +  BFD_RELOC_SPARC_TLS_IE_LDX,
30299 +  BFD_RELOC_SPARC_TLS_IE_ADD,
30300 +  BFD_RELOC_SPARC_TLS_LE_HIX22,
30301 +  BFD_RELOC_SPARC_TLS_LE_LOX10,
30302 +  BFD_RELOC_SPARC_TLS_DTPMOD32,
30303 +  BFD_RELOC_SPARC_TLS_DTPMOD64,
30304 +  BFD_RELOC_SPARC_TLS_DTPOFF32,
30305 +  BFD_RELOC_SPARC_TLS_DTPOFF64,
30306 +  BFD_RELOC_SPARC_TLS_TPOFF32,
30307 +  BFD_RELOC_SPARC_TLS_TPOFF64,
30308 +
30309 +/* Alpha ECOFF and ELF relocations.  Some of these treat the symbol or
30310 +"addend" in some special way.
30311 +For GPDISP_HI16 ("gpdisp") relocations, the symbol is ignored when
30312 +writing; when reading, it will be the absolute section symbol.  The
30313 +addend is the displacement in bytes of the "lda" instruction from
30314 +the "ldah" instruction (which is at the address of this reloc).  */
30315 +  BFD_RELOC_ALPHA_GPDISP_HI16,
30316 +
30317 +/* For GPDISP_LO16 ("ignore") relocations, the symbol is handled as
30318 +with GPDISP_HI16 relocs.  The addend is ignored when writing the
30319 +relocations out, and is filled in with the file's GP value on
30320 +reading, for convenience.  */
30321 +  BFD_RELOC_ALPHA_GPDISP_LO16,
30322 +
30323 +/* The ELF GPDISP relocation is exactly the same as the GPDISP_HI16
30324 +relocation except that there is no accompanying GPDISP_LO16
30325 +relocation.  */
30326 +  BFD_RELOC_ALPHA_GPDISP,
30327 +
30328 +/* The Alpha LITERAL/LITUSE relocs are produced by a symbol reference;
30329 +the assembler turns it into a LDQ instruction to load the address of
30330 +the symbol, and then fills in a register in the real instruction.
30331 +
30332 +The LITERAL reloc, at the LDQ instruction, refers to the .lita
30333 +section symbol.  The addend is ignored when writing, but is filled
30334 +in with the file's GP value on reading, for convenience, as with the
30335 +GPDISP_LO16 reloc.
30336 +
30337 +The ELF_LITERAL reloc is somewhere between 16_GOTOFF and GPDISP_LO16.
30338 +It should refer to the symbol to be referenced, as with 16_GOTOFF,
30339 +but it generates output not based on the position within the .got
30340 +section, but relative to the GP value chosen for the file during the
30341 +final link stage.
30342 +
30343 +The LITUSE reloc, on the instruction using the loaded address, gives
30344 +information to the linker that it might be able to use to optimize
30345 +away some literal section references.  The symbol is ignored (read
30346 +as the absolute section symbol), and the "addend" indicates the type
30347 +of instruction using the register:
30348 +1 - "memory" fmt insn
30349 +2 - byte-manipulation (byte offset reg)
30350 +3 - jsr (target of branch)  */
30351 +  BFD_RELOC_ALPHA_LITERAL,
30352 +  BFD_RELOC_ALPHA_ELF_LITERAL,
30353 +  BFD_RELOC_ALPHA_LITUSE,
30354 +
30355 +/* The HINT relocation indicates a value that should be filled into the
30356 +"hint" field of a jmp/jsr/ret instruction, for possible branch-
30357 +prediction logic which may be provided on some processors.  */
30358 +  BFD_RELOC_ALPHA_HINT,
30359 +
30360 +/* The LINKAGE relocation outputs a linkage pair in the object file,
30361 +which is filled by the linker.  */
30362 +  BFD_RELOC_ALPHA_LINKAGE,
30363 +
30364 +/* The CODEADDR relocation outputs a STO_CA in the object file,
30365 +which is filled by the linker.  */
30366 +  BFD_RELOC_ALPHA_CODEADDR,
30367 +
30368 +/* The GPREL_HI/LO relocations together form a 32-bit offset from the
30369 +GP register.  */
30370 +  BFD_RELOC_ALPHA_GPREL_HI16,
30371 +  BFD_RELOC_ALPHA_GPREL_LO16,
30372 +
30373 +/* Like BFD_RELOC_23_PCREL_S2, except that the source and target must
30374 +share a common GP, and the target address is adjusted for
30375 +STO_ALPHA_STD_GPLOAD.  */
30376 +  BFD_RELOC_ALPHA_BRSGP,
30377 +
30378 +/* Alpha thread-local storage relocations.  */
30379 +  BFD_RELOC_ALPHA_TLSGD,
30380 +  BFD_RELOC_ALPHA_TLSLDM,
30381 +  BFD_RELOC_ALPHA_DTPMOD64,
30382 +  BFD_RELOC_ALPHA_GOTDTPREL16,
30383 +  BFD_RELOC_ALPHA_DTPREL64,
30384 +  BFD_RELOC_ALPHA_DTPREL_HI16,
30385 +  BFD_RELOC_ALPHA_DTPREL_LO16,
30386 +  BFD_RELOC_ALPHA_DTPREL16,
30387 +  BFD_RELOC_ALPHA_GOTTPREL16,
30388 +  BFD_RELOC_ALPHA_TPREL64,
30389 +  BFD_RELOC_ALPHA_TPREL_HI16,
30390 +  BFD_RELOC_ALPHA_TPREL_LO16,
30391 +  BFD_RELOC_ALPHA_TPREL16,
30392 +
30393 +/* Bits 27..2 of the relocation address shifted right 2 bits;
30394 +simple reloc otherwise.  */
30395 +  BFD_RELOC_MIPS_JMP,
30396 +
30397 +/* The MIPS16 jump instruction.  */
30398 +  BFD_RELOC_MIPS16_JMP,
30399 +
30400 +/* MIPS16 GP relative reloc.  */
30401 +  BFD_RELOC_MIPS16_GPREL,
30402 +
30403 +/* High 16 bits of 32-bit value; simple reloc.  */
30404 +  BFD_RELOC_HI16,
30405 +
30406 +/* High 16 bits of 32-bit value but the low 16 bits will be sign
30407 +extended and added to form the final result.  If the low 16
30408 +bits form a negative number, we need to add one to the high value
30409 +to compensate for the borrow when the low bits are added.  */
30410 +  BFD_RELOC_HI16_S,
30411 +
30412 +/* Low 16 bits.  */
30413 +  BFD_RELOC_LO16,
30414 +
30415 +/* High 16 bits of 32-bit pc-relative value  */
30416 +  BFD_RELOC_HI16_PCREL,
30417 +
30418 +/* High 16 bits of 32-bit pc-relative value, adjusted  */
30419 +  BFD_RELOC_HI16_S_PCREL,
30420 +
30421 +/* Low 16 bits of pc-relative value  */
30422 +  BFD_RELOC_LO16_PCREL,
30423 +
30424 +/* MIPS16 high 16 bits of 32-bit value.  */
30425 +  BFD_RELOC_MIPS16_HI16,
30426 +
30427 +/* MIPS16 high 16 bits of 32-bit value but the low 16 bits will be sign
30428 +extended and added to form the final result.  If the low 16
30429 +bits form a negative number, we need to add one to the high value
30430 +to compensate for the borrow when the low bits are added.  */
30431 +  BFD_RELOC_MIPS16_HI16_S,
30432 +
30433 +/* MIPS16 low 16 bits.  */
30434 +  BFD_RELOC_MIPS16_LO16,
30435 +
30436 +/* Relocation against a MIPS literal section.  */
30437 +  BFD_RELOC_MIPS_LITERAL,
30438 +
30439 +/* MIPS ELF relocations.  */
30440 +  BFD_RELOC_MIPS_GOT16,
30441 +  BFD_RELOC_MIPS_CALL16,
30442 +  BFD_RELOC_MIPS_GOT_HI16,
30443 +  BFD_RELOC_MIPS_GOT_LO16,
30444 +  BFD_RELOC_MIPS_CALL_HI16,
30445 +  BFD_RELOC_MIPS_CALL_LO16,
30446 +  BFD_RELOC_MIPS_SUB,
30447 +  BFD_RELOC_MIPS_GOT_PAGE,
30448 +  BFD_RELOC_MIPS_GOT_OFST,
30449 +  BFD_RELOC_MIPS_GOT_DISP,
30450 +  BFD_RELOC_MIPS_SHIFT5,
30451 +  BFD_RELOC_MIPS_SHIFT6,
30452 +  BFD_RELOC_MIPS_INSERT_A,
30453 +  BFD_RELOC_MIPS_INSERT_B,
30454 +  BFD_RELOC_MIPS_DELETE,
30455 +  BFD_RELOC_MIPS_HIGHEST,
30456 +  BFD_RELOC_MIPS_HIGHER,
30457 +  BFD_RELOC_MIPS_SCN_DISP,
30458 +  BFD_RELOC_MIPS_REL16,
30459 +  BFD_RELOC_MIPS_RELGOT,
30460 +  BFD_RELOC_MIPS_JALR,
30461 +  BFD_RELOC_MIPS_TLS_DTPMOD32,
30462 +  BFD_RELOC_MIPS_TLS_DTPREL32,
30463 +  BFD_RELOC_MIPS_TLS_DTPMOD64,
30464 +  BFD_RELOC_MIPS_TLS_DTPREL64,
30465 +  BFD_RELOC_MIPS_TLS_GD,
30466 +  BFD_RELOC_MIPS_TLS_LDM,
30467 +  BFD_RELOC_MIPS_TLS_DTPREL_HI16,
30468 +  BFD_RELOC_MIPS_TLS_DTPREL_LO16,
30469 +  BFD_RELOC_MIPS_TLS_GOTTPREL,
30470 +  BFD_RELOC_MIPS_TLS_TPREL32,
30471 +  BFD_RELOC_MIPS_TLS_TPREL64,
30472 +  BFD_RELOC_MIPS_TLS_TPREL_HI16,
30473 +  BFD_RELOC_MIPS_TLS_TPREL_LO16,
30474 +
30475 +
30476 +/* Fujitsu Frv Relocations.  */
30477 +  BFD_RELOC_FRV_LABEL16,
30478 +  BFD_RELOC_FRV_LABEL24,
30479 +  BFD_RELOC_FRV_LO16,
30480 +  BFD_RELOC_FRV_HI16,
30481 +  BFD_RELOC_FRV_GPREL12,
30482 +  BFD_RELOC_FRV_GPRELU12,
30483 +  BFD_RELOC_FRV_GPREL32,
30484 +  BFD_RELOC_FRV_GPRELHI,
30485 +  BFD_RELOC_FRV_GPRELLO,
30486 +  BFD_RELOC_FRV_GOT12,
30487 +  BFD_RELOC_FRV_GOTHI,
30488 +  BFD_RELOC_FRV_GOTLO,
30489 +  BFD_RELOC_FRV_FUNCDESC,
30490 +  BFD_RELOC_FRV_FUNCDESC_GOT12,
30491 +  BFD_RELOC_FRV_FUNCDESC_GOTHI,
30492 +  BFD_RELOC_FRV_FUNCDESC_GOTLO,
30493 +  BFD_RELOC_FRV_FUNCDESC_VALUE,
30494 +  BFD_RELOC_FRV_FUNCDESC_GOTOFF12,
30495 +  BFD_RELOC_FRV_FUNCDESC_GOTOFFHI,
30496 +  BFD_RELOC_FRV_FUNCDESC_GOTOFFLO,
30497 +  BFD_RELOC_FRV_GOTOFF12,
30498 +  BFD_RELOC_FRV_GOTOFFHI,
30499 +  BFD_RELOC_FRV_GOTOFFLO,
30500 +  BFD_RELOC_FRV_GETTLSOFF,
30501 +  BFD_RELOC_FRV_TLSDESC_VALUE,
30502 +  BFD_RELOC_FRV_GOTTLSDESC12,
30503 +  BFD_RELOC_FRV_GOTTLSDESCHI,
30504 +  BFD_RELOC_FRV_GOTTLSDESCLO,
30505 +  BFD_RELOC_FRV_TLSMOFF12,
30506 +  BFD_RELOC_FRV_TLSMOFFHI,
30507 +  BFD_RELOC_FRV_TLSMOFFLO,
30508 +  BFD_RELOC_FRV_GOTTLSOFF12,
30509 +  BFD_RELOC_FRV_GOTTLSOFFHI,
30510 +  BFD_RELOC_FRV_GOTTLSOFFLO,
30511 +  BFD_RELOC_FRV_TLSOFF,
30512 +  BFD_RELOC_FRV_TLSDESC_RELAX,
30513 +  BFD_RELOC_FRV_GETTLSOFF_RELAX,
30514 +  BFD_RELOC_FRV_TLSOFF_RELAX,
30515 +  BFD_RELOC_FRV_TLSMOFF,
30516 +
30517 +
30518 +/* This is a 24bit GOT-relative reloc for the mn10300.  */
30519 +  BFD_RELOC_MN10300_GOTOFF24,
30520 +
30521 +/* This is a 32bit GOT-relative reloc for the mn10300, offset by two bytes
30522 +in the instruction.  */
30523 +  BFD_RELOC_MN10300_GOT32,
30524 +
30525 +/* This is a 24bit GOT-relative reloc for the mn10300, offset by two bytes
30526 +in the instruction.  */
30527 +  BFD_RELOC_MN10300_GOT24,
30528 +
30529 +/* This is a 16bit GOT-relative reloc for the mn10300, offset by two bytes
30530 +in the instruction.  */
30531 +  BFD_RELOC_MN10300_GOT16,
30532 +
30533 +/* Copy symbol at runtime.  */
30534 +  BFD_RELOC_MN10300_COPY,
30535 +
30536 +/* Create GOT entry.  */
30537 +  BFD_RELOC_MN10300_GLOB_DAT,
30538 +
30539 +/* Create PLT entry.  */
30540 +  BFD_RELOC_MN10300_JMP_SLOT,
30541 +
30542 +/* Adjust by program base.  */
30543 +  BFD_RELOC_MN10300_RELATIVE,
30544 +
30545 +
30546 +/* i386/elf relocations  */
30547 +  BFD_RELOC_386_GOT32,
30548 +  BFD_RELOC_386_PLT32,
30549 +  BFD_RELOC_386_COPY,
30550 +  BFD_RELOC_386_GLOB_DAT,
30551 +  BFD_RELOC_386_JUMP_SLOT,
30552 +  BFD_RELOC_386_RELATIVE,
30553 +  BFD_RELOC_386_GOTOFF,
30554 +  BFD_RELOC_386_GOTPC,
30555 +  BFD_RELOC_386_TLS_TPOFF,
30556 +  BFD_RELOC_386_TLS_IE,
30557 +  BFD_RELOC_386_TLS_GOTIE,
30558 +  BFD_RELOC_386_TLS_LE,
30559 +  BFD_RELOC_386_TLS_GD,
30560 +  BFD_RELOC_386_TLS_LDM,
30561 +  BFD_RELOC_386_TLS_LDO_32,
30562 +  BFD_RELOC_386_TLS_IE_32,
30563 +  BFD_RELOC_386_TLS_LE_32,
30564 +  BFD_RELOC_386_TLS_DTPMOD32,
30565 +  BFD_RELOC_386_TLS_DTPOFF32,
30566 +  BFD_RELOC_386_TLS_TPOFF32,
30567 +
30568 +/* x86-64/elf relocations  */
30569 +  BFD_RELOC_X86_64_GOT32,
30570 +  BFD_RELOC_X86_64_PLT32,
30571 +  BFD_RELOC_X86_64_COPY,
30572 +  BFD_RELOC_X86_64_GLOB_DAT,
30573 +  BFD_RELOC_X86_64_JUMP_SLOT,
30574 +  BFD_RELOC_X86_64_RELATIVE,
30575 +  BFD_RELOC_X86_64_GOTPCREL,
30576 +  BFD_RELOC_X86_64_32S,
30577 +  BFD_RELOC_X86_64_DTPMOD64,
30578 +  BFD_RELOC_X86_64_DTPOFF64,
30579 +  BFD_RELOC_X86_64_TPOFF64,
30580 +  BFD_RELOC_X86_64_TLSGD,
30581 +  BFD_RELOC_X86_64_TLSLD,
30582 +  BFD_RELOC_X86_64_DTPOFF32,
30583 +  BFD_RELOC_X86_64_GOTTPOFF,
30584 +  BFD_RELOC_X86_64_TPOFF32,
30585 +  BFD_RELOC_X86_64_GOTOFF64,
30586 +  BFD_RELOC_X86_64_GOTPC32,
30587 +
30588 +/* ns32k relocations  */
30589 +  BFD_RELOC_NS32K_IMM_8,
30590 +  BFD_RELOC_NS32K_IMM_16,
30591 +  BFD_RELOC_NS32K_IMM_32,
30592 +  BFD_RELOC_NS32K_IMM_8_PCREL,
30593 +  BFD_RELOC_NS32K_IMM_16_PCREL,
30594 +  BFD_RELOC_NS32K_IMM_32_PCREL,
30595 +  BFD_RELOC_NS32K_DISP_8,
30596 +  BFD_RELOC_NS32K_DISP_16,
30597 +  BFD_RELOC_NS32K_DISP_32,
30598 +  BFD_RELOC_NS32K_DISP_8_PCREL,
30599 +  BFD_RELOC_NS32K_DISP_16_PCREL,
30600 +  BFD_RELOC_NS32K_DISP_32_PCREL,
30601 +
30602 +/* PDP11 relocations  */
30603 +  BFD_RELOC_PDP11_DISP_8_PCREL,
30604 +  BFD_RELOC_PDP11_DISP_6_PCREL,
30605 +
30606 +/* Picojava relocs.  Not all of these appear in object files.  */
30607 +  BFD_RELOC_PJ_CODE_HI16,
30608 +  BFD_RELOC_PJ_CODE_LO16,
30609 +  BFD_RELOC_PJ_CODE_DIR16,
30610 +  BFD_RELOC_PJ_CODE_DIR32,
30611 +  BFD_RELOC_PJ_CODE_REL16,
30612 +  BFD_RELOC_PJ_CODE_REL32,
30613 +
30614 +/* Power(rs6000) and PowerPC relocations.  */
30615 +  BFD_RELOC_PPC_B26,
30616 +  BFD_RELOC_PPC_BA26,
30617 +  BFD_RELOC_PPC_TOC16,
30618 +  BFD_RELOC_PPC_B16,
30619 +  BFD_RELOC_PPC_B16_BRTAKEN,
30620 +  BFD_RELOC_PPC_B16_BRNTAKEN,
30621 +  BFD_RELOC_PPC_BA16,
30622 +  BFD_RELOC_PPC_BA16_BRTAKEN,
30623 +  BFD_RELOC_PPC_BA16_BRNTAKEN,
30624 +  BFD_RELOC_PPC_COPY,
30625 +  BFD_RELOC_PPC_GLOB_DAT,
30626 +  BFD_RELOC_PPC_JMP_SLOT,
30627 +  BFD_RELOC_PPC_RELATIVE,
30628 +  BFD_RELOC_PPC_LOCAL24PC,
30629 +  BFD_RELOC_PPC_EMB_NADDR32,
30630 +  BFD_RELOC_PPC_EMB_NADDR16,
30631 +  BFD_RELOC_PPC_EMB_NADDR16_LO,
30632 +  BFD_RELOC_PPC_EMB_NADDR16_HI,
30633 +  BFD_RELOC_PPC_EMB_NADDR16_HA,
30634 +  BFD_RELOC_PPC_EMB_SDAI16,
30635 +  BFD_RELOC_PPC_EMB_SDA2I16,
30636 +  BFD_RELOC_PPC_EMB_SDA2REL,
30637 +  BFD_RELOC_PPC_EMB_SDA21,
30638 +  BFD_RELOC_PPC_EMB_MRKREF,
30639 +  BFD_RELOC_PPC_EMB_RELSEC16,
30640 +  BFD_RELOC_PPC_EMB_RELST_LO,
30641 +  BFD_RELOC_PPC_EMB_RELST_HI,
30642 +  BFD_RELOC_PPC_EMB_RELST_HA,
30643 +  BFD_RELOC_PPC_EMB_BIT_FLD,
30644 +  BFD_RELOC_PPC_EMB_RELSDA,
30645 +  BFD_RELOC_PPC64_HIGHER,
30646 +  BFD_RELOC_PPC64_HIGHER_S,
30647 +  BFD_RELOC_PPC64_HIGHEST,
30648 +  BFD_RELOC_PPC64_HIGHEST_S,
30649 +  BFD_RELOC_PPC64_TOC16_LO,
30650 +  BFD_RELOC_PPC64_TOC16_HI,
30651 +  BFD_RELOC_PPC64_TOC16_HA,
30652 +  BFD_RELOC_PPC64_TOC,
30653 +  BFD_RELOC_PPC64_PLTGOT16,
30654 +  BFD_RELOC_PPC64_PLTGOT16_LO,
30655 +  BFD_RELOC_PPC64_PLTGOT16_HI,
30656 +  BFD_RELOC_PPC64_PLTGOT16_HA,
30657 +  BFD_RELOC_PPC64_ADDR16_DS,
30658 +  BFD_RELOC_PPC64_ADDR16_LO_DS,
30659 +  BFD_RELOC_PPC64_GOT16_DS,
30660 +  BFD_RELOC_PPC64_GOT16_LO_DS,
30661 +  BFD_RELOC_PPC64_PLT16_LO_DS,
30662 +  BFD_RELOC_PPC64_SECTOFF_DS,
30663 +  BFD_RELOC_PPC64_SECTOFF_LO_DS,
30664 +  BFD_RELOC_PPC64_TOC16_DS,
30665 +  BFD_RELOC_PPC64_TOC16_LO_DS,
30666 +  BFD_RELOC_PPC64_PLTGOT16_DS,
30667 +  BFD_RELOC_PPC64_PLTGOT16_LO_DS,
30668 +
30669 +/* PowerPC and PowerPC64 thread-local storage relocations.  */
30670 +  BFD_RELOC_PPC_TLS,
30671 +  BFD_RELOC_PPC_DTPMOD,
30672 +  BFD_RELOC_PPC_TPREL16,
30673 +  BFD_RELOC_PPC_TPREL16_LO,
30674 +  BFD_RELOC_PPC_TPREL16_HI,
30675 +  BFD_RELOC_PPC_TPREL16_HA,
30676 +  BFD_RELOC_PPC_TPREL,
30677 +  BFD_RELOC_PPC_DTPREL16,
30678 +  BFD_RELOC_PPC_DTPREL16_LO,
30679 +  BFD_RELOC_PPC_DTPREL16_HI,
30680 +  BFD_RELOC_PPC_DTPREL16_HA,
30681 +  BFD_RELOC_PPC_DTPREL,
30682 +  BFD_RELOC_PPC_GOT_TLSGD16,
30683 +  BFD_RELOC_PPC_GOT_TLSGD16_LO,
30684 +  BFD_RELOC_PPC_GOT_TLSGD16_HI,
30685 +  BFD_RELOC_PPC_GOT_TLSGD16_HA,
30686 +  BFD_RELOC_PPC_GOT_TLSLD16,
30687 +  BFD_RELOC_PPC_GOT_TLSLD16_LO,
30688 +  BFD_RELOC_PPC_GOT_TLSLD16_HI,
30689 +  BFD_RELOC_PPC_GOT_TLSLD16_HA,
30690 +  BFD_RELOC_PPC_GOT_TPREL16,
30691 +  BFD_RELOC_PPC_GOT_TPREL16_LO,
30692 +  BFD_RELOC_PPC_GOT_TPREL16_HI,
30693 +  BFD_RELOC_PPC_GOT_TPREL16_HA,
30694 +  BFD_RELOC_PPC_GOT_DTPREL16,
30695 +  BFD_RELOC_PPC_GOT_DTPREL16_LO,
30696 +  BFD_RELOC_PPC_GOT_DTPREL16_HI,
30697 +  BFD_RELOC_PPC_GOT_DTPREL16_HA,
30698 +  BFD_RELOC_PPC64_TPREL16_DS,
30699 +  BFD_RELOC_PPC64_TPREL16_LO_DS,
30700 +  BFD_RELOC_PPC64_TPREL16_HIGHER,
30701 +  BFD_RELOC_PPC64_TPREL16_HIGHERA,
30702 +  BFD_RELOC_PPC64_TPREL16_HIGHEST,
30703 +  BFD_RELOC_PPC64_TPREL16_HIGHESTA,
30704 +  BFD_RELOC_PPC64_DTPREL16_DS,
30705 +  BFD_RELOC_PPC64_DTPREL16_LO_DS,
30706 +  BFD_RELOC_PPC64_DTPREL16_HIGHER,
30707 +  BFD_RELOC_PPC64_DTPREL16_HIGHERA,
30708 +  BFD_RELOC_PPC64_DTPREL16_HIGHEST,
30709 +  BFD_RELOC_PPC64_DTPREL16_HIGHESTA,
30710 +
30711 +/* IBM 370/390 relocations  */
30712 +  BFD_RELOC_I370_D12,
30713 +
30714 +/* The type of reloc used to build a constructor table - at the moment
30715 +probably a 32 bit wide absolute relocation, but the target can choose.
30716 +It generally does map to one of the other relocation types.  */
30717 +  BFD_RELOC_CTOR,
30718 +
30719 +/* ARM 26 bit pc-relative branch.  The lowest two bits must be zero and are
30720 +not stored in the instruction.  */
30721 +  BFD_RELOC_ARM_PCREL_BRANCH,
30722 +
30723 +/* ARM 26 bit pc-relative branch.  The lowest bit must be zero and is
30724 +not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
30725 +field in the instruction.  */
30726 +  BFD_RELOC_ARM_PCREL_BLX,
30727 +
30728 +/* Thumb 22 bit pc-relative branch.  The lowest bit must be zero and is
30729 +not stored in the instruction.  The 2nd lowest bit comes from a 1 bit
30730 +field in the instruction.  */
30731 +  BFD_RELOC_THUMB_PCREL_BLX,
30732 +
30733 +/* Thumb 7-, 9-, 12-, 20-, 23-, and 25-bit pc-relative branches.
30734 +The lowest bit must be zero and is not stored in the instruction.
30735 +Note that the corresponding ELF R_ARM_THM_JUMPnn constant has an
30736 +"nn" one smaller in all cases.  Note further that BRANCH23
30737 +corresponds to R_ARM_THM_CALL.  */
30738 +  BFD_RELOC_THUMB_PCREL_BRANCH7,
30739 +  BFD_RELOC_THUMB_PCREL_BRANCH9,
30740 +  BFD_RELOC_THUMB_PCREL_BRANCH12,
30741 +  BFD_RELOC_THUMB_PCREL_BRANCH20,
30742 +  BFD_RELOC_THUMB_PCREL_BRANCH23,
30743 +  BFD_RELOC_THUMB_PCREL_BRANCH25,
30744 +
30745 +/* 12-bit immediate offset, used in ARM-format ldr and str instructions.  */
30746 +  BFD_RELOC_ARM_OFFSET_IMM,
30747 +
30748 +/* 5-bit immediate offset, used in Thumb-format ldr and str instructions.  */
30749 +  BFD_RELOC_ARM_THUMB_OFFSET,
30750 +
30751 +/* Pc-relative or absolute relocation depending on target.  Used for
30752 +entries in .init_array sections.  */
30753 +  BFD_RELOC_ARM_TARGET1,
30754 +
30755 +/* Read-only segment base relative address.  */
30756 +  BFD_RELOC_ARM_ROSEGREL32,
30757 +
30758 +/* Data segment base relative address.  */
30759 +  BFD_RELOC_ARM_SBREL32,
30760 +
30761 +/* This reloc is used for references to RTTI data from exception handling
30762 +tables.  The actual definition depends on the target.  It may be a
30763 +pc-relative or some form of GOT-indirect relocation.  */
30764 +  BFD_RELOC_ARM_TARGET2,
30765 +
30766 +/* 31-bit PC relative address.  */
30767 +  BFD_RELOC_ARM_PREL31,
30768 +
30769 +/* Relocations for setting up GOTs and PLTs for shared libraries.  */
30770 +  BFD_RELOC_ARM_JUMP_SLOT,
30771 +  BFD_RELOC_ARM_GLOB_DAT,
30772 +  BFD_RELOC_ARM_GOT32,
30773 +  BFD_RELOC_ARM_PLT32,
30774 +  BFD_RELOC_ARM_RELATIVE,
30775 +  BFD_RELOC_ARM_GOTOFF,
30776 +  BFD_RELOC_ARM_GOTPC,
30777 +
30778 +/* ARM thread-local storage relocations.  */
30779 +  BFD_RELOC_ARM_TLS_GD32,
30780 +  BFD_RELOC_ARM_TLS_LDO32,
30781 +  BFD_RELOC_ARM_TLS_LDM32,
30782 +  BFD_RELOC_ARM_TLS_DTPOFF32,
30783 +  BFD_RELOC_ARM_TLS_DTPMOD32,
30784 +  BFD_RELOC_ARM_TLS_TPOFF32,
30785 +  BFD_RELOC_ARM_TLS_IE32,
30786 +  BFD_RELOC_ARM_TLS_LE32,
30787 +
30788 +/* These relocs are only used within the ARM assembler.  They are not
30789 +(at present) written to any object files.  */
30790 +  BFD_RELOC_ARM_IMMEDIATE,
30791 +  BFD_RELOC_ARM_ADRL_IMMEDIATE,
30792 +  BFD_RELOC_ARM_T32_IMMEDIATE,
30793 +  BFD_RELOC_ARM_SHIFT_IMM,
30794 +  BFD_RELOC_ARM_SMI,
30795 +  BFD_RELOC_ARM_SWI,
30796 +  BFD_RELOC_ARM_MULTI,
30797 +  BFD_RELOC_ARM_CP_OFF_IMM,
30798 +  BFD_RELOC_ARM_CP_OFF_IMM_S2,
30799 +  BFD_RELOC_ARM_ADR_IMM,
30800 +  BFD_RELOC_ARM_LDR_IMM,
30801 +  BFD_RELOC_ARM_LITERAL,
30802 +  BFD_RELOC_ARM_IN_POOL,
30803 +  BFD_RELOC_ARM_OFFSET_IMM8,
30804 +  BFD_RELOC_ARM_T32_OFFSET_U8,
30805 +  BFD_RELOC_ARM_T32_OFFSET_IMM,
30806 +  BFD_RELOC_ARM_HWLITERAL,
30807 +  BFD_RELOC_ARM_THUMB_ADD,
30808 +  BFD_RELOC_ARM_THUMB_IMM,
30809 +  BFD_RELOC_ARM_THUMB_SHIFT,
30810 +
30811 +/* Renesas / SuperH SH relocs.  Not all of these appear in object files.  */
30812 +  BFD_RELOC_SH_PCDISP8BY2,
30813 +  BFD_RELOC_SH_PCDISP12BY2,
30814 +  BFD_RELOC_SH_IMM3,
30815 +  BFD_RELOC_SH_IMM3U,
30816 +  BFD_RELOC_SH_DISP12,
30817 +  BFD_RELOC_SH_DISP12BY2,
30818 +  BFD_RELOC_SH_DISP12BY4,
30819 +  BFD_RELOC_SH_DISP12BY8,
30820 +  BFD_RELOC_SH_DISP20,
30821 +  BFD_RELOC_SH_DISP20BY8,
30822 +  BFD_RELOC_SH_IMM4,
30823 +  BFD_RELOC_SH_IMM4BY2,
30824 +  BFD_RELOC_SH_IMM4BY4,
30825 +  BFD_RELOC_SH_IMM8,
30826 +  BFD_RELOC_SH_IMM8BY2,
30827 +  BFD_RELOC_SH_IMM8BY4,
30828 +  BFD_RELOC_SH_PCRELIMM8BY2,
30829 +  BFD_RELOC_SH_PCRELIMM8BY4,
30830 +  BFD_RELOC_SH_SWITCH16,
30831 +  BFD_RELOC_SH_SWITCH32,
30832 +  BFD_RELOC_SH_USES,
30833 +  BFD_RELOC_SH_COUNT,
30834 +  BFD_RELOC_SH_ALIGN,
30835 +  BFD_RELOC_SH_CODE,
30836 +  BFD_RELOC_SH_DATA,
30837 +  BFD_RELOC_SH_LABEL,
30838 +  BFD_RELOC_SH_LOOP_START,
30839 +  BFD_RELOC_SH_LOOP_END,
30840 +  BFD_RELOC_SH_COPY,
30841 +  BFD_RELOC_SH_GLOB_DAT,
30842 +  BFD_RELOC_SH_JMP_SLOT,
30843 +  BFD_RELOC_SH_RELATIVE,
30844 +  BFD_RELOC_SH_GOTPC,
30845 +  BFD_RELOC_SH_GOT_LOW16,
30846 +  BFD_RELOC_SH_GOT_MEDLOW16,
30847 +  BFD_RELOC_SH_GOT_MEDHI16,
30848 +  BFD_RELOC_SH_GOT_HI16,
30849 +  BFD_RELOC_SH_GOTPLT_LOW16,
30850 +  BFD_RELOC_SH_GOTPLT_MEDLOW16,
30851 +  BFD_RELOC_SH_GOTPLT_MEDHI16,
30852 +  BFD_RELOC_SH_GOTPLT_HI16,
30853 +  BFD_RELOC_SH_PLT_LOW16,
30854 +  BFD_RELOC_SH_PLT_MEDLOW16,
30855 +  BFD_RELOC_SH_PLT_MEDHI16,
30856 +  BFD_RELOC_SH_PLT_HI16,
30857 +  BFD_RELOC_SH_GOTOFF_LOW16,
30858 +  BFD_RELOC_SH_GOTOFF_MEDLOW16,
30859 +  BFD_RELOC_SH_GOTOFF_MEDHI16,
30860 +  BFD_RELOC_SH_GOTOFF_HI16,
30861 +  BFD_RELOC_SH_GOTPC_LOW16,
30862 +  BFD_RELOC_SH_GOTPC_MEDLOW16,
30863 +  BFD_RELOC_SH_GOTPC_MEDHI16,
30864 +  BFD_RELOC_SH_GOTPC_HI16,
30865 +  BFD_RELOC_SH_COPY64,
30866 +  BFD_RELOC_SH_GLOB_DAT64,
30867 +  BFD_RELOC_SH_JMP_SLOT64,
30868 +  BFD_RELOC_SH_RELATIVE64,
30869 +  BFD_RELOC_SH_GOT10BY4,
30870 +  BFD_RELOC_SH_GOT10BY8,
30871 +  BFD_RELOC_SH_GOTPLT10BY4,
30872 +  BFD_RELOC_SH_GOTPLT10BY8,
30873 +  BFD_RELOC_SH_GOTPLT32,
30874 +  BFD_RELOC_SH_SHMEDIA_CODE,
30875 +  BFD_RELOC_SH_IMMU5,
30876 +  BFD_RELOC_SH_IMMS6,
30877 +  BFD_RELOC_SH_IMMS6BY32,
30878 +  BFD_RELOC_SH_IMMU6,
30879 +  BFD_RELOC_SH_IMMS10,
30880 +  BFD_RELOC_SH_IMMS10BY2,
30881 +  BFD_RELOC_SH_IMMS10BY4,
30882 +  BFD_RELOC_SH_IMMS10BY8,
30883 +  BFD_RELOC_SH_IMMS16,
30884 +  BFD_RELOC_SH_IMMU16,
30885 +  BFD_RELOC_SH_IMM_LOW16,
30886 +  BFD_RELOC_SH_IMM_LOW16_PCREL,
30887 +  BFD_RELOC_SH_IMM_MEDLOW16,
30888 +  BFD_RELOC_SH_IMM_MEDLOW16_PCREL,
30889 +  BFD_RELOC_SH_IMM_MEDHI16,
30890 +  BFD_RELOC_SH_IMM_MEDHI16_PCREL,
30891 +  BFD_RELOC_SH_IMM_HI16,
30892 +  BFD_RELOC_SH_IMM_HI16_PCREL,
30893 +  BFD_RELOC_SH_PT_16,
30894 +  BFD_RELOC_SH_TLS_GD_32,
30895 +  BFD_RELOC_SH_TLS_LD_32,
30896 +  BFD_RELOC_SH_TLS_LDO_32,
30897 +  BFD_RELOC_SH_TLS_IE_32,
30898 +  BFD_RELOC_SH_TLS_LE_32,
30899 +  BFD_RELOC_SH_TLS_DTPMOD32,
30900 +  BFD_RELOC_SH_TLS_DTPOFF32,
30901 +  BFD_RELOC_SH_TLS_TPOFF32,
30902 +
30903 +/* ARC Cores relocs.
30904 +ARC 22 bit pc-relative branch.  The lowest two bits must be zero and are
30905 +not stored in the instruction.  The high 20 bits are installed in bits 26
30906 +through 7 of the instruction.  */
30907 +  BFD_RELOC_ARC_B22_PCREL,
30908 +
30909 +/* ARC 26 bit absolute branch.  The lowest two bits must be zero and are not
30910 +stored in the instruction.  The high 24 bits are installed in bits 23
30911 +through 0.  */
30912 +  BFD_RELOC_ARC_B26,
30913 +
30914 +/* Mitsubishi D10V relocs.
30915 +This is a 10-bit reloc with the right 2 bits
30916 +assumed to be 0.  */
30917 +  BFD_RELOC_D10V_10_PCREL_R,
30918 +
30919 +/* Mitsubishi D10V relocs.
30920 +This is a 10-bit reloc with the right 2 bits
30921 +assumed to be 0.  This is the same as the previous reloc
30922 +except it is in the left container, i.e.,
30923 +shifted left 15 bits.  */
30924 +  BFD_RELOC_D10V_10_PCREL_L,
30925 +
30926 +/* This is an 18-bit reloc with the right 2 bits
30927 +assumed to be 0.  */
30928 +  BFD_RELOC_D10V_18,
30929 +
30930 +/* This is an 18-bit reloc with the right 2 bits
30931 +assumed to be 0.  */
30932 +  BFD_RELOC_D10V_18_PCREL,
30933 +
30934 +/* Mitsubishi D30V relocs.
30935 +This is a 6-bit absolute reloc.  */
30936 +  BFD_RELOC_D30V_6,
30937 +
30938 +/* This is a 6-bit pc-relative reloc with
30939 +the right 3 bits assumed to be 0.  */
30940 +  BFD_RELOC_D30V_9_PCREL,
30941 +
30942 +/* This is a 6-bit pc-relative reloc with
30943 +the right 3 bits assumed to be 0. Same
30944 +as the previous reloc but on the right side
30945 +of the container.  */
30946 +  BFD_RELOC_D30V_9_PCREL_R,
30947 +
30948 +/* This is a 12-bit absolute reloc with the
30949 +right 3 bitsassumed to be 0.  */
30950 +  BFD_RELOC_D30V_15,
30951 +
30952 +/* This is a 12-bit pc-relative reloc with
30953 +the right 3 bits assumed to be 0.  */
30954 +  BFD_RELOC_D30V_15_PCREL,
30955 +
30956 +/* This is a 12-bit pc-relative reloc with
30957 +the right 3 bits assumed to be 0. Same
30958 +as the previous reloc but on the right side
30959 +of the container.  */
30960 +  BFD_RELOC_D30V_15_PCREL_R,
30961 +
30962 +/* This is an 18-bit absolute reloc with
30963 +the right 3 bits assumed to be 0.  */
30964 +  BFD_RELOC_D30V_21,
30965 +
30966 +/* This is an 18-bit pc-relative reloc with
30967 +the right 3 bits assumed to be 0.  */
30968 +  BFD_RELOC_D30V_21_PCREL,
30969 +
30970 +/* This is an 18-bit pc-relative reloc with
30971 +the right 3 bits assumed to be 0. Same
30972 +as the previous reloc but on the right side
30973 +of the container.  */
30974 +  BFD_RELOC_D30V_21_PCREL_R,
30975 +
30976 +/* This is a 32-bit absolute reloc.  */
30977 +  BFD_RELOC_D30V_32,
30978 +
30979 +/* This is a 32-bit pc-relative reloc.  */
30980 +  BFD_RELOC_D30V_32_PCREL,
30981 +
30982 +/* DLX relocs  */
30983 +  BFD_RELOC_DLX_HI16_S,
30984 +
30985 +/* DLX relocs  */
30986 +  BFD_RELOC_DLX_LO16,
30987 +
30988 +/* DLX relocs  */
30989 +  BFD_RELOC_DLX_JMP26,
30990 +
30991 +/* Renesas M16C/M32C Relocations.  */
30992 +  BFD_RELOC_M16C_8_PCREL8,
30993 +  BFD_RELOC_M16C_16_PCREL8,
30994 +  BFD_RELOC_M16C_8_PCREL16,
30995 +  BFD_RELOC_M16C_8_ELABEL24,
30996 +  BFD_RELOC_M16C_8_ABS16,
30997 +  BFD_RELOC_M16C_16_ABS16,
30998 +  BFD_RELOC_M16C_16_ABS24,
30999 +  BFD_RELOC_M16C_16_ABS32,
31000 +  BFD_RELOC_M16C_24_ABS16,
31001 +  BFD_RELOC_M16C_24_ABS24,
31002 +  BFD_RELOC_M16C_24_ABS32,
31003 +  BFD_RELOC_M16C_32_ABS16,
31004 +  BFD_RELOC_M16C_32_ABS24,
31005 +  BFD_RELOC_M16C_32_ABS32,
31006 +  BFD_RELOC_M16C_40_ABS16,
31007 +  BFD_RELOC_M16C_40_ABS24,
31008 +  BFD_RELOC_M16C_40_ABS32,
31009 +
31010 +/* Renesas M32R (formerly Mitsubishi M32R) relocs.
31011 +This is a 24 bit absolute address.  */
31012 +  BFD_RELOC_M32R_24,
31013 +
31014 +/* This is a 10-bit pc-relative reloc with the right 2 bits assumed to be 0.  */
31015 +  BFD_RELOC_M32R_10_PCREL,
31016 +
31017 +/* This is an 18-bit reloc with the right 2 bits assumed to be 0.  */
31018 +  BFD_RELOC_M32R_18_PCREL,
31019 +
31020 +/* This is a 26-bit reloc with the right 2 bits assumed to be 0.  */
31021 +  BFD_RELOC_M32R_26_PCREL,
31022 +
31023 +/* This is a 16-bit reloc containing the high 16 bits of an address
31024 +used when the lower 16 bits are treated as unsigned.  */
31025 +  BFD_RELOC_M32R_HI16_ULO,
31026 +
31027 +/* This is a 16-bit reloc containing the high 16 bits of an address
31028 +used when the lower 16 bits are treated as signed.  */
31029 +  BFD_RELOC_M32R_HI16_SLO,
31030 +
31031 +/* This is a 16-bit reloc containing the lower 16 bits of an address.  */
31032 +  BFD_RELOC_M32R_LO16,
31033 +
31034 +/* This is a 16-bit reloc containing the small data area offset for use in
31035 +add3, load, and store instructions.  */
31036 +  BFD_RELOC_M32R_SDA16,
31037 +
31038 +/* For PIC.  */
31039 +  BFD_RELOC_M32R_GOT24,
31040 +  BFD_RELOC_M32R_26_PLTREL,
31041 +  BFD_RELOC_M32R_COPY,
31042 +  BFD_RELOC_M32R_GLOB_DAT,
31043 +  BFD_RELOC_M32R_JMP_SLOT,
31044 +  BFD_RELOC_M32R_RELATIVE,
31045 +  BFD_RELOC_M32R_GOTOFF,
31046 +  BFD_RELOC_M32R_GOTOFF_HI_ULO,
31047 +  BFD_RELOC_M32R_GOTOFF_HI_SLO,
31048 +  BFD_RELOC_M32R_GOTOFF_LO,
31049 +  BFD_RELOC_M32R_GOTPC24,
31050 +  BFD_RELOC_M32R_GOT16_HI_ULO,
31051 +  BFD_RELOC_M32R_GOT16_HI_SLO,
31052 +  BFD_RELOC_M32R_GOT16_LO,
31053 +  BFD_RELOC_M32R_GOTPC_HI_ULO,
31054 +  BFD_RELOC_M32R_GOTPC_HI_SLO,
31055 +  BFD_RELOC_M32R_GOTPC_LO,
31056 +
31057 +/* This is a 9-bit reloc  */
31058 +  BFD_RELOC_V850_9_PCREL,
31059 +
31060 +/* This is a 22-bit reloc  */
31061 +  BFD_RELOC_V850_22_PCREL,
31062 +
31063 +/* This is a 16 bit offset from the short data area pointer.  */
31064 +  BFD_RELOC_V850_SDA_16_16_OFFSET,
31065 +
31066 +/* This is a 16 bit offset (of which only 15 bits are used) from the
31067 +short data area pointer.  */
31068 +  BFD_RELOC_V850_SDA_15_16_OFFSET,
31069 +
31070 +/* This is a 16 bit offset from the zero data area pointer.  */
31071 +  BFD_RELOC_V850_ZDA_16_16_OFFSET,
31072 +
31073 +/* This is a 16 bit offset (of which only 15 bits are used) from the
31074 +zero data area pointer.  */
31075 +  BFD_RELOC_V850_ZDA_15_16_OFFSET,
31076 +
31077 +/* This is an 8 bit offset (of which only 6 bits are used) from the
31078 +tiny data area pointer.  */
31079 +  BFD_RELOC_V850_TDA_6_8_OFFSET,
31080 +
31081 +/* This is an 8bit offset (of which only 7 bits are used) from the tiny
31082 +data area pointer.  */
31083 +  BFD_RELOC_V850_TDA_7_8_OFFSET,
31084 +
31085 +/* This is a 7 bit offset from the tiny data area pointer.  */
31086 +  BFD_RELOC_V850_TDA_7_7_OFFSET,
31087 +
31088 +/* This is a 16 bit offset from the tiny data area pointer.  */
31089 +  BFD_RELOC_V850_TDA_16_16_OFFSET,
31090 +
31091 +/* This is a 5 bit offset (of which only 4 bits are used) from the tiny
31092 +data area pointer.  */
31093 +  BFD_RELOC_V850_TDA_4_5_OFFSET,
31094 +
31095 +/* This is a 4 bit offset from the tiny data area pointer.  */
31096 +  BFD_RELOC_V850_TDA_4_4_OFFSET,
31097 +
31098 +/* This is a 16 bit offset from the short data area pointer, with the
31099 +bits placed non-contiguously in the instruction.  */
31100 +  BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET,
31101 +
31102 +/* This is a 16 bit offset from the zero data area pointer, with the
31103 +bits placed non-contiguously in the instruction.  */
31104 +  BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET,
31105 +
31106 +/* This is a 6 bit offset from the call table base pointer.  */
31107 +  BFD_RELOC_V850_CALLT_6_7_OFFSET,
31108 +
31109 +/* This is a 16 bit offset from the call table base pointer.  */
31110 +  BFD_RELOC_V850_CALLT_16_16_OFFSET,
31111 +
31112 +/* Used for relaxing indirect function calls.  */
31113 +  BFD_RELOC_V850_LONGCALL,
31114 +
31115 +/* Used for relaxing indirect jumps.  */
31116 +  BFD_RELOC_V850_LONGJUMP,
31117 +
31118 +/* Used to maintain alignment whilst relaxing.  */
31119 +  BFD_RELOC_V850_ALIGN,
31120 +
31121 +/* This is a variation of BFD_RELOC_LO16 that can be used in v850e ld.bu
31122 +instructions.  */
31123 +  BFD_RELOC_V850_LO16_SPLIT_OFFSET,
31124 +
31125 +/* This is a 32bit pcrel reloc for the mn10300, offset by two bytes in the
31126 +instruction.  */
31127 +  BFD_RELOC_MN10300_32_PCREL,
31128 +
31129 +/* This is a 16bit pcrel reloc for the mn10300, offset by two bytes in the
31130 +instruction.  */
31131 +  BFD_RELOC_MN10300_16_PCREL,
31132 +
31133 +/* This is a 8bit DP reloc for the tms320c30, where the most
31134 +significant 8 bits of a 24 bit word are placed into the least
31135 +significant 8 bits of the opcode.  */
31136 +  BFD_RELOC_TIC30_LDP,
31137 +
31138 +/* This is a 7bit reloc for the tms320c54x, where the least
31139 +significant 7 bits of a 16 bit word are placed into the least
31140 +significant 7 bits of the opcode.  */
31141 +  BFD_RELOC_TIC54X_PARTLS7,
31142 +
31143 +/* This is a 9bit DP reloc for the tms320c54x, where the most
31144 +significant 9 bits of a 16 bit word are placed into the least
31145 +significant 9 bits of the opcode.  */
31146 +  BFD_RELOC_TIC54X_PARTMS9,
31147 +
31148 +/* This is an extended address 23-bit reloc for the tms320c54x.  */
31149 +  BFD_RELOC_TIC54X_23,
31150 +
31151 +/* This is a 16-bit reloc for the tms320c54x, where the least
31152 +significant 16 bits of a 23-bit extended address are placed into
31153 +the opcode.  */
31154 +  BFD_RELOC_TIC54X_16_OF_23,
31155 +
31156 +/* This is a reloc for the tms320c54x, where the most
31157 +significant 7 bits of a 23-bit extended address are placed into
31158 +the opcode.  */
31159 +  BFD_RELOC_TIC54X_MS7_OF_23,
31160 +
31161 +/* This is a 48 bit reloc for the FR30 that stores 32 bits.  */
31162 +  BFD_RELOC_FR30_48,
31163 +
31164 +/* This is a 32 bit reloc for the FR30 that stores 20 bits split up into
31165 +two sections.  */
31166 +  BFD_RELOC_FR30_20,
31167 +
31168 +/* This is a 16 bit reloc for the FR30 that stores a 6 bit word offset in
31169 +4 bits.  */
31170 +  BFD_RELOC_FR30_6_IN_4,
31171 +
31172 +/* This is a 16 bit reloc for the FR30 that stores an 8 bit byte offset
31173 +into 8 bits.  */
31174 +  BFD_RELOC_FR30_8_IN_8,
31175 +
31176 +/* This is a 16 bit reloc for the FR30 that stores a 9 bit short offset
31177 +into 8 bits.  */
31178 +  BFD_RELOC_FR30_9_IN_8,
31179 +
31180 +/* This is a 16 bit reloc for the FR30 that stores a 10 bit word offset
31181 +into 8 bits.  */
31182 +  BFD_RELOC_FR30_10_IN_8,
31183 +
31184 +/* This is a 16 bit reloc for the FR30 that stores a 9 bit pc relative
31185 +short offset into 8 bits.  */
31186 +  BFD_RELOC_FR30_9_PCREL,
31187 +
31188 +/* This is a 16 bit reloc for the FR30 that stores a 12 bit pc relative
31189 +short offset into 11 bits.  */
31190 +  BFD_RELOC_FR30_12_PCREL,
31191 +
31192 +/* Motorola Mcore relocations.  */
31193 +  BFD_RELOC_MCORE_PCREL_IMM8BY4,
31194 +  BFD_RELOC_MCORE_PCREL_IMM11BY2,
31195 +  BFD_RELOC_MCORE_PCREL_IMM4BY2,
31196 +  BFD_RELOC_MCORE_PCREL_32,
31197 +  BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2,
31198 +  BFD_RELOC_MCORE_RVA,
31199 +
31200 +/* These are relocations for the GETA instruction.  */
31201 +  BFD_RELOC_MMIX_GETA,
31202 +  BFD_RELOC_MMIX_GETA_1,
31203 +  BFD_RELOC_MMIX_GETA_2,
31204 +  BFD_RELOC_MMIX_GETA_3,
31205 +
31206 +/* These are relocations for a conditional branch instruction.  */
31207 +  BFD_RELOC_MMIX_CBRANCH,
31208 +  BFD_RELOC_MMIX_CBRANCH_J,
31209 +  BFD_RELOC_MMIX_CBRANCH_1,
31210 +  BFD_RELOC_MMIX_CBRANCH_2,
31211 +  BFD_RELOC_MMIX_CBRANCH_3,
31212 +
31213 +/* These are relocations for the PUSHJ instruction.  */
31214 +  BFD_RELOC_MMIX_PUSHJ,
31215 +  BFD_RELOC_MMIX_PUSHJ_1,
31216 +  BFD_RELOC_MMIX_PUSHJ_2,
31217 +  BFD_RELOC_MMIX_PUSHJ_3,
31218 +  BFD_RELOC_MMIX_PUSHJ_STUBBABLE,
31219 +
31220 +/* These are relocations for the JMP instruction.  */
31221 +  BFD_RELOC_MMIX_JMP,
31222 +  BFD_RELOC_MMIX_JMP_1,
31223 +  BFD_RELOC_MMIX_JMP_2,
31224 +  BFD_RELOC_MMIX_JMP_3,
31225 +
31226 +/* This is a relocation for a relative address as in a GETA instruction or
31227 +a branch.  */
31228 +  BFD_RELOC_MMIX_ADDR19,
31229 +
31230 +/* This is a relocation for a relative address as in a JMP instruction.  */
31231 +  BFD_RELOC_MMIX_ADDR27,
31232 +
31233 +/* This is a relocation for an instruction field that may be a general
31234 +register or a value 0..255.  */
31235 +  BFD_RELOC_MMIX_REG_OR_BYTE,
31236 +
31237 +/* This is a relocation for an instruction field that may be a general
31238 +register.  */
31239 +  BFD_RELOC_MMIX_REG,
31240 +
31241 +/* This is a relocation for two instruction fields holding a register and
31242 +an offset, the equivalent of the relocation.  */
31243 +  BFD_RELOC_MMIX_BASE_PLUS_OFFSET,
31244 +
31245 +/* This relocation is an assertion that the expression is not allocated as
31246 +a global register.  It does not modify contents.  */
31247 +  BFD_RELOC_MMIX_LOCAL,
31248 +
31249 +/* This is a 16 bit reloc for the AVR that stores 8 bit pc relative
31250 +short offset into 7 bits.  */
31251 +  BFD_RELOC_AVR_7_PCREL,
31252 +
31253 +/* This is a 16 bit reloc for the AVR that stores 13 bit pc relative
31254 +short offset into 12 bits.  */
31255 +  BFD_RELOC_AVR_13_PCREL,
31256 +
31257 +/* This is a 16 bit reloc for the AVR that stores 17 bit value (usually
31258 +program memory address) into 16 bits.  */
31259 +  BFD_RELOC_AVR_16_PM,
31260 +
31261 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually
31262 +data memory address) into 8 bit immediate value of LDI insn.  */
31263 +  BFD_RELOC_AVR_LO8_LDI,
31264 +
31265 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
31266 +of data memory address) into 8 bit immediate value of LDI insn.  */
31267 +  BFD_RELOC_AVR_HI8_LDI,
31268 +
31269 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
31270 +of program memory address) into 8 bit immediate value of LDI insn.  */
31271 +  BFD_RELOC_AVR_HH8_LDI,
31272 +
31273 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
31274 +(usually data memory address) into 8 bit immediate value of SUBI insn.  */
31275 +  BFD_RELOC_AVR_LO8_LDI_NEG,
31276 +
31277 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
31278 +(high 8 bit of data memory address) into 8 bit immediate value of
31279 +SUBI insn.  */
31280 +  BFD_RELOC_AVR_HI8_LDI_NEG,
31281 +
31282 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
31283 +(most high 8 bit of program memory address) into 8 bit immediate value
31284 +of LDI or SUBI insn.  */
31285 +  BFD_RELOC_AVR_HH8_LDI_NEG,
31286 +
31287 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (usually
31288 +command address) into 8 bit immediate value of LDI insn.  */
31289 +  BFD_RELOC_AVR_LO8_LDI_PM,
31290 +
31291 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (high 8 bit
31292 +of command address) into 8 bit immediate value of LDI insn.  */
31293 +  BFD_RELOC_AVR_HI8_LDI_PM,
31294 +
31295 +/* This is a 16 bit reloc for the AVR that stores 8 bit value (most high 8 bit
31296 +of command address) into 8 bit immediate value of LDI insn.  */
31297 +  BFD_RELOC_AVR_HH8_LDI_PM,
31298 +
31299 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
31300 +(usually command address) into 8 bit immediate value of SUBI insn.  */
31301 +  BFD_RELOC_AVR_LO8_LDI_PM_NEG,
31302 +
31303 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
31304 +(high 8 bit of 16 bit command address) into 8 bit immediate value
31305 +of SUBI insn.  */
31306 +  BFD_RELOC_AVR_HI8_LDI_PM_NEG,
31307 +
31308 +/* This is a 16 bit reloc for the AVR that stores negated 8 bit value
31309 +(high 6 bit of 22 bit command address) into 8 bit immediate
31310 +value of SUBI insn.  */
31311 +  BFD_RELOC_AVR_HH8_LDI_PM_NEG,
31312 +
31313 +/* This is a 32 bit reloc for the AVR that stores 23 bit value
31314 +into 22 bits.  */
31315 +  BFD_RELOC_AVR_CALL,
31316 +
31317 +/* This is a 16 bit reloc for the AVR that stores all needed bits
31318 +for absolute addressing with ldi with overflow check to linktime  */
31319 +  BFD_RELOC_AVR_LDI,
31320 +
31321 +/* This is a 6 bit reloc for the AVR that stores offset for ldd/std
31322 +instructions  */
31323 +  BFD_RELOC_AVR_6,
31324 +
31325 +/* This is a 6 bit reloc for the AVR that stores offset for adiw/sbiw
31326 +instructions  */
31327 +  BFD_RELOC_AVR_6_ADIW,
31328 +
31329 +/* Direct 12 bit.  */
31330 +  BFD_RELOC_390_12,
31331 +
31332 +/* 12 bit GOT offset.  */
31333 +  BFD_RELOC_390_GOT12,
31334 +
31335 +/* 32 bit PC relative PLT address.  */
31336 +  BFD_RELOC_390_PLT32,
31337 +
31338 +/* Copy symbol at runtime.  */
31339 +  BFD_RELOC_390_COPY,
31340 +
31341 +/* Create GOT entry.  */
31342 +  BFD_RELOC_390_GLOB_DAT,
31343 +
31344 +/* Create PLT entry.  */
31345 +  BFD_RELOC_390_JMP_SLOT,
31346 +
31347 +/* Adjust by program base.  */
31348 +  BFD_RELOC_390_RELATIVE,
31349 +
31350 +/* 32 bit PC relative offset to GOT.  */
31351 +  BFD_RELOC_390_GOTPC,
31352 +
31353 +/* 16 bit GOT offset.  */
31354 +  BFD_RELOC_390_GOT16,
31355 +
31356 +/* PC relative 16 bit shifted by 1.  */
31357 +  BFD_RELOC_390_PC16DBL,
31358 +
31359 +/* 16 bit PC rel. PLT shifted by 1.  */
31360 +  BFD_RELOC_390_PLT16DBL,
31361 +
31362 +/* PC relative 32 bit shifted by 1.  */
31363 +  BFD_RELOC_390_PC32DBL,
31364 +
31365 +/* 32 bit PC rel. PLT shifted by 1.  */
31366 +  BFD_RELOC_390_PLT32DBL,
31367 +
31368 +/* 32 bit PC rel. GOT shifted by 1.  */
31369 +  BFD_RELOC_390_GOTPCDBL,
31370 +
31371 +/* 64 bit GOT offset.  */
31372 +  BFD_RELOC_390_GOT64,
31373 +
31374 +/* 64 bit PC relative PLT address.  */
31375 +  BFD_RELOC_390_PLT64,
31376 +
31377 +/* 32 bit rel. offset to GOT entry.  */
31378 +  BFD_RELOC_390_GOTENT,
31379 +
31380 +/* 64 bit offset to GOT.  */
31381 +  BFD_RELOC_390_GOTOFF64,
31382 +
31383 +/* 12-bit offset to symbol-entry within GOT, with PLT handling.  */
31384 +  BFD_RELOC_390_GOTPLT12,
31385 +
31386 +/* 16-bit offset to symbol-entry within GOT, with PLT handling.  */
31387 +  BFD_RELOC_390_GOTPLT16,
31388 +
31389 +/* 32-bit offset to symbol-entry within GOT, with PLT handling.  */
31390 +  BFD_RELOC_390_GOTPLT32,
31391 +
31392 +/* 64-bit offset to symbol-entry within GOT, with PLT handling.  */
31393 +  BFD_RELOC_390_GOTPLT64,
31394 +
31395 +/* 32-bit rel. offset to symbol-entry within GOT, with PLT handling.  */
31396 +  BFD_RELOC_390_GOTPLTENT,
31397 +
31398 +/* 16-bit rel. offset from the GOT to a PLT entry.  */
31399 +  BFD_RELOC_390_PLTOFF16,
31400 +
31401 +/* 32-bit rel. offset from the GOT to a PLT entry.  */
31402 +  BFD_RELOC_390_PLTOFF32,
31403 +
31404 +/* 64-bit rel. offset from the GOT to a PLT entry.  */
31405 +  BFD_RELOC_390_PLTOFF64,
31406 +
31407 +/* s390 tls relocations.  */
31408 +  BFD_RELOC_390_TLS_LOAD,
31409 +  BFD_RELOC_390_TLS_GDCALL,
31410 +  BFD_RELOC_390_TLS_LDCALL,
31411 +  BFD_RELOC_390_TLS_GD32,
31412 +  BFD_RELOC_390_TLS_GD64,
31413 +  BFD_RELOC_390_TLS_GOTIE12,
31414 +  BFD_RELOC_390_TLS_GOTIE32,
31415 +  BFD_RELOC_390_TLS_GOTIE64,
31416 +  BFD_RELOC_390_TLS_LDM32,
31417 +  BFD_RELOC_390_TLS_LDM64,
31418 +  BFD_RELOC_390_TLS_IE32,
31419 +  BFD_RELOC_390_TLS_IE64,
31420 +  BFD_RELOC_390_TLS_IEENT,
31421 +  BFD_RELOC_390_TLS_LE32,
31422 +  BFD_RELOC_390_TLS_LE64,
31423 +  BFD_RELOC_390_TLS_LDO32,
31424 +  BFD_RELOC_390_TLS_LDO64,
31425 +  BFD_RELOC_390_TLS_DTPMOD,
31426 +  BFD_RELOC_390_TLS_DTPOFF,
31427 +  BFD_RELOC_390_TLS_TPOFF,
31428 +
31429 +/* Long displacement extension.  */
31430 +  BFD_RELOC_390_20,
31431 +  BFD_RELOC_390_GOT20,
31432 +  BFD_RELOC_390_GOTPLT20,
31433 +  BFD_RELOC_390_TLS_GOTIE20,
31434 +
31435 +/* Scenix IP2K - 9-bit register number / data address  */
31436 +  BFD_RELOC_IP2K_FR9,
31437 +
31438 +/* Scenix IP2K - 4-bit register/data bank number  */
31439 +  BFD_RELOC_IP2K_BANK,
31440 +
31441 +/* Scenix IP2K - low 13 bits of instruction word address  */
31442 +  BFD_RELOC_IP2K_ADDR16CJP,
31443 +
31444 +/* Scenix IP2K - high 3 bits of instruction word address  */
31445 +  BFD_RELOC_IP2K_PAGE3,
31446 +
31447 +/* Scenix IP2K - ext/low/high 8 bits of data address  */
31448 +  BFD_RELOC_IP2K_LO8DATA,
31449 +  BFD_RELOC_IP2K_HI8DATA,
31450 +  BFD_RELOC_IP2K_EX8DATA,
31451 +
31452 +/* Scenix IP2K - low/high 8 bits of instruction word address  */
31453 +  BFD_RELOC_IP2K_LO8INSN,
31454 +  BFD_RELOC_IP2K_HI8INSN,
31455 +
31456 +/* Scenix IP2K - even/odd PC modifier to modify snb pcl.0  */
31457 +  BFD_RELOC_IP2K_PC_SKIP,
31458 +
31459 +/* Scenix IP2K - 16 bit word address in text section.  */
31460 +  BFD_RELOC_IP2K_TEXT,
31461 +
31462 +/* Scenix IP2K - 7-bit sp or dp offset  */
31463 +  BFD_RELOC_IP2K_FR_OFFSET,
31464 +
31465 +/* Scenix VPE4K coprocessor - data/insn-space addressing  */
31466 +  BFD_RELOC_VPE4KMATH_DATA,
31467 +  BFD_RELOC_VPE4KMATH_INSN,
31468 +
31469 +/* These two relocations are used by the linker to determine which of
31470 +the entries in a C++ virtual function table are actually used.  When
31471 +the --gc-sections option is given, the linker will zero out the entries
31472 +that are not used, so that the code for those functions need not be
31473 +included in the output.
31474 +
31475 +VTABLE_INHERIT is a zero-space relocation used to describe to the
31476 +linker the inheritance tree of a C++ virtual function table.  The
31477 +relocation's symbol should be the parent class' vtable, and the
31478 +relocation should be located at the child vtable.
31479 +
31480 +VTABLE_ENTRY is a zero-space relocation that describes the use of a
31481 +virtual function table entry.  The reloc's symbol should refer to the
31482 +table of the class mentioned in the code.  Off of that base, an offset
31483 +describes the entry that is being used.  For Rela hosts, this offset
31484 +is stored in the reloc's addend.  For Rel hosts, we are forced to put
31485 +this offset in the reloc's section offset.  */
31486 +  BFD_RELOC_VTABLE_INHERIT,
31487 +  BFD_RELOC_VTABLE_ENTRY,
31488 +
31489 +/* Intel IA64 Relocations.  */
31490 +  BFD_RELOC_IA64_IMM14,
31491 +  BFD_RELOC_IA64_IMM22,
31492 +  BFD_RELOC_IA64_IMM64,
31493 +  BFD_RELOC_IA64_DIR32MSB,
31494 +  BFD_RELOC_IA64_DIR32LSB,
31495 +  BFD_RELOC_IA64_DIR64MSB,
31496 +  BFD_RELOC_IA64_DIR64LSB,
31497 +  BFD_RELOC_IA64_GPREL22,
31498 +  BFD_RELOC_IA64_GPREL64I,
31499 +  BFD_RELOC_IA64_GPREL32MSB,
31500 +  BFD_RELOC_IA64_GPREL32LSB,
31501 +  BFD_RELOC_IA64_GPREL64MSB,
31502 +  BFD_RELOC_IA64_GPREL64LSB,
31503 +  BFD_RELOC_IA64_LTOFF22,
31504 +  BFD_RELOC_IA64_LTOFF64I,
31505 +  BFD_RELOC_IA64_PLTOFF22,
31506 +  BFD_RELOC_IA64_PLTOFF64I,
31507 +  BFD_RELOC_IA64_PLTOFF64MSB,
31508 +  BFD_RELOC_IA64_PLTOFF64LSB,
31509 +  BFD_RELOC_IA64_FPTR64I,
31510 +  BFD_RELOC_IA64_FPTR32MSB,
31511 +  BFD_RELOC_IA64_FPTR32LSB,
31512 +  BFD_RELOC_IA64_FPTR64MSB,
31513 +  BFD_RELOC_IA64_FPTR64LSB,
31514 +  BFD_RELOC_IA64_PCREL21B,
31515 +  BFD_RELOC_IA64_PCREL21BI,
31516 +  BFD_RELOC_IA64_PCREL21M,
31517 +  BFD_RELOC_IA64_PCREL21F,
31518 +  BFD_RELOC_IA64_PCREL22,
31519 +  BFD_RELOC_IA64_PCREL60B,
31520 +  BFD_RELOC_IA64_PCREL64I,
31521 +  BFD_RELOC_IA64_PCREL32MSB,
31522 +  BFD_RELOC_IA64_PCREL32LSB,
31523 +  BFD_RELOC_IA64_PCREL64MSB,
31524 +  BFD_RELOC_IA64_PCREL64LSB,
31525 +  BFD_RELOC_IA64_LTOFF_FPTR22,
31526 +  BFD_RELOC_IA64_LTOFF_FPTR64I,
31527 +  BFD_RELOC_IA64_LTOFF_FPTR32MSB,
31528 +  BFD_RELOC_IA64_LTOFF_FPTR32LSB,
31529 +  BFD_RELOC_IA64_LTOFF_FPTR64MSB,
31530 +  BFD_RELOC_IA64_LTOFF_FPTR64LSB,
31531 +  BFD_RELOC_IA64_SEGREL32MSB,
31532 +  BFD_RELOC_IA64_SEGREL32LSB,
31533 +  BFD_RELOC_IA64_SEGREL64MSB,
31534 +  BFD_RELOC_IA64_SEGREL64LSB,
31535 +  BFD_RELOC_IA64_SECREL32MSB,
31536 +  BFD_RELOC_IA64_SECREL32LSB,
31537 +  BFD_RELOC_IA64_SECREL64MSB,
31538 +  BFD_RELOC_IA64_SECREL64LSB,
31539 +  BFD_RELOC_IA64_REL32MSB,
31540 +  BFD_RELOC_IA64_REL32LSB,
31541 +  BFD_RELOC_IA64_REL64MSB,
31542 +  BFD_RELOC_IA64_REL64LSB,
31543 +  BFD_RELOC_IA64_LTV32MSB,
31544 +  BFD_RELOC_IA64_LTV32LSB,
31545 +  BFD_RELOC_IA64_LTV64MSB,
31546 +  BFD_RELOC_IA64_LTV64LSB,
31547 +  BFD_RELOC_IA64_IPLTMSB,
31548 +  BFD_RELOC_IA64_IPLTLSB,
31549 +  BFD_RELOC_IA64_COPY,
31550 +  BFD_RELOC_IA64_LTOFF22X,
31551 +  BFD_RELOC_IA64_LDXMOV,
31552 +  BFD_RELOC_IA64_TPREL14,
31553 +  BFD_RELOC_IA64_TPREL22,
31554 +  BFD_RELOC_IA64_TPREL64I,
31555 +  BFD_RELOC_IA64_TPREL64MSB,
31556 +  BFD_RELOC_IA64_TPREL64LSB,
31557 +  BFD_RELOC_IA64_LTOFF_TPREL22,
31558 +  BFD_RELOC_IA64_DTPMOD64MSB,
31559 +  BFD_RELOC_IA64_DTPMOD64LSB,
31560 +  BFD_RELOC_IA64_LTOFF_DTPMOD22,
31561 +  BFD_RELOC_IA64_DTPREL14,
31562 +  BFD_RELOC_IA64_DTPREL22,
31563 +  BFD_RELOC_IA64_DTPREL64I,
31564 +  BFD_RELOC_IA64_DTPREL32MSB,
31565 +  BFD_RELOC_IA64_DTPREL32LSB,
31566 +  BFD_RELOC_IA64_DTPREL64MSB,
31567 +  BFD_RELOC_IA64_DTPREL64LSB,
31568 +  BFD_RELOC_IA64_LTOFF_DTPREL22,
31569 +
31570 +/* Motorola 68HC11 reloc.
31571 +This is the 8 bit high part of an absolute address.  */
31572 +  BFD_RELOC_M68HC11_HI8,
31573 +
31574 +/* Motorola 68HC11 reloc.
31575 +This is the 8 bit low part of an absolute address.  */
31576 +  BFD_RELOC_M68HC11_LO8,
31577 +
31578 +/* Motorola 68HC11 reloc.
31579 +This is the 3 bit of a value.  */
31580 +  BFD_RELOC_M68HC11_3B,
31581 +
31582 +/* Motorola 68HC11 reloc.
31583 +This reloc marks the beginning of a jump/call instruction.
31584 +It is used for linker relaxation to correctly identify beginning
31585 +of instruction and change some branches to use PC-relative
31586 +addressing mode.  */
31587 +  BFD_RELOC_M68HC11_RL_JUMP,
31588 +
31589 +/* Motorola 68HC11 reloc.
31590 +This reloc marks a group of several instructions that gcc generates
31591 +and for which the linker relaxation pass can modify and/or remove
31592 +some of them.  */
31593 +  BFD_RELOC_M68HC11_RL_GROUP,
31594 +
31595 +/* Motorola 68HC11 reloc.
31596 +This is the 16-bit lower part of an address.  It is used for 'call'
31597 +instruction to specify the symbol address without any special
31598 +transformation (due to memory bank window).  */
31599 +  BFD_RELOC_M68HC11_LO16,
31600 +
31601 +/* Motorola 68HC11 reloc.
31602 +This is a 8-bit reloc that specifies the page number of an address.
31603 +It is used by 'call' instruction to specify the page number of
31604 +the symbol.  */
31605 +  BFD_RELOC_M68HC11_PAGE,
31606 +
31607 +/* Motorola 68HC11 reloc.
31608 +This is a 24-bit reloc that represents the address with a 16-bit
31609 +value and a 8-bit page number.  The symbol address is transformed
31610 +to follow the 16K memory bank of 68HC12 (seen as mapped in the window).  */
31611 +  BFD_RELOC_M68HC11_24,
31612 +
31613 +/* Motorola 68HC12 reloc.
31614 +This is the 5 bits of a value.  */
31615 +  BFD_RELOC_M68HC12_5B,
31616 +
31617 +/* NS CR16C Relocations.  */
31618 +  BFD_RELOC_16C_NUM08,
31619 +  BFD_RELOC_16C_NUM08_C,
31620 +  BFD_RELOC_16C_NUM16,
31621 +  BFD_RELOC_16C_NUM16_C,
31622 +  BFD_RELOC_16C_NUM32,
31623 +  BFD_RELOC_16C_NUM32_C,
31624 +  BFD_RELOC_16C_DISP04,
31625 +  BFD_RELOC_16C_DISP04_C,
31626 +  BFD_RELOC_16C_DISP08,
31627 +  BFD_RELOC_16C_DISP08_C,
31628 +  BFD_RELOC_16C_DISP16,
31629 +  BFD_RELOC_16C_DISP16_C,
31630 +  BFD_RELOC_16C_DISP24,
31631 +  BFD_RELOC_16C_DISP24_C,
31632 +  BFD_RELOC_16C_DISP24a,
31633 +  BFD_RELOC_16C_DISP24a_C,
31634 +  BFD_RELOC_16C_REG04,
31635 +  BFD_RELOC_16C_REG04_C,
31636 +  BFD_RELOC_16C_REG04a,
31637 +  BFD_RELOC_16C_REG04a_C,
31638 +  BFD_RELOC_16C_REG14,
31639 +  BFD_RELOC_16C_REG14_C,
31640 +  BFD_RELOC_16C_REG16,
31641 +  BFD_RELOC_16C_REG16_C,
31642 +  BFD_RELOC_16C_REG20,
31643 +  BFD_RELOC_16C_REG20_C,
31644 +  BFD_RELOC_16C_ABS20,
31645 +  BFD_RELOC_16C_ABS20_C,
31646 +  BFD_RELOC_16C_ABS24,
31647 +  BFD_RELOC_16C_ABS24_C,
31648 +  BFD_RELOC_16C_IMM04,
31649 +  BFD_RELOC_16C_IMM04_C,
31650 +  BFD_RELOC_16C_IMM16,
31651 +  BFD_RELOC_16C_IMM16_C,
31652 +  BFD_RELOC_16C_IMM20,
31653 +  BFD_RELOC_16C_IMM20_C,
31654 +  BFD_RELOC_16C_IMM24,
31655 +  BFD_RELOC_16C_IMM24_C,
31656 +  BFD_RELOC_16C_IMM32,
31657 +  BFD_RELOC_16C_IMM32_C,
31658 +
31659 +/* NS CRX Relocations.  */
31660 +  BFD_RELOC_CRX_REL4,
31661 +  BFD_RELOC_CRX_REL8,
31662 +  BFD_RELOC_CRX_REL8_CMP,
31663 +  BFD_RELOC_CRX_REL16,
31664 +  BFD_RELOC_CRX_REL24,
31665 +  BFD_RELOC_CRX_REL32,
31666 +  BFD_RELOC_CRX_REGREL12,
31667 +  BFD_RELOC_CRX_REGREL22,
31668 +  BFD_RELOC_CRX_REGREL28,
31669 +  BFD_RELOC_CRX_REGREL32,
31670 +  BFD_RELOC_CRX_ABS16,
31671 +  BFD_RELOC_CRX_ABS32,
31672 +  BFD_RELOC_CRX_NUM8,
31673 +  BFD_RELOC_CRX_NUM16,
31674 +  BFD_RELOC_CRX_NUM32,
31675 +  BFD_RELOC_CRX_IMM16,
31676 +  BFD_RELOC_CRX_IMM32,
31677 +  BFD_RELOC_CRX_SWITCH8,
31678 +  BFD_RELOC_CRX_SWITCH16,
31679 +  BFD_RELOC_CRX_SWITCH32,
31680 +
31681 +/* These relocs are only used within the CRIS assembler.  They are not
31682 +(at present) written to any object files.  */
31683 +  BFD_RELOC_CRIS_BDISP8,
31684 +  BFD_RELOC_CRIS_UNSIGNED_5,
31685 +  BFD_RELOC_CRIS_SIGNED_6,
31686 +  BFD_RELOC_CRIS_UNSIGNED_6,
31687 +  BFD_RELOC_CRIS_SIGNED_8,
31688 +  BFD_RELOC_CRIS_UNSIGNED_8,
31689 +  BFD_RELOC_CRIS_SIGNED_16,
31690 +  BFD_RELOC_CRIS_UNSIGNED_16,
31691 +  BFD_RELOC_CRIS_LAPCQ_OFFSET,
31692 +  BFD_RELOC_CRIS_UNSIGNED_4,
31693 +
31694 +/* Relocs used in ELF shared libraries for CRIS.  */
31695 +  BFD_RELOC_CRIS_COPY,
31696 +  BFD_RELOC_CRIS_GLOB_DAT,
31697 +  BFD_RELOC_CRIS_JUMP_SLOT,
31698 +  BFD_RELOC_CRIS_RELATIVE,
31699 +
31700 +/* 32-bit offset to symbol-entry within GOT.  */
31701 +  BFD_RELOC_CRIS_32_GOT,
31702 +
31703 +/* 16-bit offset to symbol-entry within GOT.  */
31704 +  BFD_RELOC_CRIS_16_GOT,
31705 +
31706 +/* 32-bit offset to symbol-entry within GOT, with PLT handling.  */
31707 +  BFD_RELOC_CRIS_32_GOTPLT,
31708 +
31709 +/* 16-bit offset to symbol-entry within GOT, with PLT handling.  */
31710 +  BFD_RELOC_CRIS_16_GOTPLT,
31711 +
31712 +/* 32-bit offset to symbol, relative to GOT.  */
31713 +  BFD_RELOC_CRIS_32_GOTREL,
31714 +
31715 +/* 32-bit offset to symbol with PLT entry, relative to GOT.  */
31716 +  BFD_RELOC_CRIS_32_PLT_GOTREL,
31717 +
31718 +/* 32-bit offset to symbol with PLT entry, relative to this relocation.  */
31719 +  BFD_RELOC_CRIS_32_PLT_PCREL,
31720 +
31721 +/* Intel i860 Relocations.  */
31722 +  BFD_RELOC_860_COPY,
31723 +  BFD_RELOC_860_GLOB_DAT,
31724 +  BFD_RELOC_860_JUMP_SLOT,
31725 +  BFD_RELOC_860_RELATIVE,
31726 +  BFD_RELOC_860_PC26,
31727 +  BFD_RELOC_860_PLT26,
31728 +  BFD_RELOC_860_PC16,
31729 +  BFD_RELOC_860_LOW0,
31730 +  BFD_RELOC_860_SPLIT0,
31731 +  BFD_RELOC_860_LOW1,
31732 +  BFD_RELOC_860_SPLIT1,
31733 +  BFD_RELOC_860_LOW2,
31734 +  BFD_RELOC_860_SPLIT2,
31735 +  BFD_RELOC_860_LOW3,
31736 +  BFD_RELOC_860_LOGOT0,
31737 +  BFD_RELOC_860_SPGOT0,
31738 +  BFD_RELOC_860_LOGOT1,
31739 +  BFD_RELOC_860_SPGOT1,
31740 +  BFD_RELOC_860_LOGOTOFF0,
31741 +  BFD_RELOC_860_SPGOTOFF0,
31742 +  BFD_RELOC_860_LOGOTOFF1,
31743 +  BFD_RELOC_860_SPGOTOFF1,
31744 +  BFD_RELOC_860_LOGOTOFF2,
31745 +  BFD_RELOC_860_LOGOTOFF3,
31746 +  BFD_RELOC_860_LOPC,
31747 +  BFD_RELOC_860_HIGHADJ,
31748 +  BFD_RELOC_860_HAGOT,
31749 +  BFD_RELOC_860_HAGOTOFF,
31750 +  BFD_RELOC_860_HAPC,
31751 +  BFD_RELOC_860_HIGH,
31752 +  BFD_RELOC_860_HIGOT,
31753 +  BFD_RELOC_860_HIGOTOFF,
31754 +
31755 +/* OpenRISC Relocations.  */
31756 +  BFD_RELOC_OPENRISC_ABS_26,
31757 +  BFD_RELOC_OPENRISC_REL_26,
31758 +
31759 +/* H8 elf Relocations.  */
31760 +  BFD_RELOC_H8_DIR16A8,
31761 +  BFD_RELOC_H8_DIR16R8,
31762 +  BFD_RELOC_H8_DIR24A8,
31763 +  BFD_RELOC_H8_DIR24R8,
31764 +  BFD_RELOC_H8_DIR32A16,
31765 +
31766 +/* Sony Xstormy16 Relocations.  */
31767 +  BFD_RELOC_XSTORMY16_REL_12,
31768 +  BFD_RELOC_XSTORMY16_12,
31769 +  BFD_RELOC_XSTORMY16_24,
31770 +  BFD_RELOC_XSTORMY16_FPTR16,
31771 +
31772 +/* Relocations used by VAX ELF.  */
31773 +  BFD_RELOC_VAX_GLOB_DAT,
31774 +  BFD_RELOC_VAX_JMP_SLOT,
31775 +  BFD_RELOC_VAX_RELATIVE,
31776 +
31777 +/* Morpho MS1 - 16 bit immediate relocation.  */
31778 +  BFD_RELOC_MS1_PC16,
31779 +
31780 +/* Morpho MS1 - Hi 16 bits of an address.  */
31781 +  BFD_RELOC_MS1_HI16,
31782 +
31783 +/* Morpho MS1 - Low 16 bits of an address.  */
31784 +  BFD_RELOC_MS1_LO16,
31785 +
31786 +/* Morpho MS1 - Used to tell the linker which vtable entries are used.  */
31787 +  BFD_RELOC_MS1_GNU_VTINHERIT,
31788 +
31789 +/* Morpho MS1 - Used to tell the linker which vtable entries are used.  */
31790 +  BFD_RELOC_MS1_GNU_VTENTRY,
31791 +
31792 +/* msp430 specific relocation codes  */
31793 +  BFD_RELOC_MSP430_10_PCREL,
31794 +  BFD_RELOC_MSP430_16_PCREL,
31795 +  BFD_RELOC_MSP430_16,
31796 +  BFD_RELOC_MSP430_16_PCREL_BYTE,
31797 +  BFD_RELOC_MSP430_16_BYTE,
31798 +  BFD_RELOC_MSP430_2X_PCREL,
31799 +  BFD_RELOC_MSP430_RL_PCREL,
31800 +
31801 +/* IQ2000 Relocations.  */
31802 +  BFD_RELOC_IQ2000_OFFSET_16,
31803 +  BFD_RELOC_IQ2000_OFFSET_21,
31804 +  BFD_RELOC_IQ2000_UHI16,
31805 +
31806 +/* Special Xtensa relocation used only by PLT entries in ELF shared
31807 +objects to indicate that the runtime linker should set the value
31808 +to one of its own internal functions or data structures.  */
31809 +  BFD_RELOC_XTENSA_RTLD,
31810 +
31811 +/* Xtensa relocations for ELF shared objects.  */
31812 +  BFD_RELOC_XTENSA_GLOB_DAT,
31813 +  BFD_RELOC_XTENSA_JMP_SLOT,
31814 +  BFD_RELOC_XTENSA_RELATIVE,
31815 +
31816 +/* Xtensa relocation used in ELF object files for symbols that may require
31817 +PLT entries.  Otherwise, this is just a generic 32-bit relocation.  */
31818 +  BFD_RELOC_XTENSA_PLT,
31819 +
31820 +/* Xtensa relocations to mark the difference of two local symbols.
31821 +These are only needed to support linker relaxation and can be ignored
31822 +when not relaxing.  The field is set to the value of the difference
31823 +assuming no relaxation.  The relocation encodes the position of the
31824 +first symbol so the linker can determine whether to adjust the field
31825 +value.  */
31826 +  BFD_RELOC_XTENSA_DIFF8,
31827 +  BFD_RELOC_XTENSA_DIFF16,
31828 +  BFD_RELOC_XTENSA_DIFF32,
31829 +
31830 +/* Generic Xtensa relocations for instruction operands.  Only the slot
31831 +number is encoded in the relocation.  The relocation applies to the
31832 +last PC-relative immediate operand, or if there are no PC-relative
31833 +immediates, to the last immediate operand.  */
31834 +  BFD_RELOC_XTENSA_SLOT0_OP,
31835 +  BFD_RELOC_XTENSA_SLOT1_OP,
31836 +  BFD_RELOC_XTENSA_SLOT2_OP,
31837 +  BFD_RELOC_XTENSA_SLOT3_OP,
31838 +  BFD_RELOC_XTENSA_SLOT4_OP,
31839 +  BFD_RELOC_XTENSA_SLOT5_OP,
31840 +  BFD_RELOC_XTENSA_SLOT6_OP,
31841 +  BFD_RELOC_XTENSA_SLOT7_OP,
31842 +  BFD_RELOC_XTENSA_SLOT8_OP,
31843 +  BFD_RELOC_XTENSA_SLOT9_OP,
31844 +  BFD_RELOC_XTENSA_SLOT10_OP,
31845 +  BFD_RELOC_XTENSA_SLOT11_OP,
31846 +  BFD_RELOC_XTENSA_SLOT12_OP,
31847 +  BFD_RELOC_XTENSA_SLOT13_OP,
31848 +  BFD_RELOC_XTENSA_SLOT14_OP,
31849 +
31850 +/* Alternate Xtensa relocations.  Only the slot is encoded in the
31851 +relocation.  The meaning of these relocations is opcode-specific.  */
31852 +  BFD_RELOC_XTENSA_SLOT0_ALT,
31853 +  BFD_RELOC_XTENSA_SLOT1_ALT,
31854 +  BFD_RELOC_XTENSA_SLOT2_ALT,
31855 +  BFD_RELOC_XTENSA_SLOT3_ALT,
31856 +  BFD_RELOC_XTENSA_SLOT4_ALT,
31857 +  BFD_RELOC_XTENSA_SLOT5_ALT,
31858 +  BFD_RELOC_XTENSA_SLOT6_ALT,
31859 +  BFD_RELOC_XTENSA_SLOT7_ALT,
31860 +  BFD_RELOC_XTENSA_SLOT8_ALT,
31861 +  BFD_RELOC_XTENSA_SLOT9_ALT,
31862 +  BFD_RELOC_XTENSA_SLOT10_ALT,
31863 +  BFD_RELOC_XTENSA_SLOT11_ALT,
31864 +  BFD_RELOC_XTENSA_SLOT12_ALT,
31865 +  BFD_RELOC_XTENSA_SLOT13_ALT,
31866 +  BFD_RELOC_XTENSA_SLOT14_ALT,
31867 +
31868 +/* Xtensa relocations for backward compatibility.  These have all been
31869 +replaced by BFD_RELOC_XTENSA_SLOT0_OP.  */
31870 +  BFD_RELOC_XTENSA_OP0,
31871 +  BFD_RELOC_XTENSA_OP1,
31872 +  BFD_RELOC_XTENSA_OP2,
31873 +
31874 +/* Xtensa relocation to mark that the assembler expanded the
31875 +instructions from an original target.  The expansion size is
31876 +encoded in the reloc size.  */
31877 +  BFD_RELOC_XTENSA_ASM_EXPAND,
31878 +
31879 +/* Xtensa relocation to mark that the linker should simplify
31880 +assembler-expanded instructions.  This is commonly used
31881 +internally by the linker after analysis of a
31882 +BFD_RELOC_XTENSA_ASM_EXPAND.  */
31883 +  BFD_RELOC_XTENSA_ASM_SIMPLIFY,
31884 +  BFD_RELOC_UNUSED };
31885 +typedef enum bfd_reloc_code_real bfd_reloc_code_real_type;
31886 +reloc_howto_type *bfd_reloc_type_lookup
31887 +   (bfd *abfd, bfd_reloc_code_real_type code);
31888 +
31889 +const char *bfd_get_reloc_code_name (bfd_reloc_code_real_type code);
31890 +
31891 +/* Extracted from syms.c.  */
31892 +
31893 +typedef struct bfd_symbol
31894 +{
31895 +  /* A pointer to the BFD which owns the symbol. This information
31896 +     is necessary so that a back end can work out what additional
31897 +     information (invisible to the application writer) is carried
31898 +     with the symbol.
31899 +
31900 +     This field is *almost* redundant, since you can use section->owner
31901 +     instead, except that some symbols point to the global sections
31902 +     bfd_{abs,com,und}_section.  This could be fixed by making
31903 +     these globals be per-bfd (or per-target-flavor).  FIXME.  */
31904 +  struct bfd *the_bfd; /* Use bfd_asymbol_bfd(sym) to access this field.  */
31905 +
31906 +  /* The text of the symbol. The name is left alone, and not copied; the
31907 +     application may not alter it.  */
31908 +  const char *name;
31909 +
31910 +  /* The value of the symbol.  This really should be a union of a
31911 +     numeric value with a pointer, since some flags indicate that
31912 +     a pointer to another symbol is stored here.  */
31913 +  symvalue value;
31914 +
31915 +  /* Attributes of a symbol.  */
31916 +#define BSF_NO_FLAGS    0x00
31917 +
31918 +  /* The symbol has local scope; <<static>> in <<C>>. The value
31919 +     is the offset into the section of the data.  */
31920 +#define BSF_LOCAL      0x01
31921 +
31922 +  /* The symbol has global scope; initialized data in <<C>>. The
31923 +     value is the offset into the section of the data.  */
31924 +#define BSF_GLOBAL     0x02
31925 +
31926 +  /* The symbol has global scope and is exported. The value is
31927 +     the offset into the section of the data.  */
31928 +#define BSF_EXPORT     BSF_GLOBAL /* No real difference.  */
31929 +
31930 +  /* A normal C symbol would be one of:
31931 +     <<BSF_LOCAL>>, <<BSF_FORT_COMM>>,  <<BSF_UNDEFINED>> or
31932 +     <<BSF_GLOBAL>>.  */
31933 +
31934 +  /* The symbol is a debugging record. The value has an arbitrary
31935 +     meaning, unless BSF_DEBUGGING_RELOC is also set.  */
31936 +#define BSF_DEBUGGING  0x08
31937 +
31938 +  /* The symbol denotes a function entry point.  Used in ELF,
31939 +     perhaps others someday.  */
31940 +#define BSF_FUNCTION    0x10
31941 +
31942 +  /* Used by the linker.  */
31943 +#define BSF_KEEP        0x20
31944 +#define BSF_KEEP_G      0x40
31945 +
31946 +  /* A weak global symbol, overridable without warnings by
31947 +     a regular global symbol of the same name.  */
31948 +#define BSF_WEAK        0x80
31949 +
31950 +  /* This symbol was created to point to a section, e.g. ELF's
31951 +     STT_SECTION symbols.  */
31952 +#define BSF_SECTION_SYM 0x100
31953 +
31954 +  /* The symbol used to be a common symbol, but now it is
31955 +     allocated.  */
31956 +#define BSF_OLD_COMMON  0x200
31957 +
31958 +  /* The default value for common data.  */
31959 +#define BFD_FORT_COMM_DEFAULT_VALUE 0
31960 +
31961 +  /* In some files the type of a symbol sometimes alters its
31962 +     location in an output file - ie in coff a <<ISFCN>> symbol
31963 +     which is also <<C_EXT>> symbol appears where it was
31964 +     declared and not at the end of a section.  This bit is set
31965 +     by the target BFD part to convey this information.  */
31966 +#define BSF_NOT_AT_END    0x400
31967 +
31968 +  /* Signal that the symbol is the label of constructor section.  */
31969 +#define BSF_CONSTRUCTOR   0x800
31970 +
31971 +  /* Signal that the symbol is a warning symbol.  The name is a
31972 +     warning.  The name of the next symbol is the one to warn about;
31973 +     if a reference is made to a symbol with the same name as the next
31974 +     symbol, a warning is issued by the linker.  */
31975 +#define BSF_WARNING       0x1000
31976 +
31977 +  /* Signal that the symbol is indirect.  This symbol is an indirect
31978 +     pointer to the symbol with the same name as the next symbol.  */
31979 +#define BSF_INDIRECT      0x2000
31980 +
31981 +  /* BSF_FILE marks symbols that contain a file name.  This is used
31982 +     for ELF STT_FILE symbols.  */
31983 +#define BSF_FILE          0x4000
31984 +
31985 +  /* Symbol is from dynamic linking information.  */
31986 +#define BSF_DYNAMIC       0x8000
31987 +
31988 +  /* The symbol denotes a data object.  Used in ELF, and perhaps
31989 +     others someday.  */
31990 +#define BSF_OBJECT        0x10000
31991 +
31992 +  /* This symbol is a debugging symbol.  The value is the offset
31993 +     into the section of the data.  BSF_DEBUGGING should be set
31994 +     as well.  */
31995 +#define BSF_DEBUGGING_RELOC 0x20000
31996 +
31997 +  /* This symbol is thread local.  Used in ELF.  */
31998 +#define BSF_THREAD_LOCAL  0x40000
31999 +
32000 +  flagword flags;
32001 +
32002 +  /* A pointer to the section to which this symbol is
32003 +     relative.  This will always be non NULL, there are special
32004 +     sections for undefined and absolute symbols.  */
32005 +  struct bfd_section *section;
32006 +
32007 +  /* Back end special data.  */
32008 +  union
32009 +    {
32010 +      void *p;
32011 +      bfd_vma i;
32012 +    }
32013 +  udata;
32014 +}
32015 +asymbol;
32016 +
32017 +#define bfd_get_symtab_upper_bound(abfd) \
32018 +     BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
32019 +
32020 +bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);
32021 +
32022 +bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);
32023 +
32024 +#define bfd_is_local_label_name(abfd, name) \
32025 +  BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
32026 +
32027 +bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
32028 +
32029 +#define bfd_is_target_special_symbol(abfd, sym) \
32030 +  BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))
32031 +
32032 +#define bfd_canonicalize_symtab(abfd, location) \
32033 +  BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
32034 +
32035 +bfd_boolean bfd_set_symtab
32036 +   (bfd *abfd, asymbol **location, unsigned int count);
32037 +
32038 +void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
32039 +
32040 +#define bfd_make_empty_symbol(abfd) \
32041 +  BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
32042 +
32043 +asymbol *_bfd_generic_make_empty_symbol (bfd *);
32044 +
32045 +#define bfd_make_debug_symbol(abfd,ptr,size) \
32046 +  BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
32047 +
32048 +int bfd_decode_symclass (asymbol *symbol);
32049 +
32050 +bfd_boolean bfd_is_undefined_symclass (int symclass);
32051 +
32052 +void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
32053 +
32054 +bfd_boolean bfd_copy_private_symbol_data
32055 +   (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
32056 +
32057 +#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
32058 +  BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
32059 +            (ibfd, isymbol, obfd, osymbol))
32060 +
32061 +/* Extracted from bfd.c.  */
32062 +struct bfd
32063 +{
32064 +  /* A unique identifier of the BFD  */
32065 +  unsigned int id;
32066 +
32067 +  /* The filename the application opened the BFD with.  */
32068 +  const char *filename;
32069 +
32070 +  /* A pointer to the target jump table.  */
32071 +  const struct bfd_target *xvec;
32072 +
32073 +  /* The IOSTREAM, and corresponding IO vector that provide access
32074 +     to the file backing the BFD.  */
32075 +  void *iostream;
32076 +  const struct bfd_iovec *iovec;
32077 +
32078 +  /* Is the file descriptor being cached?  That is, can it be closed as
32079 +     needed, and re-opened when accessed later?  */
32080 +  bfd_boolean cacheable;
32081 +
32082 +  /* Marks whether there was a default target specified when the
32083 +     BFD was opened. This is used to select which matching algorithm
32084 +     to use to choose the back end.  */
32085 +  bfd_boolean target_defaulted;
32086 +
32087 +  /* The caching routines use these to maintain a
32088 +     least-recently-used list of BFDs.  */
32089 +  struct bfd *lru_prev, *lru_next;
32090 +
32091 +  /* When a file is closed by the caching routines, BFD retains
32092 +     state information on the file here...  */
32093 +  ufile_ptr where;
32094 +
32095 +  /* ... and here: (``once'' means at least once).  */
32096 +  bfd_boolean opened_once;
32097 +
32098 +  /* Set if we have a locally maintained mtime value, rather than
32099 +     getting it from the file each time.  */
32100 +  bfd_boolean mtime_set;
32101 +
32102 +  /* File modified time, if mtime_set is TRUE.  */
32103 +  long mtime;
32104 +
32105 +  /* Reserved for an unimplemented file locking extension.  */
32106 +  int ifd;
32107 +
32108 +  /* The format which belongs to the BFD. (object, core, etc.)  */
32109 +  bfd_format format;
32110 +
32111 +  /* The direction with which the BFD was opened.  */
32112 +  enum bfd_direction
32113 +    {
32114 +      no_direction = 0,
32115 +      read_direction = 1,
32116 +      write_direction = 2,
32117 +      both_direction = 3
32118 +    }
32119 +  direction;
32120 +
32121 +  /* Format_specific flags.  */
32122 +  flagword flags;
32123 +
32124 +  /* Currently my_archive is tested before adding origin to
32125 +     anything. I believe that this can become always an add of
32126 +     origin, with origin set to 0 for non archive files.  */
32127 +  ufile_ptr origin;
32128 +
32129 +  /* Remember when output has begun, to stop strange things
32130 +     from happening.  */
32131 +  bfd_boolean output_has_begun;
32132 +
32133 +  /* A hash table for section names.  */
32134 +  struct bfd_hash_table section_htab;
32135 +
32136 +  /* Pointer to linked list of sections.  */
32137 +  struct bfd_section *sections;
32138 +
32139 +  /* The last section on the section list.  */
32140 +  struct bfd_section *section_last;
32141 +
32142 +  /* The number of sections.  */
32143 +  unsigned int section_count;
32144 +
32145 +  /* Stuff only useful for object files:
32146 +     The start address.  */
32147 +  bfd_vma start_address;
32148 +
32149 +  /* Used for input and output.  */
32150 +  unsigned int symcount;
32151 +
32152 +  /* Symbol table for output BFD (with symcount entries).  */
32153 +  struct bfd_symbol  **outsymbols;
32154 +
32155 +  /* Used for slurped dynamic symbol tables.  */
32156 +  unsigned int dynsymcount;
32157 +
32158 +  /* Pointer to structure which contains architecture information.  */
32159 +  const struct bfd_arch_info *arch_info;
32160 +
32161 +  /* Flag set if symbols from this BFD should not be exported.  */
32162 +  bfd_boolean no_export;
32163 +
32164 +  /* Stuff only useful for archives.  */
32165 +  void *arelt_data;
32166 +  struct bfd *my_archive;      /* The containing archive BFD.  */
32167 +  struct bfd *next;            /* The next BFD in the archive.  */
32168 +  struct bfd *archive_head;    /* The first BFD in the archive.  */
32169 +  bfd_boolean has_armap;
32170 +
32171 +  /* A chain of BFD structures involved in a link.  */
32172 +  struct bfd *link_next;
32173 +
32174 +  /* A field used by _bfd_generic_link_add_archive_symbols.  This will
32175 +     be used only for archive elements.  */
32176 +  int archive_pass;
32177 +
32178 +  /* Used by the back end to hold private data.  */
32179 +  union
32180 +    {
32181 +      struct aout_data_struct *aout_data;
32182 +      struct artdata *aout_ar_data;
32183 +      struct _oasys_data *oasys_obj_data;
32184 +      struct _oasys_ar_data *oasys_ar_data;
32185 +      struct coff_tdata *coff_obj_data;
32186 +      struct pe_tdata *pe_obj_data;
32187 +      struct xcoff_tdata *xcoff_obj_data;
32188 +      struct ecoff_tdata *ecoff_obj_data;
32189 +      struct ieee_data_struct *ieee_data;
32190 +      struct ieee_ar_data_struct *ieee_ar_data;
32191 +      struct srec_data_struct *srec_data;
32192 +      struct ihex_data_struct *ihex_data;
32193 +      struct tekhex_data_struct *tekhex_data;
32194 +      struct elf_obj_tdata *elf_obj_data;
32195 +      struct nlm_obj_tdata *nlm_obj_data;
32196 +      struct bout_data_struct *bout_data;
32197 +      struct mmo_data_struct *mmo_data;
32198 +      struct sun_core_struct *sun_core_data;
32199 +      struct sco5_core_struct *sco5_core_data;
32200 +      struct trad_core_struct *trad_core_data;
32201 +      struct som_data_struct *som_data;
32202 +      struct hpux_core_struct *hpux_core_data;
32203 +      struct hppabsd_core_struct *hppabsd_core_data;
32204 +      struct sgi_core_struct *sgi_core_data;
32205 +      struct lynx_core_struct *lynx_core_data;
32206 +      struct osf_core_struct *osf_core_data;
32207 +      struct cisco_core_struct *cisco_core_data;
32208 +      struct versados_data_struct *versados_data;
32209 +      struct netbsd_core_struct *netbsd_core_data;
32210 +      struct mach_o_data_struct *mach_o_data;
32211 +      struct mach_o_fat_data_struct *mach_o_fat_data;
32212 +      struct bfd_pef_data_struct *pef_data;
32213 +      struct bfd_pef_xlib_data_struct *pef_xlib_data;
32214 +      struct bfd_sym_data_struct *sym_data;
32215 +      void *any;
32216 +    }
32217 +  tdata;
32218 +
32219 +  /* Used by the application to hold private data.  */
32220 +  void *usrdata;
32221 +
32222 +  /* Where all the allocated stuff under this BFD goes.  This is a
32223 +     struct objalloc *, but we use void * to avoid requiring the inclusion
32224 +     of objalloc.h.  */
32225 +  void *memory;
32226 +};
32227 +
32228 +typedef enum bfd_error
32229 +{
32230 +  bfd_error_no_error = 0,
32231 +  bfd_error_system_call,
32232 +  bfd_error_invalid_target,
32233 +  bfd_error_wrong_format,
32234 +  bfd_error_wrong_object_format,
32235 +  bfd_error_invalid_operation,
32236 +  bfd_error_no_memory,
32237 +  bfd_error_no_symbols,
32238 +  bfd_error_no_armap,
32239 +  bfd_error_no_more_archived_files,
32240 +  bfd_error_malformed_archive,
32241 +  bfd_error_file_not_recognized,
32242 +  bfd_error_file_ambiguously_recognized,
32243 +  bfd_error_no_contents,
32244 +  bfd_error_nonrepresentable_section,
32245 +  bfd_error_no_debug_section,
32246 +  bfd_error_bad_value,
32247 +  bfd_error_file_truncated,
32248 +  bfd_error_file_too_big,
32249 +  bfd_error_invalid_error_code
32250 +}
32251 +bfd_error_type;
32252 +
32253 +bfd_error_type bfd_get_error (void);
32254 +
32255 +void bfd_set_error (bfd_error_type error_tag);
32256 +
32257 +const char *bfd_errmsg (bfd_error_type error_tag);
32258 +
32259 +void bfd_perror (const char *message);
32260 +
32261 +typedef void (*bfd_error_handler_type) (const char *, ...);
32262 +
32263 +bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type);
32264 +
32265 +void bfd_set_error_program_name (const char *);
32266 +
32267 +bfd_error_handler_type bfd_get_error_handler (void);
32268 +
32269 +long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect);
32270 +
32271 +long bfd_canonicalize_reloc
32272 +   (bfd *abfd, asection *sec, arelent **loc, asymbol **syms);
32273 +
32274 +void bfd_set_reloc
32275 +   (bfd *abfd, asection *sec, arelent **rel, unsigned int count);
32276 +
32277 +bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags);
32278 +
32279 +int bfd_get_arch_size (bfd *abfd);
32280 +
32281 +int bfd_get_sign_extend_vma (bfd *abfd);
32282 +
32283 +bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
32284 +
32285 +unsigned int bfd_get_gp_size (bfd *abfd);
32286 +
32287 +void bfd_set_gp_size (bfd *abfd, unsigned int i);
32288 +
32289 +bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
32290 +
32291 +bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
32292 +
32293 +#define bfd_copy_private_header_data(ibfd, obfd) \
32294 +     BFD_SEND (obfd, _bfd_copy_private_header_data, \
32295 +               (ibfd, obfd))
32296 +bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
32297 +
32298 +#define bfd_copy_private_bfd_data(ibfd, obfd) \
32299 +     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
32300 +               (ibfd, obfd))
32301 +bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);
32302 +
32303 +#define bfd_merge_private_bfd_data(ibfd, obfd) \
32304 +     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
32305 +               (ibfd, obfd))
32306 +bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
32307 +
32308 +#define bfd_set_private_flags(abfd, flags) \
32309 +     BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
32310 +#define bfd_sizeof_headers(abfd, reloc) \
32311 +       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc))
32312 +
32313 +#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
32314 +       BFD_SEND (abfd, _bfd_find_nearest_line, \
32315 +                 (abfd, sec, syms, off, file, func, line))
32316 +
32317 +#define bfd_find_line(abfd, syms, sym, file, line) \
32318 +       BFD_SEND (abfd, _bfd_find_line, \
32319 +                 (abfd, syms, sym, file, line))
32320 +
32321 +#define bfd_find_inliner_info(abfd, file, func, line) \
32322 +       BFD_SEND (abfd, _bfd_find_inliner_info, \
32323 +                 (abfd, file, func, line))
32324 +
32325 +#define bfd_debug_info_start(abfd) \
32326 +       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
32327 +
32328 +#define bfd_debug_info_end(abfd) \
32329 +       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
32330 +
32331 +#define bfd_debug_info_accumulate(abfd, section) \
32332 +       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
32333 +
32334 +#define bfd_stat_arch_elt(abfd, stat) \
32335 +       BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
32336 +
32337 +#define bfd_update_armap_timestamp(abfd) \
32338 +       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
32339 +
32340 +#define bfd_set_arch_mach(abfd, arch, mach)\
32341 +       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
32342 +
32343 +#define bfd_relax_section(abfd, section, link_info, again) \
32344 +       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
32345 +
32346 +#define bfd_gc_sections(abfd, link_info) \
32347 +       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
32348 +
32349 +#define bfd_merge_sections(abfd, link_info) \
32350 +       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
32351 +
32352 +#define bfd_is_group_section(abfd, sec) \
32353 +       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
32354 +
32355 +#define bfd_discard_group(abfd, sec) \
32356 +       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
32357 +
32358 +#define bfd_link_hash_table_create(abfd) \
32359 +       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
32360 +
32361 +#define bfd_link_hash_table_free(abfd, hash) \
32362 +       BFD_SEND (abfd, _bfd_link_hash_table_free, (hash))
32363 +
32364 +#define bfd_link_add_symbols(abfd, info) \
32365 +       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
32366 +
32367 +#define bfd_link_just_syms(abfd, sec, info) \
32368 +       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
32369 +
32370 +#define bfd_final_link(abfd, info) \
32371 +       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
32372 +
32373 +#define bfd_free_cached_info(abfd) \
32374 +       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
32375 +
32376 +#define bfd_get_dynamic_symtab_upper_bound(abfd) \
32377 +       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
32378 +
32379 +#define bfd_print_private_bfd_data(abfd, file)\
32380 +       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
32381 +
32382 +#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
32383 +       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
32384 +
32385 +#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
32386 +       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
32387 +                                                   dyncount, dynsyms, ret))
32388 +
32389 +#define bfd_get_dynamic_reloc_upper_bound(abfd) \
32390 +       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
32391 +
32392 +#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
32393 +       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
32394 +
32395 +extern bfd_byte *bfd_get_relocated_section_contents
32396 +  (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
32397 +   bfd_boolean, asymbol **);
32398 +
32399 +bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
32400 +
32401 +struct bfd_preserve
32402 +{
32403 +  void *marker;
32404 +  void *tdata;
32405 +  flagword flags;
32406 +  const struct bfd_arch_info *arch_info;
32407 +  struct bfd_section *sections;
32408 +  struct bfd_section *section_last;
32409 +  unsigned int section_count;
32410 +  struct bfd_hash_table section_htab;
32411 +};
32412 +
32413 +bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *);
32414 +
32415 +void bfd_preserve_restore (bfd *, struct bfd_preserve *);
32416 +
32417 +void bfd_preserve_finish (bfd *, struct bfd_preserve *);
32418 +
32419 +/* Extracted from archive.c.  */
32420 +symindex bfd_get_next_mapent
32421 +   (bfd *abfd, symindex previous, carsym **sym);
32422 +
32423 +bfd_boolean bfd_set_archive_head (bfd *output, bfd *new_head);
32424 +
32425 +bfd *bfd_openr_next_archived_file (bfd *archive, bfd *previous);
32426 +
32427 +/* Extracted from corefile.c.  */
32428 +const char *bfd_core_file_failing_command (bfd *abfd);
32429 +
32430 +int bfd_core_file_failing_signal (bfd *abfd);
32431 +
32432 +bfd_boolean core_file_matches_executable_p
32433 +   (bfd *core_bfd, bfd *exec_bfd);
32434 +
32435 +/* Extracted from targets.c.  */
32436 +#define BFD_SEND(bfd, message, arglist) \
32437 +  ((*((bfd)->xvec->message)) arglist)
32438 +
32439 +#ifdef DEBUG_BFD_SEND
32440 +#undef BFD_SEND
32441 +#define BFD_SEND(bfd, message, arglist) \
32442 +  (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
32443 +    ((*((bfd)->xvec->message)) arglist) : \
32444 +    (bfd_assert (__FILE__,__LINE__), NULL))
32445 +#endif
32446 +#define BFD_SEND_FMT(bfd, message, arglist) \
32447 +  (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist)
32448 +
32449 +#ifdef DEBUG_BFD_SEND
32450 +#undef BFD_SEND_FMT
32451 +#define BFD_SEND_FMT(bfd, message, arglist) \
32452 +  (((bfd) && (bfd)->xvec && (bfd)->xvec->message) ? \
32453 +   (((bfd)->xvec->message[(int) ((bfd)->format)]) arglist) : \
32454 +   (bfd_assert (__FILE__,__LINE__), NULL))
32455 +#endif
32456 +
32457 +enum bfd_flavour
32458 +{
32459 +  bfd_target_unknown_flavour,
32460 +  bfd_target_aout_flavour,
32461 +  bfd_target_coff_flavour,
32462 +  bfd_target_ecoff_flavour,
32463 +  bfd_target_xcoff_flavour,
32464 +  bfd_target_elf_flavour,
32465 +  bfd_target_ieee_flavour,
32466 +  bfd_target_nlm_flavour,
32467 +  bfd_target_oasys_flavour,
32468 +  bfd_target_tekhex_flavour,
32469 +  bfd_target_srec_flavour,
32470 +  bfd_target_ihex_flavour,
32471 +  bfd_target_som_flavour,
32472 +  bfd_target_os9k_flavour,
32473 +  bfd_target_versados_flavour,
32474 +  bfd_target_msdos_flavour,
32475 +  bfd_target_ovax_flavour,
32476 +  bfd_target_evax_flavour,
32477 +  bfd_target_mmo_flavour,
32478 +  bfd_target_mach_o_flavour,
32479 +  bfd_target_pef_flavour,
32480 +  bfd_target_pef_xlib_flavour,
32481 +  bfd_target_sym_flavour
32482 +};
32483 +
32484 +enum bfd_endian { BFD_ENDIAN_BIG, BFD_ENDIAN_LITTLE, BFD_ENDIAN_UNKNOWN };
32485 +
32486 +/* Forward declaration.  */
32487 +typedef struct bfd_link_info _bfd_link_info;
32488 +
32489 +typedef struct bfd_target
32490 +{
32491 +  /* Identifies the kind of target, e.g., SunOS4, Ultrix, etc.  */
32492 +  char *name;
32493 +
32494 + /* The "flavour" of a back end is a general indication about
32495 +    the contents of a file.  */
32496 +  enum bfd_flavour flavour;
32497 +
32498 +  /* The order of bytes within the data area of a file.  */
32499 +  enum bfd_endian byteorder;
32500 +
32501 + /* The order of bytes within the header parts of a file.  */
32502 +  enum bfd_endian header_byteorder;
32503 +
32504 +  /* A mask of all the flags which an executable may have set -
32505 +     from the set <<BFD_NO_FLAGS>>, <<HAS_RELOC>>, ...<<D_PAGED>>.  */
32506 +  flagword object_flags;
32507 +
32508 + /* A mask of all the flags which a section may have set - from
32509 +    the set <<SEC_NO_FLAGS>>, <<SEC_ALLOC>>, ...<<SET_NEVER_LOAD>>.  */
32510 +  flagword section_flags;
32511 +
32512 + /* The character normally found at the front of a symbol.
32513 +    (if any), perhaps `_'.  */
32514 +  char symbol_leading_char;
32515 +
32516 + /* The pad character for file names within an archive header.  */
32517 +  char ar_pad_char;
32518 +
32519 +  /* The maximum number of characters in an archive header.  */
32520 +  unsigned short ar_max_namelen;
32521 +
32522 +  /* Entries for byte swapping for data. These are different from the
32523 +     other entry points, since they don't take a BFD as the first argument.
32524 +     Certain other handlers could do the same.  */
32525 +  bfd_uint64_t   (*bfd_getx64) (const void *);
32526 +  bfd_int64_t    (*bfd_getx_signed_64) (const void *);
32527 +  void           (*bfd_putx64) (bfd_uint64_t, void *);
32528 +  bfd_vma        (*bfd_getx32) (const void *);
32529 +  bfd_signed_vma (*bfd_getx_signed_32) (const void *);
32530 +  void           (*bfd_putx32) (bfd_vma, void *);
32531 +  bfd_vma        (*bfd_getx16) (const void *);
32532 +  bfd_signed_vma (*bfd_getx_signed_16) (const void *);
32533 +  void           (*bfd_putx16) (bfd_vma, void *);
32534 +
32535 +  /* Byte swapping for the headers.  */
32536 +  bfd_uint64_t   (*bfd_h_getx64) (const void *);
32537 +  bfd_int64_t    (*bfd_h_getx_signed_64) (const void *);
32538 +  void           (*bfd_h_putx64) (bfd_uint64_t, void *);
32539 +  bfd_vma        (*bfd_h_getx32) (const void *);
32540 +  bfd_signed_vma (*bfd_h_getx_signed_32) (const void *);
32541 +  void           (*bfd_h_putx32) (bfd_vma, void *);
32542 +  bfd_vma        (*bfd_h_getx16) (const void *);
32543 +  bfd_signed_vma (*bfd_h_getx_signed_16) (const void *);
32544 +  void           (*bfd_h_putx16) (bfd_vma, void *);
32545 +
32546 +  /* Format dependent routines: these are vectors of entry points
32547 +     within the target vector structure, one for each format to check.  */
32548 +
32549 +  /* Check the format of a file being read.  Return a <<bfd_target *>> or zero.  */
32550 +  const struct bfd_target *(*_bfd_check_format[bfd_type_end]) (bfd *);
32551 +
32552 +  /* Set the format of a file being written.  */
32553 +  bfd_boolean (*_bfd_set_format[bfd_type_end]) (bfd *);
32554 +
32555 +  /* Write cached information into a file being written, at <<bfd_close>>.  */
32556 +  bfd_boolean (*_bfd_write_contents[bfd_type_end]) (bfd *);
32557 +
32558 +
32559 +  /* Generic entry points.  */
32560 +#define BFD_JUMP_TABLE_GENERIC(NAME) \
32561 +  NAME##_close_and_cleanup, \
32562 +  NAME##_bfd_free_cached_info, \
32563 +  NAME##_new_section_hook, \
32564 +  NAME##_get_section_contents, \
32565 +  NAME##_get_section_contents_in_window
32566 +
32567 +  /* Called when the BFD is being closed to do any necessary cleanup.  */
32568 +  bfd_boolean (*_close_and_cleanup) (bfd *);
32569 +  /* Ask the BFD to free all cached information.  */
32570 +  bfd_boolean (*_bfd_free_cached_info) (bfd *);
32571 +  /* Called when a new section is created.  */
32572 +  bfd_boolean (*_new_section_hook) (bfd *, sec_ptr);
32573 +  /* Read the contents of a section.  */
32574 +  bfd_boolean (*_bfd_get_section_contents)
32575 +    (bfd *, sec_ptr, void *, file_ptr, bfd_size_type);
32576 +  bfd_boolean (*_bfd_get_section_contents_in_window)
32577 +    (bfd *, sec_ptr, bfd_window *, file_ptr, bfd_size_type);
32578 +
32579 +  /* Entry points to copy private data.  */
32580 +#define BFD_JUMP_TABLE_COPY(NAME) \
32581 +  NAME##_bfd_copy_private_bfd_data, \
32582 +  NAME##_bfd_merge_private_bfd_data, \
32583 +  NAME##_bfd_copy_private_section_data, \
32584 +  NAME##_bfd_copy_private_symbol_data, \
32585 +  NAME##_bfd_copy_private_header_data, \
32586 +  NAME##_bfd_set_private_flags, \
32587 +  NAME##_bfd_print_private_bfd_data
32588 +
32589 +  /* Called to copy BFD general private data from one object file
32590 +     to another.  */
32591 +  bfd_boolean (*_bfd_copy_private_bfd_data) (bfd *, bfd *);
32592 +  /* Called to merge BFD general private data from one object file
32593 +     to a common output file when linking.  */
32594 +  bfd_boolean (*_bfd_merge_private_bfd_data) (bfd *, bfd *);
32595 +  /* Called to copy BFD private section data from one object file
32596 +     to another.  */
32597 +  bfd_boolean (*_bfd_copy_private_section_data)
32598 +    (bfd *, sec_ptr, bfd *, sec_ptr);
32599 +  /* Called to copy BFD private symbol data from one symbol
32600 +     to another.  */
32601 +  bfd_boolean (*_bfd_copy_private_symbol_data)
32602 +    (bfd *, asymbol *, bfd *, asymbol *);
32603 +  /* Called to copy BFD private header data from one object file
32604 +     to another.  */
32605 +  bfd_boolean (*_bfd_copy_private_header_data)
32606 +    (bfd *, bfd *);
32607 +  /* Called to set private backend flags.  */
32608 +  bfd_boolean (*_bfd_set_private_flags) (bfd *, flagword);
32609 +
32610 +  /* Called to print private BFD data.  */
32611 +  bfd_boolean (*_bfd_print_private_bfd_data) (bfd *, void *);
32612 +
32613 +  /* Core file entry points.  */
32614 +#define BFD_JUMP_TABLE_CORE(NAME) \
32615 +  NAME##_core_file_failing_command, \
32616 +  NAME##_core_file_failing_signal, \
32617 +  NAME##_core_file_matches_executable_p
32618 +
32619 +  char *      (*_core_file_failing_command) (bfd *);
32620 +  int         (*_core_file_failing_signal) (bfd *);
32621 +  bfd_boolean (*_core_file_matches_executable_p) (bfd *, bfd *);
32622 +
32623 +  /* Archive entry points.  */
32624 +#define BFD_JUMP_TABLE_ARCHIVE(NAME) \
32625 +  NAME##_slurp_armap, \
32626 +  NAME##_slurp_extended_name_table, \
32627 +  NAME##_construct_extended_name_table, \
32628 +  NAME##_truncate_arname, \
32629 +  NAME##_write_armap, \
32630 +  NAME##_read_ar_hdr, \
32631 +  NAME##_openr_next_archived_file, \
32632 +  NAME##_get_elt_at_index, \
32633 +  NAME##_generic_stat_arch_elt, \
32634 +  NAME##_update_armap_timestamp
32635 +
32636 +  bfd_boolean (*_bfd_slurp_armap) (bfd *);
32637 +  bfd_boolean (*_bfd_slurp_extended_name_table) (bfd *);
32638 +  bfd_boolean (*_bfd_construct_extended_name_table)
32639 +    (bfd *, char **, bfd_size_type *, const char **);
32640 +  void        (*_bfd_truncate_arname) (bfd *, const char *, char *);
32641 +  bfd_boolean (*write_armap)
32642 +    (bfd *, unsigned int, struct orl *, unsigned int, int);
32643 +  void *      (*_bfd_read_ar_hdr_fn) (bfd *);
32644 +  bfd *       (*openr_next_archived_file) (bfd *, bfd *);
32645 +#define bfd_get_elt_at_index(b,i) BFD_SEND (b, _bfd_get_elt_at_index, (b,i))
32646 +  bfd *       (*_bfd_get_elt_at_index) (bfd *, symindex);
32647 +  int         (*_bfd_stat_arch_elt) (bfd *, struct stat *);
32648 +  bfd_boolean (*_bfd_update_armap_timestamp) (bfd *);
32649 +
32650 +  /* Entry points used for symbols.  */
32651 +#define BFD_JUMP_TABLE_SYMBOLS(NAME) \
32652 +  NAME##_get_symtab_upper_bound, \
32653 +  NAME##_canonicalize_symtab, \
32654 +  NAME##_make_empty_symbol, \
32655 +  NAME##_print_symbol, \
32656 +  NAME##_get_symbol_info, \
32657 +  NAME##_bfd_is_local_label_name, \
32658 +  NAME##_bfd_is_target_special_symbol, \
32659 +  NAME##_get_lineno, \
32660 +  NAME##_find_nearest_line, \
32661 +  _bfd_generic_find_line, \
32662 +  NAME##_find_inliner_info, \
32663 +  NAME##_bfd_make_debug_symbol, \
32664 +  NAME##_read_minisymbols, \
32665 +  NAME##_minisymbol_to_symbol
32666 +
32667 +  long        (*_bfd_get_symtab_upper_bound) (bfd *);
32668 +  long        (*_bfd_canonicalize_symtab)
32669 +    (bfd *, struct bfd_symbol **);
32670 +  struct bfd_symbol *
32671 +              (*_bfd_make_empty_symbol) (bfd *);
32672 +  void        (*_bfd_print_symbol)
32673 +    (bfd *, void *, struct bfd_symbol *, bfd_print_symbol_type);
32674 +#define bfd_print_symbol(b,p,s,e) BFD_SEND (b, _bfd_print_symbol, (b,p,s,e))
32675 +  void        (*_bfd_get_symbol_info)
32676 +    (bfd *, struct bfd_symbol *, symbol_info *);
32677 +#define bfd_get_symbol_info(b,p,e) BFD_SEND (b, _bfd_get_symbol_info, (b,p,e))
32678 +  bfd_boolean (*_bfd_is_local_label_name) (bfd *, const char *);
32679 +  bfd_boolean (*_bfd_is_target_special_symbol) (bfd *, asymbol *);
32680 +  alent *     (*_get_lineno) (bfd *, struct bfd_symbol *);
32681 +  bfd_boolean (*_bfd_find_nearest_line)
32682 +    (bfd *, struct bfd_section *, struct bfd_symbol **, bfd_vma,
32683 +     const char **, const char **, unsigned int *);
32684 +  bfd_boolean (*_bfd_find_line)
32685 +    (bfd *, struct bfd_symbol **, struct bfd_symbol *,
32686 +     const char **, unsigned int *);
32687 +  bfd_boolean (*_bfd_find_inliner_info)
32688 +    (bfd *, const char **, const char **, unsigned int *);
32689 + /* Back-door to allow format-aware applications to create debug symbols
32690 +    while using BFD for everything else.  Currently used by the assembler
32691 +    when creating COFF files.  */
32692 +  asymbol *   (*_bfd_make_debug_symbol)
32693 +    (bfd *, void *, unsigned long size);
32694 +#define bfd_read_minisymbols(b, d, m, s) \
32695 +  BFD_SEND (b, _read_minisymbols, (b, d, m, s))
32696 +  long        (*_read_minisymbols)
32697 +    (bfd *, bfd_boolean, void **, unsigned int *);
32698 +#define bfd_minisymbol_to_symbol(b, d, m, f) \
32699 +  BFD_SEND (b, _minisymbol_to_symbol, (b, d, m, f))
32700 +  asymbol *   (*_minisymbol_to_symbol)
32701 +    (bfd *, bfd_boolean, const void *, asymbol *);
32702 +
32703 +  /* Routines for relocs.  */
32704 +#define BFD_JUMP_TABLE_RELOCS(NAME) \
32705 +  NAME##_get_reloc_upper_bound, \
32706 +  NAME##_canonicalize_reloc, \
32707 +  NAME##_bfd_reloc_type_lookup
32708 +
32709 +  long        (*_get_reloc_upper_bound) (bfd *, sec_ptr);
32710 +  long        (*_bfd_canonicalize_reloc)
32711 +    (bfd *, sec_ptr, arelent **, struct bfd_symbol **);
32712 +  /* See documentation on reloc types.  */
32713 +  reloc_howto_type *
32714 +              (*reloc_type_lookup) (bfd *, bfd_reloc_code_real_type);
32715 +
32716 +  /* Routines used when writing an object file.  */
32717 +#define BFD_JUMP_TABLE_WRITE(NAME) \
32718 +  NAME##_set_arch_mach, \
32719 +  NAME##_set_section_contents
32720 +
32721 +  bfd_boolean (*_bfd_set_arch_mach)
32722 +    (bfd *, enum bfd_architecture, unsigned long);
32723 +  bfd_boolean (*_bfd_set_section_contents)
32724 +    (bfd *, sec_ptr, const void *, file_ptr, bfd_size_type);
32725 +
32726 +  /* Routines used by the linker.  */
32727 +#define BFD_JUMP_TABLE_LINK(NAME) \
32728 +  NAME##_sizeof_headers, \
32729 +  NAME##_bfd_get_relocated_section_contents, \
32730 +  NAME##_bfd_relax_section, \
32731 +  NAME##_bfd_link_hash_table_create, \
32732 +  NAME##_bfd_link_hash_table_free, \
32733 +  NAME##_bfd_link_add_symbols, \
32734 +  NAME##_bfd_link_just_syms, \
32735 +  NAME##_bfd_final_link, \
32736 +  NAME##_bfd_link_split_section, \
32737 +  NAME##_bfd_gc_sections, \
32738 +  NAME##_bfd_merge_sections, \
32739 +  NAME##_bfd_is_group_section, \
32740 +  NAME##_bfd_discard_group, \
32741 +  NAME##_section_already_linked \
32742 +
32743 +  int         (*_bfd_sizeof_headers) (bfd *, bfd_boolean);
32744 +  bfd_byte *  (*_bfd_get_relocated_section_contents)
32745 +    (bfd *, struct bfd_link_info *, struct bfd_link_order *,
32746 +     bfd_byte *, bfd_boolean, struct bfd_symbol **);
32747 +
32748 +  bfd_boolean (*_bfd_relax_section)
32749 +    (bfd *, struct bfd_section *, struct bfd_link_info *, bfd_boolean *);
32750 +
32751 +  /* Create a hash table for the linker.  Different backends store
32752 +     different information in this table.  */
32753 +  struct bfd_link_hash_table *
32754 +              (*_bfd_link_hash_table_create) (bfd *);
32755 +
32756 +  /* Release the memory associated with the linker hash table.  */
32757 +  void        (*_bfd_link_hash_table_free) (struct bfd_link_hash_table *);
32758 +
32759 +  /* Add symbols from this object file into the hash table.  */
32760 +  bfd_boolean (*_bfd_link_add_symbols) (bfd *, struct bfd_link_info *);
32761 +
32762 +  /* Indicate that we are only retrieving symbol values from this section.  */
32763 +  void        (*_bfd_link_just_syms) (asection *, struct bfd_link_info *);
32764 +
32765 +  /* Do a link based on the link_order structures attached to each
32766 +     section of the BFD.  */
32767 +  bfd_boolean (*_bfd_final_link) (bfd *, struct bfd_link_info *);
32768 +
32769 +  /* Should this section be split up into smaller pieces during linking.  */
32770 +  bfd_boolean (*_bfd_link_split_section) (bfd *, struct bfd_section *);
32771 +
32772 +  /* Remove sections that are not referenced from the output.  */
32773 +  bfd_boolean (*_bfd_gc_sections) (bfd *, struct bfd_link_info *);
32774 +
32775 +  /* Attempt to merge SEC_MERGE sections.  */
32776 +  bfd_boolean (*_bfd_merge_sections) (bfd *, struct bfd_link_info *);
32777 +
32778 +  /* Is this section a member of a group?  */
32779 +  bfd_boolean (*_bfd_is_group_section) (bfd *, const struct bfd_section *);
32780 +
32781 +  /* Discard members of a group.  */
32782 +  bfd_boolean (*_bfd_discard_group) (bfd *, struct bfd_section *);
32783 +
32784 +  /* Check if SEC has been already linked during a reloceatable or
32785 +     final link.  */
32786 +  void (*_section_already_linked) (bfd *, struct bfd_section *);
32787 +
32788 +  /* Routines to handle dynamic symbols and relocs.  */
32789 +#define BFD_JUMP_TABLE_DYNAMIC(NAME) \
32790 +  NAME##_get_dynamic_symtab_upper_bound, \
32791 +  NAME##_canonicalize_dynamic_symtab, \
32792 +  NAME##_get_synthetic_symtab, \
32793 +  NAME##_get_dynamic_reloc_upper_bound, \
32794 +  NAME##_canonicalize_dynamic_reloc
32795 +
32796 +  /* Get the amount of memory required to hold the dynamic symbols.  */
32797 +  long        (*_bfd_get_dynamic_symtab_upper_bound) (bfd *);
32798 +  /* Read in the dynamic symbols.  */
32799 +  long        (*_bfd_canonicalize_dynamic_symtab)
32800 +    (bfd *, struct bfd_symbol **);
32801 +  /* Create synthetized symbols.  */
32802 +  long        (*_bfd_get_synthetic_symtab)
32803 +    (bfd *, long, struct bfd_symbol **, long, struct bfd_symbol **,
32804 +     struct bfd_symbol **);
32805 +  /* Get the amount of memory required to hold the dynamic relocs.  */
32806 +  long        (*_bfd_get_dynamic_reloc_upper_bound) (bfd *);
32807 +  /* Read in the dynamic relocs.  */
32808 +  long        (*_bfd_canonicalize_dynamic_reloc)
32809 +    (bfd *, arelent **, struct bfd_symbol **);
32810 +
32811 +  /* Opposite endian version of this target.  */
32812 +  const struct bfd_target * alternative_target;
32813 +
32814 +  /* Data for use by back-end routines, which isn't
32815 +     generic enough to belong in this structure.  */
32816 +  const void *backend_data;
32817 +
32818 +} bfd_target;
32819 +
32820 +bfd_boolean bfd_set_default_target (const char *name);
32821 +
32822 +const bfd_target *bfd_find_target (const char *target_name, bfd *abfd);
32823 +
32824 +const char ** bfd_target_list (void);
32825 +
32826 +const bfd_target *bfd_search_for_target
32827 +   (int (*search_func) (const bfd_target *, void *),
32828 +    void *);
32829 +
32830 +/* Extracted from format.c.  */
32831 +bfd_boolean bfd_check_format (bfd *abfd, bfd_format format);
32832 +
32833 +bfd_boolean bfd_check_format_matches
32834 +   (bfd *abfd, bfd_format format, char ***matching);
32835 +
32836 +bfd_boolean bfd_set_format (bfd *abfd, bfd_format format);
32837 +
32838 +const char *bfd_format_string (bfd_format format);
32839 +
32840 +/* Extracted from linker.c.  */
32841 +bfd_boolean bfd_link_split_section (bfd *abfd, asection *sec);
32842 +
32843 +#define bfd_link_split_section(abfd, sec) \
32844 +       BFD_SEND (abfd, _bfd_link_split_section, (abfd, sec))
32845 +
32846 +void bfd_section_already_linked (bfd *abfd, asection *sec);
32847 +
32848 +#define bfd_section_already_linked(abfd, sec) \
32849 +       BFD_SEND (abfd, _section_already_linked, (abfd, sec))
32850 +
32851 +/* Extracted from simple.c.  */
32852 +bfd_byte *bfd_simple_get_relocated_section_contents
32853 +   (bfd *abfd, asection *sec, bfd_byte *outbuf, asymbol **symbol_table);
32854 +
32855 +#ifdef __cplusplus
32856 +}
32857 +#endif
32858 +#endif
32859 --- /dev/null
32860 +++ b/include/asm-x86/bfd.h
32861 @@ -0,0 +1,5 @@
32862 +#ifdef CONFIG_X86_32
32863 +# include "bfd_32.h"
32864 +#else
32865 +# include "bfd_64.h"
32866 +#endif
32867 --- a/include/asm-x86/irq_vectors.h
32868 +++ b/include/asm-x86/irq_vectors.h
32869 @@ -16,6 +16,7 @@
32870  #else
32871  # define IA32_SYSCALL_VECTOR   0x80
32872  #endif
32873 +#define KDBENTER_VECTOR        0x81
32874
32875  /*
32876   * Reserve the lowest usable priority level 0x20 - 0x2f for triggering
32877 @@ -65,6 +66,7 @@
32878  # define RESCHEDULE_VECTOR             0xfc
32879  # define CALL_FUNCTION_VECTOR          0xfb
32880  # define CALL_FUNCTION_SINGLE_VECTOR   0xfa
32881 +#define        KDB_VECTOR                      0xf9
32882  # define THERMAL_APIC_VECTOR           0xf0
32883
32884  #else
32885 @@ -77,6 +79,10 @@
32886  #define THERMAL_APIC_VECTOR            0xfa
32887  #define THRESHOLD_APIC_VECTOR          0xf9
32888  #define UV_BAU_MESSAGE                 0xf8
32889 +/* Overload KDB_VECTOR with UV_BAU_MESSAGE. By the time the UV hardware is
32890 + * ready, we should have moved to a dynamically allocated vector scheme.
32891 + */
32892 +#define KDB_VECTOR                     0xf8
32893  #define INVALIDATE_TLB_VECTOR_END      0xf7
32894  #define INVALIDATE_TLB_VECTOR_START    0xf0    /* f0-f7 used for TLB flush */
32895
32896 --- /dev/null
32897 +++ b/include/asm-x86/kdb.h
32898 @@ -0,0 +1,134 @@
32899 +#ifndef        _ASM_KDB_H
32900 +#define _ASM_KDB_H
32901 +
32902 +/*
32903 + * Kernel Debugger Architecture Dependent (x86) Global Headers
32904 + *
32905 + * This file is subject to the terms and conditions of the GNU General Public
32906 + * License.  See the file "COPYING" in the main directory of this archive
32907 + * for more details.
32908 + *
32909 + * Copyright (c) 1999-2008 Silicon Graphics, Inc.  All Rights Reserved.
32910 + */
32911 +
32912 +/*
32913 + * KDB_ENTER() is a macro which causes entry into the kernel
32914 + * debugger from any point in the kernel code stream.  If it
32915 + * is intended to be used from interrupt level, it must  use
32916 + * a non-maskable entry method. The vector is KDB_VECTOR,
32917 + * defined in hw_irq.h
32918 + */
32919 +#define KDB_ENTER()    do {if (kdb_on && !KDB_IS_RUNNING()) { asm("\tint $129\n"); }} while(0)
32920 +
32921 +/*
32922 + * Needed for exported symbols.
32923 + */
32924 +typedef unsigned long kdb_machreg_t;
32925 +
32926 +/*
32927 + * Per cpu arch specific kdb state.  Must be in range 0xff000000.
32928 + */
32929 +#define KDB_STATE_A_IF         0x01000000      /* Saved IF flag */
32930 +
32931 +
32932 +#ifdef CONFIG_X86_32
32933 +
32934 +#define kdb_machreg_fmt                "0x%lx"
32935 +#define kdb_machreg_fmt0       "0x%08lx"
32936 +#define kdb_bfd_vma_fmt                "0x%lx"
32937 +#define kdb_bfd_vma_fmt0       "0x%08lx"
32938 +#define kdb_elfw_addr_fmt      "0x%x"
32939 +#define kdb_elfw_addr_fmt0     "0x%08x"
32940 +
32941 +#else  /* CONFIG_X86_32 */
32942 +
32943 +#define kdb_machreg_fmt                "0x%lx"
32944 +#define kdb_machreg_fmt0       "0x%016lx"
32945 +#define kdb_bfd_vma_fmt                "0x%lx"
32946 +#define kdb_bfd_vma_fmt0       "0x%016lx"
32947 +#define kdb_elfw_addr_fmt      "0x%x"
32948 +#define kdb_elfw_addr_fmt0     "0x%016x"
32949 +
32950 +/*
32951 + * Functions to safely read and write kernel areas.  The {to,from}_xxx
32952 + * addresses are not necessarily valid, these functions must check for
32953 + * validity.  If the arch already supports get and put routines with
32954 + * suitable validation and/or recovery on invalid addresses then use
32955 + * those routines, otherwise check it yourself.
32956 + */
32957 +
32958 +/*
32959 + * asm-i386 uaccess.h supplies __copy_to_user which relies on MMU to
32960 + * trap invalid addresses in the _xxx fields.  Verify the other address
32961 + * of the pair is valid by accessing the first and last byte ourselves,
32962 + * then any access violations should only be caused by the _xxx
32963 + * addresses,
32964 + */
32965 +
32966 +#include <asm/uaccess.h>
32967 +
32968 +static inline int
32969 +__kdba_putarea_size(unsigned long to_xxx, void *from, size_t size)
32970 +{
32971 +       mm_segment_t oldfs = get_fs();
32972 +       int r;
32973 +       char c;
32974 +       c = *((volatile char *)from);
32975 +       c = *((volatile char *)from + size - 1);
32976 +
32977 +       if (to_xxx < PAGE_OFFSET) {
32978 +               return kdb_putuserarea_size(to_xxx, from, size);
32979 +       }
32980 +
32981 +       set_fs(KERNEL_DS);
32982 +       r = __copy_to_user_inatomic((void *)to_xxx, from, size);
32983 +       set_fs(oldfs);
32984 +       return r;
32985 +}
32986 +
32987 +static inline int
32988 +__kdba_getarea_size(void *to, unsigned long from_xxx, size_t size)
32989 +{
32990 +       mm_segment_t oldfs = get_fs();
32991 +       int r;
32992 +       *((volatile char *)to) = '\0';
32993 +       *((volatile char *)to + size - 1) = '\0';
32994 +
32995 +       if (from_xxx < PAGE_OFFSET) {
32996 +               return kdb_getuserarea_size(to, from_xxx, size);
32997 +       }
32998 +
32999 +       set_fs(KERNEL_DS);
33000 +       r = __copy_to_user_inatomic(to, (void *)from_xxx, size);
33001 +       set_fs(oldfs);
33002 +       return r;
33003 +}
33004 +
33005 +/* For numa with replicated code/data, the platform must supply its own
33006 + * kdba_putarea_size and kdba_getarea_size routines.  Without replication kdb
33007 + * uses the standard architecture routines.
33008 + */
33009 +#ifdef CONFIG_NUMA_REPLICATE
33010 +extern int kdba_putarea_size(unsigned long to_xxx, void *from, size_t size);
33011 +extern int kdba_getarea_size(void *to, unsigned long from_xxx, size_t size);
33012 +#else
33013 +#define kdba_putarea_size __kdba_putarea_size
33014 +#define kdba_getarea_size __kdba_getarea_size
33015 +#endif
33016 +
33017 +static inline int
33018 +kdba_verify_rw(unsigned long addr, size_t size)
33019 +{
33020 +       unsigned char data[size];
33021 +       return(kdba_getarea_size(data, addr, size) || kdba_putarea_size(addr, data, size));
33022 +}
33023 +
33024 +#endif /* !CONFIG_X86_32 */
33025 +
33026 +static inline unsigned long
33027 +kdba_funcptr_value(void *fp)
33028 +{
33029 +       return (unsigned long)fp;
33030 +}
33031 +
33032 +#endif /* !_ASM_KDB_H */
33033 --- /dev/null
33034 +++ b/include/asm-x86/kdbprivate.h
33035 @@ -0,0 +1,241 @@
33036 +#ifndef _ASM_KDBPRIVATE_H
33037 +#define _ASM_KDBPRIVATE_H
33038 +
33039 +/*
33040 + * Kernel Debugger Architecture Dependent (x86) Private Headers
33041 + *
33042 + * This file is subject to the terms and conditions of the GNU General Public
33043 + * License.  See the file "COPYING" in the main directory of this archive
33044 + * for more details.
33045 + *
33046 + * Copyright (c) 1999-2008 Silicon Graphics, Inc.  All Rights Reserved.
33047 + */
33048 +
33049 +typedef unsigned char kdb_machinst_t;
33050 +
33051 +/*
33052 + * KDB_MAXBPT describes the total number of breakpoints
33053 + * supported by this architecure.
33054 + */
33055 +#define KDB_MAXBPT     16
33056 +
33057 +/*
33058 + * KDB_MAXHARDBPT describes the total number of hardware
33059 + * breakpoint registers that exist.
33060 + */
33061 +#define KDB_MAXHARDBPT 4
33062 +
33063 +/* Maximum number of arguments to a function  */
33064 +#define KDBA_MAXARGS    16
33065 +
33066 +/*
33067 + * Support for ia32 debug registers
33068 + */
33069 +typedef struct _kdbhard_bp {
33070 +       kdb_machreg_t   bph_reg;        /* Register this breakpoint uses */
33071 +
33072 +       unsigned int    bph_free:1;     /* Register available for use */
33073 +       unsigned int    bph_data:1;     /* Data Access breakpoint */
33074 +
33075 +       unsigned int    bph_write:1;    /* Write Data breakpoint */
33076 +       unsigned int    bph_mode:2;     /* 0=inst, 1=write, 2=io, 3=read */
33077 +       unsigned int    bph_length:2;   /* 0=1, 1=2, 2=BAD, 3=4 (bytes) */
33078 +       unsigned int    bph_installed;  /* flag: hw bp is installed */
33079 +} kdbhard_bp_t;
33080 +
33081 +#define IA32_BREAKPOINT_INSTRUCTION    0xcc
33082 +
33083 +#define DR6_BT  0x00008000
33084 +#define DR6_BS  0x00004000
33085 +#define DR6_BD  0x00002000
33086 +
33087 +#define DR6_B3  0x00000008
33088 +#define DR6_B2  0x00000004
33089 +#define DR6_B1  0x00000002
33090 +#define DR6_B0  0x00000001
33091 +#define DR6_DR_MASK  0x0000000F
33092 +
33093 +#define DR7_RW_VAL(dr, drnum) \
33094 +       (((dr) >> (16 + (4 * (drnum)))) & 0x3)
33095 +
33096 +#define DR7_RW_SET(dr, drnum, rw)                              \
33097 +       do {                                                    \
33098 +              (dr) &= ~(0x3 << (16 + (4 * (drnum))));         \
33099 +              (dr) |= (((rw) & 0x3) << (16 + (4 * (drnum)))); \
33100 +       } while (0)
33101 +
33102 +#define DR7_RW0(dr)            DR7_RW_VAL(dr, 0)
33103 +#define DR7_RW0SET(dr,rw)      DR7_RW_SET(dr, 0, rw)
33104 +#define DR7_RW1(dr)            DR7_RW_VAL(dr, 1)
33105 +#define DR7_RW1SET(dr,rw)      DR7_RW_SET(dr, 1, rw)
33106 +#define DR7_RW2(dr)            DR7_RW_VAL(dr, 2)
33107 +#define DR7_RW2SET(dr,rw)      DR7_RW_SET(dr, 2, rw)
33108 +#define DR7_RW3(dr)            DR7_RW_VAL(dr, 3)
33109 +#define DR7_RW3SET(dr,rw)      DR7_RW_SET(dr, 3, rw)
33110 +
33111 +
33112 +#define DR7_LEN_VAL(dr, drnum) \
33113 +       (((dr) >> (18 + (4 * (drnum)))) & 0x3)
33114 +
33115 +#define DR7_LEN_SET(dr, drnum, rw)                             \
33116 +       do {                                                    \
33117 +              (dr) &= ~(0x3 << (18 + (4 * (drnum))));         \
33118 +              (dr) |= (((rw) & 0x3) << (18 + (4 * (drnum)))); \
33119 +       } while (0)
33120 +
33121 +#define DR7_LEN0(dr)           DR7_LEN_VAL(dr, 0)
33122 +#define DR7_LEN0SET(dr,len)    DR7_LEN_SET(dr, 0, len)
33123 +#define DR7_LEN1(dr)           DR7_LEN_VAL(dr, 1)
33124 +#define DR7_LEN1SET(dr,len)    DR7_LEN_SET(dr, 1, len)
33125 +#define DR7_LEN2(dr)           DR7_LEN_VAL(dr, 2)
33126 +#define DR7_LEN2SET(dr,len)    DR7_LEN_SET(dr, 2, len)
33127 +#define DR7_LEN3(dr)           DR7_LEN_VAL(dr, 3)
33128 +#define DR7_LEN3SET(dr,len)    DR7_LEN_SET(dr, 3, len)
33129 +
33130 +#define DR7_G0(dr)    (((dr)>>1)&0x1)
33131 +#define DR7_G0SET(dr) ((dr) |= 0x2)
33132 +#define DR7_G0CLR(dr) ((dr) &= ~0x2)
33133 +#define DR7_G1(dr)    (((dr)>>3)&0x1)
33134 +#define DR7_G1SET(dr) ((dr) |= 0x8)
33135 +#define DR7_G1CLR(dr) ((dr) &= ~0x8)
33136 +#define DR7_G2(dr)    (((dr)>>5)&0x1)
33137 +#define DR7_G2SET(dr) ((dr) |= 0x20)
33138 +#define DR7_G2CLR(dr) ((dr) &= ~0x20)
33139 +#define DR7_G3(dr)    (((dr)>>7)&0x1)
33140 +#define DR7_G3SET(dr) ((dr) |= 0x80)
33141 +#define DR7_G3CLR(dr) ((dr) &= ~0x80)
33142 +
33143 +#define DR7_L0(dr)    (((dr))&0x1)
33144 +#define DR7_L0SET(dr) ((dr) |= 0x1)
33145 +#define DR7_L0CLR(dr) ((dr) &= ~0x1)
33146 +#define DR7_L1(dr)    (((dr)>>2)&0x1)
33147 +#define DR7_L1SET(dr) ((dr) |= 0x4)
33148 +#define DR7_L1CLR(dr) ((dr) &= ~0x4)
33149 +#define DR7_L2(dr)    (((dr)>>4)&0x1)
33150 +#define DR7_L2SET(dr) ((dr) |= 0x10)
33151 +#define DR7_L2CLR(dr) ((dr) &= ~0x10)
33152 +#define DR7_L3(dr)    (((dr)>>6)&0x1)
33153 +#define DR7_L3SET(dr) ((dr) |= 0x40)
33154 +#define DR7_L3CLR(dr) ((dr) &= ~0x40)
33155 +
33156 +#define DR7_GD          0x00002000              /* General Detect Enable */
33157 +#define DR7_GE          0x00000200              /* Global exact */
33158 +#define DR7_LE          0x00000100              /* Local exact */
33159 +
33160 +extern kdb_machreg_t kdba_getdr6(void);
33161 +extern void kdba_putdr6(kdb_machreg_t);
33162 +
33163 +extern kdb_machreg_t kdba_getdr7(void);
33164 +
33165 +struct kdba_running_process {
33166 +       long sp;        /* KDB may be on a different stack */
33167 +       long ip;        /* eip when esp was set */
33168 +};
33169 +
33170 +static inline
33171 +void kdba_unsave_running(struct kdba_running_process *k, struct pt_regs *regs)
33172 +{
33173 +}
33174 +
33175 +struct kdb_activation_record;
33176 +extern void kdba_get_stack_info_alternate(kdb_machreg_t addr, int cpu,
33177 +                                         struct kdb_activation_record *ar);
33178 +
33179 +extern void kdba_wait_for_cpus(void);
33180 +
33181 +
33182 +#ifdef CONFIG_X86_32
33183 +
33184 +#define DR_TYPE_EXECUTE        0x0
33185 +#define DR_TYPE_WRITE  0x1
33186 +#define DR_TYPE_IO     0x2
33187 +#define DR_TYPE_RW     0x3
33188 +
33189 +/*
33190 + * Platform specific environment entries
33191 + */
33192 +#define KDB_PLATFORM_ENV       "IDMODE=x86", "BYTESPERWORD=4", "IDCOUNT=16"
33193 +
33194 +/*
33195 + * Support for setjmp/longjmp
33196 + */
33197 +#define JB_BX   0
33198 +#define JB_SI   1
33199 +#define JB_DI   2
33200 +#define JB_BP   3
33201 +#define JB_SP   4
33202 +#define JB_PC   5
33203 +
33204 +typedef struct __kdb_jmp_buf {
33205 +       unsigned long   regs[6];        /* kdba_setjmp assumes fixed offsets here */
33206 +} kdb_jmp_buf;
33207 +
33208 +extern int asmlinkage kdba_setjmp(kdb_jmp_buf *);
33209 +extern void asmlinkage kdba_longjmp(kdb_jmp_buf *, int);
33210 +#define kdba_setjmp kdba_setjmp
33211 +
33212 +extern kdb_jmp_buf  *kdbjmpbuf;
33213 +
33214 +/* Arch specific data saved for running processes */
33215 +static inline
33216 +void kdba_save_running(struct kdba_running_process *k, struct pt_regs *regs)
33217 +{
33218 +       k->sp = current_stack_pointer;
33219 +       __asm__ __volatile__ ( " lea 1f,%%eax; movl %%eax,%0 ; 1: " : "=r"(k->ip) : : "eax" );
33220 +}
33221 +
33222 +extern void kdb_interrupt(void);
33223 +
33224 +#define        KDB_INT_REGISTERS       8
33225 +
33226 +#else  /* CONFIG_X86_32 */
33227 +
33228 +extern kdb_machreg_t kdba_getdr(int);
33229 +extern void kdba_putdr(int, kdb_machreg_t);
33230 +
33231 +extern kdb_machreg_t kdb_getcr(int);
33232 +
33233 +/*
33234 + * Platform specific environment entries
33235 + */
33236 +#define KDB_PLATFORM_ENV       "IDMODE=x86_64", "BYTESPERWORD=8", "IDCOUNT=16"
33237 +
33238 +/*
33239 + * reg indicies for x86_64 setjmp/longjmp
33240 + */
33241 +#define JB_RBX   0
33242 +#define JB_RBP   1
33243 +#define JB_R12   2
33244 +#define JB_R13   3
33245 +#define JB_R14   4
33246 +#define JB_R15   5
33247 +#define JB_RSP   6
33248 +#define JB_PC    7
33249 +
33250 +typedef struct __kdb_jmp_buf {
33251 +        unsigned long   regs[8];       /* kdba_setjmp assumes fixed offsets here */
33252 +} kdb_jmp_buf;
33253 +
33254 +extern int asmlinkage kdba_setjmp(kdb_jmp_buf *);
33255 +extern void asmlinkage kdba_longjmp(kdb_jmp_buf *, int);
33256 +#define kdba_setjmp kdba_setjmp
33257 +
33258 +extern kdb_jmp_buf  *kdbjmpbuf;
33259 +
33260 +/* Arch specific data saved for running processes */
33261 +register unsigned long current_stack_pointer asm("rsp") __used;
33262 +
33263 +static inline
33264 +void kdba_save_running(struct kdba_running_process *k, struct pt_regs *regs)
33265 +{
33266 +       k->sp = current_stack_pointer;
33267 +       __asm__ __volatile__ ( " lea 0(%%rip),%%rax; movq %%rax,%0 ; " : "=r"(k->ip) : : "rax" );
33268 +}
33269 +
33270 +extern asmlinkage void kdb_interrupt(void);
33271 +
33272 +#define        KDB_INT_REGISTERS       16
33273 +
33274 +#endif /* !CONFIG_X86_32 */
33275 +
33276 +#endif /* !_ASM_KDBPRIVATE_H */
33277 --- a/include/asm-x86/kdebug.h
33278 +++ b/include/asm-x86/kdebug.h
33279 @@ -15,6 +15,8 @@ enum die_val {
33280         DIE_DIE,
33281         DIE_NMIWATCHDOG,
33282         DIE_KERNELDEBUG,
33283 +       DIE_KDEBUG_ENTER,
33284 +       DIE_KDEBUG_LEAVE,
33285         DIE_TRAP,
33286         DIE_GPF,
33287         DIE_CALL,
33288 --- a/include/asm-x86/kmap_types.h
33289 +++ b/include/asm-x86/kmap_types.h
33290 @@ -21,7 +21,8 @@ D(9)  KM_IRQ0,
33291  D(10)  KM_IRQ1,
33292  D(11)  KM_SOFTIRQ0,
33293  D(12)  KM_SOFTIRQ1,
33294 -D(13)  KM_TYPE_NR
33295 +D(13)  KM_KDB,
33296 +D(14)  KM_TYPE_NR
33297  };
33298
33299  #undef D
33300 --- a/include/asm-x86/ptrace.h
33301 +++ b/include/asm-x86/ptrace.h
33302 @@ -16,6 +16,29 @@
33303  /* this struct defines the way the registers are stored on the
33304     stack during a system call. */
33305
33306 +enum EFLAGS {
33307 +        EF_CF   = 0x00000001,
33308 +        EF_PF   = 0x00000004,
33309 +        EF_AF   = 0x00000010,
33310 +        EF_ZF   = 0x00000040,
33311 +        EF_SF   = 0x00000080,
33312 +        EF_TF   = 0x00000100,
33313 +        EF_IE   = 0x00000200,
33314 +        EF_DF   = 0x00000400,
33315 +        EF_OF   = 0x00000800,
33316 +        EF_IOPL = 0x00003000,
33317 +        EF_IOPL_RING0 = 0x00000000,
33318 +        EF_IOPL_RING1 = 0x00001000,
33319 +        EF_IOPL_RING2 = 0x00002000,
33320 +        EF_NT   = 0x00004000,   /* nested task */
33321 +        EF_RF   = 0x00010000,   /* resume */
33322 +        EF_VM   = 0x00020000,   /* virtual mode */
33323 +        EF_AC   = 0x00040000,   /* alignment */
33324 +        EF_VIF  = 0x00080000,   /* virtual interrupt */
33325 +        EF_VIP  = 0x00100000,   /* virtual interrupt pending */
33326 +        EF_ID   = 0x00200000,   /* id */
33327 +};
33328 +
33329  #ifndef __KERNEL__
33330
33331  struct pt_regs {