index [ptgmedia.pearsoncmg.com]ptgmedia.pearsoncmg.com/images/0131013726/index/... ·...

505

Index

his index begins with symbolic andnumeric items, listed in accordance

with the ASCII character code ordering (seeTable 2-3), followed by the A–Z items." " characters

enclosing string data, 60enclosing string parameters, 470

# character (preprocessor), 201$ character

beginning a system-defined macro, 56in symbols, 58

% characterin format strings, 270in parameters for asm function, 482

& characterlogical AND operator, 63reference indicator (C language), 210

() characters, clarifying precedence, 63* character

multiplication operator, 63+ character

addition operator, 63unary positive operator, 63

, character, separating specifiers, 55- character

introducing an option (Unix/Linux), 53subtraction operator, 63unary negation operator, 63

. characterintroducing a directive, 56in symbols, 58symbol for location counter, 62

/ characterdivision operator, 63double, for comment delimiter, 14, 56examine command (adb), 72

@ character@gprel, 15in floating-point class mnemonics, 247in macros, 475

: characterin adb commands, 72, 74double, 55terminating a label, 55

; characterdouble, 15, 55marking instruction dependencies, 55,

138–140= character for symbol definition, 59[] characters in register indirect addressing, 111\ character

T

027_evans_IX.fm Page 505 Monday, April 7, 2003 10:03 PM

506 Index

in macros, 467–470in repeat blocks, 462–463

^ character for exclusive OR operator, 63_ character in symbols, 58| character, logical OR operator, 63~ character, binary complement operator, 630 prefix for octal, 58–590b prefix for hexadecimal, 58–590x prefix for binary, 591620 computer, 3360 computer, 14004 processor, 78008 processor, 78080 processor, 7–88085 processor, 7–88086 processor, 7–8, 268088 processor, 8, 2680286 processor, 8

Aa access mode, 279a flag, 473-a option for requesting assembly listing file, 67A class of instruction, 86–88a.out (C default output file), 180Absolute path (see Path)Absolute symbols (see Symbols)Absolute value (floating-point), 239aCC command (HP compiler), 52, 343Access mode, 279Accumulator register, 33Accuracy (floating-point), 38acq completer, 388–390Actual parameters, 467–468Ada language as a 3GL, 3, 405adb debugger (Unix), 53, 70–71, 73–74add instruction, 88–89, 94–96Addition

floating-point, 240integer, 88–89logical basis, 162–163

addl instruction, 88–89, 94–96Address space, 29

Addressescomparing as unsigned values, 129definition of, 27number of, 32–34symbolic, 56

Addressing modesautodecrement, 116, 190autodecrement deferred, 118autoincrement, 111, 116, 190autoincrement deferred, 117–118base addressing, 117branch, 135–136direct, 110–111, 117displacement, 117displacement deferred, 118immediate, 89, 110, 112indirect, 111Itanium, 110–112memory direct, 110–111memory indirect, 111other architectures, 116–118performance issues, 325postincrement, 101, 102, 111–112register direct, 89, 101–102, 110–112register indirect, 101–102, 111–112, 116register indirect deferred, 117relative, 117relative deferred, 117for stacks (see Stacks)

Addressing range for branches, 135–136addp4 instruction, 107adds instruction, 88–89, 94Advanced load (see Load types)-Ae option for HP-UX compilers, 53, 422AINT function (FORTRAN), 249ALAT (advanced load address table), 308–309,

312.align directive, 57Alignment

of floating-point data, 38, 40, 236–237of integer data, 101–102for pipeline efficiency, 298

alloc instruction, 179–180, 198–199, 313Allocation, storage (see Storage allocation)


Index 507

Alpha architecture, 7, 9, 34, 84, 301Alphanumeric characters, 41–44Altivec extensions (PowerPC), 407.altrp directive, 212–213ALU (see Arithmetic logic unit)Ampersand character (see & character)and compare type, 161and instruction, 157–158AND logical function, 157and.orcm compare type, 161andcm compare type, 161andcm instruction, 157–158ANSI/IEEE 754 (see IEEE floating-point numbers)Answers for selected exercises, 495–502Antidependency, 298Application registers (see Registers)Approximation instructions

reciprocal, 253–254reciprocal square root, 254–255

APPROXPI program, 256–260ar.bsp register, 212ar.bspstore register, 212ar.ccv register, 389ar.csd register, 389–390ar.ec register, 313–316ar.fpsr register, 212, 242–243ar.itc register, 480–482ar.lc register, 143–145, 212ar.pfs register, 180–181, 198–199, 212, 456ar.rnat register, 212ar.unat register, 212Architecture

Alpha, 7, 9, 301CISC, 6–7, 84CRAY-1, 378–379defined, 1EPIC, 6, 10–11, 301extensions to, 393–394IA-16, IA-32, IA-64, 10instruction-level parallelism, 300–301Itanium, 9–11, 34–35lifetime, 396load/store, 33–34one-address, 33

PA-RISC, 10–11, 34PDP-8 architecture, 23, 32PDP-11, 7, 9, 33–34, 83Pentium, 35of the piano, 2–3PowerPC, 296, 301RISC, 6–7, 9–11, 84, 300–301, 340–341SPARC, 197–198stack-based, 32–33superscalar, 35, 295–296three-address, 33two-address, 33UltraSparc, 384VAX, 7, 9, 33–34, 84VLIW, 296, 301zero-address, 32–33

Argument passingfor C, 210for COBOL, 210by descriptor, 209–210for FORTRAN, 210locations, 208–209methods, 209–210by reference, 209–210by value, 209–210

Argument return registers, 214, 451Arguments for conditional assembly, 464–465Arguments for macros (see Macros)Aries (PA-RISC to Itanium migration), 34Arithmetic instructions

as a category, 30floating-point, 240–243integer, 88–93parallel floating-point, 385parallel integer, 380special cases, 91–92

Arithmetic logic unit, 156Arithmetic overflow

floating-point, 243integer, 89–90

Arithmetic shift, 165Arrays

record structures, 104–105shladd instruction for indexing, 91


508 Index

AS/400, 34ASCII characters, 41–44ASCII codes, table of, 43.ascii directive, 60ASCII file (see Text file)ASCII mode (ftp), 415.asciz directive, 60_Asm functions (HP-UX C), 4, 479–481asm keyword (C language), 4, 481–482Assembler directives, 57, 60Assemblers, 3, 49, 57, 66–67, 142Assembly language

advantages and disadvantages, 4, 49–50architectural dependence of, 4compared with other languages, 3–4for Itanium, 14–15lack of portability of, 50operators, 56–57statement types, 54–55why study, 4

Assembly process, 66–67Asterisk character (see * character)At character (see @ character)Atomic instructions, 386–390Authors, 503.auto directive, 460Autodecrement addressing (see Addressing modes)Autodecrement deferred addressing (see Address-

ing modes)Autoincrement addressing

postincrementing as Itanium equivalent, 111for stacks, 190

Autoincrement deferred addressing (see Addressing modes)

Automatic registers (see Registers)Automatic variables, 191–192

B/b byte display mode (debuggers), 72:b command (adb), 72b suffix, temporary labels, 142–143B class of instruction, 86–88B-unit, 87–88Backing store, 199–200

Backside cache (see Cache)BACKWARD program, 181–183Banked registers (see Registers)Base addressing (see Addressing modes)Base for number systems

binary, 16decimal, 16hexadecimal, 16for machine language, 3octal, 16

BASIC language as a 3GL, 3BBEdit, 427BetterTelnet, 427Biased exponent, 37–41, 234–235Bibliography, 485–493Big-endian convention, 36–37bin subdirectory, 53, 416Binary files, 288Binary mode (ftp), 416Binary multiples

names for, 5prefixes for, 5

Binary operators, arithmetic and logical, 62–63Bit encoding of instructions, 93–96Bit-field layouts for instructions, 85–86Bits, numbering of, 36.body directive, 57, 145, 180–181Boolean functions, 156–157Boolean operations

AND, 157NAND, 157NOR, 157NOT, 92, 157NXOR, 157OR, 157XOR, 157

booth function, 215–216Booth’s algorithm for multiplication, 170–173br instruction, 130–131br.call instruction, 179–180, 205br.cexit instruction, 315br.cloop instruction, 143–145br.ctop instruction, 315br.ia instruction, 408


Index 509

br.ret instruction, 179–180, 205

br.wexit instruction, 315–316

br.wtop instruction, 315–316

Branch addressing, 135–136

Branch deallocation hint, 130–131

Branch instructions

call, 205

completers, 130–131

conditional, 130–131

ordinary, 130–131

pipeline behavior, 298–299

return, 205

unconditional, 130–131

Branch offset, IP-relative, 135–136

Branch penalty

in general, 131, 143

Itanium 2 processor, 297

Itanium processor, 402

Branch prediction, 299, 404

Branch prefetch hint, 130

Branch range, 135–136

Branch registers (see Registers)

Branch type, 130

Branch whether hint, 130

break command (gdb), 71–73

break statement (C language), 149

Breakpoints, 71–74

brl instruction, 136, 405

brp instruction, 404

brtype completer (branch instructions), 130

Bubble sort

integers (SORTINT), 284–288

strings (SORTSTR), 273–277

Bubbles in a pipline, 294–300

Bundle template (see Template)

Bundle of instructions, 35, 85

Bus, 26

bwh completer (branch instructions), 130

.byte directive, 60

Byte-addressable memory (see Memory)

Bytes, numbering of, 36

C/c display mode (debuggers), 72:c command (adb), 72.c file (see File types)C language

as a 3GL, 3argument passing, 210compiler output, 345–349library functions for I/O, 269, 278SQUARES program, 12–13

C++ language as a 4GL, 3Cache

backside, 99hit ratio, 120–121, 325Itanium 2 processor, 98–100Itanium processor, 399–400levels, 29, 98–100line size, 98–99structures, 98–100, 399–400subsystem, 29, 98–100

call branch type, 130, 205Call to procedure, 205–207Calling conventions, 203–214Caret character (see ^ character)Carriage return character, 415Carry bit, 162–163Case sensitivity (Unix/Linux), 53Case structures, 148–150cat command (Unix/Linux), 416cc command (HP compiler), 52, 343, 422cc_bundled command (HP compiler), 52, 343,

422cd command (DOS, Unix/Linux), 416CDC 6600, 340Central processing unit, 26–27cexit branch type, 130, 315cfm register, 199, 205–207Characters

ASCII codes, 41–44byte storage for, 44control, 44cr (for line termination), 415lf (for line termination), 415

Check load (see Load types)

027_evans_IX.fm 09 Monday, April 7, 2003 10:03 PM

510 Index

chk.a instruction, 309, 397, 405chk.s instruction, 310–311, 397, 405chrget routine, 178–179chrput routine, 178–179Circumflex character (see ^ character)CISC architecture (see Architecture)CISC instructions, power of, 325–326Classes of instructions (see Instruction classes)Classification of floating-point value, 247–248Clearing a register, 92, 239Client software, 426–428Clipping saturation (see Saturation)clock function (C), 333–334CLOCKS_PER_SEC, 333cloop branch type, 130, 143–145Closed routines, 465Closing a file, 279clr deallocation hint, 130–131, 309cmp instruction, 126–129cmp4 instruction, 126–129cmpxchg instruction, 389COBOL language

as a 3GL, 3, 405argument passing, 210SQUARES program, 13–14

Codesfor operations, 56–57for pseudo-operations, 56–57

Colon character (see : character)COM_C program, 345COM_F program, 345Comma character (see , character)Command-line programming environments, 50,

413–417Command-line prompt, 414Commands, DOS and Unix/Linux, 416Comment field

in assembly language, 56importance of, 77–78

.common directive, 371Comparative instructions

as a category, 30floating-point, 246integer, 126–129

Compare instructionscompleters for, 127–129floating-point, 246parallel floating-point, 385parallel integer, 379parallel logical types, 160–161signed integer, 127–128unconditional, 146unsigned integer, 128–129

Compare relationshipfloating-point, 246signed integer, 128unsigned integer, 129

Compare type, 128, 146Comparing addresses, 129Comparing source files, 54Compiler warning messages, 360–361Compilers, 3, 49, 339–341Complementation of a Boolean, 92Completers, 55, 100 (also see individual

instructions)Complex instruction set computer (see

Architecture, CISC)Computer architecture (see Architecture)Computer languages (see Languages)Computer structures

central processing unit, 26–27input and output devices, 29–30memory, 29

cond branch type, 130Condition codes, 124–125Conditional assembly, 464–465Conditional branch instruction, 130–131Constants, 58

assembler syntax, 58–59loading into registers, 91, 103–104

Contents of an information unit, 27continue command (gdb), 72Control characters, 44Control dependency, 310–311Control instructions

branches, 123–126as a category, 30

Control path, 27


Index 511

Control registers (see Registers)Control speculation (see Speculation)Control statements (see Statement types)Control string for formatted I/O, 270, 280Control structures

case structuresif-based structures, 131–134loop structures, 134–135

Conventions for argument passing, 208–210Conventions for register use, 204, 450–455Conversion instructions, 248–251Copying, register to register, 91Coroutines, 202–203Counted loops (see Loops)Counter, location (see Location counter)CPU (see Central processing unit)cpuid registers, 409cr character for line termination, 415CRAY-1 architecture (see Architecture)crel completer (compare instructions), 128–129Cross-reference table, 64ctop branch type, 130, 315ctype completer (compare instructions), 128czx instruction, 380, 392

D/d display mode (debuggers), 72:d command (adb), 72.data directive, 57Data access instructions, 98, 101–105Data conversion instructions, 248–251Data dependency, 140–142, 297–300, 307–310Data movement instruction

as a category, 30mov pseudo-op (floating-point), 239mov pseudo-op (integer), 91movl instruction, 103–104(see also Load, Store)

Data speculation (see Speculation)Data stalls, 298Data types

alphanumeric characters, 41–44floating-point numbers, 37–41

integers, 37logical, 156

data1 directive, 60data2 directive, 60data4 directive, 60data8 directive, 60Datapath, 6, 27, 84+DD64 option (HP-UX compilers), 53, 423Dead code, 361Deallocation hint, 130–131Debuggers

adb example, 73–74breakpoints, 71–74capabilities of, 71disassembly, 76–77gdb example, 71–73and optimization, 369–370role of, 69–70single-stepping, 75–76watchpoints, 74–75

Declarative statements (see Statement types)DECNUM program, 175–178DECNUM2 program, 194–196DECNUM3 program, 216–218.default directive, 460del command (DOS), 416Delay slot (RISC), 301delete command (gdb), 72dep instruction, 167–168dep.z instruction, 167–168Denormal numbers, 233Dependency

control (see Control dependency)data (see Data dependency)

Deposit instructions, 167Depth of pipeline (see Pipeline depth)%DESCR function (FORTRAN), 210Descriptor, passing argument by, 209–210DET (exception detection pipeline stage),

296–297, 401–402Device drivers, 30dh completer (branch instructions), 130–131diff command (Linux/Unix), 54Digital Equipment Corporation processors


512 Index

Alpha, 7, 9PDP-8, 23, 32PDP-11, 7, 9, 33VAX, 7, 9, 33

dir command (DOS), 416Direct addressing (see Addressing modes)Direct assignment of a symbol, 58Direct memory access controllers, 30, 200Directives, assembler, 56–57Directories, 266–267disas command (gdb), 76–77Disassembly, 76–77Displacement addresing (see Addressing modes)Displacement addresing deferred (see Addressing

modes)Display modes for debuggers, 71–72Display output, 268–270Division

floating-point, 255–256floating-point software routines, 256IEEE requirement, 253integer, 93, 173–175, 219–220integer software routines, 219–220shr instruction for powers of 2, 166by ten, 173–175by zero (floating-point), 243

DMA controllers (see Direct memory access controllers)

Dollar sign character (see $ character)DOS commands, 416Dot character (see Period character)Dot product (see Scalar product)DOTCLOOP program, 143–145DOTCTOP program, 316–321DOTCTOP2 program, 321–324DOTLOOP program, 136–137DOTPROD program, 107–109, 113–116.double directive, 60Double precision, 38–40Double word, 35–36dpnt branch whether hint, 130, 404dptk branch whether hint, 130, 404+DSblended option, 407+DSitanium option, 407

+DSitanium2 option, 407+DSmckinley option, 407Dual issue, 401Dynamic binding, 219Dynamic optimization, 369

E/e display mode (adb), 72ecc command (Intel C/C++ compiler), 53, 342,

422Editors, use of, 52efc command (Intel FORTRAN compiler), 342,

422Effective address, 111–112, 116Ei (symbol for binary prefix), 5ELF binary file format, 210.else directive, 464Encapsulation, 178–179End of file, 278, 280, 283Endian conventions (big- and little-), 36–37.endif directive, 464–465.endm directive, 466–467.endp directive, 57.endr directive, 460–463Enforced lazy mode (RSE), 199EOF condition, 278, 280, 283EPIC architecture (see Architecture)EPIC instruction-level parallelism, 301Epilog counter, 205, 313–316Epilog phase of loop, 314Epilogue, 210–211eq compare relationship, 128Equal sign (see = character).err directive, 472Error detection and printing, 288exa- (decimal prefix), 5exbi- (binary prefix), 5Exceptions, 243excl completer, 326–327EXE (execute pipeline stage), 296–297, 401–402Executable file, 49Execution control with debugger, 71Execution units (B, F, I, M), 87–88, 305exit branch predict hint, 404


Index 513

.exitm directive, 472EXP (instruction dispersal pipeline stage),

296–297, 401–402.explicit directive, 460Explicit parallelism, 302Explicitly parallel instruction computer (see Archi-

tecture, EPIC)Exponent, 37–41, 234–235Expressions, 62–63External symbol (see Symbols)extr instruction, 166–168extr.u instruction, 166–168Extract instructions, 166–167

Ff command (adb), 72.f file (see File types)-f option (Linux compilers), 342f suffix, temporary labels, 142–143F class of instruction, 86–88F-unit, 87–88f90 command (HP compiler), 343, 422fabs instruction, 239Factorial function, 337, 471–472fadd instruction, 240famax instruction, 242famin instruction, 242fand instruction, 252fandcm instruction, 252fault completer, 326–327fclass instruction, 247–248fclose function (C), 278–279fcmp instruction, 246fcvt instruction, 249–250Feature size, 395FET (instruction prefetch pipeline stage), 401–402Fetch, 427fetchadd instruction, 388–390few prefetch hint, 130.fframe directive, 212–213fgets function (C), 278, 279–280fib function, 370–373FIB1 function, 329–331FIB2 function, 331–332

Fibonacci numbers, 328–334, 337, 370–373Fields in assembly language statements

comments, 56, 77–78labels, 55operators, 55specifiers, 55

Fields in record structures,104–105Figure of merit for loops, 140File name, 278–279File pointer, 278–279File storage (logical and physical), 265–267File systems, 266–267File types, default naming of

.c (Unix/Linux), 225

.f (Unix/Linux), 225

.o (Unix/Linux), 356

.s (Unix/Linux), 52Fill form of load instruction

floating-point, 237–238integer, 101–102

Flag value on stack, 195–196Floating-point instructions

arithmetic, 240–243compare, 246compared to integer instructions, 232conversion, 248–251load, 236–238logical, 252–253store, 235–236

Floating-point numbersdouble extended precision, 234double precision, 38–41, 234IEEE special values, 233IEEE standards, 37–41memory representation, 37–41natural alignment of, 38, 40register representation, 39–40, 234–235single-precision, 39–40, 234

Floating-point registers (see Registers)Floating-point status register (FPSR), 242–243Flynn’s classification, 378–379fma instruction, 241fmax instruction, 242fmerge instruction, 239


514 Index

fmin instruction, 242fmix instruction, 385fmpy instruction, 240fms instruction, 241fneg instruction, 239fnegabs instruction, 239fnma instruction, 241fnmpy instruction, 240fnorm instruction, 241–242fopen function (C), 278–279for instruction, 252Formal parameter, 462, 466–467Format

assembly language statements, 55–56Itanium instructions, 85–86

Format control string for I/O, 270, 280Formatted I/O, 270, 280FORTRAN language

as a 3GL, 3argument passing, 210compiler output, 349–352SQUARES program, 13

Forwarding, 299fpabs instruction, 385fpack instruction, 385–386fpamax instruction, 385fpamin instruction, 385fpcmp instruction, 385fpcvt instruction, 385fpma instruction, 385fpmax instruction, 385fpmerge instruction, 385fpmin instruction, 385fpmpy instruction, 385fpms instruction, 385fpneg instruction, 385fpnegabs instruction, 385fpnma instruction, 385fpnmpy instruction, 385fprcpa instruction, 385__fpreg data type, 480fprintf function (C), 278, 280fprsqrta instruction, 385FPSR (floating-point status register), 242–243

fpswap instruction, 385fpsxt instruction, 385fputs function (C), 278–280Fraction, 37–41Frame marker, 205–207Frame size, 191–192frcpa instruction, 253–254FreeBSD, 425Free Software Foundation, 417frsqrta instruction, 254–255fscanf function (C), 278, 280fselect instruction, 252–253fsub instruction, 240fswap instruction, 385fsxt instruction, 385ftp program, use of, 415–416Full adder, 162–163Full stop (see . character)Functional units (see Execution units)Functions, 203Fused multiply–add instruction, 241fxor instruction, 252

G/g display mode (debuggers), 72g77 command (Linux compiler), 341gcc command (Linux compiler), 53, 341gdb debugger (Linux), 53, 71–73ge compare relationship, 128GEM compilers, 341General registers (see Registers)get (ftp command), 415getchar function (C), 178–179getf instruction, 250getput (encapsulated C routines), 178–179gets function (C), 269–270gettimeofday function (Unix/Linux), 222–224Gettysburg address, 283–284geu compare relationship, 129Gi (symbol for binary prefix), 5gibi- (binary prefix), 5giga- (decimal prefix), 5.global directive, 57


Index 515

Global label (see Label)Global pointer (see Registers)Global symbols (see Symbols)GNU Project, 417goto instructions, 123gp register, 103, 113, 451@gprel assembler indicator, 15, 218–219Groups of instructions, 137–138gt compare relationship, 128gtu compare relationship, 129Guard bits, 234

Hh completer, 380/h display mode (adb), 72Half adder, 162Harvard architecture, 99–100Hazards, pipeline

branch effects, 298–299data stalls, 298multiple-issue effects, 300producer–consumer effects, 299–300

Hewlett-Packard processors7xxx series, 118xxx series, 11PA-RISC, 10–11, 23, 34

HEXNUM program, 96–98HEXNUM2 program, 163–164Hidden bit, 37–41High-level languages (see also Languages)

defined, 3–4portability of, 49–50standardization of, 49–50

Hintsfor branch instructions, 130–131for load instructions, 102for store instructions, 101

Hints for exercises, 495–502Hit ratio (see Cache)HORNER program, 243–245Horner’s rule, 243–244HP-UX software, 422–423Hyphen character (see - character)

I/i display mode (debuggers), 72I class of instruction, 86–88I-unit, 87–88ia branch type, 130, 408IA-16, IA-32, IA-64 architectures, 10IA-32 instruction set mode, 408–409ias (Intel assembler), 422IBM processors

1620, 3360, 1, 7801, 340AS/400, 34System/36, 34System/38, 34

Identifier (synonym for symbol), 58–59IEEE floating-point numbers

ANSI/IEEE specification, 38denormal, 233double precision, 38–41infinity, 233NaN (not a number), 38, 233single precision, 39–41special values, 38, 233zero, 233

.if directive, 464–465

.ifdef directive, 464–465

.ifndef directive, 464

.ifnotdef directive, 464if…then…else structures, 131–134, 146–147ILP (see Instruction-level parallelism)ILP32 scheme, 422Immediate addressing (see Addressing modes)Immediate data in instructions, 86, 95–96imp importance hint, 404Imperative statements (see Statement types)Implementation

changes to, 394–397defined, 1of the piano, 2–3version, determining, 409

IN instruction for I/O, 30in0–in7 stacked registers, 198, 205–207, 451#include directive (preprocessor), 201


516 Index

.include directive, 64Indefinite repeat block, 462–463Indexing of arrays (see Arrays)Indirect addressing (see Addressing modes)@inf mnemonic for fclass, 247Infinity as IEEE number, 233Information units

address of, 27–28bytes, 35–36contents of, 27double words, 35–36quad words, 35–36size of, 28–29, 35words, 35–36

Inline assembly, 479–483Inline functions, 327, 366–369INLINE program, 367Inner product (see Scalar product)Input stacked registers, 198Input/output

C functions, 268–270, 277–280system, 29–30

Instruction architecturesload/store, 33–34one-address, 33stack-based, 32–33three-address, 33two-address, 33zero-address, 32–33

Instruction bundles, 35, 85Instruction categories

arithmetic, 30, 88–93, 380, 385comparative, 30, 380, 385control, 30data access, 98, 101–105data movement, 30logical, 30semaphore, 31, 386–390

Instruction classes (A, B, F, I, M, X), 86–88Instruction completers (see Completers)Instruction components

operand specifiers, 31operation code (opcode), 31

Instruction encoding at the bit level, 93–96

Instruction execution cycle, 31–32Instruction groups (see Groups)Instruction issue, 295, 306–307Instruction-level parallelism

difficult outside loops, 406EPIC, 301RISC, 300–301throughput advantage, 300VLIW, 301

Instruction pipelining, 294–295Instruction pointer, 27, 31–32, 449–450Instruction power, 325–326Instruction reordering, 327Instruction retiring, 295Instruction set architecture, 5–6, 10, 32–34Instruction size, 325Instruction slots, 85Instruction templates, 302–307Instruction widths, 83–85Instructions (see Itanium instruction set)int data type (C), 178–179Integer division (see Division)Integer multiplication (see Multiplication)Integer sizes

byte, 37double word, 37quad word, 37word, 37

Integersin floating-point registers, 235representations of, 16–20, 37signed, 18–20, 37unsigned, 17–18, 37

Intel assembler (ias), 422Intel processors

4004, 78008, 78080, 7–88085, 88086, 7–8, 268088, 7, 2680286, 8Intel386, 8, 46Intel486, 8


Index 517

Itanium, 9–11, 397–405

Itanium 2, 10–11

Pentium, 8

Intel386 CPU, 8, 46Intel486 CPU, 8

Interface, user-visible, 1

Interrupt handling, 200

Interval time counter, 480–482

Intrinsic functions, 479–481

invala instruction, 309–310

I/O (see Input/output)

IO_C program, 179–180

-ip option (Intel compilers), 342

IP (see Instruction pointer)IPF (see Itanium Processor Family)

IPG (IP generation pipeline stage), 296–297, 401–402

-ipo option (Intel compilers), 342

.irp directive, 462

.irpc directive, 463

ISA (instruction set architecture), 5–6, 10

ISAM files, 288

Issue, multiple (see Multiple issue)

Issue ports, 400–401

Issuing of instructions, 295

Itanium architecture, 9–11

Itanium instruction set

by function, 430–437

by opcode, 438–447Itanium 2 processor

cache, 98–100

contrasted with first Itanium processor, 397–399

execution units, 87–88latency factors, 402–403

pipelines, 296–297

Itanium processor

cache, 399–400

contrasted with Itanium 2 processor, 397–399

execution units, 400–401

latency factors, 402–403

pipelines, 401–402

Itanium Processor Family, 10–11

J/j display mode (adb), 72Java, 3, 42JMPE instruction (IA-32 mode), 408Jump table, 148

KKernel phase of loop, 314Keyboard input, 268–270Keyword parameters, 469–470Ki (symbol for binary prefix), 5kibi- (binary prefix), 5kilo- (decimal prefix), 5

Ll completer, 380Label

global, 55local, 56local in macros, 470–471macro-generated, 475temporary, 142–143

Label field, 55Languages

1GL, 2GL, 3GL, 4GL, 3ANSI C, 3artificial intelligence, 3assembly, 3–4database access, 3high-level, 3–4machine, 3natural language, 3object-oriented, 3

Latency, 131, 140–142, 295, 299, 402–403LC, location counter, 64–66.lcomm directive, 60ld instructions, 101–102, 389–390LDC instruction (PA-RISC), 387ldf instructions, 236–237le compare relationship, 128leu compare relationship, 129lf character for line termination, 415lfetch instructions, 326–327


518 Index

Libraries in linking process, 53lincoln.txt test file, 283Line feed character, 415Line numbers in listing file, 64–66Line prefetch instructions, 326–327Line size (see Cache)Line terminators in text files, 279–280, 415Linear congruential method, 221Link map, 68–69Linkers, 49, 68–69Linking process, 68–69Linux operating system

client software, 426commands, 53, 416I/O software, 267line terminator, 415online documentation, 417support for Unicode, 42

LISP language as a 4GL, 3Listing file, 51, 57, 64–67Little-endian convention, 36–37Live quantity in software pipeline, 317Load hints

floating-point, 237–238integer, 102

Load instructionsfloating-point, 236–238floating-point pair, 238integer, 101–102semaphore, 389–390

Load typesadvanced, 308–309check, 308floating-point, 236–238integer, 102speculative, 310–312speculative advanced, 311–312

loc0–loc127 stacked registers, 198, 205–207,451

Local labels (see Label)Local stacked registers, 198Local variables, 205–207, 328Locality, 136Location counter

. character as symbol for, 62in listing file, 64–66maintained by assembler, 57multiple instances, 61–62in object file sections, 473

Logging in and out, 413–414Logical data, 156Logical difference, 158Logical functions

binary, 156–157unary, 156–157

Logical instructionsas a category, 30floating-point, 252–253integer, 157–158

Logical mask, 159, 163–164Logical product, 158Logical shift, 165Logical sum, 158.long directive, 60long long int (C data type), 178–179Long shift instruction, 166loop branch predict hint, 404Loop count register, 143–145, 315Loop structures, 134–135, 314–316Loops

counted, 134, 314–315modulo-scheduled, 313–324unrolling, 312–313, 361–366while, 315–316

Lower case usage, 53Lower case, converting to upper, 159LP64 scheme, 423ls command (Unix/Linux), 416lt compare relationship, 128ltu compare relationship, 129

M-M option for requesting map file, 68-m option (Linux compilers), 342M class of instruction, 86–88M-unit, 87–88Macintosh


Index 519

client software, 426–427line terminator, 415

.macro directive, 466–467Macro libraries, 51Macros

actual parameters, 466–470assembler, 200, 465–472default values, 469–470defining, 466–467formal parameters, 466–470invoking, 467–468keyword parameters, 469–470names, 466–467positional parameters, 468–469purposes, 466recursive, 471–472self-redefining, 471string parameters, 470

MacSFTP, 427MacSSH, 427Maintainability, writing for, 77–78man command (Unix/Linux), 417many prefetch hint, 130Map file, 51, 68–69Masking, 106, 159, 163–164Math coprocessor, 231MATRIX program, 376MAX-2 additions to PA-RISC, 384Maximum

floating-point, 242parallel floating-point, 385parallel integer, 380

MAXIMUM program, 150–151McKinley code name, 10, 398md command (DOS), 416MDMX extensions (MIPS), 407mebi- (binary prefix), 5mega- (decimal prefix), 5Memory

as an array, 28byte-addressable, 28holding instructions and data, 27information units, 27–29word size, 28

Memory direct addressing (see Addressing modes)Memory indirect addressing

(see Addressing modes)Memory-mapped I/O, 30Memory stacks, 190–194Merced code name, 10–11, 398Merge (see fpmerge instruction)Mi (symbol for binary prefix), 5mi (Macintosh text editor), 427Minimum

floating-point, 242parallel floating-point, 385parallel integer, 380

-minline-divide option (gcc), 341Minus sign character (see - character)MIMD computing systems, 378–379MIPS compilers, 340MISD computing systems, 378mix instruction, 380mkdir command (Unix/Linux), 416MMX instructions, 378, 407Modular programming, 200–203Modulo-scheduling of loops, 313–324MONEY macro, 473–476Moore’s law, 395more command, 416Motion video instructions, 407Motorola processors

680x0 series, 231PowerPC, 29, 296, 301

mov instruction, 105mov pseudo-instruction

floating-point, 239integer, 57, 91

movl instruction, 103–104Multimedia instructions, 379–381, 407Multiple-issue effects, 300Multiplication

Booth’s algorithm, 170–173floating-point, 240–241integer, 92–93, 170–173, 251–252, 381–384parallel instructions for 32-bits, 381–384pmpy2 instruction for 16-bits, 92–93scalar product of vectors, 107–109


520 Index

shl instruction for powers of 2, 166shladd instruction for special cases, 90–91unsigned integers, 173

Multiply-defined symbols, 67Multiway branching, 147–150mux instruction, 380mv command (Unix/Linux), 416

NNaN (see Not a number)NAND function, 157@nat mnemonic for fclass, 247NaT bit, 310–311, 450Natural alignment

of floating-point data, 38, 40, 236–237of integer data, 101–102

NaTVal (see Not a thing value)nc completer (check load), 308–309ne compare relationship, 128@neg mnemonic for fclass, 247Negation

of a floating-point value, 239of an integer value, 91

Nestingof conditionals, 146–147of macros, 467of parentheses in expressions, 63

Newline character, 269–270nge compare relationship, 246ngt compare relationship, 246NiftyTelnet SSH, 427nle compare relationship, 246nlt compare relationship, 246nm command (Unix/Linux), 52–53, 69–70-nolib_inline option (Intel compilers), 343nop instructions, 66, 305–306NOR function, 157@norm mnemonic for fclass, 247Normalization, floating-point, 241Not a number, 38, 233Not a thing value, 235NOT operation, 92, 157NotePad, 427

nt1 completerfloating-point load instructions, 237integer load instructions, 102line prefetch instruction, 327semaphore instructions, 388–389

nt2 completerline prefetch instruction, 327

nta completerfloating-point load instructions, 237floating-point store instructions, 236integer load instructions, 102integer store instructions, 101line prefetch instruction, 327semaphore instructions, 388–389

NUE (native user environment), 423–425NUL character, terminating a string, 60Number of addresses within instructions, 32–34Number conversion, 175–178Number systems

base, for machine language, 3binary, 16–18decimal, 16–17floating-point, 37–41hexadecimal, 17–18IEEE floating-point, 37–41integers, 16–20octal, 16one’s complement, 18–19sign and magnitude, 18–19signed integers, 18–20two’s complement, 18–20

Numeric rangesfloating-point numbers, 39integers, 37

NXOR function, 157nz test bit type, 160

O.o file, 356-o option (Unix/Linux), 53+O0 option (HP-UX compilers), 343-O0 option (Linux compilers), 53, 342+O1 option (HP-UX compilers), 343


Index 521

-O1 option (Linux compilers), 342+O2 option (HP-UX compilers), 343-O2 option (Linux compilers), 342–343+O3 option (HP-UX compilers), 343-O3 option (Linux compilers), 342–343+O4 option (HP-UX compilers), 343Object file, 49, 51, 57, 69Object file sections, 473Object libraries, 51Object-oriented languages, 3od command (Unix/Linux), 417+Ofast option (HP compilers), 343+Ofaster option (HP compilers), 343Offset

in branch instructions, 135–136in displacement addressing, 117location counter value as, 62

+Olimit option (HP compilers), 343On-chip cache, 98–100, 399–400One-address instruction set, 33One’s complement representation, 18–19Opcode, 31, 56–57, 84–86, 87–88Opcode extension fields, 87–88, 93–96Open routines, 466Opening a file, 279OpenVMS operating system, 415, 426Operand, 31Operand specifiers, 31, 55Operation code (see Opcode)Operator field, 55Operators

assembly language, 56–57binary and unary, 62–63

Optimizationand debugging, 369–370dynamic, 369enabling, 356–361factors in a program, 325–328inline functions, 366–369inhibition of, 53, 345levels for cc, aCC, and f90, 343levels for ecc and efc, 342–343levels for gcc and g77, 341–342loop unrolling, 361–366

post-compilation, 369profile-guided, 369static, 369

Options for Unix/Linux commands, 53or compare type, 161or instruction, 157–158OR logical function, 157or.andcm compare type, 161orcm compare type, 161ord compare relationship, 246Ordinateur (French for computer), 183Organization of a computer, 1-Os option (Linux compilers), 342+Osize option (HP compilers), 343OUT instruction for I/O, 30out0–out7 stacked registers, 199, 205–207, 451Output dependency, 298Output stacked registers, 199Overflow


PPA-RISC processors, 10–11, 46pack instruction, 380Packing data not encouraged, 78padd instruction, 380Palindromes, 188Parallel logical compare instructions, 160–161Parallel operations

floating-point, 384–386integer, 379–381

Parametersactual, 466–470default values, 469–470formal, 462, 466–470keyword, 469–470null, 469positional, 468–469

Parentheses, clarifying precedence, 63Pascal language as a 3GL, 3Passing arguments (see Argument passing)passwd command (Unix/Linux), 414


522 Index

Passwords, 414Path (for directory searches), 416pavg instruction, 380pavgsub instruction, 380PC (see Program counter)PCI bus, 30pcmp instruction, 380PDP-8 architecture, 23, 32PDP-11 architecture, 7, 9, 33–34, 83PDP-11 emulation, 34pebi- (binary prefix), 5Pentium CPU, 8Performance considerations, 293Performance for loops, 138–140Period character (see . character)perror function (C), 269, 288peta- (decimal prefix), 5PFE (Programmer’s File Editor), 427pfm (previous frame marker), 205–207ph completer (branch instructions), 130Pi (symbol for binary prefix), 5Piano architecture and implementation, 2–3Pipeline bubbles, 294–300Pipeline depth, 294Pipeline hazards (see Hazards)Pipeline stages

for a generic processor, 294–295Itanium 2 processor, 296–297Itanium processor (initial implementation),

401–402Pipelined loops, 312–316Pipelining

bubbles, 295floating-point, 296hardware, 294–300hazards, 297software, 313stalls, 295superpipelining, 295superscalar, 295

PL/I language as a 3GL, 3Plus sign character (see + character)pmax instruction, 380pmin instruction, 380

pmpy2 instruction, 92–93, 380pmpyshr2 instruction, 380Pointers, 103–104, 107, 422–423Polynomial evaluation, 241, 243–245Pop item from a stack, 190popcnt instruction, 380, 392Portability of programs, 50@pos mnemonic for fclass, 247Position-independent code, 218–219Positional coefficients, 16Positional parameters, 468–469Postcompilation optimization, 369Postincrement addressing (see Addressing)Postincrementing

with floating-point load, 236–238with floating-point load pair, 238with floating-point store, 235–236with integer load, 102with integer store, 101

PowerPC (see Motorola processors)pr register, 212Precedence of operators, 63Precision, floating-point, 39–40, 240Precision completer, 240, 250Predicate (see Qualifying predicate)Predicate registers (see Registers)Predication, 131–135, 245–246, 316–323Prediction, branch (see Branch prediction)Prefetch hint, 130Prefetching (see Advanced loads, Line prefetch

instructions, Speculative loads)Preprocessors, 201Preserved registers (see Registers)print command (gdb), 72–73printenv command, 417printf function (C), 269–270@priunat preservation, 212Privilege level, 205.proc directive, 57Procedural dependency (see Control dependency)Procedure frame, 191–192Procedures, 203Producer–consumer effects, 299–300Profile-guided optimization, 369


Index 523

progbits type, 473Program counter, 27, 31Program optimization, 293Program segmentation, 200–203Program size, 326Programming environments

command-line, 50tools, 52–53

ProgramsAPPROXPI, 256–260BACKWARD, 181–183booth (function), 215–216chrget (function), 178–179chrput (function), 178–179COM_C, 345COM_F, 345DECNUM, 175–178DECNUM2, 194–196DECNUM3, 216–218DOTCLOOP, 143–145DOTCTOP, 316–321DOTCTOP2, 321–324DOTLOOP, 136–137DOTPROD, 107–109, 113–116fib function, 370–373FIB1 function, 329–331FIB2 function, 331–332getput (encapsulated C routines), 178–179HEXNUM, 96–98HEXNUM2, 163–164HORNER, 243–245INLINE, 367IO_C, 179–180MATRIX, 376MAXIMUM, 150–151MONEY (macro), 473–476RANDC, 225RANDF, 225–226random (function), 222–224random_ (function) for FORTRAN,

222–224SCANFILE, 280–284SCANTERM, 270–273SCANTEXT, 168–169

SORTINT, 284–288SORTSTR, 273–277SQUARES, 12–15, 71, 73–74, 95–96,

112–115TESTFIB, 333–334

Prolog phase of loop, 314.prologue directive, 145, 180–181, 212Prologue section, 145, 210–213Prompt, command-line (see Command line)pr.rot (rotating predicate registers), 452psad1 instruction, 380Pseudo-operations, 56–57, 89, 91Pseudo-random numbers, 220–221, 256–260pshl instruction, 380pshladd2 instruction, 380pshr instruction, 380pshradd2 instruction, 380psp (previous stack pointer), 212psub instruction, 380Push item onto a stack, 190put (ftp command), 415putchar function (C), 178–179puts function (C), 269–270pwd command (Unix/Linux), 416

Qq command (adb), 72@qnan mnemonic for fclass, 247-Qoption option (ecc), 68qp (qualifying predicate), 55, 86.quad directive, 60Quad word, 35–36Qualifying predicate, 55, 86, 315–316quit command (gdb), 72Quotation marks (see " character)Quotient in division, 219–220

Rr access mode, 279:r command (adb), 72r command (adb), 72r completer, 380ra command (adb), 72


524 Index

Radix control, 58–59RANDC, 225RANDF, 225–226random (function), 222–224random_ (function) for FORTRAN, 222–224Random numbers, 220–226, 257–260RAR dependency, 307RAW dependency, 307rd command (DOS), 416readelf (Linux utility), 210–211real4 directive, 60real8 directive, 60Reciprocal

approximate, 253–254approximate square root, 254–255known, for division, 173–175

Record structures, 104–105Recurrence relationship, 329Recursion, 327–329, 333–334, 370–373Recursive macros, 471–472Reduced instruction set computer (see

Architecture, RISC)%REF function (FORTRAN), 210Reference, passing argument by, 209–210REG (register read pipeline stage), 296–297,

401–402Register-level programming, 27Register direct addressing (see Addressing modes)Register indirect addressing (see

Addressing modes)Register indirect deferred addressing (see

Addressing modes)Register-level programming, 27Register naming

gdb debugger, 71Itanium assemblers, 14

Register renaming, 298, 314Register stack. 198Register stack engine. 199–200Register windows (SPARC), 197–198Registers

adding to an architecture, 407application, 105, 143, 453–455for argument passing, 205–207

automatic, 450–451banked, 200, 451branch, 130, 452constant, 450–451, 453conventions for use, 204, 450–455in the CPU, 27cpuid, 409floating-point, 27, 39–40, 212–213, 453function returned values, 214general, 450–451global pointer, 103, 113, 451integer, 27, 450–451predicate, 126, 451–452preserved, 204read-only, 454register rename base, 314rotating, 199, 313–314scratch, 204special, 450–451stack pointer, 190–192, 451stacked, 198–199, 205–209, 451state management, 455–457system control, 457–458system information, 457

.regstk directive, 214rel completer

integer store instructions, 101semaphore instructions, 388–390

Relative addressing (see Addressing modes)Relative deferred addressing

(see Addressing modes)Relative path (see Path)Relocatable symbols (see Symbols)Remainder, in division, 175, 219–220REN (rename registers pipeline stage), 296–297,

401–402ren command (DOS), 416Repeat blocks

indefinite, 462–463simple, 460–461

Representation of numbersintegers, 16–20one’s complement, 18–19sign and magnitude, 18–19


Index 525

signed integers, 18–20two’s complement, 18–20

.rept directive, 461Reserved opcodes, 88.restore directive, 212ret branch type, 205ret0–ret3 function return value registers, 214,

451Retiring of instructions, 295Return from procedure, 205–207RISC architecture (see Architecture)RISC instruction-level parallelism, 300–301rm command (Unix/Linux), 416rmdir command (Unix/Linux), 416ROT (rotate instructions pipeline stage), 296–297,

401–402Rotate using shrp instruction, 166Rotating stacked registers (see Registers)Rounding, 242–243rp register, 212, 452rrb register, 314, 456RSE (see Register stack engine)run command (gdb) , 72

S.s file type (see File types)-S option (Linux/Unix compilers), 345:s command (adb), 72/s display mode (debuggers), 72Saturation, clipping, 381.save directive, 144–145, 180–181, 212–213.sbttl directive, 64Scalar product of vectors, 107–109, 136–137,

143–145, 316–324scanf function (C), 269–270SCANFILE program, 280–284SCANTERM program, 270–273SCANTEXT program, 168–169Scope, frame and stack, 190–192Scratch area, stack, 191–192Scratch registers (see Registers).section directive, 473Secure client software, 426–428Seed, 221

Self-redefining macros, 471Semaphore instructions

as a category, 31Itanium support, 386–390ordering completers, 388–389

Semicolon character (see ; character)set command (gdb), 72setf instruction, 250Shared library functions, 203Shell program, 417Shift instructions, 165–166, 380shl instruction, 165shladd instruction, 90–91shladdp4 instruction, 107shr instruction, 165shr.u instruction, 165shrp instruction, 166si command (see stepi command)SI units, 5Sign and magnitude representation

floating-point numbers, 37–41, 234–235integers, 18–19

Sign extension, 106Sign-manipulation instructions, 105–107Signed integers (see Integers)Significand, 37–41, 234–235Signum function, 154, 262SIMD computing systems, 378–379Simics, 421.single directive, 60Single-stepping with debugger, 75–76SISD computing systems, 378Ski simulator, 420–421, 423–425.skip directive, 57, 60Slash character (see / character)Slots for instructions in bundle, 85Smalltalk language as a 4GL, 3@snan mnemonic for fclass, 247sof field (cfm register), 199, 206–207Software-pipelined loops, 312–316sol field (cfm register), 199, 206–207sor field (cfm register), 199, 207Sorting

integers, 284–288


526 Index

strings, 273–277SORTINT program, 284–288SORTSTR program, 273–277Source files, comparing variants, 54Source program, 49

sp register, 190–192, 451

Space character, use in statements, 55–56SPARC register windows, 197–198Special registers (see Registers)Special values (IEEE), 38, 233Specifier field, 55Speculation

data, 307–310control, 310–312

Speculative load (see Load types).spill directive, 213Spill form of store instruction

floating-point, 236integer, 101

Split issue, 304–305spnt branch whether hint, 130sptk branch whether hint, 130SQL language as a 4GL, 3Square brackets (see [] characters)Square root

floating-point software routines, 256IEEE requirement, 253

SQUARES program, 12–15, 71, 73–74, 95–96,112–115

sscanf function (C), 290SSE extensions, 379. 407st instructions, 101, 390Stack-based instruction set, 32–33Stack pointer (see Registers)Stack unwinding (see Unwind tables)Stacked registers (see Registers)Stacks

addressing, 190–194CISC architectures, 190for argument passing, 208–209Itanium architecture, 191–192load/store architectures, 190–191memory, 190–194register, 196–200

user-defined, 192–194Stalls, data, (see Data stalls)Standard C library, 268Standard error, 268Standard input, 268Standard output, 268Starting address, 32State examination with debugger, 71State management by an architecture, 125–126State management registers (see Registers)Statement format, assembly language, 55–56Statement types, assembly language

control, 55, 64declarative, 54imperative, 54

Static binding, 219Static initialization, 474Status field completer, 240stderr, 268stdin, 268<stdio.h> header file, 178, 268stdout, 268stepi command (gdb), 72Stepwise development, 50–53stf instructions, 235–236Stop (double semicolon), 15, 138–140, 460Storage allocation, 49, 60Store hints, 101, 236Store instructions

floating-point, 235–236integer, 101semaphore, 389–390

Store typesfloating-point, 235–236integer, 101

Streaming single-instruction, multiple data exten-sions (see SSE extensions)

String of characters, 44string directive, 60String parameters, 470stringz directive, 60sub instruction, 88–89, 94Subroutines, 201–202Subtraction


Index 527


Subword instructions, 384Superpipelining, 295Superscalar parallelism, 35, 87, 295–296switch statement (C language), 149sxt instruction, 106Symbol table, 57, 64, 66–67Symbolic addresses, 56Symbolic assembler (see Assemblers)Symbolic debugger (see Debuggers)Symbols

absolute, 64characters used in, 58external, 67, 68global, 57, 64, 67multiply-defined error, 67relocatable, 64scope of, 59undefined, 67–68

System/36, 34System/38, 34System calls for I/O

Linux, 267Unix, 267

System control registers (see Registers)System information registers (see Registers)System libraries in linking process, 53

TTab character, use in statements, 56tbit instruction, 160tebi- (binary prefix), 5telnet program, use of, 413–414Template

assembler-selected, 303codes, 302in instruction bundle, 85, 302–307manually assigned, 303

Temporary label (see Label)tera- (decimal prefix), 5Tera Term, 427–428Terminal I/O, 268–270

Terminators, line (see Line terminators)Terms in expressions, 63Test relationship, 310TESTFIB program, 333–334.text directive, 57Text editors, 414–415Text file I/O, 277–280Text files, comparing variants, 54Text mode (ftp), 415TextWrangler, 427Threads, 203Three-address instruction set, 33Ti (symbol for binary prefix), 5Tilde character (see ~ character)Time from operating system, 222–224.title directive, 64tnat instruction, 310tp register, 451trel completer (test bit instruction), 160trunc completer, 249Truncation

floating-point, 242–243, 249integer, 166

Two-address instruction set, 33Two-pass assembler, 66–67Two’s complement representation, 18–20type command (DOS), 416.type directive, 180Typed language, 61Types of instructions (see Instruction classes)

Uuint64_rem_min_lat (Intel open source),

220, 224UltraSparc, 384Unary operators, arithmetic and logical, 63Unbiased rounding, 242–243unc compare type, 146, 246Unconditional branch, 130–131Unconditional compare, 146Underflow, floating-point, 243Underscore character (see _ character)Unformatted line I/O, 269–270, 279–280


528 Index

Unicode, 42Unix operating system

commands, 416I/O software, 267line terminators, 415on-line documentation, 417

unord compare relationship, 246@unorm mnemonic for fclass, 247unpack instruction, 380Unrolling of loops (see Loop unrolling)Unsigned integers (see Integers)Unwind information, 181, 210–211Uploading files, 415Upper case, converting to lower, 159Upper case usage, 53Usernames, 414UTF-8, UTF-16, UTF-32, 42

V%VAL function (FORTRAN), 210Value, passing argument by, 209–210Value of a number, 16Variable-width instructions, 84VAX architecture, 7, 9, 33–34, 84Vectors, scalar product (see Scalar product)Vertical bar character (see | character)Very long instruction word (see Architecture,

VLIW).vframe directive, 212–213Virtual addresses, 35Virtual machine, 420–421Virtual PC, 420–421VIS extensions (UltraSparc), 407VLIW architecture (see Architecture)VLIW instruction-level parallelism, 301VMS (see OpenVMS)von Neumann architecture, 27, 99–100

Ww access mode, 279+w option (acc), 53, 369/w display mode (gdb), 72

-w2 option (ecc), 53, 360-Wa option (gcc), 67-Wall option (gcc), 53, 360WAR dependency, 307Warnings from compilers, 360–361watch command (gdb), 72Watchpoints, 71, 74–75WAW dependency, 307Weights of digits, 16wexit branch type, 130, 315While loops (see Loops)Width of instructions, 83–85Windows

64-bit, 425client software, 427–428line terminators, 415

Wired or, 160-Wl option (gcc), 68WLD (word-line decide pipeline stage), 401–402Word (data width), 35–36Word counting, 168–169.word directive, 60-wp-ipo option (Intel compilers), 342WRB (write-back pipeline stage), 296–297, 401–

402Writing programs, conventions for, 77–78wtop branch type, 130, 315

X-x option (nm command), 53/x display mode (debuggers), 72x command (gdb), 72–73X class of instruction, 86–88XCHG instruction (IA-32 architecture), 387xchg instruction, 388xma instruction, 251xmpy instruction, 251xor instruction, 157–158XOR logical function, 157

YY2K problem, 405


Index 529

Z-Z option (gcc), 472z test bit type, 160@zero mnemonic for fclass, 247Zero as IEEE number, 38, 40, 233

Zero-address instruction set, 32–33Zero extension, 106–107Zero latency, 131, 140zxt instruction, 106–107


index [ptgmedia.pearsoncmg.com]ptgmedia.pearsoncmg.com/images/0131013726/index/... ·...

Documents