No Starch Write Great Code Thinking Low Level Writing High Level Volume 2 May 2006 ISBN 1593270658 pdf
Get better resu lts Get better resu lts from your from your sourc e code sourc e code
V W W O L U M R R E W R I T E G R E AT
IT
IT
2 W R I T E G R E AT : T H
IN E K E
O W assembly language required!
IN G G G L No prior knowledge of
V T H I N K I N G ,
V O L U M E 2 : L O W - L E V E L E CODE L , A A W R I T I N G W H I G H - L E V E L R
IT
IG About the author
IN T C T C G H O O
R R E E CODE - L E
H D - L D E
V E E E L
PRAISE FOR WRITE GREAT CODE, VOLUME 1:
“If you are programming without benefit of formal training, or if you lack the aegis of a mentor, Randall Hyde’s Write Great Code series should rouse your interest . . . The first five chapters and the Boolean Logic chapter are worth the price of the book.”
UNIX REVIEW
— “The book explains in detail what most programmers take for granted.”
- COMPUTER SHOPPER UK
( ) “Great fun to read.”
VSJ MAGAZINE
— “Not for the novice, this book details the innermost workings of the machine at a very complex level. Programmers who are interested in working at that level will the find the book most helpful.”
SECURITYITWORLD COM — .
“It fills in the blanks nicely and really could be part of a Computer Science degree required reading set. . . . Once this book is read, you will have a greater understanding and appreciation for code that is written efficiently—and you may just know enough to do that yourself." — MACCOMPANION , AFTER GIVING IT A
5 OUT OF
5 STARS RATING “Write Great Code: Understanding the Machine should be on the required reading list for anyone who wants to develop terrific code in any language without having to learn assembly language.” — WEBSERVERTALK “Hyde is taking on a topic that continues to lie at the core of all development, the foundations of computer architecture.”
PRACTICAL APPLICATIONS
— “Isn’t your typical ‘teach yourself to program’ book. . . . It’s relevant to all languages, and all levels of programming experience. . . . Run, don’t walk, to buy and read this book.”
BAY AREA LARGE INSTALLATION SYSTEM ADMINISTRATORS BAYLISA
— ( )
WRITE GREAT
CODE
V o lu m e 2 : T h i n ki n g L o w -
L e v e l , W r i ti n g H i g h - L e v e l
by Randall Hyde
San Francisco
WRITE GREAT CODE, Vol. 2: Thinking Low-Level, Writing High-Level. Copyright © 2006 by Randall Hyde.
All rights reserved. No part of this work may be reproduced or transmitted in any form or by any means, electronic or
mechanical, including photocopying, recording, or by any information storage or retrieval system, without the prior
written permission of the copyright owner and the publisher.Printed on recycled paper in the United States of America 1 2 3 4 5 6 7 8 9 10 – 09 08 07 06
No Starch Press and the No Starch Press logo are registered trademarks of No Starch Press, Inc. Other product and
company names mentioned herein may be the trademarks of their respective owners. Rather than use a trademark
symbol with every occurrence of a trademarked name, we are using the names only in an editorial fashion and to the
benefit of the trademark owner, with no intention of infringement of the trademark. Publisher: William Pollock Managing Editor: Elizabeth Campbell Cover and Interior Design: Octopod Studios Developmental Editor: Jim Compton Technical Reviewer: Benjamin David Lunt Copyeditor: Kathy Grider-Carlyle Compositor: Riley Hoffman Proofreader: Stephanie Provines For information on book distributors or translations, please contact No Starch Press, Inc. directly: No Starch Press, Inc. 555 De Haro Street, Suite 250, San Francisco, CA 94107 phone: 415.863.9900; fax: 415.863.9950; info@nostarch.com; www.nostarch.comThe information in this book is distributed on an “As Is” basis, without warranty. While every precaution has been
taken in the preparation of this work, neither the author nor No Starch Press, Inc. shall have any liability to any person or entity with respect to any loss or damage caused or alleged to be caused directly or indirectly by the information contained in it.Librar y of Congress Cataloging-in-Publication Data (Volume 1) Hyde, Randall.
Write great code : understanding the machine / Randall Hyde. p. cm.
ISBN 1-59327-003-8 1. Computer programming. 2. Computer architecture. I. Title.
QA76.6.H94 2004 005.1--dc22 2003017502
B R I E F C O N T E N T S
Acknowledgments ..........................................................................................................xv Introduction .................................................................................................................xvii
Chapter 1: Thinking Low-Level, Writing High-Level ..............................................................1 Chapter 2: Shouldn’t You Learn Assembly Language? .......................................................11 Chapter 3: 80x86 Assembly for the HLL Programmer ........................................................21 Chapter 4: PowerPC Assembly for the HLL Programmer ....................................................47 Chapter 5: Compiler Operation and Code Generation .....................................................61 Chapter 6: Tools for Analyzing Compiler Output ............................................................115 Chapter 7: Constants and High-Level Languages ............................................................165 Chapter 8: Variables in a High-Level Language .............................................................189 Chapter 9: Array Data Types .......................................................................................241 Chapter 10: String Data Types ....................................................................................281 Chapter 11: Pointer Data Types ...................................................................................315 Chapter 12: Record, Union, and Class Data Types ........................................................341
Chapter 13: Arithmetic and Logical Expressions .............................................................385 Chapter 14: Control Structures and Programmatic Decisions ...........................................439 Chapter 15: Iterative Control Structures .........................................................................489 Chapter 16: Functions and Procedures ..........................................................................521 Engineering Software .................................................................................................579 Appendix: A Brief Comparison of the 80x86 and PowerPC CPU Families .........................581 Online Appendices .....................................................................................................589 Index .........................................................................................................................591
C O N T E N T S I N D E T A I L A CK N O W LED GM EN T S xv
I NT RO D UC TI O N xvii
1 TH IN K I N G L O W -L EV EL , WR I TI N G H IG H- L EV EL
1
1.1 Misconceptions About Compiler Quality .............................................................. 2
1.2 Why Learning Assembly Language Is Still a Good Idea ......................................... 2
1.3 Why Learning Assembly Language Isn’t Absolutely Necessary................................ 3
1.4 Thinking Low-Level............................................................................................. 3
1.4.1 Compilers Are Only as Good as the Source Code You Feed Them.......... 4
1.4.2 Helping the Compiler Produce Better Machine Code ............................. 4
1.4.3 How to Think in Assembly While Writing HLL Code .............................. 5
1.5 Writing High-Level ............................................................................................ 7
1.6 Assumptions ..................................................................................................... 7
1.7 Language-Neutral Approach .............................................................................. 8
1.8 Characteristics of Great Code ............................................................................ 8
1.9 The Environment for This Text.............................................................................. 9
1.10 For More Information..................................................................................... 10
2 S HO U L DN ’ T YO U LEA R N A SS EM B L Y L AN GU A GE?
11
2.1 Roadblocks to Learning Assembly Language....................................................... 12
2.2 Write Great Code, Volume 2, to the Rescue....................................................... 12
2.3 High-Level Assemblers to the Rescue .................................................................. 13
2.4 The High-Level Assembler (HLA) ........................................................................ 14
2.5 Thinking High-Level, Writing Low-Level............................................................... 15
2.6 The Assembly Programming Paradigm (Thinking Low-Level) .................................. 16
2.7 The Art of Assembly Language and Other Resources ........................................... 18
3 8 0X 8 6 A S S EM BL Y F O R TH E HL L P RO G RA M M ER
21
3.1 Learning One Assembly Language Is Good, Learning More Is Better ..................... 22 3.2 80x86 Assembly Syntaxes ............................................................................... 22
3.3 Basic 80x86 Architecture................................................................................. 23
3.3.1 Registers ........................................................................................ 23 3.3.2 80x86 General-Purpose Registers ..................................................... 24
3.3.3 The 80x86 EFLAGS Register............................................................. 25
3.4 Literal Constants.............................................................................................. 26
3.4.1 Binary Literal Constants.................................................................... 26
3.4.2 Decimal Literal Constants ................................................................. 27
3.4.3 Hexadecimal Literal Constants .......................................................... 27
3.4.4 Character and String Literal Constants ............................................... 28
3.4.5 Floating-Point Literal Constants .......................................................... 29
3.5 Manifest (Symbolic) Constants in Assembly Language.......................................... 30
3.5.1 Manifest Constants in HLA ............................................................... 30
3.5.2 Manifest Constants in Gas ............................................................... 30
3.5.3 Manifest Constants in MASM and TASM ........................................... 31 3.6 80x86 Addressing Modes ............................................................................... 31
3.6.1 80x86 Register Addressing Modes ................................................... 31
3.6.2 Immediate Addressing Mode............................................................ 32
3.6.3 Displacement-Only Memory Addressing Mode ................................... 33
3.6.4 Register Indirect Addressing Mode .................................................... 35
3.6.5 Indexed Addressing Mode ............................................................... 36
3.6.6 Scaled-Indexed Addressing Modes.................................................... 38
3.7 Declaring Data in Assembly Language .............................................................. 39
3.7.1 Data Declarations in HLA ................................................................. 40
3.7.2 Data Declarations in MASM and TASM............................................. 41
3.7.3 Data Declarations in Gas ................................................................. 41
3.8 Specifying Operand Sizes in Assembly Language............................................... 44
3.8.1 Type Coercion in HLA ..................................................................... 44
3.8.2 Type Coercion in MASM and TASM ................................................. 45
3.8.3 Type Coercion in Gas ..................................................................... 45
3.9 The Minimal 80x86 Instruction Set .................................................................... 46
3.10 For More Information..................................................................................... 46
4 P O WER P C AS S EM B LY FO R T HE H LL PR O GR AM M E R
47
4.1 Learning One Assembly Language Is Good; More Is Better .................................. 48
4.2 Assembly Syntaxes.......................................................................................... 48
4.3 Basic PowerPC Architecture.............................................................................. 49
4.3.1 General-Purpose Integer Registers ..................................................... 49
4.3.2 General-Purpose Floating-Point Registers ............................................ 49
4.3.3 User-Mode-Accessible Special-Purpose Registers ................................. 49
4.4 Literal Constants.............................................................................................. 52
4.4.1 Binary Literal Constants.................................................................... 52
4.4.2 Decimal Literal Constants ................................................................. 53
4.4.3 Hexadecimal Literal Constants .......................................................... 53
4.4.4 Character and String Literal Constants ............................................... 53
4.4.5 Floating-Point Literal Constants .......................................................... 53
4.5 Manifest (Symbolic) Constants in Assembly Language.......................................... 54
4.6 PowerPC Addressing Modes ............................................................................ 54
4.6.1 PowerPC Register Access ................................................................. 54
4.6.2 The Immediate Addressing Mode ...................................................... 54
4.6.3 PowerPC Memory Addressing Modes................................................ 55
4.7 Declaring Data in Assembly Language .............................................................. 56
4.8 Specifying Operand Sizes in Assembly Language............................................... 59
4.9 The Minimal Instruction Set............................................................................... 59
4.10 For More Information..................................................................................... 59
5 C O M PI L E R O P E RA TI O N A N D CO DE G E N E RA TI O N
61
5.1 File Types That Programming Languages Use...................................................... 62
5.2 Programming Language Source Files ................................................................. 62
5.2.1 Tokenized Source Files .................................................................... 62
5.2.2 Specialized Source File Formats........................................................ 63
5.3 Types of Computer Language Processors............................................................ 63
5.3.1 Pure Interpreters .............................................................................. 64
5.3.2 Interpreters ..................................................................................... 64
5.3.3 Compilers ...................................................................................... 64
5.3.4 Incremental Compilers ..................................................................... 65
5.4 The Translation Process.................................................................................... 66
5.4.1 Lexical Analysis and Tokens ............................................................. 68
5.4.2 Parsing (Syntax Analysis) ................................................................. 69
5.4.3 Intermediate Code Generation.......................................................... 69
5.4.4 Optimization .................................................................................. 70
5.4.5 Comparing Different Compilers’ Optimizations ................................... 81
5.4.6 Native Code Generation ................................................................. 81
5.5 Compiler Output ............................................................................................. 81
5.5.1 Emitting HLL Code as Compiler Output .............................................. 82
5.5.2 Emitting Assembly Language as Compiler Output................................ 83
5.5.3 Emitting Object Files as Compiler Output ........................................... 84
5.5.4 Emitting Executable Files as Compiler Output ..................................... 85
5.6 Object File Formats ......................................................................................... 85
5.6.1 The COFF File Header ..................................................................... 86
5.6.2 The COFF Optional Header ............................................................. 88
5.6.3 COFF Section Headers .................................................................... 91
5.6.4 COFF Sections................................................................................ 93
5.6.5 The Relocation Section..................................................................... 94
5.6.6 Debugging and Symbolic Information................................................ 94
5.6.7 Learning More About Object File Formats .......................................... 94
5.7 Executable File Formats ................................................................................... 94
5.7.1 Pages, Segments, and File Size ........................................................ 95
5.7.2 Internal Fragmentation ..................................................................... 97
5.7.3 So Why Optimize for Space?........................................................... 98
5.8 Data and Code Alignment in an Object File ....................................................... 99
5.8.1 Choosing a Section Alignment Size................................................. 100
5.8.2 Combining Sections ...................................................................... 101
5.8.3 Controlling the Section Alignment ................................................... 102
5.8.4 Section Alignment and Library Modules ........................................... 102
5.9 Linkers and Their Effect on Code ..................................................................... 110
5.10 For More Information................................................................................... 113
6 TO O L S F O R A N A LY Z IN G C O M P IL E R O U TP UT 115
6.1 Background.................................................................................................. 116
6.2 Telling a Compiler to Produce Assembly Output ................................................ 117
6.2.1 Assembly Output from GNU and Borland Compilers ......................... 118
6.2.2 Assembly Output from Visual C++ .................................................. 118
6.2.3 Example Assembly Language Output............................................... 118
6.2.4 Analyzing Assembly Output from a Compiler ................................... 128
6.3 Using Object-Code Utilities to Analyze Compiler Output .................................... 129
8.2.5 Scope.......................................................................................... 198
8.1.3 The BSS Section............................................................................ 194
8.1.4 The Stack Section.......................................................................... 195
8.1.5 The Heap Section and Dynamic Memory Allocation .......................... 196
8.2 What Is a Variable? ...................................................................................... 196
8.2.1 Attributes ..................................................................................... 197
8.2.2 Binding........................................................................................ 197
8.2.3 Static Objects ............................................................................... 197
8.2.4 Dynamic Objects .......................................................................... 197
8.2.6 Lifetime ........................................................................................ 198
8.1.1 The Code, Constant, and Read-Only Sections................................... 191
8.2.7 So What Is a Variable? ................................................................. 199
8.3 Variable Storage .......................................................................................... 199
8.3.1 Static Binding and Static Variables.................................................. 199
8.3.2 Pseudo-Static Binding and Automatic Variables................................. 203
8.3.3 Dynamic Binding and Dynamic Variables ........................................ 206
8.4 Common Primitive Data Types ........................................................................ 210
8.4.1 Integer Variables .......................................................................... 210
8.4.2 Floating-Point/Real Variables ......................................................... 213
8.4.3 Character Variables ...................................................................... 214
8.1.2 The Static Variables Section ........................................................... 193
8.1 Runtime Memory Organization ....................................................................... 190
6.3.1 The Microsoft dumpbin.exe Utility ................................................... 129
7 C O NS T AN T S A ND H I GH- L EV EL L AN GU A GES 165
6.3.2 The FSF/GNU objdump.exe Utility .................................................. 142
6.4 Using a Disassembler to Analyze Compiler Output............................................ 146
6.5 Using a Debugger to Analyze Compiler Output ................................................ 149
6.5.1 Using an IDE’s Debugger ............................................................... 149
6.5.2 Using a Stand-Alone Debugger....................................................... 151
6.6 Comparing Output from Two Compilations ...................................................... 152
6.6.1 Before-and-After Comparisons with diff ............................................ 153
6.6.2 Manual Comparison ..................................................................... 162
6.7 For More Information..................................................................................... 163
7.1 Literal Constants and Program Efficiency .......................................................... 166
8 V AR I AB LES IN A HI GH -L EV EL L A N GU AG E 189
7.2 Literal Constants Versus Manifest Constants ...................................................... 168
7.3 Constant Expressions ..................................................................................... 169
7.4 Manifest Constants Versus Read-Only Memory Objects...................................... 171
7.5 Enumerated Types ......................................................................................... 172
7.6 Boolean Constants ........................................................................................ 174
7.7 Floating-Point Constants ................................................................................. 176
7.8 String Constants............................................................................................ 182
7.9 Composite Data Type Constants ..................................................................... 186
7.10 For More Information................................................................................... 188
8.4.4 Boolean Variables......................................................................... 215
8.5 Variable Addresses and High-level Languages.................................................. 215
10.4 Delphi/Kylix Strings .................................................................................... 310
10.1.4 HLA Strings ................................................................................ 303
10.1.5 Descriptor-Based Strings .............................................................. 306
10.2 Static, Pseudo-Dynamic, and Dynamic Strings................................................. 307
10.2.1 Static Strings .............................................................................. 308
10.2.2 Pseudo-Dynamic Strings ............................................................... 308
10.2.3 Dynamic Strings.......................................................................... 308
10.3 Reference Counting for Strings...................................................................... 309
10.5 Using Strings in a High-Level Language ......................................................... 310
10.1.1 Zero-Terminated Strings ............................................................... 283
10.6 Character Data in Strings............................................................................. 312
10.7 For More Information................................................................................... 314
1 1 P O IN T ER DA TA T YP ES 315
11.1 Defining and Demystifying Pointers ............................................................... 316
11.2 Pointer Implementation in High-Level Languages.............................................. 317
11.3 Pointers and Dynamic Memory Allocation ...................................................... 320
11.4 Pointer Operations and Pointer Arithmetic ...................................................... 320
11.4.1 Adding an Integer to a Pointer...................................................... 322
10.1.2 Length-Prefixed Strings ................................................................. 300 10.1.3 7-Bit Strings ................................................................................ 302
10.1 Character String Formats ............................................................................. 282
8.5.1 Storage Allocation for Global and Static Variables ........................... 216
8.7 For More Information..................................................................................... 239
8.5.2 Using Automatic Variables to Reduce Offset Sizes............................. 217
8.5.3 Storage Allocation for Intermediate Variables ................................... 223
8.5.4 Storage Allocation for Dynamic Variables and Pointers...................... 224
8.5.5 Using Records/Structures to Reduce Instruction Offset Sizes................ 226
8.5.6 Register Variables ......................................................................... 228
8.6 Variable Alignment in Memory ....................................................................... 229
8.6.1 Records and Alignment.................................................................. 235
9 A RR AY DA TA T Y PES 241
1 0 S TR IN G DA TA T Y PES 281
9.1 What Is an Array? ........................................................................................ 242
9.1.1 Array Declarations ........................................................................ 242
9.1.2 Array Representation in Memory..................................................... 246
9.1.3 Accessing Elements of an Array ...................................................... 250
9.1.4 Padding Versus Packing................................................................. 252
9.1.5 Multidimensional Arrays ................................................................ 255
9.1.6 Dynamic Versus Static Arrays ......................................................... 270
9.2 For More Information..................................................................................... 279
11.4.2 Subtracting an Integer from a Pointer............................................. 323
11.4.3 Subtracting a Pointer from a Pointer .............................................. 324
12.8.1 Classes Versus Objects ................................................................ 371
12.3.1 Union Declarations in C/C++....................................................... 361
12.3.2 Union Declarations in Pascal/Delphi/Kylix .................................... 361
12.3.3 Union Declarations in HLA ........................................................... 362
12.4 Memory Storage of Unions .......................................................................... 362
12.5 Other Uses of Unions .................................................................................. 363
12.6 Variant Types ............................................................................................. 364
12.7 Namespaces .............................................................................................. 369
12.8 Classes and Objects.................................................................................... 371
12.8.2 Simple Class Declarations in C++ ................................................. 371
12.2 Discriminant Unions..................................................................................... 360
12.8.3 Virtual Method Tables.................................................................. 373
12.8.4 Sharing VMTs............................................................................. 377
12.8.5 Inheritance in Classes .................................................................. 377
12.8.6 Polymorphism in Classes .............................................................. 380
12.8.7 Classes, Objects, and Performance ............................................... 381
12.9 For More Information................................................................................... 382
1 3
A RI TH M ETI C A N D L O G IC A L EXP RES S IO NS 385
13.1 Arithmetic Expressions and Computer Architecture .......................................... 386
13.1.1 Stack-Based Machines ................................................................. 386
12.3 Union Declarations in Various Languages ...................................................... 360
12.1.6 Dynamic Record Types and Databases .......................................... 359
11.4.4 Comparing Pointers..................................................................... 325
11.9.2 Using a Pointer That Contains an Illegal Value................................ 337
11.4.5 Logical AND/OR and Pointers...................................................... 327
11.4.6 Other Operations with Pointers ..................................................... 328
11.5 A Simple Memory Allocator Example ............................................................ 329
11.6 Garbage Collection .................................................................................... 332
11.7 The OS and Memory Allocation.................................................................... 332
11.8 Heap Memory Overhead............................................................................. 333
11.9 Common Pointer Problems............................................................................ 335
11.9.1 Using an Uninitialized Pointer....................................................... 336
11.9.3 Continuing to Use Storage After It Has Been Freed.......................... 337
12.1.5 Using Records to Improve Memory Performance ............................. 358
11.9.4 Failing to Free Storage When Done with It ..................................... 338
11.9.5 Accessing Indirect Data Using the Wrong Data Type....................... 339
11.10 For More Information................................................................................. 340
1 2
REC O R D, U NI O N , A N D C L A SS DA TA T Y PES 341
12.1 Records ..................................................................................................... 342
12.1.1 Record Declarations in Various Languages ..................................... 342
12.1.2 Instantiation of a Record .............................................................. 344
12.1.3 Initialization of Record Data at Compile Time ................................. 350
12.1.4 Memory Storage of Records ......................................................... 355
13.1.2 Accumulator-Based Machines ....................................................... 391
13.1.3 Register-Based Machines.............................................................. 393
14.6 The switch/case Statement ........................................................................... 466
1 4 C O NT RO L ST RU C TUR ES A N D P RO GR A M M AT IC DEC IS I O N S 439
14.1 Control Structures Are Slower Than Computations! .......................................... 440
14.2 Introduction to Low-Level Control Structures..................................................... 440
14.3 The goto Statement...................................................................................... 443 14.4 break, continue, next, return, and Other Limited Forms of the goto Statement ..... 447
14.5 The if Statement .......................................................................................... 448
14.5.1 Improving the Efficiency of Certain if/else Statements ...................... 450
14.5.2 Forcing Complete Boolean Evaluation in an if Statement .................. 453
14.5.3 Forcing Short-Circuit Boolean Evaluation in an if Statement .............. 460
14.6.1 Semantics of a switch/case Statement ........................................... 467
13.8 The Relative Cost of Arithmetic Operations ..................................................... 436
14.6.2 Jump Tables Versus Chained Comparisons ..................................... 468
14.6.3 Other Implementations of switch/case ........................................... 475
14.6.4 Compiler Output for switch Statements........................................... 486
14.7 For More Information................................................................................... 486
1 5
I TERA TI V E CO N T RO L S T RU CT UR ES 489
15.1 The while Loop ........................................................................................... 489
15.1.1 Forcing Complete Boolean Evaluation in a while Loop ..................... 492
13.9 For More Information................................................................................... 437
13.7.3 Efficiency Issues .......................................................................... 432
13.1.4 Typical Forms of Arithmetic Expressions ......................................... 394
13.2.4 Common Subexpression Elimination .............................................. 402
13.1.5 Three-Address Architectures.......................................................... 395
13.1.6 Two-Address Architectures............................................................ 395
13.1.7 Architectural Differences and Your Code........................................ 396
13.1.8 Handling Complex Expressions..................................................... 397
13.2 Optimization of Arithmetic Statements ........................................................... 397
13.2.1 Constant Folding......................................................................... 398
13.2.2 Constant Propagation .................................................................. 399
13.2.3 Dead Code Elimination................................................................ 400
13.2.5 Strength Reduction ...................................................................... 406
13.7.2 Forcing Short-Circuit or Complete Boolean Evaluation...................... 430
13.2.6 Induction.................................................................................... 410
13.2.7 Loop Invariants ........................................................................... 413
13.2.8 Optimizers and Programmers ....................................................... 416
13.3 Side Effects in Arithmetic Expressions ............................................................ 416
13.4 Containing Side Effects: Sequence Points ....................................................... 421
13.5 Avoiding Problems Caused by Side Effects..................................................... 425
13.6 Forcing a Particular Order of Evaluation ........................................................ 425
13.7 Short-Circuit Evaluation ................................................................................ 427
13.7.1 Short-Circuit Evaluation and Boolean Expressions............................ 428
15.1.2 Forcing Short-Circuit Boolean Evaluation in a while Loop ................. 501
15.2 The repeat..until (do..until/do..while) Loop..................................................... 504
15.2.1 Forcing Complete Boolean Evaluation in a repeat..until Loop............ 507
15.2.2 Forcing Short-Circuit Boolean Evaluation in a repeat..until Loop ........ 510
15.3 The forever..endfor Loop .............................................................................. 515
15.3.1 Forcing Complete Boolean Evaluation in a forever Loop................... 518
15.3.2 Forcing Short-Circuit Boolean Evaluation in a forever Loop ............... 518
15.4 The Definite Loop (for Loops) ........................................................................ 518
15.5 For More Information................................................................................... 520
1 6
F UN C TI O N S A ND P R O CE D UR E S 521
16.1 Simple Function and Procedure Calls ............................................................. 522
16.1.1 Storing the Return Address ........................................................... 525
16.1.2 Other Sources of Overhead ......................................................... 529
16.2 Leaf Functions and Procedures ...................................................................... 530
16.3 Macros and Inline Functions ......................................................................... 534
16.4 Passing Parameters to a Function or Procedure ............................................... 540
16.5 Activation Records and the Stack .................................................................. 547
16.5.1 Composition of the Activation Record ............................................ 549
16.5.2 Assigning Offsets to Local Variables .............................................. 552
16.5.3 Associating Offsets with Parameters .............................................. 554
16.5.4 Accessing Parameters and Local Variables ..................................... 559
16.6 Parameter-Passing Mechanisms..................................................................... 567
16.6.1 Pass-by-Value ............................................................................. 568
16.6.2 Pass-by-Reference........................................................................ 568
16.7 Function Return Values................................................................................. 570
16.8 For More Information................................................................................... 577
EN GI N EERI N G S O F TW A RE 579
A PP EN DI X A BR I EF CO M PA R IS O N O F TH E 8 0 X 86 AN DP O WER P C CP U F AM IL I ES 581
A.1 Architectural Differences Between RISC and CISC............................................. 582 A.1.1 Work Accomplished per Instruction................................................. 582 A.1.2 Instruction Size ............................................................................. 583 A.1.3 Clock Speed and Clocks per Instruction........................................... 583 A.1.4 Memory Access and Addressing Modes .......................................... 584 A.1.5 Registers...................................................................................... 585 A.1.6 Immediate (Constant) Operands ..................................................... 585 A.1.7 Stacks ......................................................................................... 585
A.2 Compiler and Application Binary Interface Issues.............................................. 586 A.3 Writing Great Code for Both Architectures....................................................... 587
O N L IN E AP P EN DI CE S 589
I ND EX 591
A C K N O W L E D G M E N T S
Originally, the material in this book was intended to appear as the last chapter of Write Great Code, Volume 1. Hillel Heinstein, the developmental editor for Volume 1, was concerned that the chapter was way too long and, despite its length, did not do the topic justice. We decided to expand the material and turn it into a separate volume, so Hillel is the first person I must acknowledge for this book’s existence.
Of course, turning a 200-page chapter into a complete book is a major undertaking, and there have been a large number of people involved with the production of this book. I’d like to take a few moments to mention their names and the contributions they’ve made.