Grapple Man (Prototype) Mac OS

1. Grapple Man (prototype) Mac Os X
2. Grapple Man (prototype) Mac Os Catalina

This document is a Mac OS X manual page. Manual pages are a command-line technology for providing documentation. You can view these manual pages locally using the man(1) command. These manual pages come from many different sources, and thus, have a variety of writing styles. Mack Grapples are designed to be durable and long lasting. Some of the advantages of Mack Grapples include: Wear points are hardened to extend service Moving parts are supplied with protective grease fittings to prevent accidental damage and ensure proper lubrication.

These notes are for the MacOS X Xcode 2.0 Release of the compilertools. They contain information about the following topics:

• The Mac OS X Mach-O GNU-based assemblers
• The Mac OS X 32-bit Mach-O static link editor
• Mach-O object file tools (nm, otool, and so on)

Notes Specific to Mac OS X Xcode 2.0 Release

New Features

The tools now support development of 64-bit Mach-O binaries forthe PowerPC with the -arch ppc64 flag. The one tool that has not beenseamlessly ported for this release is otool(1). And there is anotool64(1) for 64-bit Mach-O binaries.

Notes Specific to Mac OS X Xcode 1.5 Release

New Features

The static linker has an option to do dead codestripping

Highest number in roulette. The static link editor now can do dead code stripping. The newld(1) option to do this is -dead_strip. There is alsoan additional option -no_dead_strip_inits_and_terms that canbe used when -dead_strip is specified to cause allconstructors and destructors to never be dead code stripped. The loadmap printed with the ld(1) option -M notes what wasdead stripped from the input files.

There is one known bug with the tools that do dead code stripping.It is possible for some debugging information for types made to bestripped. This can lead to the debugger not being able to print thevalues of some variables and get unknow type errors.

For testing, the environment variable LD_DEAD_STRIP can be set.which causes -dead_strip to specified for all ld(1)commands that don't specify the -r option. The environmentvariable LD_NO_DEAD_STRIP_INITS_AND_TERMS likewise causes-no_dead_strip_inits_and_terms to specified for allld(1) commands that don't specify the -r option. Andthe environment variable LD_DEAD_STRIP_DYLIB causes-dead_strip to specified for all ld(1) commands thathave the -dylib option specified.

The static link editor determines what unreachable code and datacan be stripped based on the references from the initial live symbolsand blocks. The initial live symbols include the symbols to beexported in the linked output. The set of exported symbols arespecified with the -exported_symbols_list option or a list ofsymbols not to be exported is specified with the-unexported_symbols_list option. If no exported symbols arespecified and the output is not an executable (shared library,bundle, etc) it is assumed all global symbols are to be exported. Ifthe output is a shared library and a shared library initializationsymbol is specified with -initsymbol_name option thenthat symbol_name is an initial live symbol. If the output isan executable then the block that contains the entry point or thesymbol specified with the -esymbol_name is an initiallive symbol. Other symbols can be marked by the programmer as aninitial live symbols with the GNU compiler's __attribute__((used)).For Objective-C code, the compiler will also mark the blocks ofObjective-C runtime data it produces so they are part of the initiallive blocks. For symbols marked referenced dynamically (via theREFERENCED_DYNAMICALLY bit in <mach-o/nlist.h>), such as thesymbol _environ from /usr/lib/crt1.o, they are also part ofthe initial live symbols.

Before turning on the -dead_strip option your project willfirst have to be 'ported' to work with dead code stripping. This willinclude changing from -gused (the default for -g) to -gfull andre-compiling all of the objects files being linked into your programwith the new compiler from the Mac OS X June 2004 release. Also ifyour building an executable that loads plugins, which uses symbolsfrom the executable, you will have to make sure the symbols theplugins use are not stripped (by using __attribute__((used)) or the-exported_symbols_list option). If you are using an exportlist and building a shared library, or an executable that will beused with ld(1)'s -bundle_loader flag, you need to include thesymbols for exception frame information in the export list for yourexported C++ symbols. These symbols end with .eh and can be seen withthe nm(1) tool.

Various auto configure test programs that expect to get undefinedsymbol errors when they have a possible undefined symbol referencedfrom dead code can't use the -dead_strip option. Because thedead code and the unused undefined reference will be strippedallowing the program to successfully linked. We have geneally foundthat auto configure programs on UNIX based system can't be configuredwith the -dead_strip option on.

Recompiling with a new compiler is required to get effective deadcode stripping. As it marks the object files it creates as OK todivide up the section contents into individual blocks by the symbolsthat are in the object files. Objects not marked are assumed to begenerated from assembly code, older compilers, or from compilers thatare not know to be safe to divide up their section contents by theirsymbols. For non-marked objects if any symbol is used from a sectionthe entire section is kept and not dead stripped.

Work around for objects incorrectly marked object files as OK todivide up

The new compiler unconditionally marks the object files it createsas OK to divide up. There may be cases, especially with asm()statements, that it should not mark the object it creates as OK todivide up. In these cases turning on the -dead_strip optionmay fail to produce a working program because it can incorrectlystrip a live block. The reason for this is that the heuristic ofdividing up the section contents by their symbols is incorrect if anyindividual block has more than one symbol. This makes the heuristicfragile.

The reason that the current dead code stripping inplementation isfragile is because the static linker is guessing at the structure ofthe program. Namely it is guess at which bytes of a section make up aindividual block of code or data. It makes its guess based on thesymbols that are in the object files being linked. In the same way itguesses for the blocks it uses for the -sectorder option. Withthe difference being that all sections are broken up into individualblocks with the goal to eliminate the unreachable (dead) blocks inthe linked output. The reason this is fragile is that all the symbolsin an object file may not be the start of an individual block.

As a workaround to the problem of incorrectly strip a live blockyou can produce a -sectorder file for objects that havesection contents that must be linked whole. You would create a linein the sectorder file specifying the object and the psuedo symbol.section_all. For example if .text section of crt1.o and thearchive member of darwin-tramp.o in libgcc.a must be linked whole,you would add the following:

/usr/lib/crt1.o:.section_all
/usr/lib/libgcc.a:darwin-tramp.o:section_all

to your order_file for the __TEXT __text section. Then usethe ld(1) option -sectorder __TEXT __text order_filewhen linking.

Current design limitations

There is a limitation in the current design for individual blocksthat have no symbols visible in the object file. Symbols that aretemporary labels that start with a 'L', or symbols that have beenstripped. An individual block that starts with these symbols willappear to be part of the previous block that has a symbol in theobject file. This can result in a linked image that does not have allof its dead code stripped. When what would have been a deadindividual block becomes part of the previous block which is live.Causing the dead individual block and all of its references to belive.

By default when there are multiply defined symbols in the linkedobjects this is treated as an error. Even when the -dead_stripoption is specified. Unused multiply defined symbols can be strippedif the strongly discouraged -m option is also specified. Theduplicate symbols other than the first symbol may still end up beingused in the resulting output file through local referenceshowever.

Symbols from the linked objects in the output file that are onlyreferenced via a shared library will not be dead stripped. Currentlythe static linker marks them with the REFERENCED_DYNAMICALLY bit in<mach-o/nlist.h> which causes them to be live.

There is no support in the current design to dead strip branchislands created with the compiler option -mlongcall.

Assembly level and object file support for dead codestripping

Marking of objects that can have their section contents dividedup

The marking of object files which are OK to divide their sectioncontents into individual blocks is done with the new assemblerdirective .subsections_via_symbols. This directive sets apreviously unused bit in the object file's mach_header structure inthe flags field. This bit is defined as the following new constant inthe header file <mach-o/loader.h>:

#define MH_SUBSECTIONS_VIA_SYMBOLS 0x2000 /* safe to divide up the sections into
sub-sections via symbols for dead
code stripping */

This can be see with otool(1)'s -hv options andshows up as SUBSECTIONS_VIA_SYMBOLS in the followingoutput:

% otool.NEW -hv a.out
a.out:
Mach header
magic cputype cpusubtype filetype ncmds sizeofcmds flags
MH_MAGIC PPC ALL OBJECT 3 228 SUBSECTIONS_VIA_SYMBOLS

The new assembler directive .subsections_via_symbols can beadded to hand written assembly files provided the symbols are at thestart of individual blocks. Since this applies to the entire file,when multiple object files are combined by the static link ediror,ld(1), to produce a relocable object, using the -r flag, if any ofthe objects do not have this flag set the output file will not havethis flag set.

For example this assembly code contains only two individual blocksbut four symbols:

.text
.globl _plus_three
_plus_three:
addi r3, r3, 1
.globl _plus_two
_plus_two:
addi r3, r3, 1
.globl _plus_one
_plus_one:
addi r3, r3, 1
blr
.globl _some_other_routine
_some_other_routine:
blr

And if the new assembler directive .subsections_via_symbolswere added to the above code the static link editor would make 4blocks about of the above code. Then if the program uses _add_threebut not _add_two or _add_one it will get the wrong answer if the-dead_strip option is used. As the blocks for _add_two or_add_one will be dead stripped. And if _some_other_routine is notlive then when _add_three is called it will fall through to what everbit of code follows it and likely crash.

The .no_dead_strip assembler directive

The new assembler directive .no_dead_stripsymbol_name can be used to specify that a symbol is not to bedead stripped. For example:

.no_dead_strip _my_version_string
.cstring
_my_version_string:
.ascii 'cctools-501'

This can be seen (in object files only) with nm(1)'s-m option and shows up as [no dead strip] inthe following output:

% nm -m x.o
00000000 (__TEXT,__cstring) non-external [no dead strip] _my_version_string

The .no_dead_strip directive is generated by the newcompiler when the __attribute__((used)) is specified on a symbol.

In object files, this bit is N_NO_DEAD_STRIP as defined in<mach-o/nlist.h>. And is set in relocatable .o files (MH_OBJECTfiletype) only in the n_desc field of an nlist struct.

The section attribute no_dead_strip

The new section attribute no_dead_strip can be specified ona section to cause its entire contents to not to be dead stripped.The new compiler uses this for all Objective-C sections it creates.For example:

Grapple Man (prototype) Mac Os X

.section __OBJC, __image_info, regular, no_dead_strip

In object files, this bit is S_ATTR_NO_DEAD_STRIP as defined in<mach-o/loader.h>. And is set in the flags field of a sectionstruct.

The section attribute live_support

The new section attribute live_support can be specified ona section to cause its blocks to not be dead stripped if theyreference something that is live. The new compiler uses this for C++exception frame information. For example:

.section __TEXT, __eh_frame, coalesced, no_toc+strip_static_syms+live_support

In object files, this bit is S_ATTR_LIVE_SUPPORT as defined in<mach-o/loader.h>. And is set in the flags field of a sectionstruct.

The assembler has a new .machinedirective

The assembler now takes a new .machine directive as analternate to using the command line -archarch_nameoption. It is specified as for example as:

.machine ppc970

Where ppc970 can be any arch_name that would appearin the -archarch_name option as listed on thearch(3) man page for the assembler's architecture family.

Notes Specific to Mac OS X 10.3.4 Release

New Features

Improved launch times of applications

The dynamic linker has been changed that improve launch times ofapplications.

The redo_prebinding command supportsunprebinding

The redo_prebinding(1) command has a new option, -u,that does a unprebind operation. The unprebind operation produces acanonical form of a Mach-O file that can be used for binary diffingand patching. Bundles and non-prebound executables and dylibs canalso be canonicalized with the unprebind operation.

Notes Specific to Mac OS X December 2003 Release

• There are no notes specific to the Mac OS X December 2003 release of the compiler tools.

Notes Specific to Mac OS X 10.3 Release

New Features

The static linker has an option to find@executable_path dynamic libraries

Added the -executable_path path_name option told(1) where path_name is is used to replace@executable_path for dependent libraries.

Notes Specific to Mac OS X June 2003 Developer Release

New Features

The compiler tools now support the PowerPC 970processor

The compiler tools now support the PowerPC 970 processor. Thearchitecture specific flag -arch ppc970 is used to specifythis specific processor. The assembler will only assemble 64-bitinstructions and other PowerPC AS User Instruction Set ArchitectureVersion 2.00 instructions supported by the PowerPC 970 processor when-arch ppc970 or -force_cpusubtype_ALL is specified.

To specify branch predictions which use the AT bit encodings forThe branch is very likely to be taken and The branch isvery likely not to be taken the two character suffixes ++ and --are used. For example:

bge-- foo

The single character suffixes + and - continue to encode branchpredictions which use the Y-bit encoding by default. The encoding canbe changed for the single character suffixes to use the AT bitencodings with the assembler flag-static_branch_prediction_AT_bits (see the as(1) manpage for more details).

The compiler tools now support stublibraries

The compiler tools now support stub libraries created from dynamiclibraries which are used in the SDKs. Stub libraries are created viastrip(1) and the new -c option. And can be linkedagainst in place of the actual dynamic library.

The static linker now can search for librariesfirst in the library paths

By default when the -dynamic flag is in effect, the-lx and -weak-lx options first search fora file of the form libx.dylib in each directory in the librarysearch path, then a file of the form libx.a is searched for inthe library search paths. The new option -search_paths_firstchanges it so that in each path libx.dylib is searched forthen libx.a before the next path in the library search path issearched.

The static linker now supports forcing a dynamiclibrary to be weak

Added the -weak_framework, -weak_library and-weak-l options to ld(1) to force the dynamic libraryand the symbols referenced from it to be marked as weak imports. Seethe ld(1) man page for more details.

The static linker now has a work around for nothaving dead code stripping

Added the -undefined define_a_way option to ld(1) asa work a round to not having dead-code stripping that also strips outreferences to undefined symbols from the dead code. Which leads tolink time failures due to undefined symbols. With this optionld(1) defines the remaining undefined symbols as privatedefinitions and allows the link to succeed. The program then runs aslong as it does not use any of the undefined symbols.

Notes Specific to Mac OS X November 2002 Developer Release

New Features

Exports lists can now be specified to the staticlinker

The static link editor, ld(1), now has two new options,-exported_symbols_list filename and-unexported_symbols_list filename to limit theglobal symbols in the linked output file. This was previously done bywith an nmedit(1). By using the new options to ld(1)the use of nmedit(1) can be eliminated resulting in fasterbuild times.

The static linker now can build single moduledynamic libraries

The static link editor, ld(1), now has a new option,-single_module, to build a dynamic library containing only onemodule. This was previously done by first creating a master.o filewith an ld(1) -r step and then using the master.o tocreated the dynamic library. By using the new -single_moduleoption to ld(1) this first step can be eliminated resulting infaster build times.

The default in the static link editor remains the same and dynamiclibraries are built with multiple modules. The new flag-multi_module has also been added to allow this to beexplicitly specified.

The static linker's -s option now works likestrip on dynamic executables

The static link editor's -s option can now be used to stripan executable that use the dynamic link editor. This will produce thesame result as running strip(1) with no options on theexecutable. By using the -s option when building an executablethe strip(1) step can be eliminated resulting in faster buildtimes.

Notes Specific to Mac OS X 10.2 Release

The compiler tools for the MacOS X 10.2 Release must be used withprebound images (executables, and shared libraries) from the MacOS X10.2 User Release. The compiler tools in MacOS 10.1 will not workwith prebound images from with the MacOS X 10.2 User Release. If the10.1 compiler tools are used on prebound images from the MacOS X 10.2User Release the compiler tools will generate error messagesindicating that the image is a malformed file.

New Features

The dynamic linker now supports weak referencesand weak dylibs

The dynamic linker now supports weak symbol references and weakdymamic libraries. When creating a binary with the static link editorif all the symbols referenced from a given dependent dynamic libraryare weak references then the library is marked weak. When the binaryis used at execution time and a weak library is missing the dynamiclinker will not cause an error. For all weak symbols that are missingexecution time the dynamic linker uses zero as their address. Thisallows a weak symbol's address to be tested for zero at runtimeallowing the code to avoid using the weak symbol when it is missing.Binaries that use weak references require a dynamic linker from MacOS X 10.2 or later.

To indicate a symbol is to be a weak reference the__attribute((weak_import)) is used on the prototype of the symbol.When a binary is created by the static link editor normally the allthe undefined symbol references of the object files being linkedshould be consistent for each undefined symbol. That is all undefinedsymbols should either be weak or non-weak references. If they are notby default this is treated as an error and can be changed with theld(1) -weak_reference_mismatchestreatment flag (seethe ld(1) man page for more details).

Weak referenced symbols and weak libraries are only created in theoutput by the static link editor, ld(1), when theMACOSX_DEPLOYMENT_TARGET environment variable is set to 10.2. If nota warning is generated when a weak reference would be in the outputand it is not marked weak. Note the default for theMACOSX_DEPLOYMENT_TARGET environment variable 10.1 so weak referencedsymbols and weak libraries are not created by default. See theld(1) man page for more information on theMACOSX_DEPLOYMENT_TARGET environment variable.

redo_prebinding can now slide dylibs

The redo_prebinding(1) command now can slide dymamic libraries tonew prefered addresses (see the man page for more details).

Grapple Man (prototype) Mac Os Catalina

Notes Specific to Mac OS X 10.1 Release

You must use the 10.1 compiler tools with images (executables,plugins and shared libraries) created with the 10.1 tools. Thecompiler tools in MacOS 10.0 will not work with images created withthe 10.1 compiler tools. If you attempt to use the 10.0 compilertools on images created with the 10.1 compiler tools, error messagesmay result indicating that the image is a malformed file.

By default the compiler tools build images using the new two-levelnamespace binding semantics, which has important consequences forcompatibility with Mac OS X 10.0 (see belowfor more information).

New Features

The following new features have been added to the Compiler Toolsfor the Mac OS X 10.1 system release.

• The compiler tools now support two-level namespaces for binding undefined references from shared libraries. In flat namespace images, all symbols are referenced globally using a single name table. In two-level namespace images, symbols are referenced by library name and symbol name. This prevents multiple-defined-symbol errors when one image exports the same symbol as another image in the same program. You must rebuild your applications and plugins to take advantage of this feature, and there are compatibility restrictions with Mac OS X 10.0 that you should understand. For more information see the ld(1) man page and the two-level namespace release note.
• The dynamic linker now has API's for doing two-levelnamespace lookups. They are NSAddImage(), NSLookupSymbolInImage() and NSIsSymbolNameDefinedInImage(). For more information see the NSModule(3) man page. [This fixes Apple bug number 2689833.]
• Prebinding is now documented in a release note. [This fixes Apple bug number 2611234.]

Notes Specific to Mac OS X 10.0 Release

• There are no notes specific to the Mac OS X 10.0 release of the compiler tools.

Notes Specific to Mac OS X Public Beta Release

New Features

The following new features have been added to the Compiler Toolssince the Mac OS X Developer Release 4.

• The dynamic linker now calls shared library initialization routines in their dependent order (reference number 2441683).
• The new function __initialize_Cplusplus() now can be called from a shared library initialization routine to cause the static C++ objects in the library to be initialized. This allows shared library initialization routines to make use of statically initialized C++ objects (reference number 2441683).
• The dynamic linker now supports module termination functions for all types of images (executables, plugins that are not unloaded and shared libraries). See the decription below as part of the notes specific to Mac OS X Developer preview of module termination functions (reference number 2469527).
• The compiler tools support the new directory layout for MacOS X Public Beta. The new location for Frameworks local to the machine is /MacOSX/Library/Framework (in DP4 and previous releases this was /Local/Library/Frameworks).

Notes Specific to Mac OS X Developer Release 4

• There are no notes specific to the compiler tools for Developer Release 4.

Notes Specific to Mac OS X Developer Release 3

New Features

The following new features have been added to the Compiler Toolssince the Mac OS X Developer Release 2.

• The static linker supports removing duplicate debugging information from header files when this information appears in multiple linked object files. This is done with the -Si option to the static link editor and is now the default. To have no symbols stripped when linking use the new -Sn option.

Notes Specific to Mac OS X Developer Release 2

New Features

The following new features have been added to the Compiler Toolssince the Mac OS X Developer Preview Release.

• Dynamic shared libraries now can have a dynamic shared library initialization routine (reference number 2367584). This routine is specified to libtool(1) with the new '-init symbol_name' argument. The library initialization routine is called before any symbol is used from the library including C++ static initializers (and #pragma CALL_ON_MODULE_BIND routines). So the code in a library initialization routine or code called by it can not depend on C++ static initializers. Also code in a library initialization routine or code called by it can not call any of the dynamic linker API, <mach-o/dyld.h>, otherwise that could result in more than one library initialization routine being partially executed on the stack.
• The dynamic linker now supports shared library install names that start with '@executable_path/' and substitutes the directory path of the executable for '@executable_path/'when locating the library. This requires a kernel from Mac OS X Developer Release 2 or later. Without that kernel, this feature can only be used if argv[0] is in fact the name of the executable and it is an absolute path or relative to the current directory (contains at a '/' in the argv[0] string).
• The NSLinkModule() API now has an option to cause it to return when there is an error loading the module and a new API NSLinkEditError() to get the error information. To use this the constant NSLINKMODULE_OPTION_RETURN_ON_ERROR needs to be or'ed into the options parameter to NSLinkModule(). Then if NSLinkModule() returns NULL the error information can be retrieved with NSLinkEditError().

  The NSLINKMODULE_OPTION_RETURN_ON_ERROR option is an alternative method to the existing dyld error handling which fits better with a plugin model. With the NSLINKMODULE_OPTION_RETURN_ON_ERROR option, the model for handling errors is to simply return without any changes to the program. To support this model of error handling a new API has been added to allow the programmer to get the error information that the dyld error handlers would normally have gotten. The API is similar to the dyld linkEdit error handler except that all the parameters are passed as pointers to be filled in.

  • extern void NSLinkEditError(
    NSLinkEditErrors *c,
    int *errorNumber,
    const char **fileName,
    const char **errorString);

  The last two parameters return pointers to static buffers allocated in the dynamic linker which get reused on subsequent calls to NSLinkEditError(). The NSLinkEditErrors enum has been extended to include NSLinkEditUndefinedError and NSLinkEditMultiplyDefinedError.

Notes Specific to Mac OS X Developer Preview Release

New Features

The following new features have been added to the Compiler Toolssince the Mac OS X Server Release.

• The NSLinkModule() API now can create private modules and the new API NSLookupSymbolInModule() allows symbols to be looked up in a private module. To do this the interface to NSLinkModule() has changed in a compatible way from:
  • extern NSModule NSLinkModule(
    NSObjectFileImage objectFileImage,
    const char *moduleName,
    enum bool bindNow);

  to:

  • extern NSModule NSLinkModule(
    NSObjectFileImage objectFileImage,
    const char *moduleName,
    unsigned long options);

  with the options as follows:

  • #define NSLINKMODULE_OPTION_NONE 0x0
    #define NSLINKMODULE_OPTION_BINDNOW 0x1
    #define NSLINKMODULE_OPTION_PRIVATE 0x2

  The first two are the same as bindNow with a value of FALSE and TRUE. The private options are used to load a private module. The API for getting to the symbols of a NSModule that has been privately linked is:

  • extern NSSymbol NSLookupSymbolInModule(
    NSModule module,
    const char *symbolName);

  Then to get the address of the returned NSSymbol, the existing NSAddressOfSymbol() API can be used.

  The NSUnLinkModule() API is now implemented with enough functionality to make Apache work (reference number 2262020). It currently has the following limitations (to be fixed in future releases):

  • only works for plugins (can only be called on modules that were returned by NSLinkModule).
  • C++ plugins that have a static destructor can't be unloaded. The program will crash in atexit(3) when the unlinked destructor is attempted to be called.
  • Objective-C plugins should not be unloaded. The Objective-C runtime has not been updated to know about unloading and the result is very likely to crash the program.
  • The debugger has not been updated to know about unloading and trying to debug a program that unloads its plugins may confuse or crash the debugger.

  The interface to NSUnLinkModule has changed in a compatible way from:

  • extern enum bool NSUnLinkModule(
    NSModule module,
    enum bool keepMemoryMapped);

  to:

  • extern enum bool NSUnLinkModule(
    NSModule module,
    int options);

  where the options are:

  • #define NSUNLINKMODULE_OPTION_NONE 0x0
    #define NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED 0x1
    #define NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES 0x2

  The first two are the same as keepMemoryMapped with a value of FALSE and TRUE. The reset lazy references option allows unloading modules with only call sites to undefined functions (direct calls, not calls through pointers) to not cause an undefined symbol error. Then if a subsequent module is loaded that defines symbols that were previously undefined, the call sites will use the new definitions. This is currently only implemented for PowerPC.

  Support for module termination functions has been added for plugins (only). Currently the compiler pragma CALL_ON_UNLOAD (as well as CALL_ON_LOAD) is not yet implemented to use this feature as intended. A work around can be done in place of having the pragma:

  • void my_term(void)
    {
    /* do module termination */
    }
    /* #pragma CALL_ON_UNLOAD my_term */
    #pragma SECTION data '.section __DATA, __mod_term_func, mod_init_funcs'
    static void (*dummy)(void) = my_term;
    #pragma SECTION data

Notes Specific to Mac OS X Server Release

New Features

The following new features have been added to the Compiler Toolssince the Rhapsody Developer Release 2.

• The 4.4bsd ar extended format #1 is now supported by the compiler tools. The default is to use 4.4bsd ar extended format #1 when creating static archives whose member names are longer than 16 characters or have spaces in the name. The tools that create static archives, ar(1), libtool(1) and ranlib(1), all take the options -T (to truncate member names) and -L (to used long member names, the default) (reference 1670513).
• The AltiVec opcodes have been added to the Mac OS X PowerPC assembler. To assemble files with these instructions it requires the option -force_cpusubtype_ALL and then it is the code's responsibility to only use these instructions when the CPU supports them. (references 2237908, 2227999, 2213821, 2004760).
• The header file <mach-o/getsect.h> has been added to the system as the proper place to get the prototypes of the Mach-O routines. (reference 2227839).

There are no Notes Specific to Rhapsody Developer Release 2

Notes Specific to Rhapsody Developer Release

New Features

The following new features have been added to the compiler toolssince OPENSTEP 4.2 (NeXT).

• The PowerPC architecture is now supported via the -arch ppc switch.
  

Known Problems

These bugs are known to exist in the compiler tools:

Bugs Fixed

The following bug has been fixed:

PowerPC Assembly Instruction Parameter Differences

Register names can't be designated with just a number. You mustrefer to them with their register name. This restriction includesgeneral registers (rN), floating point registers,(fN), condition registers(crN), and segment registers(srN). However, you can refer to specialregisters by their register number or their special register names.The special register names are in lowercase only (for example,mq, xer, lr, ctr,and dsisr).

For instance, for the ppcasm assember you could code a movefrom segment register instruction as:

But, for the Mac OS X assembler, this same move would be codedas:

For instructions that take the value 0 or a register, shown in theprocessor manual as '(rA 0)', r0 can't be used and 0 must be coded.The Mac OS X assembler generates an error messages in thesecases.

Where a numeric value is expected as a parameter, a register namecan't be use. For example, the ppcasm assembler allows thefollowing:

For Mac OS X, this must be coded as:

The Mac OS X assembler generates a warning if branch prediction iscoded with an unconditional branch.

The Mac OS X assembler checks all fields for range errors andgenerates error messages if an expression is out of range. Theppcasm assembler simply uses the low N bits of theexpression (where N is the field width) if the value isgreater than zero. For example the simplified mnemonic:

is equivalent to

The following code:

assembles to

with ppcasm. This generates an out-of-range error with theMac OS X assembler.

For fields less than zero, the ppcasm assembler uses thevalue of zero. For example, the simplified mnemonic:

is equivalent to

Thus the following code:

assembles to:

with ppcasm. This generates an out-of-range error with theMac OS X assembler.

All integer expressions in the Mac OS X assembler are signed32-bit values. Parameters that are 16-bit signed or unsignedimmediate values must agree in their upper 16 bits or the assemblergenerates an out-of-range error message.

For example:

generates the message 'Parameter error: expression out of range(parameter 3)'.

The addi instruction takes a signed immediate valueso it will sign extend its parameter to 32 bits before performing theoperation. If the value 0xffffffff is intended, it would be codedas:

If this is half of a two-instruction 32-bit add it should be codedas:

Many of the simplified mnemonics are implemented as Mac OS Xassembler macros (as noted in the listing of PowerPC assemblerinstructions in the assember manual). Like all macros, the macro isexpanded and assembled. This expansion can result in errors that canseem confusing when you look at the coded macro. For example, thesimplified mnemonic:

is equivalent to

Thus the following code:

generates the error message 'Parameter error: expression out ofrange (parameter 4),' which refers to 'n-1' or '0-1', or parameter 4of the expanded macro.

The instruction tlbiex, which has been removed fromthe PowerPC architecture, is not supported by the Mac OS X assembler.This instruction is assembled by ppcasm.

Copyright ©2003 Apple Computer, Inc.

Grapple Man (Prototype) Mac OS