| Index Entry | | Section |
|---|
|
| A | | |
|---|
| actual source: | | The Original and Actual Source |
| advising: | | Encapsulation Functions |
| aliens: | | Type Translations |
| argument syntax, efficiency: | | Complex Argument Syntax |
| arithmetic, generic: | | Generic Arithmetic |
| arithmetic type inference: | | Operation Specific Type Inference |
| array types, specialized: | | Specialized Arrays |
| arrays, efficiency of: | | Arrays |
| assembly listing: | | Trace Files and Disassembly |
| availability of debug variables: | | Variable Value Availability |
|
| B | | |
|---|
| benchmarking techniques: | | Benchmarking Techniques |
| bignums: | | Fixnums |
| bit-vectors, efficiency of: | | Bit-Vectors |
| block, basic: | | Source Location Availability |
| block, start location: | | Source Location Availability |
| block compilation, debugger implications: | | Funny Frames |
| block compilation: | | Block Compilation |
| breakpoints: | | Breakpoint Commands |
| breakpoints, errors: | | Function Tracing |
| breakpoints, function-end: | | Function Tracing |
| byte coded compilation: | | Byte Coded Compilation |
|
| C | | |
|---|
| call, local: | | Local Call |
| call, inline: | | Inline Expansion |
| call, numeric operands: | | Interactions With Local Call |
| canonicalization of types: | | Canonicalization |
| characters: | | Representation of Characters |
| cleanup, stack frame kind: | | Funny Frames |
| closures: | | Closures |
| compatibility with other Lisps: | | Getting Existing Programs to Run |
| compilation, units: | | Compilation Units |
| compilation, block: | | Block Compilation |
| compilation, why to: | | Compile Your Code |
| compilation-speed optimization quality: | | The Optimize Declaration |
| compile time type errors: | | Compile Time Type Errors |
| compile-file, block compilation arguments: | | Compiler Arguments |
| compiler error messages: | | Interpreting Error Messages |
| compiler error severity: | | Error Severity |
| compiler policy: | | Compiler Policy |
| compiling: | | Calling the Compiler |
| complemented type checks: | | Type Check Optimization |
| conditional type inference: | | Dynamic Type Inference |
| consing, overhead of: | | Descriptors |
| consing: | | Avoid Unnecessary Consing |
| consing: | | Profiling |
| constant folding: | | Constant Folding |
| constant-function declaration: | | Constant Folding |
| context sensitive declarations: | | Context Declarations |
| continuations, implicit representation: | | Trace Files and Disassembly |
| control optimization: | | Control Optimization |
| CPU time, interpretation of: | | A Note on Timing |
| cross-referencing: | | Cross-Referencing Facility |
|
| D | | |
|---|
| dead code elimination: | | Unused Expression Elimination |
| dead code elimination: | | Unreachable Code Deletion |
| debug optimization quality: | | Variable Value Availability |
| debug optimization quality: | | Source Location Availability |
| debug optimization quality: | | Compiler Policy Control |
| debug optimization quality: | | The Optimize Declaration |
| debug variables: | | Variable Access |
| debugger: | | The Debugger |
| declarations, optimize: | | The Optimize Declaration |
| declarations, optimize-interface: | | The Optimize-Interface Declaration |
| declarations, block compilation: | | Block Compilation Declarations |
| declarations, context-sensitive: | | Context Declarations |
| defstruct types: | | Structure Types |
| derivation of types: | | Type Inference |
| descriptor representations, forcing of: | | Representation Efficiency Notes |
| descriptors, object: | | Descriptors |
| dynamic type inference: | | Dynamic Type Inference |
| dynamic-extent: | | Dynamic-Extent Declarations |
| dynamic-extent, rest lists: | | &rest argument lists |
| dynamic-extent, closures: | | Dynamic-Extent Closures |
| dynamic-extent, known CL functions: | | Dynamic-Extent Closures |
| dynamic-extent, list, list*, cons: | | list list* and cons |
|
| E | | |
|---|
| effective method: | | Inlining Methods in Effective Methods |
| effective method, inlining of methods: | | Inlining Methods in Effective Methods |
| effective method, precomputation: | | Effective Method Precomputation |
| efficiency, of objects: | | Object Representation |
| efficiency, of numeric variables: | | Variables |
| efficiency, general hints: | | General Efficiency Hints |
| efficiency, of memory use: | | Avoid Unnecessary Consing |
| efficiency, of argument syntax: | | Complex Argument Syntax |
| efficiency, of type checking: | | Efficiency Notes and Type Checking |
| efficiency notes: | | Efficiency Notes |
| efficiency notes, for representation: | | Representation Efficiency Notes |
| efficiency notes, verbosity: | | Verbosity Control |
| empty type, the: | | The Empty Type |
| encapsulation: | | Encapsulation Functions |
| end-block declaration: | | Block Compilation Declarations |
| entry points, external: | | Funny Frames |
| equivalence of types: | | Canonicalization |
| error messages, compiler: | | Interpreting Error Messages |
| error messages, verbosity: | | Error Message Parameterization |
| errors, run-time: | | Unknown Locations and Interrupts |
| errors, breakpoints: | | Function Tracing |
| errors, result type of: | | The Empty Type |
| evaluation, debugger: | | The Command Loop |
| evaluation, debugger: | | Note On Lexical Variable Access |
| existing programs, to run: | | Getting Existing Programs to Run |
| expansion, inline: | | Inline Expansion |
| external, stack frame kind: | | Funny Frames |
| external entry points: | | Funny Frames |
|
| F | | |
|---|
| fixnums: | | Fixnums |
| floating point efficiency: | | Floating Point Efficiency |
| folding, constant: | | Constant Folding |
| frames, stack: | | Stack Frames |
| free, C function: | | System Area Pointers |
| freeze-type declaration: | | The Freeze-Type Declaration |
| function, names: | | Function Names |
| function, tracing: | | Function Tracing |
| function, types: | | Function Types |
| function, type inference: | | Global Function Type Inference |
| function call, local: | | Local Call |
| function call, inline: | | Inline Expansion |
| function wrappers: | | Function Wrappers |
| function-end breakpoints: | | Function Tracing |
| fwrappers: | | Function Wrappers |
|
| G | | |
|---|
| garbage collection: | | Avoid Unnecessary Consing |
| generic arithmetic: | | Generic Arithmetic |
|
| H | | |
|---|
| hash-tables, efficiency of: | | Hashtables |
| hierarchical packages: | | Hierarchical Packages |
|
| I | | |
|---|
| implicit continuation representation (IR1): | | Trace Files and Disassembly |
| inference of types: | | Type Inference |
| inhibit-warnings optimization quality: | | The Optimize Declaration |
| inline: | | Inlining Methods in Effective Methods |
| inline expansion: | | Compiler Policy Control |
| inline expansion: | | Open Coding and Inline Expansion |
| inline expansion: | | Inline Expansion |
| Internationalization: | | Internationalization |
| interpretation of run time: | | A Note on Timing |
| interrupts: | | Unknown Locations and Interrupts |
|
| K | | |
|---|
| keyword argument efficiency: | | Complex Argument Syntax |
|
| L | | |
|---|
| let optimization: | | Let Optimization |
| lisp threads: | | Lisp Threads |
| listing files, trace: | | Trace Files and Disassembly |
| lists, efficiency of: | | Think Before You Use a List |
| local call, type inference: | | Local Function Type Inference |
| local call: | | Local Call |
| local call, return values: | | Return Values |
| local call, numeric operands: | | Interactions With Local Call |
| locations, unknown: | | Unknown Locations and Interrupts |
| logical pathnames: | | Logical Pathnames |
|
| M | | |
|---|
| macroexpansion: | | The Processing Path |
| macroexpansion, errors during: | | Errors During Macroexpansion |
| malloc, C function: | | System Area Pointers |
| mapping, efficiency of: | | Mapping and Iteration |
| maybe-inline declaration: | | The Maybe-Inline Declaration |
| member types: | | Member Types |
| memory allocation: | | Avoid Unnecessary Consing |
| methods: | | Automatic Method Recompilation |
| methods, auto-compilation: | | Automatic Method Recompilation |
| methods, inlining in effective methods: | | Inlining Methods in Effective Methods |
| methods, load time: | | Effective Method Precomputation |
| methods, emf precomputation: | | Effective Method Precomputation |
| methods, sealing: | | Sealing |
| methods, tracing: | | Method Tracing and Profiling |
| methods, profiling: | | Method Tracing and Profiling |
| methods, interpreted: | | Misc |
| modular-arith: | | Modular Arithmetic |
| multiple value optimization: | | Multiple Values Optimization |
|
| N | | |
|---|
| names, function: | | Function Names |
| NIL type: | | The Empty Type |
| non-descriptor representations: | | Non-Descriptor Representations |
| non-descriptor representations: | | Representation Efficiency Notes |
| notes, efficiency: | | Efficiency Notes |
| numbers in local call: | | Interactions With Local Call |
| numeric, type inference: | | Operation Specific Type Inference |
| numeric, types: | | Numbers |
| numeric, operation efficiency: | | Generic Arithmetic |
|
| O | | |
|---|
| object representation: | | Object Representation |
| object representation: | | Descriptors |
| object representation efficiency notes: | | Representation Efficiency Notes |
| object sets: | | Object Sets |
| open-coding: | | Open Coding and Inline Expansion |
| operation specific type inference: | | Operation Specific Type Inference |
| optimization, type check: | | Type Check Optimization |
| optimization: | | Source Optimization |
| optimization, let: | | Let Optimization |
| optimization, control: | | Control Optimization |
| optimization, multiple value: | | Multiple Values Optimization |
| optimization, function call: | | Inline Expansion |
| optimization, type check: | | Efficiency Notes and Type Checking |
| optimize declaration: | | Compiler Policy Control |
| optimize declaration: | | The Optimize Declaration |
| optimize-interface declaration: | | The Optimize-Interface Declaration |
| optional, stack frame kind: | | Funny Frames |
| or (union) types: | | Union Types |
| original source: | | The Original and Actual Source |
|
| P | | |
|---|
| package locks: | | Package Locks |
| pointers: | | System Area Pointers |
| policy, debugger: | | Compiler Policy Control |
| policy, compiler: | | Compiler Policy |
| precise type checking: | | Precise Type Checking |
| primary method: | | Primary Method Errors |
| processing path: | | The Processing Path |
| profiling: | | Method Tracing and Profiling |
| profiling, methods: | | Method Tracing and Profiling |
| profiling: | | Profiling |
|
| R | | |
|---|
| random number generation: | | Random Number Generation |
| random number generation, MT-19937 generator: | | MT-19937 Generator |
| random number generation, xoroshiro128+: | | xoroshiro128+ Generator |
| read errors, compiler: | | Read Errors |
| recording of inline expansions: | | Inline Expansion Recording |
| recursion, tail: | | Debug Tail Recursion |
| recursion: | | Tail Recursion |
| recursion, self: | | Self-Recursive Calls |
| recursion, tail: | | Local Tail Recursion |
| representation, object: | | Object Representation |
| representation, object: | | Descriptors |
| representation efficiency notes: | | Representation Efficiency Notes |
| require: | | Extension to REQUIRE |
| rest argument efficiency: | | Complex Argument Syntax |
| return values, local call: | | Return Values |
| run time, interpretation of: | | A Note on Timing |
|
| S | | |
|---|
| safety optimization quality: | | The Optimize Declaration |
| sealing: | | Sealing |
| sealing, subclasses: | | Sealing |
| sealing, methods: | | Sealing |
| search lists: | | Search Lists |
| semi-inline expansion: | | Compiler Policy Control |
| severity of compiler errors: | | Error Severity |
| signals: | | Unix Signals |
| simple-streams: | | Simple Streams |
| slot access optimization: | | Slot Access Optimization |
| slot declaration, slot-boundp: | | slot-boundp Declaration |
| slot declaration, inline: | | inline Declaration |
| slot declaration, method recompilation: | | Automatic Method Recompilation |
| slot declarations: | | Slot Access Optimization |
| slot type checking: | | Slot Type Checking |
| source location printing, debugger: | | Source Location Printing |
| source-to-source transformation: | | The Processing Path |
| source-to-source transformation: | | Source to Source Transformation |
| space optimization: | | Byte Coded Compilation |
| space optimization quality: | | The Optimize Declaration |
| specialized array types: | | Specialized Arrays |
| specialized structure slots: | | Specialized Structure Slots |
| speed optimization quality: | | The Optimize Declaration |
| stack frames: | | Stack Frames |
| stack numbers: | | Non-Descriptor Representations |
| stack numbers: | | Representation Efficiency Notes |
| start-block declaration: | | Block Compilation Declarations |
| static functions: | | Open Coding and Inline Expansion |
| strings: | | Representation of Characters |
| structure types: | | Structure Types |
| structure types, efficiency of: | | Structure Representation |
| structure types, numeric slots: | | Specialized Structure Slots |
| style recommendations: | | Type Style Recommendations |
| style recommendations: | | Style Recommendations |
|
| T | | |
|---|
| tail recursion: | | Debug Tail Recursion |
| tail recursion: | | Tail Recursion |
| tail recursion: | | Local Tail Recursion |
| time formatting: | | Time Parsing and Formatting |
| time parsing: | | Time Parsing and Formatting |
| timing: | | Profiling |
| trace files: | | Trace Files and Disassembly |
| tracing: | | Method Tracing and Profiling |
| tracing, methods: | | Method Tracing and Profiling |
| tracing: | | Function Tracing |
| tracing, errors: | | Function Tracing |
| transformation, source-to-source: | | Source to Source Transformation |
| tuning: | | Efficiency Notes |
| tuning: | | Profiling |
| type checking, at compile time: | | Compile Time Type Errors |
| type checking, precise: | | Precise Type Checking |
| type checking, weakened: | | Weakened Type Checking |
| type checking, optimization: | | Type Check Optimization |
| type checking, efficiency of: | | Efficiency Notes and Type Checking |
| type declarations, variable: | | Variables |
| type inference: | | Type Inference |
| type inference, dynamic: | | Dynamic Type Inference |
| types, in python: | | Types in Python |
| types, portability: | | Getting Existing Programs to Run |
| types, in python: | | More About Types in Python |
| types, equivalence: | | Canonicalization |
| types, function: | | Function Types |
| types, structure: | | Structure Types |
| types, restrictions on: | | Type Restrictions |
| types, numeric: | | Numbers |
| types, specialized array: | | Specialized Arrays |
| types, uncertainty: | | Type Uncertainty |
| types, alien: | | Type Translations |
| types, foreign language: | | Type Translations |
|
| U | | |
|---|
| uncertainty of types: | | Type Uncertainty |
| undefined warnings: | | Undefined Warnings |
| union (or) types: | | Union Types |
| unix, pathnames: | | Unix Pathnames |
| unix signals: | | Unix Signals |
| unknown code locations: | | Unknown Locations and Interrupts |
| unreachable code deletion: | | Unreachable Code Deletion |
| unused expression elimination: | | Unused Expression Elimination |
|
| V | | |
|---|
| validity of debug variables: | | Variable Value Availability |
| values declaration: | | The Values Declaration |
| variables, debugger access: | | Variable Access |
| variables, non-descriptor: | | Variables |
| vectors, efficiency of: | | Vectors |
| verbosity, of error messages: | | Error Message Parameterization |
| verbosity, of efficiency notes: | | Verbosity Control |
| Virtual Machine (VM, or IR2) representation: | | Trace Files and Disassembly |
|
| W | | |
|---|
| weakened type checking: | | Weakened Type Checking |
| word integers: | | Word Integers |
|