Return to profile-asm.s CVS log

Up to [Apple XNU] / XNU / osfmk / profiling / i386

Annotation of XNU/osfmk/profiling/i386/profile-asm.s, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
        !             3:  *
        !             4:  * @APPLE_LICENSE_HEADER_START@
        !             5:  * 
        !             6:  * The contents of this file constitute Original Code as defined in and
        !             7:  * are subject to the Apple Public Source License Version 1.1 (the
        !             8:  * "License").  You may not use this file except in compliance with the
        !             9:  * License.  Please obtain a copy of the License at
        !            10:  * http://www.apple.com/publicsource and read it before using this file.
        !            11:  * 
        !            12:  * This Original Code and all software distributed under the License are
        !            13:  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
        !            14:  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
        !            15:  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
        !            16:  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
        !            17:  * License for the specific language governing rights and limitations
        !            18:  * under the License.
        !            19:  * 
        !            20:  * @APPLE_LICENSE_HEADER_END@
        !            21:  */
        !            22: /*
        !            23:  * @OSF_COPYRIGHT@
        !            24:  */
        !            25: /*
        !            26:  * HISTORY
        !            27:  * 
        !            28:  * Revision 1.1.1.1  1998/09/22 21:05:49  wsanchez
        !            29:  * Import of Mac OS X kernel (~semeria)
        !            30:  *
        !            31:  * Revision 1.1.1.1  1998/03/07 02:26:08  wsanchez
        !            32:  * Import of OSF Mach kernel (~mburg)
        !            33:  *
        !            34:  * Revision 1.1.7.1  1997/09/22  17:41:24  barbou
        !            35:  *     MP+RT: protect cpu_number() usage against preemption.
        !            36:  *     [97/09/16            barbou]
        !            37:  *
        !            38:  * Revision 1.1.5.1  1995/01/06  19:53:37  devrcs
        !            39:  *     mk6 CR668 - 1.3b26 merge
        !            40:  *     new file for mk6
        !            41:  *     [1994/10/12  22:25:20  dwm]
        !            42:  * 
        !            43:  * Revision 1.1.2.2  1994/05/16  19:19:17  meissner
        !            44:  *     Add support for converting 64-bit integers to a decimal string.
        !            45:  *     Use the correct address (selfpc) when creating the prof header for gprof.
        !            46:  *     [1994/04/28  21:44:59  meissner]
        !            47:  * 
        !            48:  * Revision 1.1.2.1  1994/04/08  17:51:42  meissner
        !            49:  *     Make most stats 64 bits, except for things like memory allocation.
        !            50:  *     [1994/04/02  14:58:21  meissner]
        !            51:  * 
        !            52:  *     Do not provide old mcount support under MK or server.
        !            53:  *     Fixup stats size so it is the same as in profile-md.h.
        !            54:  *     [1994/03/29  21:00:03  meissner]
        !            55:  * 
        !            56:  *     Use faster sequence for overflow addition.
        !            57:  *     Keep {dummy,prof,gprof,old}_mcount counts in double precision.
        !            58:  *     Add kernel NCPUS > 1 support.
        !            59:  *     [1994/03/17  20:13:23  meissner]
        !            60:  * 
        !            61:  *     Add gprof/prof overflow support
        !            62:  *     [1994/03/17  14:56:44  meissner]
        !            63:  * 
        !            64:  *     Add size of histogram counters & unused fields to profile_profil struct
        !            65:  *     [1994/02/17  21:41:44  meissner]
        !            66:  * 
        !            67:  *     Add too_low/too_high to profile_stats.
        !            68:  *     [1994/02/16  22:38:11  meissner]
        !            69:  * 
        !            70:  *     Bump # allocation contexts to 32 from 16.
        !            71:  *     Store unique ptr address in gprof function header structure for _profile_reset.
        !            72:  *     Add new fields from profile-{internal,md}.h.
        !            73:  *     Align loop looking for an unlocked acontext.
        !            74:  *     Count # times a locked context block was found.
        !            75:  *     Expand copyright.
        !            76:  *     [1994/02/07  12:40:56  meissner]
        !            77:  * 
        !            78:  *     Keep track of the number of times the kernel overflows the HISTCOUNTER counter.
        !            79:  *     [1994/02/03  20:13:23  meissner]
        !            80:  * 
        !            81:  *     Add stats for {user,kernel,idle} mode in the kernel.
        !            82:  *     [1994/02/03  15:17:22  meissner]
        !            83:  * 
        !            84:  *     No change.
        !            85:  *     [1994/02/03  00:58:49  meissner]
        !            86:  * 
        !            87:  *     Combine _profile_{vars,stats,md}; Allow more than one _profile_vars.
        !            88:  *     [1994/02/01  12:03:56  meissner]
        !            89:  * 
        !            90:  *     Move _mcount_ptr to be closer to other data declarations.
        !            91:  *     Add text_len to profile_profil structure for mk.
        !            92:  *     Split records_cnt into prof_cnt/gprof_cnt.
        !            93:  *     Always update prof_cnt/gprof_cnt even if not DO_STATS.
        !            94:  *     Add current/max cpu indicator to stats for kernel.
        !            95:  *     [1994/01/28  23:33:20  meissner]
        !            96:  * 
        !            97:  *     Don't do 4+Lgotoff(lab), use separate labels.
        !            98:  *     Change GPROF_HASH_SHIFT to 9 (from 8).
        !            99:  *     [1994/01/26  22:00:59  meissner]
        !           100:  * 
        !           101:  *     Fixup NO_RECURSIVE_ALLOC to do byte loads, not word loads.
        !           102:  *     [1994/01/26  20:30:57  meissner]
        !           103:  * 
        !           104:  *     Move callback pointers into separate allocation context.
        !           105:  *     Add size fields for other structures to profile-vars.
        !           106:  *     Allocate string table as one large allocation.
        !           107:  *     Rewrite old mcount code once again.
        !           108:  *     Use multiply to make hash value, not divide.
        !           109:  *     Hash table is now a power of two.
        !           110:  *     [1994/01/26  20:23:32  meissner]
        !           111:  * 
        !           112:  *     Cut hash table size back to 16189.
        !           113:  *     Add size fields to all structures.
        !           114:  *     Add major/minor version number to _profile_md.
        !           115:  *     Move allocation context block pointers to _profile_vars.
        !           116:  *     Move _gprof_dummy after _profile_md.
        !           117:  *     New function header code now falls into hash an element
        !           118:  *     to avoid having the hash code duplicated or use a macro.
        !           119:  *     Fix bug in _gprof_mcount with ELF shared libraries.
        !           120:  *     [1994/01/25  01:45:59  meissner]
        !           121:  * 
        !           122:  *     Move init functions to C code; rearrange profil varaibles.
        !           123:  *     [1994/01/22  01:11:14  meissner]
        !           124:  * 
        !           125:  *     No change.
        !           126:  *     [1994/01/20  20:56:43  meissner]
        !           127:  * 
        !           128:  *     Fixup copyright.
        !           129:  *     [1994/01/18  23:07:39  meissner]
        !           130:  * 
        !           131:  *     Make flags byte-sized.
        !           132:  *     Add have_bb flag.
        !           133:  *     Add init_format flag.
        !           134:  *     Always put word size multipler first in .space.
        !           135:  *     [1994/01/18  21:57:14  meissner]
        !           136:  * 
        !           137:  *     Fix elfpic problems in last change.
        !           138:  *     [1994/01/16  14:04:26  meissner]
        !           139:  * 
        !           140:  *     Rewrite gprof caching to be faster & not need a lock.
        !           141:  *     Record prof information for gprof too.
        !           142:  *     Bump reserved stats to 64.
        !           143:  *     Bump up hash table size 30799.
        !           144:  *     Conditionally use lock prefix.
        !           145:  *     Change most #ifdef's to #if.
        !           146:  *     DEBUG_PROFILE turns on stack frames now.
        !           147:  *     Conditionally add externs to gprof to determine where time is spent.
        !           148:  *     Prof_mcount uses xchgl to update function pointer.
        !           149:  *     [1994/01/15  18:40:33  meissner]
        !           150:  * 
        !           151:  *     Fix a comment.
        !           152:  *     Separate statistics from debugging (though debugging turns it on).
        !           153:  *     Remove debug code that traces each gprof request.
        !           154:  *     [1994/01/15  00:59:02  meissner]
        !           155:  * 
        !           156:  *     Move max hash bucket calculation into _gprof_write & put info in stats structure.
        !           157:  *     [1994/01/04  16:15:14  meissner]
        !           158:  * 
        !           159:  *     Use _profile_printf to write diagnostics; add diag_stream to hold stream to write to.
        !           160:  *     [1994/01/04  15:37:44  meissner]
        !           161:  * 
        !           162:  *     Add more allocation memory pools (gprof function hdrs in particular).
        !           163:  *     For prof, gprof arc, and gprof function hdrs, allocate 16 pages at a time.
        !           164:  *     Add major/minor version numbers to _profile_{vars,stats}.
        !           165:  *     Add # profil buckets field to _profil_stats.
        !           166:  *     [19
        !           167:  * 
        !           168:  * $EndLog$
        !           169:  */
        !           170: 
        !           171: /*
        !           172:  * Common 386 profiling module that is shared between the kernel, mach
        !           173:  * servers, and the user space library.  Each environment includes
        !           174:  * this file.
        !           175:  */
        !           176: 
        !           177:        .file   "profile-asm.s"
        !           178: 
        !           179: #include <cpus.h>
        !           180: 
        !           181: #include <machine/asm.h>
        !           182: 
        !           183: /*
        !           184:  * By default, debugging turns on statistics and stack frames.
        !           185:  */
        !           186: 
        !           187: #if DEBUG_PROFILE
        !           188: #ifndef DO_STATS
        !           189: #define DO_STATS 1
        !           190: #endif
        !           191: 
        !           192: #ifndef STACK_FRAMES
        !           193: #define STACK_FRAMES 1
        !           194: #endif
        !           195: #endif
        !           196: 
        !           197: #ifndef OLD_MCOUNT
        !           198: #define OLD_MCOUNT 0                   /* do not compile old code for mcount */
        !           199: #endif
        !           200: 
        !           201: #ifndef DO_STATS
        !           202: #define DO_STATS 1                     /* compile in statistics code */
        !           203: #endif
        !           204: 
        !           205: #ifndef DO_LOCK
        !           206: #define        DO_LOCK 0                       /* use lock; in front of increments */
        !           207: #endif
        !           208: 
        !           209: #ifndef LOCK_STATS
        !           210: #define LOCK_STATS DO_LOCK             /* update stats with lock set */
        !           211: #endif
        !           212: 
        !           213: #ifndef STACK_FRAMES
        !           214: #define STACK_FRAMES 0                 /* create stack frames for debugger */
        !           215: #endif
        !           216: 
        !           217: #ifndef NO_RECURSIVE_ALLOC
        !           218: #define NO_RECURSIVE_ALLOC 0           /* check for recursive allocs */
        !           219:                                        /* (not thread safe!) */
        !           220: #endif
        !           221: 
        !           222: #ifndef MARK_GPROF
        !           223: #define MARK_GPROF 0                   /* add externs for gprof profiling */
        !           224: #endif
        !           225: 
        !           226: #ifndef OVERFLOW
        !           227: #define        OVERFLOW 1                      /* add overflow checking support */
        !           228: #endif
        !           229: 
        !           230: /*
        !           231:  * Turn on the use of the lock prefix if desired.
        !           232:  */
        !           233: 
        !           234: #ifndef LOCK
        !           235: #if DO_LOCK
        !           236: #define LOCK lock;
        !           237: #else
        !           238: #define LOCK
        !           239: #endif
        !           240: #endif
        !           241: 
        !           242: #ifndef SLOCK
        !           243: #if LOCK_STATS
        !           244: #define SLOCK LOCK
        !           245: #else
        !           246: #define SLOCK
        !           247: #endif
        !           248: #endif
        !           249: 
        !           250: /*
        !           251:  * Double or single precision incrementing
        !           252:  */
        !           253: 
        !           254: #if OVERFLOW
        !           255: #define DINC(mem)              LOCK addl $1,mem; LOCK adcl $0,4+mem
        !           256: #define DINC2(mem,mem2)                LOCK addl $1,mem; LOCK adcl $0,mem2
        !           257: #define SDINC(mem)             SLOCK addl $1,mem; SLOCK adcl $0,4+mem
        !           258: #define SDADD(val,mem)         SLOCK addl val,mem; SLOCK adcl $0,4+mem
        !           259: #define SDADDNEG(val,mem)      SLOCK subl val,mem; SLOCK adcl $0,4+mem
        !           260: #define SDSUB(val,mem)         SLOCK subl val,mem; SLOCK sbbl $0,4+mem
        !           261: 
        !           262: #else
        !           263: #define DINC(mem)              LOCK incl mem
        !           264: #define DINC2(mem,mem2)                LOCK incl mem
        !           265: #define SDINC(mem)             SLOCK incl mem
        !           266: #define        SDADD(val,mem)          SLOCK addl val,mem
        !           267: #define        SDADDNEG(val,mem)       SLOCK subl val,mem
        !           268: #define        SDSUB(val,mem)          SLOCK subl val,mem
        !           269: #endif
        !           270: 
        !           271: /*
        !           272:  * Stack frame support so that debugger traceback works.
        !           273:  */
        !           274: 
        !           275: #if STACK_FRAMES
        !           276: #define        ENTER   pushl %ebp; movl %esp,%ebp
        !           277: #define        LEAVE0  popl %ebp
        !           278: #define        Estack  4
        !           279: #else
        !           280: #define        ENTER
        !           281: #define        LEAVE0
        !           282: #define        Estack  0
        !           283: #endif
        !           284: 
        !           285: /*
        !           286:  * Gprof profiling.
        !           287:  */
        !           288: 
        !           289: #if MARK_GPROF
        !           290: #define MARK(name) .globl EXT(name); ELF_FUNC(EXT(name)); ELF_SIZE(EXT(name),0); LEXT(name)
        !           291: #else
        !           292: #define MARK(name)
        !           293: #endif
        !           294: 
        !           295: /*
        !           296:  * Profiling allocation context block.  Each time memory is needed, the
        !           297:  * allocator loops until it finds an unlocked context block, and allocates
        !           298:  * from that block.  If no context blocks are available, a new memory
        !           299:  * pool is allocated, and added to the end of the chain.
        !           300:  */
        !           301: 
        !           302: LCL(A_next)            = 0                     /* next context block link (must be 0) */
        !           303: LCL(A_plist)           = LCL(A_next)+4         /* head of page list for context block */
        !           304: LCL(A_lock)            = LCL(A_plist)+4        /* lock word */
        !           305: LCL(A_size)            = LCL(A_lock)+4         /* size of context block */
        !           306: 
        !           307: #define        A_next          LCL(A_next)
        !           308: #define        A_plist         LCL(A_plist)
        !           309: #define        A_lock          LCL(A_lock)
        !           310: #define        A_size          LCL(A_size)
        !           311: 
        !           312: /*
        !           313:  * Allocation contexts used.
        !           314:  */
        !           315: 
        !           316: LCL(C_prof)            = 0                     /* prof records */
        !           317: LCL(C_gprof)           = 1                     /* gprof arc records */
        !           318: LCL(C_gfunc)           = 2                     /* gprof function headers */
        !           319: LCL(C_misc)            = 3                     /* misc. allocations */
        !           320: LCL(C_profil)          = 4                     /* memory for profil */
        !           321: LCL(C_dci)             = 5                     /* memory for dci */
        !           322: LCL(C_bb)              = 6                     /* memory for basic blocks */
        !           323: LCL(C_callback)                = 7                     /* memory for callbacks */
        !           324: LCL(C_max)             = 32                    /* # allocation contexts */
        !           325: 
        !           326: #define        C_prof          LCL(C_prof)
        !           327: #define        C_gprof         LCL(C_gprof)
        !           328: #define        C_gfunc         LCL(C_gfunc)
        !           329: #define        C_max           LCL(C_max)
        !           330: 
        !           331: /*
        !           332:  * Linked list of memory allocations.
        !           333:  */
        !           334: 
        !           335: LCL(M_first)           = 0                     /* pointer to first byte available */
        !           336: LCL(M_ptr)             = LCL(M_first)+4        /* pointer to next available byte */
        !           337: LCL(M_next)            = LCL(M_ptr)+4          /* next page allocated */
        !           338: LCL(M_nfree)           = LCL(M_next)+4         /* # bytes available */
        !           339: LCL(M_nalloc)          = LCL(M_nfree)+4        /* # bytes allocated */
        !           340: LCL(M_num)             = LCL(M_nalloc)+4       /* # allocations done on this page */
        !           341: LCL(M_size)            = LCL(M_num)+4          /* size of page header */
        !           342: 
        !           343: #define        M_first         LCL(M_first)
        !           344: #define        M_ptr           LCL(M_ptr)
        !           345: #define        M_next          LCL(M_next)
        !           346: #define        M_nfree         LCL(M_nfree)
        !           347: #define        M_nalloc        LCL(M_nalloc)
        !           348: #define        M_num           LCL(M_num)
        !           349: #define        M_size          LCL(M_size)
        !           350: 
        !           351: /*
        !           352:  * Prof data type.
        !           353:  */
        !           354: 
        !           355: LCL(P_addr)            = 0                     /* function address */
        !           356: LCL(P_count)           = LCL(P_addr)+4         /* # times function called */
        !           357: LCL(P_overflow)                = LCL(P_count)+4        /* # times count overflowed */
        !           358: LCL(P_size)            = LCL(P_overflow)+4     /* size of prof data type */
        !           359: 
        !           360: #define        P_addr          LCL(P_addr)
        !           361: #define        P_count         LCL(P_count)
        !           362: #define        P_overflow      LCL(P_overflow)
        !           363: #define        P_size          LCL(P_size)
        !           364: 
        !           365: /*
        !           366:  * Gprof data type.
        !           367:  */
        !           368: 
        !           369: LCL(G_next)            = 0                     /* next hash link (must be 0) */
        !           370: LCL(G_frompc)          = LCL(G_next)+4         /* caller's caller */
        !           371: LCL(G_selfpc)          = LCL(G_frompc)+4       /* caller's address */
        !           372: LCL(G_count)           = LCL(G_selfpc)+4       /* # times arc traversed */
        !           373: LCL(G_overflow)                = LCL(G_count)+4        /* # times count overflowed */
        !           374: LCL(G_size)            = LCL(G_overflow)+4     /* size of gprof data type */
        !           375: 
        !           376: #define        G_next          LCL(G_next)
        !           377: #define        G_frompc        LCL(G_frompc)
        !           378: #define        G_selfpc        LCL(G_selfpc)
        !           379: #define        G_count         LCL(G_count)
        !           380: #define        G_overflow      LCL(G_overflow)
        !           381: #define        G_size          LCL(G_size)
        !           382: 
        !           383: /*
        !           384:  * Gprof header.
        !           385:  *
        !           386:  * At least one header is allocated for each unique function that is profiled.
        !           387:  * In order to save time calculating the hash value, the last H_maxcache
        !           388:  * distinct arcs are cached within this structure.  Also, to avoid loading
        !           389:  * the GOT when searching the hash table, we copy the hash pointer to this
        !           390:  * structure, so that we only load the GOT when we need to allocate an arc.
        !           391:  */
        !           392: 
        !           393: LCL(H_maxcache)                = 3                     /* # of cache table entries */
        !           394: LCL(H_csize)           = 4*LCL(H_maxcache)     /* size of each cache array */
        !           395: 
        !           396: LCL(H_hash_ptr)                = 0                     /* hash table to use */
        !           397: LCL(H_unique_ptr)      = LCL(H_hash_ptr)+4     /* function unique pointer */
        !           398: LCL(H_prof)            = LCL(H_unique_ptr)+4   /* prof statistics */
        !           399: LCL(H_cache_ptr)       = LCL(H_prof)+P_size    /* cache table of element pointers */
        !           400: LCL(H_size)            = LCL(H_cache_ptr)+LCL(H_csize) /* size of gprof header type */
        !           401: 
        !           402: #define        H_maxcache      LCL(H_maxcache)
        !           403: #define        H_csize         LCL(H_csize)
        !           404: #define        H_hash_ptr      LCL(H_hash_ptr)
        !           405: #define        H_unique_ptr    LCL(H_unique_ptr)
        !           406: #define        H_prof          LCL(H_prof)
        !           407: #define        H_cache_ptr     LCL(H_cache_ptr)
        !           408: #define        H_size          LCL(H_size)
        !           409: 
        !           410: /*
        !           411:  * Number of digits needed to write a 64 bit number including trailing null.
        !           412:  * (rounded up to be divisable by 4).
        !           413:  */
        !           414: 
        !           415: #define N_digit                24
        !           416: 
        !           417: 
        !           418:        .data
        !           419: 
        !           420: /*
        !           421:  * Default gprof hash table size, which must be a power of two.
        !           422:  * The shift specifies how many low order bits to eliminate when
        !           423:  * calculating the hash value.
        !           424:  */
        !           425: 
        !           426: #ifndef GPROF_HASH_SIZE
        !           427: #define GPROF_HASH_SIZE 16384
        !           428: #endif
        !           429: 
        !           430: #ifndef GPROF_HASH_SHIFT
        !           431: #define        GPROF_HASH_SHIFT 9
        !           432: #endif
        !           433: 
        !           434: #define GPROF_HASH_MASK (GPROF_HASH_SIZE-1)
        !           435: 
        !           436: DATA(_profile_hash_size)
        !           437:        .long   GPROF_HASH_SIZE
        !           438: ENDDATA(_profile_hash_size)
        !           439: 
        !           440: 
        !           441: 
        !           442: /*
        !           443:  * Pointer that the compiler uses to call to the appropriate mcount function.
        !           444:  */
        !           445: 
        !           446: DATA(_mcount_ptr)
        !           447:        .long   EXT(_dummy_mcount)
        !           448: ENDDATA(_mcount_ptr)
        !           449: 
        !           450: /*
        !           451:  * Global profile variables.  The structure that accesses this in C is declared
        !           452:  * in profile-internal.h.  All items in .data that follow this will be used as
        !           453:  * one giant record, and each unique machine, thread, kgmon output or what have
        !           454:  * you will create a separate instance.  Typically there is only one instance
        !           455:  * which will be the memory laid out below.
        !           456:  */
        !           457: 
        !           458: LCL(var_major_version) = 0                             /* major version number */
        !           459: LCL(var_minor_version) = LCL(var_major_version)+4      /* minor version number */
        !           460: LCL(vars_size)         = LCL(var_minor_version)+4      /* size of _profile_vars structure */
        !           461: LCL(plist_size)                = LCL(vars_size)+4              /* size of page_list structure */
        !           462: LCL(acontext_size)     = LCL(plist_size)+4             /* size of allocation contexts */
        !           463: LCL(callback_size)     = LCL(acontext_size)+4          /* size of callback structure */
        !           464: LCL(type)              = LCL(callback_size)+4          /* profile type (gprof, prof) */
        !           465: LCL(error_msg)         = LCL(type)+4                   /* error message for perror */
        !           466: LCL(filename)          = LCL(error_msg)+4              /* filename to write to */
        !           467: LCL(str_ptr)           = LCL(filename)+4               /* string table pointer */
        !           468: LCL(stream)            = LCL(str_ptr)+4                /* stdio stream to write to */
        !           469: LCL(diag_stream)       = LCL(stream)+4                 /* stdio stream to write diagnostics to */
        !           470: LCL(fwrite_func)       = LCL(diag_stream)+4            /* function like fwrite to output bytes */
        !           471: LCL(page_size)         = LCL(fwrite_func)+4            /* page size in bytes */
        !           472: LCL(str_bytes)         = LCL(page_size)+4              /* # bytes in string table */
        !           473: LCL(str_total)         = LCL(str_bytes)+4              /* # total bytes allocated for string table */
        !           474: LCL(clock_ticks)       = LCL(str_total)+4              /* # clock ticks per second */
        !           475: 
        !           476:                                                        /* profil variables */
        !           477: LCL(profil_start)      = LCL(clock_ticks)+4            /* start of profil variables */
        !           478: LCL(lowpc)             = LCL(clock_ticks)+4            /* lowest address */
        !           479: LCL(highpc)            = LCL(lowpc)+4                  /* highest address */
        !           480: LCL(text_len)          = LCL(highpc)+4                 /* highpc-lowpc */
        !           481: LCL(profil_len)                = LCL(text_len)+4               /* size of profil buffer */
        !           482: LCL(counter_size)      = LCL(profil_len)+4             /* size of indivual counter */
        !           483: LCL(scale)             = LCL(counter_size)+4           /* scale factor */
        !           484: LCL(profil_unused)     = LCL(scale)+4                  /* unused fields */
        !           485: LCL(profil_end)                = LCL(profil_unused)+4*8        /* end of profil_info structure */
        !           486: LCL(profil_buf)                = LCL(profil_end)               /* buffer for profil */
        !           487: 
        !           488:                                                        /* Output selection func ptrs */
        !           489: LCL(output_init)       = LCL(profil_buf)+4             /* Initialization */
        !           490: LCL(output)            = LCL(output_init)+4            /* Write out profiling info */
        !           491: LCL(output_ptr)                = LCL(output)+4                 /* Output specific data ptr */
        !           492: 
        !           493:                                                        /* Memory allocation support */
        !           494: LCL(acontext)          = LCL(output_ptr)+4             /* pointers to allocation context blocks */
        !           495: 
        !           496: LCL(bogus_func)                = LCL(acontext)+4*C_max         /* function to use if gprof arc is bad */
        !           497: LCL(vars_unused)       = LCL(bogus_func)+4             /* future growth */
        !           498: 
        !           499:                                                        /* flags */
        !           500: LCL(init)              = LCL(vars_unused)+4*63         /* whether initializations were done */
        !           501: LCL(active)            = LCL(init)+1                   /* whether profiling is active */
        !           502: LCL(do_profile)                = LCL(active)+1                 /* whether to do profiling */
        !           503: LCL(use_dci)           = LCL(do_profile)+1             /* whether to use DCI */
        !           504: LCL(use_profil)                = LCL(use_dci)+1                /* whether to use profil */
        !           505: LCL(recursive_alloc)   = LCL(use_profil)+1             /* alloc called recursively */
        !           506: LCL(output_uarea)      = LCL(recursive_alloc)+1        /* output uarea */
        !           507: LCL(output_stats)      = LCL(output_uarea)+1           /* output stats info */
        !           508: LCL(output_clock)      = LCL(output_stats)+1           /* output the clock ticks */
        !           509: LCL(multiple_sections) = LCL(output_clock)+1           /* multiple sections are ok */
        !           510: LCL(have_bb)           = LCL(multiple_sections)+1      /* whether we have basic block data */
        !           511: LCL(init_format)       = LCL(have_bb)+1                /* The output format has been chosen */
        !           512: LCL(debug)             = LCL(init_format)+1            /* Whether or not we are debugging */
        !           513: LCL(check_funcs)       = LCL(debug)+1                  /* Whether to check functions for validity */
        !           514: LCL(flag_unused)       = LCL(check_funcs)+1            /* unused flags */
        !           515: LCL(end_of_vars)       = LCL(flag_unused)+62           /* size of machine independent vars */
        !           516: 
        !           517: /*
        !           518:  * Data that contains profile statistics that can be dumped out
        !           519:  * into the {,g}mon.out file.  This is defined in profile-md.h.
        !           520:  */
        !           521: 
        !           522: LCL(stats_start)       = LCL(end_of_vars)              /* start of stats substructure */
        !           523: LCL(stats_major_version)= LCL(stats_start)             /* major version number */
        !           524: LCL(stats_minor_version)= LCL(stats_major_version)+4   /* minor version number */
        !           525: LCL(stats_size)                = LCL(stats_minor_version)+4    /* size of _profile_stats structure */
        !           526: LCL(profil_buckets)    = LCL(stats_size)+4             /* # profil buckets */
        !           527: LCL(my_cpu)            = LCL(profil_buckets)+4         /* identify which cpu/thread this is */
        !           528: LCL(max_cpu)           = LCL(my_cpu)+4                 /* identify which cpu/thread this is */
        !           529: LCL(prof_records)      = LCL(max_cpu)+4                /* # of profiled functions */
        !           530: LCL(gprof_records)     = LCL(prof_records)+4           /* # of gprof arcs created */
        !           531: LCL(hash_buckets)      = LCL(gprof_records)+4          /* max gprof hash buckets on a chain */
        !           532: LCL(bogus_count)       = LCL(hash_buckets)+4           /* # bogus functions found in gprof */
        !           533: 
        !           534: LCL(cnt)               = LCL(bogus_count)+4            /* # of _{prof,gprof}_mcount calls */
        !           535: LCL(dummy)             = LCL(cnt)+8                    /* # of _dummy_mcount calls */
        !           536: LCL(old_mcount)                = LCL(dummy)+8                  /* # of old mcount calls */
        !           537: LCL(hash_search)       = LCL(old_mcount)+8             /* # gprof hash buckets searched */
        !           538: LCL(hash_num)          = LCL(hash_search)+8            /* # times hash table searched */
        !           539: LCL(user_ticks)                = LCL(hash_num)+8               /* # ticks within user space */
        !           540: LCL(kernel_ticks)      = LCL(user_ticks)+8             /* # ticks within kernel space */
        !           541: LCL(idle_ticks)                = LCL(kernel_ticks)+8           /* # ticks cpu was idle */
        !           542: LCL(overflow_ticks)    = LCL(idle_ticks)+8             /* # ticks where histcounter overflowed */
        !           543: LCL(acontext_locked)   = LCL(overflow_ticks)+8         /* # times an acontext was locked */
        !           544: LCL(too_low)           = LCL(acontext_locked)+8        /* # times histogram tick too low */
        !           545: LCL(too_high)          = LCL(too_low)+8                /* # times histogram tick too low */
        !           546: LCL(prof_overflow)     = LCL(too_high)+8               /* # times the prof count field overflowed */
        !           547: LCL(gprof_overflow)    = LCL(prof_overflow)+8          /* # times the gprof count field overflowed */
        !           548: LCL(num_alloc)         = LCL(gprof_overflow)+8         /* # allocations in each context */
        !           549: LCL(bytes_alloc)       = LCL(num_alloc)+4*C_max        /* bytes allocated in each context */
        !           550: LCL(num_context)       = LCL(bytes_alloc)+4*C_max      /* # allocation context blocks */
        !           551: LCL(wasted)            = LCL(num_context)+4*C_max      /* # bytes wasted */
        !           552: LCL(overhead)          = LCL(wasted)+4*C_max           /* # bytes of overhead */
        !           553: LCL(buckets)           = LCL(overhead)+4*C_max         /* # hash indexes that have n buckets */
        !           554: LCL(cache_hits1)       = LCL(buckets)+4*10             /* # gprof cache hits in bucket #1 */
        !           555: LCL(cache_hits2)       = LCL(cache_hits1)+8            /* # gprof cache hits in bucket #2 */
        !           556: LCL(cache_hits3)       = LCL(cache_hits2)+8            /* # gprof cache hits in bucket #3 */
        !           557: LCL(stats_unused)      = LCL(cache_hits3)+8            /* reserved for future use */
        !           558: LCL(stats_end)         = LCL(stats_unused)+8*64        /* end of stats structure */
        !           559: 
        !           560: /*
        !           561:  * Machine dependent variables that no C file should access (except for
        !           562:  * profile-md.c).
        !           563:  */
        !           564: 
        !           565: LCL(md_start)          = LCL(stats_end)                /* start of md structure */
        !           566: LCL(md_major_version)  = LCL(md_start)                 /* major version number */
        !           567: LCL(md_minor_version)  = LCL(md_major_version)+4       /* minor version number */
        !           568: LCL(md_size)           = LCL(md_minor_version)+4       /* size of _profile_stats structure */
        !           569: LCL(hash_ptr)          = LCL(md_size)+4                /* gprof hash pointer */
        !           570: LCL(hash_size)         = LCL(hash_ptr)+4               /* gprof hash size */
        !           571: LCL(num_cache)         = LCL(hash_size)+4              /* # of cache entries */
        !           572: LCL(save_mcount_ptr)   = LCL(num_cache)+4              /* save for mcount_ptr when suspending profiling */
        !           573: LCL(mcount_ptr_ptr)    = LCL(save_mcount_ptr)+4        /* pointer to _mcount_ptr */
        !           574: LCL(dummy_ptr)         = LCL(mcount_ptr_ptr)+4         /* pointer to gprof_dummy */
        !           575: LCL(alloc_pages)       = LCL(dummy_ptr)+4              /* allocate more memory */
        !           576: LCL(num_buffer)                = LCL(alloc_pages)+4            /* buffer to convert 64 bit ints in */
        !           577: LCL(md_unused)         = LCL(num_buffer)+N_digit       /* unused fields */
        !           578: LCL(md_end)            = LCL(md_unused)+4*58           /* end of md structure */
        !           579: LCL(total_size)                = LCL(md_end)                   /* size of entire structure */
        !           580: 
        !           581: /*
        !           582:  * Size of the entire _profile_vars structure.
        !           583:  */
        !           584: 
        !           585: DATA(_profile_size)
        !           586:        .long   LCL(total_size)
        !           587: ENDDATA(_profile_size)
        !           588: 
        !           589: /*
        !           590:  * Size of the statistics substructure.
        !           591:  */
        !           592: 
        !           593: DATA(_profile_stats_size)
        !           594:        .long   LCL(stats_end)-LCL(stats_start)
        !           595: ENDDATA(_profile_stats_size)
        !           596: 
        !           597: /*
        !           598:  * Size of the profil info substructure.
        !           599:  */
        !           600: 
        !           601: DATA(_profile_profil_size)
        !           602:        .long   LCL(profil_end)-LCL(profil_start)
        !           603: ENDDATA(_profile_profil_size)
        !           604: 
        !           605: /*
        !           606:  * Size of the machine dependent substructure.
        !           607:  */
        !           608: 
        !           609: DATA(_profile_md_size)
        !           610:        .long   LCL(md_end)-LCL(md_start)
        !           611: ENDDATA(_profile_profil_size)
        !           612: 
        !           613: /*
        !           614:  * Whether statistics are supported.
        !           615:  */
        !           616: 
        !           617: DATA(_profile_do_stats)
        !           618:        .long   DO_STATS
        !           619: ENDDATA(_profile_do_stats)
        !           620: 
        !           621:        .text
        !           622: 
        !           623: /*
        !           624:  * Map LCL(xxx) -> into simpler names
        !           625:  */
        !           626: 
        !           627: #define        V_acontext              LCL(acontext)
        !           628: #define        V_acontext_locked       LCL(acontext_locked)
        !           629: #define        V_alloc_pages           LCL(alloc_pages)
        !           630: #define        V_bogus_func            LCL(bogus_func)
        !           631: #define        V_bytes_alloc           LCL(bytes_alloc)
        !           632: #define        V_cache_hits1           LCL(cache_hits1)
        !           633: #define        V_cache_hits2           LCL(cache_hits2)
        !           634: #define        V_cache_hits3           LCL(cache_hits3)
        !           635: #define        V_cnt                   LCL(cnt)
        !           636: #define        V_cnt_overflow          LCL(cnt_overflow)
        !           637: #define        V_check_funcs           LCL(check_funcs)
        !           638: #define        V_dummy                 LCL(dummy)
        !           639: #define        V_dummy_overflow        LCL(dummy_overflow)
        !           640: #define        V_dummy_ptr             LCL(dummy_ptr)
        !           641: #define        V_gprof_records         LCL(gprof_records)
        !           642: #define        V_hash_num              LCL(hash_num)
        !           643: #define        V_hash_ptr              LCL(hash_ptr)
        !           644: #define        V_hash_search           LCL(hash_search)
        !           645: #define        V_mcount_ptr_ptr        LCL(mcount_ptr_ptr)
        !           646: #define        V_num_alloc             LCL(num_alloc)
        !           647: #define        V_num_buffer            LCL(num_buffer)
        !           648: #define        V_num_context           LCL(num_context)
        !           649: #define        V_old_mcount            LCL(old_mcount)
        !           650: #define        V_old_mcount_overflow   LCL(old_mcount_overflow)
        !           651: #define        V_overhead              LCL(overhead)
        !           652: #define        V_page_size             LCL(page_size)
        !           653: #define        V_prof_records          LCL(prof_records)
        !           654: #define        V_recursive_alloc       LCL(recursive_alloc)
        !           655: #define        V_wasted                LCL(wasted)
        !           656: 
        !           657: /*
        !           658:  * Loadup %ebx with the address of _profile_vars.  On a multiprocessor, this
        !           659:  * will loads up the appropriate machine's _profile_vars structure.
        !           660:  * For ELF shared libraries, rely on the fact that we won't need a GOT,
        !           661:  * except to load this pointer.
        !           662:  */
        !           663: 
        !           664: #if defined (MACH_KERNEL) && NCPUS > 1
        !           665: #define ASSEMBLER
        !           666: #if AT386
        !           667: #include <i386/AT386/mp.h>
        !           668: #endif
        !           669: 
        !           670: #if SQT
        !           671: #include <i386/SQT/asm_macros.h>
        !           672: #endif
        !           673: 
        !           674: #ifndef CPU_NUMBER
        !           675: #error "Cannot determine how to get CPU number"
        !           676: #endif
        !           677: 
        !           678: #define Vload  CPU_NUMBER(%ebx); movl EXT(_profile_vars_cpus)(,%ebx,4),%ebx
        !           679: 
        !           680: #else  /* not kernel or not multiprocessor */
        !           681: #define        Vload   Gload; Egaddr(%ebx,_profile_vars)
        !           682: #endif
        !           683: 
        !           684: 
        !           685: /*
        !           686:  * Allocate some memory for profiling.  This memory is guaranteed to
        !           687:  * be zero.
        !           688:  * %eax contains the memory size requested and will contain ptr on exit.
        !           689:  * %ebx contains the address of the appropriate profile_vars structure.
        !           690:  * %ecx is the number of the memory pool to allocate from (trashed on exit).
        !           691:  * %edx is trashed.
        !           692:  * %esi is preserved.
        !           693:  * %edi is preserved.
        !           694:  * %ebp is preserved.
        !           695:  */
        !           696: 
        !           697: Entry(_profile_alloc_asm)
        !           698:        ENTER
        !           699:        pushl   %esi
        !           700:        pushl   %edi
        !           701: 
        !           702:        movl    %ecx,%edi                       /* move context number to saved reg */
        !           703: 
        !           704: #if NO_RECURSIVE_ALLOC
        !           705:        movb    $-1,%cl
        !           706:        xchgb   %cl,V_recursive_alloc(%ebx)
        !           707:        cmpb    $0,%cl
        !           708:        je      LCL(no_recurse)
        !           709: 
        !           710:        int     $3
        !           711: 
        !           712:        .align  ALIGN
        !           713: LCL(no_recurse):
        !           714: #endif
        !           715: 
        !           716:        leal    V_acontext(%ebx,%edi,4),%ecx
        !           717: 
        !           718:        /* Loop looking for a free allocation context. */
        !           719:        /* %eax = size, %ebx = vars addr, %ecx = ptr to allocation context to try */
        !           720:        /* %edi = context number */
        !           721: 
        !           722:        .align  ALIGN
        !           723: LCL(alloc_loop):
        !           724:        movl    %ecx,%esi                       /* save ptr in case no more contexts */
        !           725:        movl    A_next(%ecx),%ecx               /* next context block */
        !           726:        cmpl    $0,%ecx
        !           727:        je      LCL(alloc_context)              /* need to allocate a new context block */
        !           728: 
        !           729:        movl    $-1,%edx
        !           730:        xchgl   %edx,A_lock(%ecx)               /* %edx == 0 if context available */
        !           731: 
        !           732: #if DO_STATS
        !           733:        SDADDNEG(%edx,V_acontext_locked(%ebx))  /* increment counter if lock was held */
        !           734: #endif
        !           735: 
        !           736:        cmpl    $0,%edx
        !           737:        jne     LCL(alloc_loop)                 /* go back if this context block is not available */
        !           738: 
        !           739:        /* Allocation context found (%ecx), now allocate. */
        !           740:        movl    A_plist(%ecx),%edx              /* pointer to current block */
        !           741:        cmpl    $0,%edx                         /* first allocation? */
        !           742:        je      LCL(alloc_new)
        !           743: 
        !           744:        cmpl    %eax,M_nfree(%edx)              /* see if we have enough space */
        !           745:        jl      LCL(alloc_new)                  /* jump if not enough space */
        !           746: 
        !           747:        /* Allocate from local block (and common exit) */
        !           748:        /* %eax = bytes to allocate, %ebx = GOT, %ecx = context, %edx = memory block */
        !           749:        /* %edi = context number */
        !           750: 
        !           751:        .align  ALIGN
        !           752: LCL(alloc_ret):
        !           753: 
        !           754: #if DO_STATS
        !           755:        SLOCK incl V_num_alloc(%ebx,%edi,4)     /* update global counters */
        !           756:        SLOCK addl %eax,V_bytes_alloc(%ebx,%edi,4)
        !           757:        SLOCK subl %eax,V_wasted(%ebx,%edi,4)
        !           758: #endif
        !           759: 
        !           760:        movl    M_ptr(%edx),%esi                /* pointer return value */
        !           761:        subl    %eax,M_nfree(%edx)              /* decrement bytes remaining */
        !           762:        addl    %eax,M_nalloc(%edx)             /* increment bytes allocated */
        !           763:        incl    M_num(%edx)                     /* increment # allocations */
        !           764:        addl    %eax,M_ptr(%edx)                /* advance pointer */
        !           765:        movl    $0,A_lock(%ecx)                 /* unlock context block */
        !           766:        movl    %esi,%eax                       /* return pointer */
        !           767: 
        !           768: #if NO_RECURSIVE_ALLOC
        !           769:        movb    $0,V_recursive_alloc(%ebx)
        !           770: #endif
        !           771: 
        !           772:        popl    %edi
        !           773:        popl    %esi
        !           774:        LEAVE0
        !           775:        ret                                     /* return to the caller */
        !           776: 
        !           777:        /* Allocate space in whole number of pages */
        !           778:        /* %eax = bytes to allocate, %ebx = vars address, %ecx = context */
        !           779:        /* %edi = context number */
        !           780: 
        !           781:        .align  ALIGN
        !           782: LCL(alloc_new):
        !           783:        pushl   %eax                            /* save regs */
        !           784:        pushl   %ecx
        !           785:        movl    V_page_size(%ebx),%edx
        !           786:        addl    $(M_size-1),%eax                /* add in overhead size & subtract 1 */
        !           787:        decl    %edx                            /* page_size - 1 */
        !           788:        addl    %edx,%eax                       /* round up to whole number of pages */
        !           789:        notl    %edx
        !           790:        andl    %edx,%eax
        !           791:        leal    -M_size(%eax),%esi              /* save allocation size */
        !           792:        pushl   %eax                            /* argument to _profile_alloc_pages */
        !           793:        call    *V_alloc_pages(%ebx)            /* allocate some memory */
        !           794:        addl    $4,%esp                         /* pop off argument */
        !           795: 
        !           796: #if DO_STATS
        !           797:        SLOCK addl %esi,V_wasted(%ebx,%edi,4)   /* udpate global counters */
        !           798:        SLOCK addl $M_size,V_overhead(%ebx,%edi,4)
        !           799: #endif
        !           800: 
        !           801:        popl    %ecx                            /* context block */
        !           802:        movl    %eax,%edx                       /* memory block pointer */
        !           803:        movl    %esi,M_nfree(%edx)              /* # free bytes */
        !           804:        addl    $M_size,%eax                    /* bump past overhead */
        !           805:        movl    A_plist(%ecx),%esi              /* previous memory block or 0 */
        !           806:        movl    %eax,M_first(%edx)              /* first space available */
        !           807:        movl    %eax,M_ptr(%edx)                /* current address available */
        !           808:        movl    %esi,M_next(%edx)               /* next memory block allocated */
        !           809:        movl    %edx,A_plist(%ecx)              /* update current page list */
        !           810:        popl    %eax                            /* user size request */
        !           811:        jmp     LCL(alloc_ret)                  /* goto common return code */
        !           812: 
        !           813:        /* Allocate a context header in addition to memory block header + data */
        !           814:        /* %eax = bytes to allocate, %ebx = GOT, %esi = ptr to store context ptr */
        !           815:        /* %edi = context number */
        !           816: 
        !           817:        .align  ALIGN
        !           818: LCL(alloc_context):
        !           819:        pushl   %eax                            /* save regs */
        !           820:        pushl   %esi
        !           821:        movl    V_page_size(%ebx),%edx
        !           822:        addl    $(A_size+M_size-1),%eax         /* add in overhead size & subtract 1 */
        !           823:        decl    %edx                            /* page_size - 1 */
        !           824:        addl    %edx,%eax                       /* round up to whole number of pages */
        !           825:        notl    %edx
        !           826:        andl    %edx,%eax
        !           827:        leal    -A_size-M_size(%eax),%esi       /* save allocation size */
        !           828:        pushl   %eax                            /* argument to _profile_alloc_pages */
        !           829:        call    *V_alloc_pages(%ebx)            /* allocate some memory */
        !           830:        addl    $4,%esp                         /* pop off argument */
        !           831: 
        !           832: #if DO_STATS
        !           833:        SLOCK incl V_num_context(%ebx,%edi,4)   /* bump # context blocks */
        !           834:        SLOCK addl %esi,V_wasted(%ebx,%edi,4)   /* update global counters */
        !           835:        SLOCK addl $(A_size+M_size),V_overhead(%ebx,%edi,4)
        !           836: #endif
        !           837: 
        !           838:        movl    %eax,%ecx                       /* context pointer */
        !           839:        leal    A_size(%eax),%edx               /* memory block pointer */
        !           840:        movl    %esi,M_nfree(%edx)              /* # free bytes */
        !           841:        addl    $(A_size+M_size),%eax           /* bump past overhead */
        !           842:        movl    %eax,M_first(%edx)              /* first space available */
        !           843:        movl    %eax,M_ptr(%edx)                /* current address available */
        !           844:        movl    $0,M_next(%edx)                 /* next memory block allocated */
        !           845:        movl    %edx,A_plist(%ecx)              /* head of memory block list */
        !           846:        movl    $1,A_lock(%ecx)                 /* set lock */
        !           847:        popl    %esi                            /* ptr to store context block link */
        !           848:        movl    %ecx,%eax                       /* context pointer temp */
        !           849:        xchgl   %eax,A_next(%esi)               /* link into chain */
        !           850:        movl    %eax,A_next(%ecx)               /* add links in case of threading */
        !           851:        popl    %eax                            /* user size request */
        !           852:        jmp     LCL(alloc_ret)                  /* goto common return code */
        !           853: 
        !           854: END(_profile_alloc_asm)
        !           855: 
        !           856: /*
        !           857:  * C callable version of the profile memory allocator.
        !           858:  * extern void *_profile_alloc(struct profile_vars *, size_t, acontext_type_t);
        !           859: */
        !           860: 
        !           861: Entry(_profile_alloc)
        !           862:        ENTER
        !           863:        pushl   %ebx
        !           864:        movl    12+Estack(%esp),%eax            /* memory size */
        !           865:        movl    8+Estack(%esp),%ebx             /* provile_vars address */
        !           866:        addl    $3,%eax                         /* round up to word boundary */
        !           867:        movl    16+Estack(%esp),%ecx            /* which memory pool to allocate from */
        !           868:        andl    $0xfffffffc,%eax
        !           869:        call    EXT(_profile_alloc_asm)
        !           870:        popl    %ebx
        !           871:        LEAVE0
        !           872:        ret
        !           873: END(_profile_alloc)
        !           874: 
        !           875: 
        !           876: /*
        !           877:  * Dummy mcount routine that just returns.
        !           878:  *
        !           879:  *             +-------------------------------+
        !           880:  *             |                               |
        !           881:  *             |                               |
        !           882:  *             | caller's caller stack,        |
        !           883:  *             | saved registers, params.      |
        !           884:  *             |                               |
        !           885:  *             |                               |
        !           886:  *             +-------------------------------+
        !           887:  *             | caller's caller return addr.  |
        !           888:  *             +-------------------------------+
        !           889:  *     esp --> | caller's return address       |
        !           890:  *             +-------------------------------+
        !           891:  *
        !           892:  *     edx --> function unqiue LCL
        !           893:  */
        !           894: 
        !           895: Entry(_dummy_mcount)
        !           896:        ENTER
        !           897: 
        !           898: #if DO_STATS
        !           899:        pushl   %ebx
        !           900:        MP_DISABLE_PREEMPTION(%ebx)
        !           901:        Vload
        !           902:        SDINC(V_dummy(%ebx))
        !           903:        MP_ENABLE_PREEMPTION(%ebx)
        !           904:        popl    %ebx
        !           905: #endif
        !           906: 
        !           907:        LEAVE0
        !           908:        ret
        !           909: END(_dummy_mcount)
        !           910: 
        !           911: 
        !           912: /*
        !           913:  * Entry point for System V based profiling, count how many times each function
        !           914:  * is called.  The function label is passed in %edx, and the top two words on
        !           915:  * the stack are the caller's address, and the caller's return address.
        !           916:  *
        !           917:  *             +-------------------------------+
        !           918:  *             |                               |
        !           919:  *             |                               |
        !           920:  *             | caller's caller stack,        |
        !           921:  *             | saved registers, params.      |
        !           922:  *             |                               |
        !           923:  *             |                               |
        !           924:  *             +-------------------------------+
        !           925:  *             | caller's caller return addr.  |
        !           926:  *             +-------------------------------+
        !           927:  *     esp --> | caller's return address       |
        !           928:  *             +-------------------------------+
        !           929:  *
        !           930:  *     edx --> function unique label
        !           931:  *
        !           932:  * We don't worry about the possibility about two threads calling
        !           933:  * the same function for the first time simulataneously.  If that
        !           934:  * happens, two records will be created, and one of the records
        !           935:  * address will be stored in in the function unique label (which
        !           936:  * is aligned by the compiler, so we don't have to watch out for
        !           937:  * crossing page/cache boundaries).
        !           938:  */
        !           939: 
        !           940: Entry(_prof_mcount)
        !           941:        ENTER
        !           942: 
        !           943: #if DO_STATS
        !           944:        pushl   %ebx
        !           945:        MP_DISABLE_PREEMPTION(%ebx)
        !           946:        Vload
        !           947:        SDINC(V_cnt(%ebx))
        !           948: #endif
        !           949: 
        !           950:        movl    (%edx),%eax                     /* initialized? */
        !           951:        cmpl    $0,%eax
        !           952:        je      LCL(pnew)
        !           953: 
        !           954:        DINC2(P_count(%eax),P_overflow(%eax))   /* bump function count (double precision) */
        !           955: 
        !           956: #if DO_STATS
        !           957:        MP_ENABLE_PREEMPTION(%ebx)
        !           958:        popl    %ebx
        !           959: #endif
        !           960: 
        !           961:        LEAVE0
        !           962:        ret
        !           963: 
        !           964:        .align  ALIGN
        !           965: LCL(pnew):
        !           966: 
        !           967: #if !DO_STATS
        !           968:        pushl   %ebx
        !           969:        MP_DISABLE_PREEMPTION(%ebx)
        !           970:        Vload
        !           971: #endif
        !           972: 
        !           973:        SLOCK incl V_prof_records(%ebx)
        !           974:        pushl   %edx
        !           975:        movl    $P_size,%eax                    /* allocation size */
        !           976:        movl    $C_prof,%ecx                    /* allocation pool */
        !           977:        call    EXT(_profile_alloc_asm)         /* allocate a new record */
        !           978:        popl    %edx
        !           979: 
        !           980:        movl    Estack+4(%esp),%ecx             /* caller's address */
        !           981:        movl    %ecx,P_addr(%eax)
        !           982:        movl    $1,P_count(%eax)                /* call count */
        !           983:        xchgl   %eax,(%edx)                     /* update function header */
        !           984:        MP_ENABLE_PREEMPTION(%ebx)
        !           985:        popl    %ebx
        !           986:        LEAVE0
        !           987:        ret
        !           988: 
        !           989: END(_prof_mcount)
        !           990: 
        !           991: 
        !           992: /*
        !           993:  * Entry point for BSD based graph profiling, count how many times each unique
        !           994:  * call graph (caller + callee) is called.  The function label is passed in
        !           995:  * %edx, and the top two words on the stack are the caller's address, and the
        !           996:  * caller's return address.
        !           997:  *
        !           998:  *             +-------------------------------+
        !           999:  *             |                               |
        !          1000:  *             |                               |
        !          1001:  *             | caller's caller stack,        |
        !          1002:  *             | saved registers, params.      |
        !          1003:  *             |                               |
        !          1004:  *             |                               |
        !          1005:  *             +-------------------------------+
        !          1006:  *             | caller's caller return addr.  |
        !          1007:  *             +-------------------------------+
        !          1008:  *     esp --> | caller's return address       |
        !          1009:  *             +-------------------------------+
        !          1010:  *
        !          1011:  *     edx --> function unqiue label
        !          1012:  *
        !          1013:  * We don't worry about the possibility about two threads calling the same
        !          1014:  * function simulataneously.  If that happens, two records will be created, and
        !          1015:  * one of the records address will be stored in in the function unique label
        !          1016:  * (which is aligned by the compiler).
        !          1017:  *
        !          1018:  * By design, the gprof header is not locked.  Each of the cache pointers is
        !          1019:  * always a valid pointer (possibily to a null record), and if another thread
        !          1020:  * comes in and modifies the pointer, it does so automatically with a simple store.
        !          1021:  * Since all arcs are in the hash table, the caches are just to avoid doing
        !          1022:  * a multiplication in the common case, and if they don't match, the arcs will
        !          1023:  * still be found.
        !          1024:  */
        !          1025: 
        !          1026: Entry(_gprof_mcount)
        !          1027: 
        !          1028:        ENTER
        !          1029:        movl    Estack+4(%esp),%ecx             /* caller's caller address */
        !          1030: 
        !          1031: #if DO_STATS
        !          1032:        pushl   %ebx
        !          1033:        MP_DISABLE_PREEMPTION(%ebx)
        !          1034:        Vload
        !          1035:        SDINC(V_cnt(%ebx))                      /* bump profile call counter (double int) */
        !          1036: #endif
        !          1037: 
        !          1038:        movl    (%edx),%eax                     /* Gprof header allocated? */
        !          1039:        cmpl    $0,%eax
        !          1040:        je      LCL(gnew)                       /* skip if first call */
        !          1041: 
        !          1042:        DINC2(H_prof+P_count(%eax),H_prof+P_overflow(%eax))     /* bump function count */
        !          1043: 
        !          1044:        /* See if this call arc is the same as the last time */
        !          1045: MARK(_gprof_mcount_cache1)
        !          1046:        movl    H_cache_ptr(%eax),%edx          /* last arc searched */
        !          1047:        cmpl    %ecx,G_frompc(%edx)             /* skip if not equal */
        !          1048:        jne     LCL(gcache2)
        !          1049: 
        !          1050:        /* Same as last time, increment and return */
        !          1051: 
        !          1052:        DINC2(G_count(%edx),G_overflow(%edx))   /* bump arc count */
        !          1053: 
        !          1054: #if DO_STATS
        !          1055:        SDINC(V_cache_hits1(%ebx))              /* update counter */
        !          1056:        MP_ENABLE_PREEMPTION(%ebx)
        !          1057:        popl    %ebx
        !          1058: #endif
        !          1059: 
        !          1060:        LEAVE0
        !          1061:        ret
        !          1062: 
        !          1063:        /* Search second cache entry */
        !          1064:        /* %eax = gprof func header, %ebx = vars address if DO_STATS, %ecx = caller's caller */
        !          1065:        /* %edx = first arc searched */
        !          1066:        /* %ebx if DO_STATS pushed on stack */
        !          1067: 
        !          1068:        .align  ALIGN
        !          1069: MARK(_gprof_mcount_cache2)
        !          1070: LCL(gcache2):
        !          1071:        pushl   %esi                            /* get a saved register */
        !          1072:        movl    H_cache_ptr+4(%eax),%esi        /* 2nd arc to be searched */
        !          1073:        cmpl    %ecx,G_frompc(%esi)             /* skip if not equal */
        !          1074:        jne     LCL(gcache3)
        !          1075: 
        !          1076:        /* Element found, increment, reset last arc searched and return */
        !          1077: 
        !          1078:        DINC2(G_count(%esi),G_overflow(%esi))   /* bump arc count */
        !          1079: 
        !          1080:        movl    %esi,H_cache_ptr+0(%eax)        /* swap 1st and 2nd cached arcs */
        !          1081:        popl    %esi
        !          1082:        movl    %edx,H_cache_ptr+4(%eax)
        !          1083: 
        !          1084: #if DO_STATS
        !          1085:        SDINC(V_cache_hits2(%ebx))              /* update counter */
        !          1086:        MP_ENABLE_PREEMPTION(%ebx)
        !          1087:        popl    %ebx
        !          1088: #endif
        !          1089: 
        !          1090:        LEAVE0
        !          1091:        ret
        !          1092: 
        !          1093:        /* Search third cache entry */
        !          1094:        /* %eax = gprof func header, %ebx = vars address if DO_STATS, %ecx = caller's caller */
        !          1095:        /* %edx = first arc searched, %esi = second arc searched */
        !          1096:        /* %esi, %ebx if DO_STATS pushed on stack */
        !          1097: 
        !          1098:        .align  ALIGN
        !          1099: MARK(_gprof_mcount_cache3)
        !          1100: LCL(gcache3):
        !          1101:        pushl   %edi
        !          1102:        movl    H_cache_ptr+8(%eax),%edi        /* 3rd arc to be searched */
        !          1103:        cmpl    %ecx,G_frompc(%edi)             /* skip if not equal */
        !          1104:        jne     LCL(gnocache)
        !          1105: 
        !          1106:        /* Element found, increment, reset last arc searched and return */
        !          1107: 
        !          1108:        DINC2(G_count(%edi),G_overflow(%edi))   /* bump arc count */
        !          1109: 
        !          1110:        movl    %edi,H_cache_ptr+0(%eax)        /* make this 1st cached arc */
        !          1111:        movl    %esi,H_cache_ptr+8(%eax)
        !          1112:        movl    %edx,H_cache_ptr+4(%eax)
        !          1113:        popl    %edi
        !          1114:        popl    %esi
        !          1115: 
        !          1116: #if DO_STATS
        !          1117:        SDINC(V_cache_hits3(%ebx))              /* update counter */
        !          1118:        MP_ENABLE_PREEMPTION(%ebx)
        !          1119:        popl    %ebx
        !          1120: #endif
        !          1121: 
        !          1122:        LEAVE0
        !          1123:        ret
        !          1124: 
        !          1125:        /* No function context, allocate a new context */
        !          1126:        /* %ebx is the variables address if DO_STATS */
        !          1127:        /* %ecx is the caller's caller's address */
        !          1128:        /* %edx is the unique function pointer */
        !          1129:        /* %ebx if DO_STATS pushed on stack */
        !          1130: 
        !          1131:        .align  ALIGN
        !          1132: MARK(_gprof_mcount_new)
        !          1133: LCL(gnew):
        !          1134:        pushl   %esi
        !          1135:        pushl   %edi
        !          1136: 
        !          1137: #if !DO_STATS
        !          1138:        pushl   %ebx                            /* Address of vars needed for alloc */
        !          1139:        MP_DISABLE_PREEMPTION(%ebx)
        !          1140:        Vload                                   /* stats already loaded address */
        !          1141: #endif
        !          1142: 
        !          1143:        SLOCK incl V_prof_records(%ebx)
        !          1144:        movl    %edx,%esi                       /* save unique function ptr */
        !          1145:        movl    %ecx,%edi                       /* and caller's caller address */
        !          1146:        movl    $H_size,%eax                    /* memory block size */
        !          1147:        movl    $C_gfunc,%ecx                   /* gprof function header memory pool */
        !          1148:        call    EXT(_profile_alloc_asm)
        !          1149: 
        !          1150:        movl    V_hash_ptr(%ebx),%ecx           /* copy hash_ptr to func header */
        !          1151:        movl    V_dummy_ptr(%ebx),%edx          /* dummy cache entry */
        !          1152:        movl    %ecx,H_hash_ptr(%eax)
        !          1153:        movl    %edx,H_cache_ptr+0(%eax)        /* store dummy cache ptrs */
        !          1154:        movl    %edx,H_cache_ptr+4(%eax)
        !          1155:        movl    %edx,H_cache_ptr+8(%eax)
        !          1156:        movl    %esi,H_unique_ptr(%eax)         /* remember function unique ptr */
        !          1157:        movl    Estack+12(%esp),%ecx            /* caller's address */
        !          1158:        movl    $1,H_prof+P_count(%eax)         /* function called once so far */
        !          1159:        movl    %ecx,H_prof+P_addr(%eax)        /* set up prof information */
        !          1160:        movl    %eax,(%esi)                     /* update context block address */
        !          1161:        movl    %edi,%ecx                       /* caller's caller address */
        !          1162:        movl    %edx,%esi                       /* 2nd cached arc */
        !          1163: 
        !          1164: #if !DO_STATS
        !          1165:        popl    %ebx
        !          1166: #endif
        !          1167: 
        !          1168:        /* Fall through to add element to the hash table.  This may involve */
        !          1169:        /* searching a few hash table elements that don't need to be searched */
        !          1170:        /* since we have a new element, but it allows the hash table function */
        !          1171:        /* to be specified in only one place */
        !          1172: 
        !          1173:        /* Didn't find entry in cache, search the global hash table */
        !          1174:        /* %eax = gprof func header, %ebx = vars address if DO_STATS */
        !          1175:        /* %ecx = caller's caller */
        !          1176:        /* %edx, %esi = cached arcs that were searched */
        !          1177:        /* %edi, %esi, %ebx if DO_STATS pushed on stack */
        !          1178: 
        !          1179:        .align  ALIGN
        !          1180: MARK(_gprof_mcount_hash)
        !          1181: LCL(gnocache):
        !          1182: 
        !          1183:        pushl   %esi                            /* save 2nd arc searched */
        !          1184:        pushl   %edx                            /* save 1st arc searched */
        !          1185:        movl    %eax,%esi                       /* save gprof func header */
        !          1186: 
        !          1187: #if DO_STATS
        !          1188:        SDINC(V_hash_num(%ebx))
        !          1189:        movl    Estack+20(%esp),%edi            /* caller's address */
        !          1190: #else
        !          1191:        movl    Estack+16(%esp),%edi            /* caller's address */
        !          1192: #endif
        !          1193:        movl    %ecx,%eax                       /* caller's caller address */
        !          1194:        imull   %edi,%eax                       /* multiply to get hash */
        !          1195:        movl    H_hash_ptr(%esi),%edx           /* hash pointer */
        !          1196:        shrl    $GPROF_HASH_SHIFT,%eax          /* eliminate low order bits */
        !          1197:        andl    $GPROF_HASH_MASK,%eax           /* mask to get hash value */
        !          1198:        leal    0(%edx,%eax,4),%eax             /* pointer to hash bucket */
        !          1199:        movl    %eax,%edx                       /* save hash bucket address */
        !          1200: 
        !          1201:        /* %eax = old arc, %ebx = vars address if DO_STATS, %ecx = caller's caller */
        !          1202:        /* %edx = hash bucket address, %esi = gfunc ptr, %edi = caller's addr */
        !          1203:        /* 2 old arcs, %edi, %esi, %ebx if DO_STATS pushed on stack */
        !          1204: 
        !          1205:        .align  ALIGN
        !          1206: LCL(ghash):
        !          1207:        movl    G_next(%eax),%eax               /* get next hash element */
        !          1208:        cmpl    $0,%eax                         /* end of line? */
        !          1209:        je      LCL(ghashnew)                   /* skip if allocate new hash */
        !          1210: 
        !          1211: #if DO_STATS
        !          1212:        SDINC(V_hash_search(%ebx))
        !          1213: #endif
        !          1214: 
        !          1215:        cmpl    G_selfpc(%eax),%edi             /* loop back if not one we want */
        !          1216:        jne     LCL(ghash)
        !          1217: 
        !          1218:        cmpl    G_frompc(%eax),%ecx             /* loop back if not one we want */
        !          1219:        jne     LCL(ghash)
        !          1220: 
        !          1221:        /* Found an entry, increment count, set up for caching, and return */
        !          1222:        /* %eax = arc, %ebx = vars address if DO_STATS, %esi = func header */
        !          1223:        /* 2 old arcs, %edi, %esi, %ebx if DO_STATS pushed on stack */
        !          1224: 
        !          1225:        DINC2(G_count(%eax),G_overflow(%eax))   /* bump arc count */
        !          1226: 
        !          1227:        popl    %ecx                            /* previous 1st arc searched */
        !          1228:        movl    %eax,H_cache_ptr+0(%esi)        /* this element is now 1st arc */
        !          1229:        popl    %edi                            /* previous 2nd arc searched */
        !          1230:        movl    %ecx,H_cache_ptr+4(%esi)        /* new 2nd arc to be searched */
        !          1231:        movl    %edi,H_cache_ptr+8(%esi)        /* new 3rd arc to be searched */
        !          1232:        popl    %edi
        !          1233:        popl    %esi
        !          1234: 
        !          1235: #if DO_STATS
        !          1236:        MP_ENABLE_PREEMPTION(%ebx)
        !          1237:        popl    %ebx
        !          1238: #endif
        !          1239: 
        !          1240:        LEAVE0
        !          1241:        ret                                     /* return to user */
        !          1242: 
        !          1243:        /* Allocate new arc */
        !          1244:        /* %eax = old arc, %ebx = vars address if DO_STATS, %ecx = caller's caller */
        !          1245:        /* %edx = hash bucket address, %esi = gfunc ptr, %edi = caller's addr */
        !          1246:        /* 2 old arcs, %edi, %esi, %ebx if DO_STATS pushed on stack */
        !          1247: 
        !          1248:        .align  ALIGN
        !          1249: MARK(_gprof_mcount_hashnew)
        !          1250: LCL(ghashnew):
        !          1251: 
        !          1252: #if !DO_STATS
        !          1253:        pushl   %ebx                            /* load address of vars if we haven't */
        !          1254:        MP_DISABLE_PREEMPTION(%ebx)
        !          1255:        Vload                                   /* already done so */
        !          1256: #endif
        !          1257: 
        !          1258:        SLOCK incl V_gprof_records(%ebx)
        !          1259:        pushl   %edx
        !          1260:        movl    %ecx,%edi                       /* save caller's caller */
        !          1261:        movl    $G_size,%eax                    /* arc size */
        !          1262:        movl    $C_gprof,%ecx                   /* gprof memory pool */
        !          1263:        call    EXT(_profile_alloc_asm)
        !          1264:        popl    %edx
        !          1265: 
        !          1266:        movl    $1,G_count(%eax)                /* set call count */
        !          1267:        movl    Estack+20(%esp),%ecx            /* caller's address */
        !          1268:        movl    %edi,G_frompc(%eax)             /* caller's caller */
        !          1269:        movl    %ecx,G_selfpc(%eax)
        !          1270: 
        !          1271: #if !DO_STATS
        !          1272:        popl    %ebx                            /* release %ebx if no stats */
        !          1273: #endif
        !          1274: 
        !          1275:        movl    (%edx),%ecx                     /* first hash bucket */
        !          1276:        movl    %ecx,G_next(%eax)               /* update link */
        !          1277:        movl    %eax,%ecx                       /* copy for xchgl */
        !          1278:        xchgl   %ecx,(%edx)                     /* add to hash linked list */
        !          1279:        movl    %ecx,G_next(%eax)               /* update in case list changed */
        !          1280: 
        !          1281:        popl    %ecx                            /* previous 1st arc searched */
        !          1282:        popl    %edi                            /* previous 2nd arc searched */
        !          1283:        movl    %eax,H_cache_ptr+0(%esi)        /* this element is now 1st arc */
        !          1284:        movl    %ecx,H_cache_ptr+4(%esi)        /* new 2nd arc to be searched */
        !          1285:        movl    %edi,H_cache_ptr+8(%esi)        /* new 3rd arc to be searched */
        !          1286: 
        !          1287:        popl    %edi
        !          1288:        popl    %esi
        !          1289: 
        !          1290: #if DO_STATS
        !          1291:        MP_ENABLE_PREEMPTION(%ebx)
        !          1292:        popl    %ebx
        !          1293: #endif
        !          1294: 
        !          1295:        LEAVE0
        !          1296:        ret                                     /* return to user */
        !          1297: 
        !          1298: END(_gprof_mcount)
        !          1299: 
        !          1300: 
        !          1301: /*
        !          1302:  * This function assumes that neither the caller or it's caller
        !          1303:  * has not omitted the frame pointer in order to get the caller's
        !          1304:  * caller.  The stack looks like the following at the time of the call:
        !          1305:  *
        !          1306:  *             +-------------------------------+
        !          1307:  *             |                               |
        !          1308:  *             |                               |
        !          1309:  *             | caller's caller stack,        |
        !          1310:  *             | saved registers, params.      |
        !          1311:  *             |                               |
        !          1312:  *             |                               |
        !          1313:  *             +-------------------------------+
        !          1314:  *             | caller's caller return addr.  |
        !          1315:  *             +-------------------------------+
        !          1316:  *     fp -->  | previous frame pointer        |
        !          1317:  *             +-------------------------------+
        !          1318:  *             |                               |
        !          1319:  *             | caller's stack, saved regs,   |
        !          1320:  *             | params.                       |
        !          1321:  *             |                               |
        !          1322:  *             +-------------------------------+
        !          1323:  *     sp -->  | caller's return address       |
        !          1324:  *             +-------------------------------+
        !          1325:  *
        !          1326:  * Recent versions of the compiler put the address of the pointer
        !          1327:  * sized word in %edx.  Previous versions did not, but this code
        !          1328:  * does not support them.
        !          1329:  */
        !          1330: 
        !          1331: /*
        !          1332:  * Note that OSF/rose blew defining _mcount, since it prepends leading
        !          1333:  * underscores, and _mcount didn't have a second leading underscore.  However,
        !          1334:  * some of the kernel/server functions 'know' that mcount has a leading
        !          1335:  * underscore, so we satisfy both camps.
        !          1336:  */
        !          1337: 
        !          1338: #if OLD_MCOUNT
        !          1339:        .globl  mcount
        !          1340:        .globl  _mcount
        !          1341:        ELF_FUNC(mcount)
        !          1342:        ELF_FUNC(_mcount)
        !          1343:        .align  FALIGN
        !          1344: _mcount:
        !          1345: mcount:
        !          1346: 
        !          1347:        pushl   %ebx
        !          1348:        MP_DISABLE_PREEMPTION(%ebx)
        !          1349:        Vload
        !          1350: 
        !          1351: #if DO_STATS
        !          1352:        SDINC(V_old_mcount(%ebx))
        !          1353: #endif
        !          1354: 
        !          1355:        /* In calling the functions, we will actually leave 1 extra word on the */
        !          1356:        /* top of the stack, but generated code will not notice, since the function */
        !          1357:        /* uses a frame pointer */
        !          1358: 
        !          1359:        movl    V_mcount_ptr_ptr(%ebx),%ecx     /* address of mcount_ptr */
        !          1360:        MP_ENABLE_PREEMPTION(%ebx)
        !          1361:        popl    %ebx
        !          1362:        movl    4(%ebp),%eax                    /* caller's caller return address */
        !          1363:        xchgl   %eax,(%esp)                     /* push & get return address */
        !          1364:        pushl   %eax                            /* push return address */
        !          1365:        jmp     *(%ecx)                         /* go to profile the function */
        !          1366: 
        !          1367: End(mcount)
        !          1368: End(_mcount)
        !          1369: #endif
        !          1370: 
        !          1371: 
        !          1372: #if !defined(KERNEL) && !defined(MACH_KERNEL)
        !          1373: 
        !          1374: /*
        !          1375:  * Convert a 64-bit integer to a string.
        !          1376:  * Arg #1 is a pointer to a string (at least 24 bytes) or NULL
        !          1377:  * Arg #2 is the low part of the 64-bit integer.
        !          1378:  * Arg #3 is the high part of the 64-bit integer.
        !          1379:  */
        !          1380: 
        !          1381: Entry(_profile_cnt_to_decimal)
        !          1382:        ENTER
        !          1383:        pushl   %ebx
        !          1384:        pushl   %esi
        !          1385:        pushl   %edi
        !          1386:        movl    Estack+16(%esp),%ebx            /* pointer or null */
        !          1387:        movl    Estack+20(%esp),%edi            /* low part of number */
        !          1388:        movl    $10,%ecx                        /* divisor */
        !          1389:        cmpl    $0,%ebx                         /* skip if pointer ok */
        !          1390:        jne     LCL(cvt_nonnull)
        !          1391: 
        !          1392:        MP_DISABLE_PREEMPTION(%ebx)
        !          1393:        Vload                                   /* get _profile_vars address */
        !          1394:        leal    V_num_buffer(%ebx),%ebx         /* temp buffer to use */
        !          1395: 
        !          1396:        .align  ALIGN
        !          1397: LCL(cvt_nonnull):
        !          1398:        addl    $(N_digit-1),%ebx               /* point string at end */
        !          1399:        movb    $0,0(%ebx)                      /* null terminate string */
        !          1400: 
        !          1401: #if OVERFLOW
        !          1402:        movl    Estack+24(%esp),%esi            /* high part of number */
        !          1403:        cmpl    $0,%esi                         /* any thing left in high part? */
        !          1404:        je      LCL(cvt_low)
        !          1405: 
        !          1406:        .align  ALIGN
        !          1407: LCL(cvt_high):
        !          1408:        movl    %esi,%eax                       /* calculate high/10 & high%10 */
        !          1409:        xorl    %edx,%edx
        !          1410:        divl    %ecx
        !          1411:        movl    %eax,%esi
        !          1412: 
        !          1413:        movl    %edi,%eax                       /* calculate (low + (high%10)*2^32) / 10 */
        !          1414:        divl    %ecx
        !          1415:        movl    %eax,%edi
        !          1416: 
        !          1417:        decl    %ebx                            /* decrement string pointer */
        !          1418:        addl    $48,%edx                        /* convert from 0..9 -> '0'..'9' */
        !          1419:        movb    %dl,0(%ebx)                     /* store digit in string */
        !          1420:        cmpl    $0,%esi                         /* any thing left in high part? */
        !          1421:        jne     LCL(cvt_high)
        !          1422: 
        !          1423: #endif /* OVERFLOW */
        !          1424: 
        !          1425:        .align  ALIGN
        !          1426: LCL(cvt_low):
        !          1427:        movl    %edi,%eax                       /* get low part into %eax */
        !          1428: 
        !          1429:        .align  ALIGN
        !          1430: LCL(cvt_low2):
        !          1431:        xorl    %edx,%edx                       /* 0 */
        !          1432:        divl    %ecx                            /* calculate next digit */
        !          1433:        decl    %ebx                            /* decrement string pointer */
        !          1434:        addl    $48,%edx                        /* convert from 0..9 -> '0'..'9' */
        !          1435:        movb    %dl,0(%ebx)                     /* store digit in string */
        !          1436:        cmpl    $0,%eax                         /* any more digits to convert? */
        !          1437:        jne     LCL(cvt_low2)
        !          1438: 
        !          1439:        movl    %ebx,%eax                       /* return value */
        !          1440:        popl    %edi
        !          1441:        popl    %esi
        !          1442:        MP_ENABLE_PREEMPTION(%ebx)
        !          1443:        popl    %ebx
        !          1444:        LEAVE0
        !          1445:        ret
        !          1446: 
        !          1447: END(_profile_cnt_to_decimal)
        !          1448: 
        !          1449: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.