diff options
61 files changed, 1062 insertions, 1060 deletions
diff --git a/include/fcntl.h b/include/fcntl.h index adeabaebb..3e0aab53e 100644 --- a/include/fcntl.h +++ b/include/fcntl.h @@ -199,7 +199,7 @@ extern int posix_fadvise64 (int __fd, __off64_t __offset, __off64_t __len, #endif -#if 0 // && defined __UCLIBC_HAS_ADVANCED_REALTIME__ +#if 0 /* && defined __UCLIBC_HAS_ADVANCED_REALTIME__ */ /* FIXME -- uClibc should probably implement these... */ diff --git a/include/libc-symbols.h b/include/libc-symbols.h index e5e3356fb..dacc03cf9 100644 --- a/include/libc-symbols.h +++ b/include/libc-symbols.h @@ -283,7 +283,7 @@ /* Tacking on "\n#APP\n\t#" to the section name makes gcc put it's bogus section attributes on what looks like a comment to the assembler. */ -#ifdef __sparc__ //HAVE_SECTION_QUOTES +#ifdef __sparc__ /* HAVE_SECTION_QUOTES */ # define __sec_comment "\"\n#APP\n\t#\"" #else # define __sec_comment "\n#APP\n\t#" diff --git a/ldso/ldso/arm/dl-startup.h b/ldso/ldso/arm/dl-startup.h index 43985d002..05741636d 100644 --- a/ldso/ldso/arm/dl-startup.h +++ b/ldso/ldso/arm/dl-startup.h @@ -159,7 +159,7 @@ void PERFORM_BOOTSTRAP_RELOC(ELF_RELOC *rpnt, unsigned long *reloc_addr, if (topbits != 0xfe000000 && topbits != 0x00000000) { #if 0 - // Don't bother with this during ldso initilization... + /* Don't bother with this during ldso initilization... */ newvalue = fix_bad_pc24(reloc_addr, symbol_addr) - (unsigned long)reloc_addr + (addend << 2); topbits = newvalue & 0xfe000000; diff --git a/ldso/ldso/powerpc/resolve.S b/ldso/ldso/powerpc/resolve.S index 03c6a79b8..c83337ccd 100644 --- a/ldso/ldso/powerpc/resolve.S +++ b/ldso/ldso/powerpc/resolve.S @@ -11,19 +11,19 @@ .type _dl_linux_resolve,@function _dl_linux_resolve: -// We need to save the registers used to pass parameters, and register 0, -// which is used by _mcount; the registers are saved in a stack frame. +/* We need to save the registers used to pass parameters, and register 0, + which is used by _mcount; the registers are saved in a stack frame. */ stwu 1,-64(1) stw 0,12(1) stw 3,16(1) stw 4,20(1) -// The code that calls this has put parameters for 'fixup' in r12 and r11. +/* The code that calls this has put parameters for 'fixup' in r12 and r11. */ mr 3,12 stw 5,24(1) mr 4,11 stw 6,28(1) mflr 0 -// We also need to save some of the condition register fields. +/* We also need to save some of the condition register fields. */ stw 7,32(1) stw 0,48(1) stw 8,36(1) @@ -32,9 +32,9 @@ _dl_linux_resolve: stw 10,44(1) stw 0,8(1) bl _dl_linux_resolver@local -// 'fixup' returns the address we want to branch to. +/* 'fixup' returns the address we want to branch to. */ mtctr 3 -// Put the registers back... +/* Put the registers back... */ lwz 0,48(1) lwz 10,44(1) lwz 9,40(1) @@ -48,7 +48,7 @@ _dl_linux_resolve: lwz 4,20(1) lwz 3,16(1) lwz 0,12(1) -// ...unwind the stack frame, and jump to the PLT entry we updated. +/* ...unwind the stack frame, and jump to the PLT entry we updated. */ addi 1,1,64 bctr diff --git a/libc/inet/rpc/rpc_thread.c b/libc/inet/rpc/rpc_thread.c index 2c7b8c1ea..43d2fc547 100644 --- a/libc/inet/rpc/rpc_thread.c +++ b/libc/inet/rpc/rpc_thread.c @@ -34,7 +34,7 @@ __rpc_thread_destroy (void) if (tvp != NULL && tvp != &__libc_tsd_RPC_VARS_mem) { __rpc_thread_svc_cleanup (); __rpc_thread_clnt_cleanup (); - //__rpc_thread_key_cleanup (); + /*__rpc_thread_key_cleanup (); */ free (tvp->authnone_private_s); free (tvp->clnt_perr_buf_s); free (tvp->clntraw_private_s); diff --git a/libc/misc/internals/tempname.c b/libc/misc/internals/tempname.c index 0883259bd..c963eae1f 100644 --- a/libc/misc/internals/tempname.c +++ b/libc/misc/internals/tempname.c @@ -75,7 +75,7 @@ static int direxists (const char *dir) int attribute_hidden ___path_search (char *tmpl, size_t tmpl_len, const char *dir, const char *pfx /*, int try_tmpdir*/) { - //const char *d; + /*const char *d; */ size_t dlen, plen; if (!pfx || !pfx[0]) diff --git a/libc/string/bfin/memchr.S b/libc/string/bfin/memchr.S index 88e46bef6..26d419f7c 100644 --- a/libc/string/bfin/memchr.S +++ b/libc/string/bfin/memchr.S @@ -25,8 +25,8 @@ .weak _memchr ENTRY(_memchr) - P0 = R0; // P0 = address - P2 = R2; // P2 = count + P0 = R0; /* P0 = address */ + P2 = R2; /* P2 = count */ R1 = R1.B(Z); CC = R2 == 0; IF CC JUMP .Lfailed; diff --git a/libc/string/bfin/strcmp.S b/libc/string/bfin/strcmp.S index 12e8c53c6..ef23aa9ab 100644 --- a/libc/string/bfin/strcmp.S +++ b/libc/string/bfin/strcmp.S @@ -29,66 +29,66 @@ ENTRY(_strcmp) p1 = r0; p2 = r1; - p0 = -1; // (need for loop counter init) + p0 = -1; /* (need for loop counter init) */ - // check if byte aligned - r0 = r0 | r1; // check both pointers at same time - r0 <<= 30; // dump all but last 2 bits - cc = az; // are they zero? - if !cc jump .Lunaligned; // no; use unaligned code. - // fall-thru for aligned case.. + /* check if byte aligned */ + r0 = r0 | r1; /* check both pointers at same time */ + r0 <<= 30; /* dump all but last 2 bits */ + cc = az; /* are they zero? */ + if !cc jump .Lunaligned; /* no; use unaligned code. */ + /* fall-thru for aligned case.. */ - // note that r0 is zero from the previous... - // p0 set to -1 + /* note that r0 is zero from the previous... */ + /* p0 set to -1 */ LSETUP (.Lbeginloop, .Lendloop) lc0=p0; - // pick up first words + /* pick up first words */ r1 = [p1++]; r2 = [p2++]; - // make up mask: 0FF0FF + /* make up mask: 0FF0FF */ r7 = 0xFF; r7.h = 0xFF; - // loop : 9 cycles to check 4 characters + /* loop : 9 cycles to check 4 characters */ cc = r1 == r2; .Lbeginloop: - if !cc jump .Lnotequal4; // compare failure, exit loop + if !cc jump .Lnotequal4; /* compare failure, exit loop */ - // starting with 44332211 - // see if char 3 or char 1 is 0 - r3 = r1 & r7; // form 00330011 - // add to zero, and (r2 is free, reload) + /* starting with 44332211 */ + /* see if char 3 or char 1 is 0 */ + r3 = r1 & r7; /* form 00330011 */ + /* add to zero, and (r2 is free, reload) */ r6 = r3 +|+ r0 || r2 = [p2++] || nop; - cc = az; // true if either is zero - r3 = r1 ^ r3; // form 44002200 (4321^0301 => 4020) - // (trick, saves having another mask) - // add to zero, and (r1 is free, reload) + cc = az; /* true if either is zero */ + r3 = r1 ^ r3; /* form 44002200 (4321^0301 => 4020) */ + /* (trick, saves having another mask) */ + /* add to zero, and (r1 is free, reload) */ r6 = r3 +|+ r0 || r1 = [p1++] || nop; - cc |= az; // true if either is zero - if cc jump .Lzero4; // leave if a zero somewhere + cc |= az; /* true if either is zero */ + if cc jump .Lzero4; /* leave if a zero somewhere */ .Lendloop: cc = r1 == r2; - // loop exits -.Lnotequal4: // compare failure on 4-char compare - // address pointers are one word ahead; - // faster to use zero4 exit code + /* loop exits */ +.Lnotequal4: /* compare failure on 4-char compare */ + /* address pointers are one word ahead; */ + /* faster to use zero4 exit code */ p1 += 4; p2 += 4; -.Lzero4: // one of the bytes in word 1 is zero - // but we've already fetched the next word; so - // backup two to look at failing word again +.Lzero4: /* one of the bytes in word 1 is zero */ + /* but we've already fetched the next word; so */ + /* backup two to look at failing word again */ p1 += -8; p2 += -8; - // here when pointers are unaligned: checks one - // character at a time. Also use at the end of - // the word-check algorithm to figure out what happened + /* here when pointers are unaligned: checks one */ + /* character at a time. Also use at the end of */ + /* the word-check algorithm to figure out what happened */ .Lunaligned: - // R0 is non-zero from before. - // p0 set to -1 + /* R0 is non-zero from before. */ + /* p0 set to -1 */ r0 = 0 (Z); r1 = B[p1++] (Z); @@ -96,18 +96,18 @@ ENTRY(_strcmp) LSETUP (.Lbeginloop1, .Lendloop1) lc0=p0; .Lbeginloop1: - cc = r1; // first char must be non-zero - // chars must be the same + cc = r1; /* first char must be non-zero */ + /* chars must be the same */ r3 = r2 - r1 (NS) || r1 = B[p1++] (Z) || nop; cc &= az; - r3 = r0 - r2; // second char must be non-zero + r3 = r0 - r2; /* second char must be non-zero */ cc &= an; if !cc jump .Lexitloop1; .Lendloop1: r2 = B[p2++] (Z); -.Lexitloop1: // here means we found a zero or a difference. - // we have r2(N), p2(N), r1(N+1), p1(N+2) +.Lexitloop1: /* here means we found a zero or a difference. */ + /* we have r2(N), p2(N), r1(N+1), p1(N+2) */ r1=B[p1+ -2] (Z); r0 = r1 - r2; (r7:4) = [sp++]; diff --git a/libc/string/generic/strtok_r.c b/libc/string/generic/strtok_r.c index d082d226e..7648212f7 100644 --- a/libc/string/generic/strtok_r.c +++ b/libc/string/generic/strtok_r.c @@ -29,17 +29,17 @@ # define __rawmemchr strchr /* Experimentally off - libc_hidden_proto(strchr) */ #endif - -/* Parse S into tokens separated by characters in DELIM. +#if 0 + Parse S into tokens separated by characters in DELIM. If S is NULL, the saved pointer in SAVE_PTR is used as the next starting point. For example: char s[] = "-abc-=-def"; char *sp; - x = strtok_r(s, "-", &sp); // x = "abc", sp = "=-def" - x = strtok_r(NULL, "-=", &sp); // x = "def", sp = NULL - x = strtok_r(NULL, "=", &sp); // x = NULL - // s = "abc\0-def\0" -*/ + x = strtok_r(s, "-", &sp); /* x = "abc", sp = "=-def" */ + x = strtok_r(NULL, "-=", &sp); /* x = "def", sp = NULL */ + x = strtok_r(NULL, "=", &sp); /* x = NULL */ + /* s = "abc\0-def\0" */ +#endif char *strtok_r (char *s, const char *delim, char **save_ptr) { char *token; diff --git a/libc/string/ia64/bzero.S b/libc/string/ia64/bzero.S index d390838a6..1f0f8b7ac 100644 --- a/libc/string/ia64/bzero.S +++ b/libc/string/ia64/bzero.S @@ -47,13 +47,13 @@ #define ptr1 r28 #define ptr2 r27 #define ptr3 r26 -#define ptr9 r24 +#define ptr9 r24 #define loopcnt r23 #define linecnt r22 #define bytecnt r21 -// This routine uses only scratch predicate registers (p6 - p15) -#define p_scr p6 // default register for same-cycle branches +/* This routine uses only scratch predicate registers (p6 - p15) */ +#define p_scr p6 /* default register for same-cycle branches */ #define p_unalgn p9 #define p_y p11 #define p_n p12 @@ -65,7 +65,7 @@ #define MIN1 15 #define MIN1P1HALF 8 #define LINE_SIZE 128 -#define LSIZE_SH 7 // shift amount +#define LSIZE_SH 7 /* shift amount */ #define PREF_AHEAD 8 #define USE_FLP @@ -87,49 +87,49 @@ ENTRY(bzero) movi0 save_lc = ar.lc } { .mmi .body - mov ret0 = dest // return value + mov ret0 = dest /* return value */ nop.m 0 cmp.eq p_scr, p0 = cnt, r0 ;; } { .mmi - and ptr2 = -(MIN1+1), dest // aligned address - and tmp = MIN1, dest // prepare to check for alignment - tbit.nz p_y, p_n = dest, 0 // Do we have an odd address? (M_B_U) + and ptr2 = -(MIN1+1), dest /* aligned address */ + and tmp = MIN1, dest /* prepare to check for alignment */ + tbit.nz p_y, p_n = dest, 0 /* Do we have an odd address? (M_B_U) */ } { .mib mov ptr1 = dest nop.i 0 -(p_scr) br.ret.dpnt.many rp // return immediately if count = 0 +(p_scr) br.ret.dpnt.many rp /* return immediately if count = 0 */ ;; } { .mib cmp.ne p_unalgn, p0 = tmp, r0 -} { .mib // NB: # of bytes to move is 1 - sub bytecnt = (MIN1+1), tmp // higher than loopcnt - cmp.gt p_scr, p0 = 16, cnt // is it a minimalistic task? -(p_scr) br.cond.dptk.many .move_bytes_unaligned // go move just a few (M_B_U) +} { .mib /* NB: # of bytes to move is 1 */ + sub bytecnt = (MIN1+1), tmp /* higher than loopcnt */ + cmp.gt p_scr, p0 = 16, cnt /* is it a minimalistic task? */ +(p_scr) br.cond.dptk.many .move_bytes_unaligned /* go move just a few (M_B_U) */ ;; } { .mmi -(p_unalgn) add ptr1 = (MIN1+1), ptr2 // after alignment -(p_unalgn) add ptr2 = MIN1P1HALF, ptr2 // after alignment -(p_unalgn) tbit.nz.unc p_y, p_n = bytecnt, 3 // should we do a st8 ? +(p_unalgn) add ptr1 = (MIN1+1), ptr2 /* after alignment */ +(p_unalgn) add ptr2 = MIN1P1HALF, ptr2 /* after alignment */ +(p_unalgn) tbit.nz.unc p_y, p_n = bytecnt, 3 /* should we do a st8 ? */ ;; } { .mib (p_y) add cnt = -8, cnt -(p_unalgn) tbit.nz.unc p_yy, p_nn = bytecnt, 2 // should we do a st4 ? +(p_unalgn) tbit.nz.unc p_yy, p_nn = bytecnt, 2 /* should we do a st4 ? */ } { .mib (p_y) st8 [ptr2] = r0,-4 (p_n) add ptr2 = 4, ptr2 ;; } { .mib (p_yy) add cnt = -4, cnt -(p_unalgn) tbit.nz.unc p_y, p_n = bytecnt, 1 // should we do a st2 ? +(p_unalgn) tbit.nz.unc p_y, p_n = bytecnt, 1 /* should we do a st2 ? */ } { .mib (p_yy) st4 [ptr2] = r0,-2 (p_nn) add ptr2 = 2, ptr2 ;; } { .mmi - mov tmp = LINE_SIZE+1 // for compare + mov tmp = LINE_SIZE+1 /* for compare */ (p_y) add cnt = -2, cnt -(p_unalgn) tbit.nz.unc p_yy, p_nn = bytecnt, 0 // should we do a st1 ? +(p_unalgn) tbit.nz.unc p_yy, p_nn = bytecnt, 0 /* should we do a st1 ? */ } { .mmi nop.m 0 (p_y) st2 [ptr2] = r0,-1 @@ -138,44 +138,44 @@ ENTRY(bzero) { .mmi (p_yy) st1 [ptr2] = r0 - cmp.gt p_scr, p0 = tmp, cnt // is it a minimalistic task? + cmp.gt p_scr, p0 = tmp, cnt /* is it a minimalistic task? */ } { .mbb (p_yy) add cnt = -1, cnt -(p_scr) br.cond.dpnt.many .fraction_of_line // go move just a few +(p_scr) br.cond.dpnt.many .fraction_of_line /* go move just a few */ ;; } { .mib - nop.m 0 + nop.m 0 shr.u linecnt = cnt, LSIZE_SH nop.b 0 ;; } .align 32 -.l1b: // ------------------// L1B: store ahead into cache lines; fill later +.l1b: /* ------------------ L1B: store ahead into cache lines; fill later */ { .mmi - and tmp = -(LINE_SIZE), cnt // compute end of range - mov ptr9 = ptr1 // used for prefetching - and cnt = (LINE_SIZE-1), cnt // remainder + and tmp = -(LINE_SIZE), cnt /* compute end of range */ + mov ptr9 = ptr1 /* used for prefetching */ + and cnt = (LINE_SIZE-1), cnt /* remainder */ } { .mmi - mov loopcnt = PREF_AHEAD-1 // default prefetch loop - cmp.gt p_scr, p0 = PREF_AHEAD, linecnt // check against actual value + mov loopcnt = PREF_AHEAD-1 /* default prefetch loop */ + cmp.gt p_scr, p0 = PREF_AHEAD, linecnt /* check against actual value */ ;; } { .mmi (p_scr) add loopcnt = -1, linecnt - add ptr2 = 16, ptr1 // start of stores (beyond prefetch stores) - add ptr1 = tmp, ptr1 // first address beyond total range + add ptr2 = 16, ptr1 /* start of stores (beyond prefetch stores) */ + add ptr1 = tmp, ptr1 /* first address beyond total range */ ;; } { .mmi - add tmp = -1, linecnt // next loop count + add tmp = -1, linecnt /* next loop count */ movi0 ar.lc = loopcnt ;; } .pref_l1b: { .mib - stf.spill [ptr9] = f0, 128 // Do stores one cache line apart + stf.spill [ptr9] = f0, 128 /* Do stores one cache line apart */ nop.i 0 br.cloop.dptk.few .pref_l1b ;; } { .mmi - add ptr0 = 16, ptr2 // Two stores in parallel + add ptr0 = 16, ptr2 /* Two stores in parallel */ movi0 ar.lc = tmp ;; } .l1bx: @@ -190,7 +190,7 @@ ENTRY(bzero) { .mmi stf.spill [ptr2] = f0, 32 stf.spill [ptr0] = f0, 64 - cmp.lt p_scr, p0 = ptr9, ptr1 // do we need more prefetching? + cmp.lt p_scr, p0 = ptr9, ptr1 /* do we need more prefetching? */ ;; } { .mmb stf.spill [ptr2] = f0, 32 @@ -198,14 +198,14 @@ ENTRY(bzero) br.cloop.dptk.few .l1bx ;; } { .mib - cmp.gt p_scr, p0 = 8, cnt // just a few bytes left ? + cmp.gt p_scr, p0 = 8, cnt /* just a few bytes left ? */ (p_scr) br.cond.dpnt.many .move_bytes_from_alignment ;; } .fraction_of_line: { .mib add ptr2 = 16, ptr1 - shr.u loopcnt = cnt, 5 // loopcnt = cnt / 32 + shr.u loopcnt = cnt, 5 /* loopcnt = cnt / 32 */ ;; } { .mib cmp.eq p_scr, p0 = loopcnt, r0 @@ -213,11 +213,11 @@ ENTRY(bzero) (p_scr) br.cond.dpnt.many .store_words ;; } { .mib - and cnt = 0x1f, cnt // compute the remaining cnt + and cnt = 0x1f, cnt /* compute the remaining cnt */ movi0 ar.lc = loopcnt ;; } .align 32 -.l2: // -----------------------------// L2A: store 32B in 2 cycles +.l2: /* ----------------------------- L2A: store 32B in 2 cycles */ { .mmb store [ptr1] = myval, 8 store [ptr2] = myval, 8 @@ -228,38 +228,38 @@ ENTRY(bzero) ;; } .store_words: { .mib - cmp.gt p_scr, p0 = 8, cnt // just a few bytes left ? -(p_scr) br.cond.dpnt.many .move_bytes_from_alignment // Branch + cmp.gt p_scr, p0 = 8, cnt /* just a few bytes left ? */ +(p_scr) br.cond.dpnt.many .move_bytes_from_alignment /* Branch */ ;; } { .mmi - store [ptr1] = myval, 8 // store - cmp.le p_y, p_n = 16, cnt // - add cnt = -8, cnt // subtract + store [ptr1] = myval, 8 /* store */ + cmp.le p_y, p_n = 16, cnt /* */ + add cnt = -8, cnt /* subtract */ ;; } { .mmi -(p_y) store [ptr1] = myval, 8 // store +(p_y) store [ptr1] = myval, 8 /* store */ (p_y) cmp.le.unc p_yy, p_nn = 16, cnt -(p_y) add cnt = -8, cnt // subtract +(p_y) add cnt = -8, cnt /* subtract */ ;; } -{ .mmi // store +{ .mmi /* store */ (p_yy) store [ptr1] = myval, 8 -(p_yy) add cnt = -8, cnt // subtract +(p_yy) add cnt = -8, cnt /* subtract */ ;; } .move_bytes_from_alignment: { .mib cmp.eq p_scr, p0 = cnt, r0 - tbit.nz.unc p_y, p0 = cnt, 2 // should we terminate with a st4 ? + tbit.nz.unc p_y, p0 = cnt, 2 /* should we terminate with a st4 ? */ (p_scr) br.cond.dpnt.few .restore_and_exit ;; } { .mib (p_y) st4 [ptr1] = r0,4 - tbit.nz.unc p_yy, p0 = cnt, 1 // should we terminate with a st2 ? + tbit.nz.unc p_yy, p0 = cnt, 1 /* should we terminate with a st2 ? */ ;; } { .mib (p_yy) st2 [ptr1] = r0,2 - tbit.nz.unc p_y, p0 = cnt, 0 // should we terminate with a st1 ? + tbit.nz.unc p_y, p0 = cnt, 0 /* should we terminate with a st1 ? */ ;; } { .mib @@ -281,38 +281,38 @@ ENTRY(bzero) (p_n) add ptr2 = 2, ptr1 } { .mmi (p_y) add ptr2 = 3, ptr1 -(p_y) st1 [ptr1] = r0, 1 // fill 1 (odd-aligned) byte -(p_y) add cnt = -1, cnt // [15, 14 (or less) left] +(p_y) st1 [ptr1] = r0, 1 /* fill 1 (odd-aligned) byte */ +(p_y) add cnt = -1, cnt /* [15, 14 (or less) left] */ ;; } { .mmi (p_yy) cmp.le.unc p_y, p0 = 8, cnt - add ptr3 = ptr1, cnt // prepare last store + add ptr3 = ptr1, cnt /* prepare last store */ movi0 ar.lc = save_lc } { .mmi -(p_yy) st2 [ptr1] = r0, 4 // fill 2 (aligned) bytes -(p_yy) st2 [ptr2] = r0, 4 // fill 2 (aligned) bytes -(p_yy) add cnt = -4, cnt // [11, 10 (o less) left] +(p_yy) st2 [ptr1] = r0, 4 /* fill 2 (aligned) bytes */ +(p_yy) st2 [ptr2] = r0, 4 /* fill 2 (aligned) bytes */ +(p_yy) add cnt = -4, cnt /* [11, 10 (o less) left] */ ;; } { .mmi (p_y) cmp.le.unc p_yy, p0 = 8, cnt - add ptr3 = -1, ptr3 // last store - tbit.nz p_scr, p0 = cnt, 1 // will there be a st2 at the end ? + add ptr3 = -1, ptr3 /* last store */ + tbit.nz p_scr, p0 = cnt, 1 /* will there be a st2 at the end ? */ } { .mmi -(p_y) st2 [ptr1] = r0, 4 // fill 2 (aligned) bytes -(p_y) st2 [ptr2] = r0, 4 // fill 2 (aligned) bytes -(p_y) add cnt = -4, cnt // [7, 6 (or less) left] +(p_y) st2 [ptr1] = r0, 4 /* fill 2 (aligned) bytes */ +(p_y) st2 [ptr2] = r0, 4 /* fill 2 (aligned) bytes */ +(p_y) add cnt = -4, cnt /* [7, 6 (or less) left] */ ;; } { .mmi -(p_yy) st2 [ptr1] = r0, 4 // fill 2 (aligned) bytes -(p_yy) st2 [ptr2] = r0, 4 // fill 2 (aligned) bytes - // [3, 2 (or less) left] - tbit.nz p_y, p0 = cnt, 0 // will there be a st1 at the end ? +(p_yy) st2 [ptr1] = r0, 4 /* fill 2 (aligned) bytes */ +(p_yy) st2 [ptr2] = r0, 4 /* fill 2 (aligned) bytes */ + /* [3, 2 (or less) left] */ + tbit.nz p_y, p0 = cnt, 0 /* will there be a st1 at the end ? */ } { .mmi (p_yy) add cnt = -4, cnt ;; } { .mmb -(p_scr) st2 [ptr1] = r0 // fill 2 (aligned) bytes -(p_y) st1 [ptr3] = r0 // fill last byte (using ptr3) +(p_scr) st2 [ptr1] = r0 /* fill 2 (aligned) bytes */ +(p_y) st1 [ptr3] = r0 /* fill last byte (using ptr3) */ br.ret.sptk.many rp ;; } END(bzero) diff --git a/libc/string/ia64/memccpy.S b/libc/string/ia64/memccpy.S index 1afba3637..259d680bc 100644 --- a/libc/string/ia64/memccpy.S +++ b/libc/string/ia64/memccpy.S @@ -23,7 +23,7 @@ Inputs: in0: dest in1: src - in2: char + in2: char in3: byte count This implementation assumes little endian mode (UM.be = 0). @@ -69,75 +69,75 @@ ENTRY(memccpy) .rotr r[MEMLAT + 7], tmp1[4], tmp2[4], val[4], tmp3[2], pos0[2] .rotp p[MEMLAT + 6 + 1] - mov ret0 = r0 // return NULL if no match + mov ret0 = r0 /* return NULL if no match */ .save pr, saved_pr - mov saved_pr = pr // save the predicate registers - mov dest = in0 // dest + mov saved_pr = pr /* save the predicate registers */ + mov dest = in0 /* dest */ .save ar.lc, saved_lc - mov saved_lc = ar.lc // save the loop counter - mov saved_ec = ar.ec // save the loop counter + mov saved_lc = ar.lc /* save the loop counter */ + mov saved_ec = ar.ec /* save the loop counter */ .body - mov src = in1 // src - extr.u char = in2, 0, 8 // char - mov len = in3 // len - sub tmp = r0, in0 // tmp = -dest - cmp.ne p7, p0 = r0, r0 // clear p7 + mov src = in1 /* src */ + extr.u char = in2, 0, 8 /* char */ + mov len = in3 /* len */ + sub tmp = r0, in0 /* tmp = -dest */ + cmp.ne p7, p0 = r0, r0 /* clear p7 */ ;; - and loopcnt = 7, tmp // loopcnt = -dest % 8 - cmp.ge p6, p0 = OP_T_THRES, len // is len <= OP_T_THRES - mov ar.ec = 0 // ec not guaranteed zero on entry -(p6) br.cond.spnt .cpyfew // copy byte by byte + and loopcnt = 7, tmp /* loopcnt = -dest % 8 */ + cmp.ge p6, p0 = OP_T_THRES, len /* is len <= OP_T_THRES */ + mov ar.ec = 0 /* ec not guaranteed zero on entry */ +(p6) br.cond.spnt .cpyfew /* copy byte by byte */ ;; cmp.eq p6, p0 = loopcnt, r0 mux1 charx8 = char, @brcst (p6) br.cond.sptk .dest_aligned - sub len = len, loopcnt // len -= -dest % 8 - adds loopcnt = -1, loopcnt // --loopcnt + sub len = len, loopcnt /* len -= -dest % 8 */ + adds loopcnt = -1, loopcnt /* --loopcnt */ ;; mov ar.lc = loopcnt -.l1: // copy -dest % 8 bytes - ld1 value = [src], 1 // value = *src++ +.l1: /* copy -dest % 8 bytes */ + ld1 value = [src], 1 /* value = *src++ */ ;; - st1 [dest] = value, 1 // *dest++ = value + st1 [dest] = value, 1 /* *dest++ = value */ cmp.eq p6, p0 = value, char (p6) br.cond.spnt .foundit br.cloop.dptk .l1 .dest_aligned: - and sh1 = 7, src // sh1 = src % 8 - and tmp = -8, len // tmp = len & -OPSIZ - and asrc = -8, src // asrc = src & -OPSIZ -- align src - shr.u loopcnt = len, 3 // loopcnt = len / 8 - and len = 7, len ;; // len = len % 8 - shl sh1 = sh1, 3 // sh1 = 8 * (src % 8) - adds loopcnt = -1, loopcnt // --loopcnt - mov pr.rot = 1 << 16 ;; // set rotating predicates - sub sh2 = 64, sh1 // sh2 = 64 - sh1 - mov ar.lc = loopcnt // set LC - cmp.eq p6, p0 = sh1, r0 // is the src aligned? + and sh1 = 7, src /* sh1 = src % 8 */ + and tmp = -8, len /* tmp = len & -OPSIZ */ + and asrc = -8, src /* asrc = src & -OPSIZ -- align src */ + shr.u loopcnt = len, 3 /* loopcnt = len / 8 */ + and len = 7, len ;; /* len = len % 8 */ + shl sh1 = sh1, 3 /* sh1 = 8 * (src % 8) */ + adds loopcnt = -1, loopcnt /* --loopcnt */ + mov pr.rot = 1 << 16 ;; /* set rotating predicates */ + sub sh2 = 64, sh1 /* sh2 = 64 - sh1 */ + mov ar.lc = loopcnt /* set LC */ + cmp.eq p6, p0 = sh1, r0 /* is the src aligned? */ (p6) br.cond.sptk .src_aligned ;; - add src = src, tmp // src += len & -OPSIZ - mov ar.ec = MEMLAT + 6 + 1 // six more passes needed - ld8 r[1] = [asrc], 8 // r[1] = w0 - cmp.ne p6, p0 = r0, r0 ;; // clear p6 + add src = src, tmp /* src += len & -OPSIZ */ + mov ar.ec = MEMLAT + 6 + 1 /* six more passes needed */ + ld8 r[1] = [asrc], 8 /* r[1] = w0 */ + cmp.ne p6, p0 = r0, r0 ;; /* clear p6 */ ALIGN(32) .l2: -(p[0]) ld8.s r[0] = [asrc], 8 // r[0] = w1 -(p[MEMLAT]) shr.u tmp1[0] = r[1 + MEMLAT], sh1 // tmp1 = w0 >> sh1 -(p[MEMLAT]) shl tmp2[0] = r[0 + MEMLAT], sh2 // tmp2 = w1 << sh2 +(p[0]) ld8.s r[0] = [asrc], 8 /* r[0] = w1 */ +(p[MEMLAT]) shr.u tmp1[0] = r[1 + MEMLAT], sh1 /* tmp1 = w0 >> sh1 */ +(p[MEMLAT]) shl tmp2[0] = r[0 + MEMLAT], sh2 /* tmp2 = w1 << sh2 */ (p[MEMLAT+4]) xor tmp3[0] = val[1], charx8 (p[MEMLAT+5]) czx1.r pos0[0] = tmp3[1] -(p[MEMLAT+6]) chk.s r[6 + MEMLAT], .recovery1 // our data isn't - // valid - rollback! +(p[MEMLAT+6]) chk.s r[6 + MEMLAT], .recovery1 /* our data isn't */ + /* valid - rollback! */ (p[MEMLAT+6]) cmp.ne p6, p0 = 8, pos0[1] (p6) br.cond.spnt .gotit -(p[MEMLAT+6]) st8 [dest] = val[3], 8 // store val to dest -(p[MEMLAT+3]) or val[0] = tmp1[3], tmp2[3] // val = tmp1 | tmp2 +(p[MEMLAT+6]) st8 [dest] = val[3], 8 /* store val to dest */ +(p[MEMLAT+3]) or val[0] = tmp1[3], tmp2[3] /* val = tmp1 | tmp2 */ br.ctop.sptk .l2 br.cond.sptk .cpyfew .src_aligned: - cmp.ne p6, p0 = r0, r0 // clear p6 - mov ar.ec = MEMLAT + 2 + 1 ;; // set EC + cmp.ne p6, p0 = r0, r0 /* clear p6 */ + mov ar.ec = MEMLAT + 2 + 1 ;; /* set EC */ .l3: (p[0]) ld8.s r[0] = [src], 8 (p[MEMLAT]) xor tmp3[0] = r[MEMLAT], charx8 @@ -149,8 +149,8 @@ ENTRY(memccpy) (p[MEMLAT+2]) st8 [dest] = r[MEMLAT+2], 8 br.ctop.dptk .l3 .cpyfew: - cmp.eq p6, p0 = len, r0 // is len == 0 ? - adds len = -1, len // --len; + cmp.eq p6, p0 = len, r0 /* is len == 0 ? */ + adds len = -1, len /* --len; */ (p6) br.cond.spnt .restore_and_exit ;; mov ar.lc = len .l4: @@ -163,14 +163,14 @@ ENTRY(memccpy) .foundit: (p6) mov ret0 = dest .restore_and_exit: - mov pr = saved_pr, -1 // restore the predicate registers - mov ar.lc = saved_lc // restore the loop counter - mov ar.ec = saved_ec ;; // restore the epilog counter + mov pr = saved_pr, -1 /* restore the predicate registers */ + mov ar.lc = saved_lc /* restore the loop counter */ + mov ar.ec = saved_ec ;; /* restore the epilog counter */ br.ret.sptk.many b0 .gotit: .pred.rel "mutex" p6, p7 -(p6) mov value = val[3] // if coming from l2 -(p7) mov value = r[MEMLAT+2] // if coming from l3 +(p6) mov value = val[3] /* if coming from l2 */ +(p7) mov value = r[MEMLAT+2] /* if coming from l3 */ mov ar.lc = pos0[1] ;; .l5: extr.u tmp = value, 0, 8 ;; diff --git a/libc/string/ia64/memchr.S b/libc/string/ia64/memchr.S index 2bf078fe6..0246b5997 100644 --- a/libc/string/ia64/memchr.S +++ b/libc/string/ia64/memchr.S @@ -62,18 +62,18 @@ ENTRY(__memchr) .rotr value[MEMLAT+1], addr[MEMLAT+3], aux[2], poschr[2] .rotp p[MEMLAT+3] .save ar.lc, saved_lc - mov saved_lc = ar.lc // save the loop counter + mov saved_lc = ar.lc /* save the loop counter */ .save pr, saved_pr - mov saved_pr = pr // save the predicates + mov saved_pr = pr /* save the predicates */ .body mov ret0 = str - and tmp = 7, str // tmp = str % 8 - cmp.ne p7, p0 = r0, r0 // clear p7 - extr.u chr = in1, 0, 8 // chr = (unsigned char) in1 + and tmp = 7, str /* tmp = str % 8 */ + cmp.ne p7, p0 = r0, r0 /* clear p7 */ + extr.u chr = in1, 0, 8 /* chr = (unsigned char) in1 */ mov len = in2 - cmp.gtu p6, p0 = 16, in2 // use a simple loop for short -(p6) br.cond.spnt .srchfew ;; // searches - sub loopcnt = 8, tmp // loopcnt = 8 - tmp + cmp.gtu p6, p0 = 16, in2 /* use a simple loop for short */ +(p6) br.cond.spnt .srchfew ;; /* searches */ + sub loopcnt = 8, tmp /* loopcnt = 8 - tmp */ cmp.eq p6, p0 = tmp, r0 (p6) br.cond.sptk .str_aligned;; sub len = len, loopcnt @@ -86,12 +86,12 @@ ENTRY(__memchr) (p6) br.cond.spnt .foundit br.cloop.sptk .l1 ;; .str_aligned: - cmp.ne p6, p0 = r0, r0 // clear p6 - shr.u loopcnt = len, 3 // loopcnt = len / 8 - and len = 7, len ;; // remaining len = len & 7 + cmp.ne p6, p0 = r0, r0 /* clear p6 */ + shr.u loopcnt = len, 3 /* loopcnt = len / 8 */ + and len = 7, len ;; /* remaining len = len & 7 */ adds loopcnt = -1, loopcnt mov ar.ec = MEMLAT + 3 - mux1 chrx8 = chr, @brcst ;; // get a word full of chr + mux1 chrx8 = chr, @brcst ;; /* get a word full of chr */ mov ar.lc = loopcnt mov pr.rot = 1 << 16 ;; .l2: @@ -114,12 +114,12 @@ ENTRY(__memchr) (p6) br.cond.dpnt .foundit br.cloop.sptk .l3 ;; .notfound: - cmp.ne p6, p0 = r0, r0 // clear p6 (p7 was already 0 when we got here) - mov ret0 = r0 ;; // return NULL + cmp.ne p6, p0 = r0, r0 /* clear p6 (p7 was already 0 when we got here) */ + mov ret0 = r0 ;; /* return NULL */ .foundit: .pred.rel "mutex" p6, p7 -(p6) adds ret0 = -1, ret0 // if we got here from l1 or l3 -(p7) add ret0 = addr[MEMLAT+2], poschr[1] // if we got here from l2 +(p6) adds ret0 = -1, ret0 /* if we got here from l1 or l3 */ +(p7) add ret0 = addr[MEMLAT+2], poschr[1] /* if we got here from l2 */ mov pr = saved_pr, -1 mov ar.lc = saved_lc br.ret.sptk.many b0 diff --git a/libc/string/ia64/memcmp.S b/libc/string/ia64/memcmp.S index 8b0c096ce..adb1a20de 100644 --- a/libc/string/ia64/memcmp.S +++ b/libc/string/ia64/memcmp.S @@ -28,7 +28,7 @@ In this form, it assumes little endian mode. For big endian mode, the the two shifts in .l2 must be inverted: - shl tmp1[0] = r[1 + MEMLAT], sh1 // tmp1 = w0 << sh1 + shl tmp1[0] = r[1 + MEMLAT], sh1 // tmp1 = w0 << sh1 shr.u tmp2[0] = r[0 + MEMLAT], sh2 // tmp2 = w1 >> sh2 and all the mux1 instructions should be replaced by plain mov's. */ @@ -36,8 +36,8 @@ #include "sysdep.h" #undef ret -#define OP_T_THRES 16 -#define OPSIZ 8 +#define OP_T_THRES 16 +#define OPSIZ 8 #define MEMLAT 2 #define start r15 @@ -56,85 +56,85 @@ ENTRY(memcmp) .prologue - alloc r2 = ar.pfs, 3, 37, 0, 40 + alloc r2 = ar.pfs, 3, 37, 0, 40 .rotr r[MEMLAT + 2], q[MEMLAT + 5], tmp1[4], tmp2[4], val[2] .rotp p[MEMLAT + 4 + 1] - mov ret0 = r0 // by default return value = 0 + mov ret0 = r0 /* by default return value = 0 */ .save pr, saved_pr - mov saved_pr = pr // save the predicate registers + mov saved_pr = pr /* save the predicate registers */ .save ar.lc, saved_lc - mov saved_lc = ar.lc // save the loop counter + mov saved_lc = ar.lc /* save the loop counter */ .body - mov dest = in0 // dest - mov src = in1 // src - mov len = in2 // len - sub tmp = r0, in0 // tmp = -dest + mov dest = in0 /* dest */ + mov src = in1 /* src */ + mov len = in2 /* len */ + sub tmp = r0, in0 /* tmp = -dest */ ;; - and loopcnt = 7, tmp // loopcnt = -dest % 8 - cmp.ge p6, p0 = OP_T_THRES, len // is len <= OP_T_THRES -(p6) br.cond.spnt .cmpfew // compare byte by byte + and loopcnt = 7, tmp /* loopcnt = -dest % 8 */ + cmp.ge p6, p0 = OP_T_THRES, len /* is len <= OP_T_THRES */ +(p6) br.cond.spnt .cmpfew /* compare byte by byte */ ;; cmp.eq p6, p0 = loopcnt, r0 (p6) br.cond.sptk .dest_aligned - sub len = len, loopcnt // len -= -dest % 8 - adds loopcnt = -1, loopcnt // --loopcnt + sub len = len, loopcnt /* len -= -dest % 8 */ + adds loopcnt = -1, loopcnt /* --loopcnt */ ;; mov ar.lc = loopcnt -.l1: // copy -dest % 8 bytes - ld1 value1 = [src], 1 // value = *src++ +.l1: /* copy -dest % 8 bytes */ + ld1 value1 = [src], 1 /* value = *src++ */ ld1 value2 = [dest], 1 ;; cmp.ne p6, p0 = value1, value2 (p6) br.cond.spnt .done br.cloop.dptk .l1 .dest_aligned: - and sh1 = 7, src // sh1 = src % 8 - and tmp = -8, len // tmp = len & -OPSIZ - and asrc = -8, src // asrc = src & -OPSIZ -- align src - shr.u loopcnt = len, 3 // loopcnt = len / 8 - and len = 7, len ;; // len = len % 8 - shl sh1 = sh1, 3 // sh1 = 8 * (src % 8) - adds loopcnt = -1, loopcnt // --loopcnt - mov pr.rot = 1 << 16 ;; // set rotating predicates - sub sh2 = 64, sh1 // sh2 = 64 - sh1 - mov ar.lc = loopcnt // set LC - cmp.eq p6, p0 = sh1, r0 // is the src aligned? + and sh1 = 7, src /* sh1 = src % 8 */ + and tmp = -8, len /* tmp = len & -OPSIZ */ + and asrc = -8, src /* asrc = src & -OPSIZ -- align src */ + shr.u loopcnt = len, 3 /* loopcnt = len / 8 */ + and len = 7, len ;; /* len = len % 8 */ + shl sh1 = sh1, 3 /* sh1 = 8 * (src % 8) */ + adds loopcnt = -1, loopcnt /* --loopcnt */ + mov pr.rot = 1 << 16 ;; /* set rotating predicates */ + sub sh2 = 64, sh1 /* sh2 = 64 - sh1 */ + mov ar.lc = loopcnt /* set LC */ + cmp.eq p6, p0 = sh1, r0 /* is the src aligned? */ (p6) br.cond.sptk .src_aligned - add src = src, tmp // src += len & -OPSIZ - mov ar.ec = MEMLAT + 4 + 1 // four more passes needed - ld8 r[1] = [asrc], 8 ;; // r[1] = w0 + add src = src, tmp /* src += len & -OPSIZ */ + mov ar.ec = MEMLAT + 4 + 1 /* four more passes needed */ + ld8 r[1] = [asrc], 8 ;; /* r[1] = w0 */ .align 32 -// We enter this loop with p6 cleared by the above comparison +/* We enter this loop with p6 cleared by the above comparison */ .l2: -(p[0]) ld8 r[0] = [asrc], 8 // r[0] = w1 +(p[0]) ld8 r[0] = [asrc], 8 /* r[0] = w1 */ (p[0]) ld8 q[0] = [dest], 8 -(p[MEMLAT]) shr.u tmp1[0] = r[1 + MEMLAT], sh1 // tmp1 = w0 >> sh1 -(p[MEMLAT]) shl tmp2[0] = r[0 + MEMLAT], sh2 // tmp2 = w1 << sh2 +(p[MEMLAT]) shr.u tmp1[0] = r[1 + MEMLAT], sh1 /* tmp1 = w0 >> sh1 */ +(p[MEMLAT]) shl tmp2[0] = r[0 + MEMLAT], sh2 /* tmp2 = w1 << sh2 */ (p[MEMLAT+4]) cmp.ne p6, p0 = q[MEMLAT + 4], val[1] -(p[MEMLAT+3]) or val[0] = tmp1[3], tmp2[3] // val = tmp1 | tmp2 +(p[MEMLAT+3]) or val[0] = tmp1[3], tmp2[3] /* val = tmp1 | tmp2 */ (p6) br.cond.spnt .l2exit br.ctop.sptk .l2 br.cond.sptk .cmpfew .l3exit: mux1 value1 = r[MEMLAT], @rev mux1 value2 = q[MEMLAT], @rev - cmp.ne p6, p0 = r0, r0 ;; // clear p6 + cmp.ne p6, p0 = r0, r0 ;; /* clear p6 */ .l2exit: (p6) mux1 value1 = val[1], @rev (p6) mux1 value2 = q[MEMLAT + 4], @rev ;; cmp.ltu p6, p7 = value2, value1 ;; (p6) mov ret0 = -1 (p7) mov ret0 = 1 - mov pr = saved_pr, -1 // restore the predicate registers - mov ar.lc = saved_lc // restore the loop counter + mov pr = saved_pr, -1 /* restore the predicate registers */ + mov ar.lc = saved_lc /* restore the loop counter */ br.ret.sptk.many b0 .src_aligned: - cmp.ne p6, p0 = r0, r0 // clear p6 - mov ar.ec = MEMLAT + 1 ;; // set EC + cmp.ne p6, p0 = r0, r0 /* clear p6 */ + mov ar.ec = MEMLAT + 1 ;; /* set EC */ .l3: (p[0]) ld8 r[0] = [src], 8 (p[0]) ld8 q[0] = [dest], 8 @@ -142,8 +142,8 @@ ENTRY(memcmp) (p6) br.cond.spnt .l3exit br.ctop.dptk .l3 ;; .cmpfew: - cmp.eq p6, p0 = len, r0 // is len == 0 ? - adds len = -1, len // --len; + cmp.eq p6, p0 = len, r0 /* is len == 0 ? */ + adds len = -1, len /* --len; */ (p6) br.cond.spnt .restore_and_exit ;; mov ar.lc = len .l4: @@ -154,10 +154,10 @@ ENTRY(memcmp) (p6) br.cond.spnt .done br.cloop.dptk .l4 ;; .done: -(p6) sub ret0 = value2, value1 // don't execute it if falling thru +(p6) sub ret0 = value2, value1 /* don't execute it if falling thru */ .restore_and_exit: - mov pr = saved_pr, -1 // restore the predicate registers - mov ar.lc = saved_lc // restore the loop counter + mov pr = saved_pr, -1 /* restore the predicate registers */ + mov ar.lc = saved_lc /* restore the loop counter */ br.ret.sptk.many b0 END(memcmp) libc_hidden_def (memcmp) diff --git a/libc/string/ia64/memcpy.S b/libc/string/ia64/memcpy.S index 810eb0c0e..6c48a72d9 100644 --- a/libc/string/ia64/memcpy.S +++ b/libc/string/ia64/memcpy.S @@ -42,8 +42,8 @@ #define LFETCH_DIST 500 -#define ALIGN_UNROLL_no 4 // no. of elements -#define ALIGN_UNROLL_sh 2 // (shift amount) +#define ALIGN_UNROLL_no 4 /* no. of elements */ +#define ALIGN_UNROLL_sh 2 /* (shift amount) */ #define MEMLAT 8 #define Nrot ((4*(MEMLAT+2) + 7) & ~7) @@ -168,76 +168,76 @@ ENTRY(memcpy) .rotr r[MEMLAT+1], s[MEMLAT+2], q[MEMLAT+1], t[MEMLAT+1] .rotp p[MEMLAT+2] .rotf fr[MEMLAT+1], fq[MEMLAT+1], fs[MEMLAT+1], ft[MEMLAT+1] - mov ret0 = in0 // return tmp2 = dest + mov ret0 = in0 /* return tmp2 = dest */ .save pr, saved_pr - movi0 saved_pr = pr // save the predicate registers + movi0 saved_pr = pr /* save the predicate registers */ } { .mmi - and tmp4 = 7, in0 // check if destination is aligned - mov dest = in0 // dest - mov src = in1 // src + and tmp4 = 7, in0 /* check if destination is aligned */ + mov dest = in0 /* dest */ + mov src = in1 /* src */ ;; } { .mii - cmp.eq p_scr, p0 = in2, r0 // if (len == 0) + cmp.eq p_scr, p0 = in2, r0 /* if (len == 0) */ .save ar.lc, saved_lc - movi0 saved_lc = ar.lc // save the loop counter + movi0 saved_lc = ar.lc /* save the loop counter */ .body - cmp.ge p_few, p0 = OP_T_THRES, in2 // is len <= OP_T_THRESH + cmp.ge p_few, p0 = OP_T_THRES, in2 /* is len <= OP_T_THRESH */ } { .mbb - mov len = in2 // len -(p_scr) br.cond.dpnt.few .restore_and_exit // Branch no. 1: return dest -(p_few) br.cond.dpnt.many .copy_bytes // Branch no. 2: copy byte by byte + mov len = in2 /* len */ +(p_scr) br.cond.dpnt.few .restore_and_exit /* Branch no. 1: return dest */ +(p_few) br.cond.dpnt.many .copy_bytes /* Branch no. 2: copy byte by byte */ ;; } { .mmi #if defined(USE_LFETCH) - lfetch.nt1 [dest] // - lfetch.nt1 [src] // + lfetch.nt1 [dest] /* */ + lfetch.nt1 [src] /* */ #endif - shr.u elemcnt = len, 3 // elemcnt = len / 8 + shr.u elemcnt = len, 3 /* elemcnt = len / 8 */ } { .mib - cmp.eq p_scr, p0 = tmp4, r0 // is destination aligned? - sub loopcnt = 7, tmp4 // + cmp.eq p_scr, p0 = tmp4, r0 /* is destination aligned? */ + sub loopcnt = 7, tmp4 /* */ (p_scr) br.cond.dptk.many .dest_aligned ;; } { .mmi - ld1 tmp2 = [src], 1 // - sub len = len, loopcnt, 1 // reduce len - movi0 ar.lc = loopcnt // + ld1 tmp2 = [src], 1 /* */ + sub len = len, loopcnt, 1 /* reduce len */ + movi0 ar.lc = loopcnt /* */ } { .mib - cmp.ne p_scr, p0 = 0, loopcnt // avoid loading beyond end-point + cmp.ne p_scr, p0 = 0, loopcnt /* avoid loading beyond end-point */ ;; } -.l0: // ---------------------------- // L0: Align src on 8-byte boundary +.l0: /* ---------------------------- L0: Align src on 8-byte boundary */ { .mmi - st1 [dest] = tmp2, 1 // -(p_scr) ld1 tmp2 = [src], 1 // + st1 [dest] = tmp2, 1 /* */ +(p_scr) ld1 tmp2 = [src], 1 /* */ } { .mib - cmp.lt p_scr, p0 = 1, loopcnt // avoid load beyond end-point + cmp.lt p_scr, p0 = 1, loopcnt /* avoid load beyond end-point */ add loopcnt = -1, loopcnt - br.cloop.dptk.few .l0 // + br.cloop.dptk.few .l0 /* */ ;; } .dest_aligned: { .mmi - and tmp4 = 7, src // ready for alignment check - shr.u elemcnt = len, 3 // elemcnt = len / 8 + and tmp4 = 7, src /* ready for alignment check */ + shr.u elemcnt = len, 3 /* elemcnt = len / 8 */ ;; } { .mib - cmp.ne p_scr, p0 = tmp4, r0 // is source also aligned - tbit.nz p_xtr, p_nxtr = src, 3 // prepare a separate move if src -} { .mib // is not 16B aligned - add ptr2 = LFETCH_DIST, dest // prefetch address + cmp.ne p_scr, p0 = tmp4, r0 /* is source also aligned */ + tbit.nz p_xtr, p_nxtr = src, 3 /* prepare a separate move if src */ +} { .mib /* is not 16B aligned */ + add ptr2 = LFETCH_DIST, dest /* prefetch address */ add ptr1 = LFETCH_DIST, src (p_scr) br.cond.dptk.many .src_not_aligned ;; } -// The optimal case, when dest, and src are aligned +/* The optimal case, when dest, and src are aligned */ .both_aligned: { .mmi .pred.rel "mutex",p_xtr,p_nxtr -(p_xtr) cmp.gt p_scr, p0 = ALIGN_UNROLL_no+1, elemcnt // Need N + 1 to qualify -(p_nxtr) cmp.gt p_scr, p0 = ALIGN_UNROLL_no, elemcnt // Need only N to qualify - movi0 pr.rot = 1 << 16 // set rotating predicates +(p_xtr) cmp.gt p_scr, p0 = ALIGN_UNROLL_no+1, elemcnt /* Need N + 1 to qualify */ +(p_nxtr) cmp.gt p_scr, p0 = ALIGN_UNROLL_no, elemcnt /* Need only N to qualify */ + movi0 pr.rot = 1 << 16 /* set rotating predicates */ } { .mib (p_scr) br.cond.dpnt.many .copy_full_words ;; } @@ -245,21 +245,21 @@ ENTRY(memcpy) { .mmi (p_xtr) load tempreg = [src], 8 (p_xtr) add elemcnt = -1, elemcnt - movi0 ar.ec = MEMLAT + 1 // set the epilog counter + movi0 ar.ec = MEMLAT + 1 /* set the epilog counter */ ;; } { .mmi -(p_xtr) add len = -8, len // - add asrc = 16, src // one bank apart (for USE_INT) - shr.u loopcnt = elemcnt, ALIGN_UNROLL_sh // cater for unrolling +(p_xtr) add len = -8, len /* */ + add asrc = 16, src /* one bank apart (for USE_INT) */ + shr.u loopcnt = elemcnt, ALIGN_UNROLL_sh /* cater for unrolling */ ;;} { .mmi add loopcnt = -1, loopcnt -(p_xtr) store [dest] = tempreg, 8 // copy the "extra" word +(p_xtr) store [dest] = tempreg, 8 /* copy the "extra" word */ nop.i 0 ;; } { .mib add adest = 16, dest - movi0 ar.lc = loopcnt // set the loop counter + movi0 ar.lc = loopcnt /* set the loop counter */ ;; } #ifdef GAS_ALIGN_BREAKS_UNWIND_INFO @@ -268,7 +268,7 @@ ENTRY(memcpy) .align 32 #endif #if defined(USE_FLP) -.l1: // ------------------------------- // L1: Everything a multiple of 8 +.l1: /* ------------------------------- L1: Everything a multiple of 8 */ { .mmi #if defined(USE_LFETCH) (p[0]) lfetch.nt1 [ptr2],32 @@ -290,7 +290,7 @@ ENTRY(memcpy) br.ctop.dptk.many .l1 ;; } #elif defined(USE_INT) -.l1: // ------------------------------- // L1: Everything a multiple of 8 +.l1: /* ------------------------------- L1: Everything a multiple of 8 */ { .mmi (p[0]) load the_r[0] = [src], 8 (p[0]) load the_q[0] = [asrc], 8 @@ -317,58 +317,58 @@ ENTRY(memcpy) .copy_full_words: { .mib - cmp.gt p_scr, p0 = 8, len // - shr.u elemcnt = len, 3 // + cmp.gt p_scr, p0 = 8, len /* */ + shr.u elemcnt = len, 3 /* */ (p_scr) br.cond.dpnt.many .copy_bytes ;; } { .mii load tempreg = [src], 8 - add loopcnt = -1, elemcnt // + add loopcnt = -1, elemcnt /* */ ;; } { .mii - cmp.ne p_scr, p0 = 0, loopcnt // - mov ar.lc = loopcnt // + cmp.ne p_scr, p0 = 0, loopcnt /* */ + mov ar.lc = loopcnt /* */ ;; } -.l2: // ------------------------------- // L2: Max 4 words copied separately +.l2: /* ------------------------------- L2: Max 4 words copied separately */ { .mmi store [dest] = tempreg, 8 -(p_scr) load tempreg = [src], 8 // +(p_scr) load tempreg = [src], 8 /* */ add len = -8, len } { .mib - cmp.lt p_scr, p0 = 1, loopcnt // avoid load beyond end-point + cmp.lt p_scr, p0 = 1, loopcnt /* avoid load beyond end-point */ add loopcnt = -1, loopcnt br.cloop.dptk.few .l2 ;; } .copy_bytes: { .mib - cmp.eq p_scr, p0 = len, r0 // is len == 0 ? - add loopcnt = -1, len // len--; + cmp.eq p_scr, p0 = len, r0 /* is len == 0 ? */ + add loopcnt = -1, len /* len--; */ (p_scr) br.cond.spnt .restore_and_exit ;; } { .mii ld1 tmp2 = [src], 1 movi0 ar.lc = loopcnt - cmp.ne p_scr, p0 = 0, loopcnt // avoid load beyond end-point + cmp.ne p_scr, p0 = 0, loopcnt /* avoid load beyond end-point */ ;; } -.l3: // ------------------------------- // L3: Final byte move +.l3: /* ------------------------------- L3: Final byte move */ { .mmi st1 [dest] = tmp2, 1 (p_scr) ld1 tmp2 = [src], 1 } { .mib - cmp.lt p_scr, p0 = 1, loopcnt // avoid load beyond end-point + cmp.lt p_scr, p0 = 1, loopcnt /* avoid load beyond end-point */ add loopcnt = -1, loopcnt br.cloop.dptk.few .l3 ;; } .restore_and_exit: { .mmi - movi0 pr = saved_pr, -1 // restore the predicate registers + movi0 pr = saved_pr, -1 /* restore the predicate registers */ ;; } { .mib - movi0 ar.lc = saved_lc // restore the loop counter + movi0 ar.lc = saved_lc /* restore the loop counter */ br.ret.sptk.many b0 ;; } @@ -376,41 +376,41 @@ ENTRY(memcpy) .src_not_aligned: { .mmi cmp.gt p_scr, p0 = 16, len - and sh1 = 7, src // sh1 = src % 8 - shr.u loopcnt = len, 4 // element-cnt = len / 16 + and sh1 = 7, src /* sh1 = src % 8 */ + shr.u loopcnt = len, 4 /* element-cnt = len / 16 */ } { .mib add tmp4 = @ltoff(.table), gp add tmp3 = @ltoff(.loop56), gp -(p_scr) br.cond.dpnt.many .copy_bytes // do byte by byte if too few +(p_scr) br.cond.dpnt.many .copy_bytes /* do byte by byte if too few */ ;; } { .mmi - and asrc = -8, src // asrc = (-8) -- align src for loop - add loopcnt = -1, loopcnt // loopcnt-- - shl sh1 = sh1, 3 // sh1 = 8 * (src % 8) + and asrc = -8, src /* asrc = (-8) -- align src for loop */ + add loopcnt = -1, loopcnt /* loopcnt-- */ + shl sh1 = sh1, 3 /* sh1 = 8 * (src % 8) */ } { .mmi - ld8 ptable = [tmp4] // ptable = &table - ld8 ploop56 = [tmp3] // ploop56 = &loop56 - and tmp2 = -16, len // tmp2 = len & -OPSIZ + ld8 ptable = [tmp4] /* ptable = &table */ + ld8 ploop56 = [tmp3] /* ploop56 = &loop56 */ + and tmp2 = -16, len /* tmp2 = len & -OPSIZ */ ;; } { .mmi - add tmp3 = ptable, sh1 // tmp3 = &table + sh1 - add src = src, tmp2 // src += len & (-16) - movi0 ar.lc = loopcnt // set LC + add tmp3 = ptable, sh1 /* tmp3 = &table + sh1 */ + add src = src, tmp2 /* src += len & (-16) */ + movi0 ar.lc = loopcnt /* set LC */ ;; } { .mmi - ld8 tmp4 = [tmp3] // tmp4 = loop offset - sub len = len, tmp2 // len -= len & (-16) - movi0 ar.ec = MEMLAT + 2 // one more pass needed + ld8 tmp4 = [tmp3] /* tmp4 = loop offset */ + sub len = len, tmp2 /* len -= len & (-16) */ + movi0 ar.ec = MEMLAT + 2 /* one more pass needed */ ;; } { .mmi - ld8 s[1] = [asrc], 8 // preload - sub loopaddr = ploop56,tmp4 // loopadd = &loop56 - loop offset - movi0 pr.rot = 1 << 16 // set rotating predicates + ld8 s[1] = [asrc], 8 /* preload */ + sub loopaddr = ploop56,tmp4 /* loopadd = &loop56 - loop offset */ + movi0 pr.rot = 1 << 16 /* set rotating predicates */ ;; } { .mib nop.m 0 movi0 b6 = loopaddr - br b6 // jump to the appropriate loop + br b6 /* jump to the appropriate loop */ ;; } LOOP(8) @@ -426,7 +426,7 @@ libc_hidden_def (memcpy) .rodata .align 8 .table: - data8 0 // dummy entry + data8 0 /* dummy entry */ data8 .loop56 - .loop8 data8 .loop56 - .loop16 data8 .loop56 - .loop24 diff --git a/libc/string/ia64/memmove.S b/libc/string/ia64/memmove.S index 00342d8e0..beaada6fc 100644 --- a/libc/string/ia64/memmove.S +++ b/libc/string/ia64/memmove.S @@ -81,48 +81,48 @@ ENTRY(memmove) alloc r2 = ar.pfs, 3, Nrot - 3, 0, Nrot .rotr r[MEMLAT + 2], q[MEMLAT + 1] .rotp p[MEMLAT + 2] - mov ret0 = in0 // return value = dest + mov ret0 = in0 /* return value = dest */ .save pr, saved_pr - mov saved_pr = pr // save the predicate registers + mov saved_pr = pr /* save the predicate registers */ .save ar.lc, saved_lc - mov saved_lc = ar.lc // save the loop counter + mov saved_lc = ar.lc /* save the loop counter */ .body - or tmp3 = in0, in1 ;; // tmp3 = dest | src - or tmp3 = tmp3, in2 // tmp3 = dest | src | len - mov dest = in0 // dest - mov src = in1 // src - mov len = in2 // len - sub tmp2 = r0, in0 // tmp2 = -dest - cmp.eq p6, p0 = in2, r0 // if (len == 0) -(p6) br.cond.spnt .restore_and_exit;;// return dest; - and tmp4 = 7, tmp3 // tmp4 = (dest | src | len) & 7 - cmp.le p6, p0 = dest, src // if dest <= src it's always safe -(p6) br.cond.spnt .forward // to copy forward + or tmp3 = in0, in1 ;; /* tmp3 = dest | src */ + or tmp3 = tmp3, in2 /* tmp3 = dest | src | len */ + mov dest = in0 /* dest */ + mov src = in1 /* src */ + mov len = in2 /* len */ + sub tmp2 = r0, in0 /* tmp2 = -dest */ + cmp.eq p6, p0 = in2, r0 /* if (len == 0) */ +(p6) br.cond.spnt .restore_and_exit;;/* return dest; */ + and tmp4 = 7, tmp3 /* tmp4 = (dest | src | len) & 7 */ + cmp.le p6, p0 = dest, src /* if dest <= src it's always safe */ +(p6) br.cond.spnt .forward /* to copy forward */ add tmp3 = src, len;; - cmp.lt p6, p0 = dest, tmp3 // if dest > src && dest < src + len -(p6) br.cond.spnt .backward // we have to copy backward + cmp.lt p6, p0 = dest, tmp3 /* if dest > src && dest < src + len */ +(p6) br.cond.spnt .backward /* we have to copy backward */ .forward: - shr.u loopcnt = len, 4 ;; // loopcnt = len / 16 - cmp.ne p6, p0 = tmp4, r0 // if ((dest | src | len) & 7 != 0) -(p6) br.cond.sptk .next // goto next; + shr.u loopcnt = len, 4 ;; /* loopcnt = len / 16 */ + cmp.ne p6, p0 = tmp4, r0 /* if ((dest | src | len) & 7 != 0) */ +(p6) br.cond.sptk .next /* goto next; */ -// The optimal case, when dest, src and len are all multiples of 8 +/* The optimal case, when dest, src and len are all multiples of 8 */ and tmp3 = 0xf, len - mov pr.rot = 1 << 16 // set rotating predicates - mov ar.ec = MEMLAT + 1 ;; // set the epilog counter - cmp.ne p6, p0 = tmp3, r0 // do we have to copy an extra word? - adds loopcnt = -1, loopcnt;; // --loopcnt + mov pr.rot = 1 << 16 /* set rotating predicates */ + mov ar.ec = MEMLAT + 1 ;; /* set the epilog counter */ + cmp.ne p6, p0 = tmp3, r0 /* do we have to copy an extra word? */ + adds loopcnt = -1, loopcnt;; /* --loopcnt */ (p6) ld8 value = [src], 8;; -(p6) st8 [dest] = value, 8 // copy the "odd" word - mov ar.lc = loopcnt // set the loop counter +(p6) st8 [dest] = value, 8 /* copy the "odd" word */ + mov ar.lc = loopcnt /* set the loop counter */ cmp.eq p6, p0 = 8, len -(p6) br.cond.spnt .restore_and_exit;;// the one-word special case - adds adest = 8, dest // set adest one word ahead of dest - adds asrc = 8, src ;; // set asrc one word ahead of src - nop.b 0 // get the "golden" alignment for - nop.b 0 // the next loop +(p6) br.cond.spnt .restore_and_exit;;/* the one-word special case */ + adds adest = 8, dest /* set adest one word ahead of dest */ + adds asrc = 8, src ;; /* set asrc one word ahead of src */ + nop.b 0 /* get the "golden" alignment for */ + nop.b 0 /* the next loop */ .l0: (p[0]) ld8 r[0] = [src], 16 (p[0]) ld8 q[0] = [asrc], 16 @@ -130,50 +130,50 @@ ENTRY(memmove) (p[MEMLAT]) st8 [adest] = q[MEMLAT], 16 br.ctop.dptk .l0 ;; - mov pr = saved_pr, -1 // restore the predicate registers - mov ar.lc = saved_lc // restore the loop counter + mov pr = saved_pr, -1 /* restore the predicate registers */ + mov ar.lc = saved_lc /* restore the loop counter */ br.ret.sptk.many b0 .next: - cmp.ge p6, p0 = OP_T_THRES, len // is len <= OP_T_THRES - and loopcnt = 7, tmp2 // loopcnt = -dest % 8 -(p6) br.cond.spnt .cpyfew // copy byte by byte + cmp.ge p6, p0 = OP_T_THRES, len /* is len <= OP_T_THRES */ + and loopcnt = 7, tmp2 /* loopcnt = -dest % 8 */ +(p6) br.cond.spnt .cpyfew /* copy byte by byte */ ;; cmp.eq p6, p0 = loopcnt, r0 (p6) br.cond.sptk .dest_aligned - sub len = len, loopcnt // len -= -dest % 8 - adds loopcnt = -1, loopcnt // --loopcnt + sub len = len, loopcnt /* len -= -dest % 8 */ + adds loopcnt = -1, loopcnt /* --loopcnt */ ;; mov ar.lc = loopcnt -.l1: // copy -dest % 8 bytes - ld1 value = [src], 1 // value = *src++ +.l1: /* copy -dest % 8 bytes */ + ld1 value = [src], 1 /* value = *src++ */ ;; - st1 [dest] = value, 1 // *dest++ = value + st1 [dest] = value, 1 /* *dest++ = value */ br.cloop.dptk .l1 .dest_aligned: - and sh1 = 7, src // sh1 = src % 8 - and tmp2 = -8, len // tmp2 = len & -OPSIZ - and asrc = -8, src // asrc = src & -OPSIZ -- align src - shr.u loopcnt = len, 3 // loopcnt = len / 8 - and len = 7, len;; // len = len % 8 - adds loopcnt = -1, loopcnt // --loopcnt + and sh1 = 7, src /* sh1 = src % 8 */ + and tmp2 = -8, len /* tmp2 = len & -OPSIZ */ + and asrc = -8, src /* asrc = src & -OPSIZ -- align src */ + shr.u loopcnt = len, 3 /* loopcnt = len / 8 */ + and len = 7, len;; /* len = len % 8 */ + adds loopcnt = -1, loopcnt /* --loopcnt */ addl tmp4 = @ltoff(.table), gp addl tmp3 = @ltoff(.loop56), gp - mov ar.ec = MEMLAT + 1 // set EC - mov pr.rot = 1 << 16;; // set rotating predicates - mov ar.lc = loopcnt // set LC - cmp.eq p6, p0 = sh1, r0 // is the src aligned? + mov ar.ec = MEMLAT + 1 /* set EC */ + mov pr.rot = 1 << 16;; /* set rotating predicates */ + mov ar.lc = loopcnt /* set LC */ + cmp.eq p6, p0 = sh1, r0 /* is the src aligned? */ (p6) br.cond.sptk .src_aligned - add src = src, tmp2 // src += len & -OPSIZ - shl sh1 = sh1, 3 // sh1 = 8 * (src % 8) - ld8 ploop56 = [tmp3] // ploop56 = &loop56 - ld8 ptable = [tmp4];; // ptable = &table - add tmp3 = ptable, sh1;; // tmp3 = &table + sh1 - mov ar.ec = MEMLAT + 1 + 1 // one more pass needed - ld8 tmp4 = [tmp3];; // tmp4 = loop offset - sub loopaddr = ploop56,tmp4 // loopadd = &loop56 - loop offset - ld8 r[1] = [asrc], 8;; // w0 + add src = src, tmp2 /* src += len & -OPSIZ */ + shl sh1 = sh1, 3 /* sh1 = 8 * (src % 8) */ + ld8 ploop56 = [tmp3] /* ploop56 = &loop56 */ + ld8 ptable = [tmp4];; /* ptable = &table */ + add tmp3 = ptable, sh1;; /* tmp3 = &table + sh1 */ + mov ar.ec = MEMLAT + 1 + 1 /* one more pass needed */ + ld8 tmp4 = [tmp3];; /* tmp4 = loop offset */ + sub loopaddr = ploop56,tmp4 /* loopadd = &loop56 - loop offset */ + ld8 r[1] = [asrc], 8;; /* w0 */ mov b6 = loopaddr;; - br b6 // jump to the appropriate loop + br b6 /* jump to the appropriate loop */ LOOP(8) LOOP(16) @@ -189,8 +189,8 @@ ENTRY(memmove) (p[MEMLAT]) st8 [dest] = r[MEMLAT], 8 br.ctop.dptk .l3 .cpyfew: - cmp.eq p6, p0 = len, r0 // is len == 0 ? - adds len = -1, len // --len; + cmp.eq p6, p0 = len, r0 /* is len == 0 ? */ + adds len = -1, len /* --len; */ (p6) br.cond.spnt .restore_and_exit ;; mov ar.lc = len .l4: @@ -199,36 +199,36 @@ ENTRY(memmove) st1 [dest] = value, 1 br.cloop.dptk .l4 ;; .restore_and_exit: - mov pr = saved_pr, -1 // restore the predicate registers - mov ar.lc = saved_lc // restore the loop counter + mov pr = saved_pr, -1 /* restore the predicate registers */ + mov ar.lc = saved_lc /* restore the loop counter */ br.ret.sptk.many b0 -// In the case of a backward copy, optimise only the case when everything -// is a multiple of 8, otherwise copy byte by byte. The backward copy is -// used only when the blocks are overlapping and dest > src. - +/* In the case of a backward copy, optimise only the case when everything + is a multiple of 8, otherwise copy byte by byte. The backward copy is + used only when the blocks are overlapping and dest > src. +*/ .backward: - shr.u loopcnt = len, 3 // loopcnt = len / 8 - add src = src, len // src points one byte past the end - add dest = dest, len ;; // dest points one byte past the end - mov ar.ec = MEMLAT + 1 // set the epilog counter - mov pr.rot = 1 << 16 // set rotating predicates - adds loopcnt = -1, loopcnt // --loopcnt - cmp.ne p6, p0 = tmp4, r0 // if ((dest | src | len) & 7 != 0) -(p6) br.cond.sptk .bytecopy ;; // copy byte by byte backward - adds src = -8, src // src points to the last word - adds dest = -8, dest // dest points to the last word - mov ar.lc = loopcnt;; // set the loop counter + shr.u loopcnt = len, 3 /* loopcnt = len / 8 */ + add src = src, len /* src points one byte past the end */ + add dest = dest, len ;; /* dest points one byte past the end */ + mov ar.ec = MEMLAT + 1 /* set the epilog counter */ + mov pr.rot = 1 << 16 /* set rotating predicates */ + adds loopcnt = -1, loopcnt /* --loopcnt */ + cmp.ne p6, p0 = tmp4, r0 /* if ((dest | src | len) & 7 != 0) */ +(p6) br.cond.sptk .bytecopy ;; /* copy byte by byte backward */ + adds src = -8, src /* src points to the last word */ + adds dest = -8, dest /* dest points to the last word */ + mov ar.lc = loopcnt;; /* set the loop counter */ .l5: (p[0]) ld8 r[0] = [src], -8 (p[MEMLAT]) st8 [dest] = r[MEMLAT], -8 br.ctop.dptk .l5 br.cond.sptk .restore_and_exit .bytecopy: - adds src = -1, src // src points to the last byte - adds dest = -1, dest // dest points to the last byte - adds loopcnt = -1, len;; // loopcnt = len - 1 - mov ar.lc = loopcnt;; // set the loop counter + adds src = -1, src /* src points to the last byte */ + adds dest = -1, dest /* dest points to the last byte */ + adds loopcnt = -1, len;; /* loopcnt = len - 1 */ + mov ar.lc = loopcnt;; /* set the loop counter */ .l6: (p[0]) ld1 r[0] = [src], -1 (p[MEMLAT]) st1 [dest] = r[MEMLAT], -1 @@ -239,7 +239,7 @@ END(memmove) .rodata .align 8 .table: - data8 0 // dummy entry + data8 0 /* dummy entry */ data8 .loop56 - .loop8 data8 .loop56 - .loop16 data8 .loop56 - .loop24 diff --git a/libc/string/ia64/memset.S b/libc/string/ia64/memset.S index ed27f3f31..45df5838e 100644 --- a/libc/string/ia64/memset.S +++ b/libc/string/ia64/memset.S @@ -46,15 +46,15 @@ #define ptr1 r28 #define ptr2 r27 #define ptr3 r26 -#define ptr9 r24 +#define ptr9 r24 #define loopcnt r23 #define linecnt r22 #define bytecnt r21 #define fvalue f6 -// This routine uses only scratch predicate registers (p6 - p15) -#define p_scr p6 // default register for same-cycle branches +/* This routine uses only scratch predicate registers (p6 - p15) */ +#define p_scr p6 /* default register for same-cycle branches */ #define p_nz p7 #define p_zr p8 #define p_unalgn p9 @@ -68,7 +68,7 @@ #define MIN1 15 #define MIN1P1HALF 8 #define LINE_SIZE 128 -#define LSIZE_SH 7 // shift amount +#define LSIZE_SH 7 /* shift amount */ #define PREF_AHEAD 8 #define USE_FLP @@ -90,97 +90,97 @@ ENTRY(memset) movi0 save_lc = ar.lc } { .mmi .body - mov ret0 = dest // return value - cmp.ne p_nz, p_zr = value, r0 // use stf.spill if value is zero + mov ret0 = dest /* return value */ + cmp.ne p_nz, p_zr = value, r0 /* use stf.spill if value is zero */ cmp.eq p_scr, p0 = cnt, r0 ;; } { .mmi - and ptr2 = -(MIN1+1), dest // aligned address - and tmp = MIN1, dest // prepare to check for alignment - tbit.nz p_y, p_n = dest, 0 // Do we have an odd address? (M_B_U) + and ptr2 = -(MIN1+1), dest /* aligned address */ + and tmp = MIN1, dest /* prepare to check for alignment */ + tbit.nz p_y, p_n = dest, 0 /* Do we have an odd address? (M_B_U) */ } { .mib mov ptr1 = dest - mux1 value = value, @brcst // create 8 identical bytes in word -(p_scr) br.ret.dpnt.many rp // return immediately if count = 0 + mux1 value = value, @brcst /* create 8 identical bytes in word */ +(p_scr) br.ret.dpnt.many rp /* return immediately if count = 0 */ ;; } { .mib cmp.ne p_unalgn, p0 = tmp, r0 -} { .mib // NB: # of bytes to move is 1 higher - sub bytecnt = (MIN1+1), tmp // than loopcnt - cmp.gt p_scr, p0 = 16, cnt // is it a minimalistic task? -(p_scr) br.cond.dptk.many .move_bytes_unaligned // go move just a few (M_B_U) +} { .mib /* NB: # of bytes to move is 1 higher */ + sub bytecnt = (MIN1+1), tmp /* than loopcnt */ + cmp.gt p_scr, p0 = 16, cnt /* is it a minimalistic task? */ +(p_scr) br.cond.dptk.many .move_bytes_unaligned /* go move just a few (M_B_U) */ ;; } { .mmi -(p_unalgn) add ptr1 = (MIN1+1), ptr2 // after alignment -(p_unalgn) add ptr2 = MIN1P1HALF, ptr2 // after alignment -(p_unalgn) tbit.nz.unc p_y, p_n = bytecnt, 3 // should we do a st8 ? +(p_unalgn) add ptr1 = (MIN1+1), ptr2 /* after alignment */ +(p_unalgn) add ptr2 = MIN1P1HALF, ptr2 /* after alignment */ +(p_unalgn) tbit.nz.unc p_y, p_n = bytecnt, 3 /* should we do a st8 ? */ ;; } { .mib (p_y) add cnt = -8, cnt -(p_unalgn) tbit.nz.unc p_yy, p_nn = bytecnt, 2 // should we do a st4 ? +(p_unalgn) tbit.nz.unc p_yy, p_nn = bytecnt, 2 /* should we do a st4 ? */ } { .mib (p_y) st8 [ptr2] = value, -4 (p_n) add ptr2 = 4, ptr2 ;; } { .mib (p_yy) add cnt = -4, cnt -(p_unalgn) tbit.nz.unc p_y, p_n = bytecnt, 1 // should we do a st2 ? +(p_unalgn) tbit.nz.unc p_y, p_n = bytecnt, 1 /* should we do a st2 ? */ } { .mib (p_yy) st4 [ptr2] = value, -2 (p_nn) add ptr2 = 2, ptr2 ;; } { .mmi - mov tmp = LINE_SIZE+1 // for compare + mov tmp = LINE_SIZE+1 /* for compare */ (p_y) add cnt = -2, cnt -(p_unalgn) tbit.nz.unc p_yy, p_nn = bytecnt, 0 // should we do a st1 ? +(p_unalgn) tbit.nz.unc p_yy, p_nn = bytecnt, 0 /* should we do a st1 ? */ } { .mmi - setf.sig fvalue=value // transfer value to FLP side + setf.sig fvalue=value /* transfer value to FLP side */ (p_y) st2 [ptr2] = value, -1 (p_n) add ptr2 = 1, ptr2 ;; } { .mmi (p_yy) st1 [ptr2] = value - cmp.gt p_scr, p0 = tmp, cnt // is it a minimalistic task? + cmp.gt p_scr, p0 = tmp, cnt /* is it a minimalistic task? */ } { .mbb (p_yy) add cnt = -1, cnt -(p_scr) br.cond.dpnt.many .fraction_of_line // go move just a few +(p_scr) br.cond.dpnt.many .fraction_of_line /* go move just a few */ ;; } { .mib nop.m 0 shr.u linecnt = cnt, LSIZE_SH -(p_zr) br.cond.dptk.many .l1b // Jump to use stf.spill +(p_zr) br.cond.dptk.many .l1b /* Jump to use stf.spill */ ;; } #ifndef GAS_ALIGN_BREAKS_UNWIND_INFO - .align 32 // -------- // L1A: store ahead into cache lines; fill later + .align 32 /* -------- L1A: store ahead into cache lines; fill later */ #endif { .mmi - and tmp = -(LINE_SIZE), cnt // compute end of range - mov ptr9 = ptr1 // used for prefetching - and cnt = (LINE_SIZE-1), cnt // remainder + and tmp = -(LINE_SIZE), cnt /* compute end of range */ + mov ptr9 = ptr1 /* used for prefetching */ + and cnt = (LINE_SIZE-1), cnt /* remainder */ } { .mmi - mov loopcnt = PREF_AHEAD-1 // default prefetch loop - cmp.gt p_scr, p0 = PREF_AHEAD, linecnt // check against actual value + mov loopcnt = PREF_AHEAD-1 /* default prefetch loop */ + cmp.gt p_scr, p0 = PREF_AHEAD, linecnt /* check against actual value */ ;; } { .mmi -(p_scr) add loopcnt = -1, linecnt // start of stores - add ptr2 = 8, ptr1 // (beyond prefetch stores) - add ptr1 = tmp, ptr1 // first address beyond total -;; } // range +(p_scr) add loopcnt = -1, linecnt /* start of stores */ + add ptr2 = 8, ptr1 /* (beyond prefetch stores) */ + add ptr1 = tmp, ptr1 /* first address beyond total */ +;; } /* range */ { .mmi - add tmp = -1, linecnt // next loop count + add tmp = -1, linecnt /* next loop count */ movi0 ar.lc = loopcnt ;; } .pref_l1a: { .mib - store [ptr9] = myval, 128 // Do stores one cache line apart + store [ptr9] = myval, 128 /* Do stores one cache line apart */ nop.i 0 br.cloop.dptk.few .pref_l1a ;; } { .mmi - add ptr0 = 16, ptr2 // Two stores in parallel + add ptr0 = 16, ptr2 /* Two stores in parallel */ movi0 ar.lc = tmp ;; } .l1ax: @@ -211,7 +211,7 @@ ENTRY(memset) { .mmi store [ptr2] = myval, 8 store [ptr0] = myval, 32 - cmp.lt p_scr, p0 = ptr9, ptr1 // do we need more prefetching? + cmp.lt p_scr, p0 = ptr9, ptr1 /* do we need more prefetching? */ ;; } { .mmb store [ptr2] = myval, 24 @@ -219,9 +219,9 @@ ENTRY(memset) br.cloop.dptk.few .l1ax ;; } { .mbb - cmp.le p_scr, p0 = 8, cnt // just a few bytes left ? -(p_scr) br.cond.dpnt.many .fraction_of_line // Branch no. 2 - br.cond.dpnt.many .move_bytes_from_alignment // Branch no. 3 + cmp.le p_scr, p0 = 8, cnt /* just a few bytes left ? */ +(p_scr) br.cond.dpnt.many .fraction_of_line /* Branch no. 2 */ + br.cond.dpnt.many .move_bytes_from_alignment /* Branch no. 3 */ ;; } #ifdef GAS_ALIGN_BREAKS_UNWIND_INFO @@ -229,32 +229,32 @@ ENTRY(memset) #else .align 32 #endif -.l1b: // ------------------ // L1B: store ahead into cache lines; fill later +.l1b: /* ------------------ L1B: store ahead into cache lines; fill later */ { .mmi - and tmp = -(LINE_SIZE), cnt // compute end of range - mov ptr9 = ptr1 // used for prefetching - and cnt = (LINE_SIZE-1), cnt // remainder + and tmp = -(LINE_SIZE), cnt /* compute end of range */ + mov ptr9 = ptr1 /* used for prefetching */ + and cnt = (LINE_SIZE-1), cnt /* remainder */ } { .mmi - mov loopcnt = PREF_AHEAD-1 // default prefetch loop - cmp.gt p_scr, p0 = PREF_AHEAD, linecnt // check against actual value + mov loopcnt = PREF_AHEAD-1 /* default prefetch loop */ + cmp.gt p_scr, p0 = PREF_AHEAD, linecnt /* check against actual value */ ;; } { .mmi (p_scr) add loopcnt = -1, linecnt - add ptr2 = 16, ptr1 // start of stores (beyond prefetch stores) - add ptr1 = tmp, ptr1 // first address beyond total range + add ptr2 = 16, ptr1 /* start of stores (beyond prefetch stores) */ + add ptr1 = tmp, ptr1 /* first address beyond total range */ ;; } { .mmi - add tmp = -1, linecnt // next loop count + add tmp = -1, linecnt /* next loop count */ movi0 ar.lc = loopcnt ;; } .pref_l1b: { .mib - stf.spill [ptr9] = f0, 128 // Do stores one cache line apart + stf.spill [ptr9] = f0, 128 /* Do stores one cache line apart */ nop.i 0 br.cloop.dptk.few .pref_l1b ;; } { .mmi - add ptr0 = 16, ptr2 // Two stores in parallel + add ptr0 = 16, ptr2 /* Two stores in parallel */ movi0 ar.lc = tmp ;; } .l1bx: @@ -269,7 +269,7 @@ ENTRY(memset) { .mmi stf.spill [ptr2] = f0, 32 stf.spill [ptr0] = f0, 64 - cmp.lt p_scr, p0 = ptr9, ptr1 // do we need more prefetching? + cmp.lt p_scr, p0 = ptr9, ptr1 /* do we need more prefetching? */ ;; } { .mmb stf.spill [ptr2] = f0, 32 @@ -277,14 +277,14 @@ ENTRY(memset) br.cloop.dptk.few .l1bx ;; } { .mib - cmp.gt p_scr, p0 = 8, cnt // just a few bytes left ? + cmp.gt p_scr, p0 = 8, cnt /* just a few bytes left ? */ (p_scr) br.cond.dpnt.many .move_bytes_from_alignment ;; } .fraction_of_line: { .mib add ptr2 = 16, ptr1 - shr.u loopcnt = cnt, 5 // loopcnt = cnt / 32 + shr.u loopcnt = cnt, 5 /* loopcnt = cnt / 32 */ ;; } { .mib cmp.eq p_scr, p0 = loopcnt, r0 @@ -292,13 +292,13 @@ ENTRY(memset) (p_scr) br.cond.dpnt.many store_words ;; } { .mib - and cnt = 0x1f, cnt // compute the remaining cnt + and cnt = 0x1f, cnt /* compute the remaining cnt */ movi0 ar.lc = loopcnt ;; } #ifndef GAS_ALIGN_BREAKS_UNWIND_INFO .align 32 #endif -.l2: // ---------------------------- // L2A: store 32B in 2 cycles +.l2: /* ---------------------------- L2A: store 32B in 2 cycles */ { .mmb store [ptr1] = myval, 8 store [ptr2] = myval, 8 @@ -309,34 +309,34 @@ ENTRY(memset) ;; } store_words: { .mib - cmp.gt p_scr, p0 = 8, cnt // just a few bytes left ? -(p_scr) br.cond.dpnt.many .move_bytes_from_alignment // Branch + cmp.gt p_scr, p0 = 8, cnt /* just a few bytes left ? */ +(p_scr) br.cond.dpnt.many .move_bytes_from_alignment /* Branch */ ;; } { .mmi - store [ptr1] = myval, 8 // store - cmp.le p_y, p_n = 16, cnt // - add cnt = -8, cnt // subtract + store [ptr1] = myval, 8 /* store */ + cmp.le p_y, p_n = 16, cnt /* */ + add cnt = -8, cnt /* subtract */ ;; } { .mmi -(p_y) store [ptr1] = myval, 8 // store -(p_y) cmp.le.unc p_yy, p_nn = 16, cnt // -(p_y) add cnt = -8, cnt // subtract +(p_y) store [ptr1] = myval, 8 /* store */ +(p_y) cmp.le.unc p_yy, p_nn = 16, cnt /* */ +(p_y) add cnt = -8, cnt /* subtract */ ;; } -{ .mmi // store -(p_yy) store [ptr1] = myval, 8 // -(p_yy) add cnt = -8, cnt // subtract +{ .mmi /* store */ +(p_yy) store [ptr1] = myval, 8 /* */ +(p_yy) add cnt = -8, cnt /* subtract */ ;; } .move_bytes_from_alignment: { .mib cmp.eq p_scr, p0 = cnt, r0 - tbit.nz.unc p_y, p0 = cnt, 2 // should we terminate with a st4 ? + tbit.nz.unc p_y, p0 = cnt, 2 /* should we terminate with a st4 ? */ (p_scr) br.cond.dpnt.few .restore_and_exit ;; } { .mib (p_y) st4 [ptr1] = value, 4 - tbit.nz.unc p_yy, p0 = cnt, 1 // should we terminate with a st2 ? + tbit.nz.unc p_yy, p0 = cnt, 1 /* should we terminate with a st2 ? */ ;; } { .mib (p_yy) st2 [ptr1] = value, 2 @@ -362,38 +362,38 @@ store_words: (p_n) add ptr2 = 2, ptr1 } { .mmi (p_y) add ptr2 = 3, ptr1 -(p_y) st1 [ptr1] = value, 1 // fill 1 (odd-aligned) byte -(p_y) add cnt = -1, cnt // [15, 14 (or less) left] +(p_y) st1 [ptr1] = value, 1 /* fill 1 (odd-aligned) byte */ +(p_y) add cnt = -1, cnt /* [15, 14 (or less) left] */ ;; } { .mmi (p_yy) cmp.le.unc p_y, p0 = 8, cnt - add ptr3 = ptr1, cnt // prepare last store + add ptr3 = ptr1, cnt /* prepare last store */ movi0 ar.lc = save_lc } { .mmi -(p_yy) st2 [ptr1] = value, 4 // fill 2 (aligned) bytes -(p_yy) st2 [ptr2] = value, 4 // fill 2 (aligned) bytes -(p_yy) add cnt = -4, cnt // [11, 10 (o less) left] +(p_yy) st2 [ptr1] = value, 4 /* fill 2 (aligned) bytes */ +(p_yy) st2 [ptr2] = value, 4 /* fill 2 (aligned) bytes */ +(p_yy) add cnt = -4, cnt /* [11, 10 (o less) left] */ ;; } { .mmi (p_y) cmp.le.unc p_yy, p0 = 8, cnt - add ptr3 = -1, ptr3 // last store - tbit.nz p_scr, p0 = cnt, 1 // will there be a st2 at the end ? + add ptr3 = -1, ptr3 /* last store */ + tbit.nz p_scr, p0 = cnt, 1 /* will there be a st2 at the end ? */ } { .mmi -(p_y) st2 [ptr1] = value, 4 // fill 2 (aligned) bytes -(p_y) st2 [ptr2] = value, 4 // fill 2 (aligned) bytes -(p_y) add cnt = -4, cnt // [7, 6 (or less) left] +(p_y) st2 [ptr1] = value, 4 /* fill 2 (aligned) bytes */ +(p_y) st2 [ptr2] = value, 4 /* fill 2 (aligned) bytes */ +(p_y) add cnt = -4, cnt /* [7, 6 (or less) left] */ ;; } { .mmi -(p_yy) st2 [ptr1] = value, 4 // fill 2 (aligned) bytes -(p_yy) st2 [ptr2] = value, 4 // fill 2 (aligned) bytes - // [3, 2 (or less) left] - tbit.nz p_y, p0 = cnt, 0 // will there be a st1 at the end ? +(p_yy) st2 [ptr1] = value, 4 /* fill 2 (aligned) bytes */ +(p_yy) st2 [ptr2] = value, 4 /* fill 2 (aligned) bytes */ + /* [3, 2 (or less) left] */ + tbit.nz p_y, p0 = cnt, 0 /* will there be a st1 at the end ? */ } { .mmi (p_yy) add cnt = -4, cnt ;; } { .mmb -(p_scr) st2 [ptr1] = value // fill 2 (aligned) bytes -(p_y) st1 [ptr3] = value // fill last byte (using ptr3) +(p_scr) st2 [ptr1] = value /* fill 2 (aligned) bytes */ +(p_y) st1 [ptr3] = value /* fill last byte (using ptr3) */ br.ret.sptk.many rp ;; } END(memset) diff --git a/libc/string/ia64/strchr.S b/libc/string/ia64/strchr.S index 401a07941..66703f26d 100644 --- a/libc/string/ia64/strchr.S +++ b/libc/string/ia64/strchr.S @@ -49,15 +49,15 @@ ENTRY(strchr) .prologue alloc r2 = ar.pfs, 2, 0, 0, 0 .save ar.lc, saved_lc - mov saved_lc = ar.lc // save the loop counter + mov saved_lc = ar.lc /* save the loop counter */ .body mov ret0 = str - and tmp = 7, str // tmp = str % 8 + and tmp = 7, str /* tmp = str % 8 */ mux1 chrx8 = chr, @brcst - extr.u chr = chr, 0, 8 // retain only the last byte - cmp.ne p8, p0 = r0, r0 // clear p8 + extr.u chr = chr, 0, 8 /* retain only the last byte */ + cmp.ne p8, p0 = r0, r0 /* clear p8 */ ;; - sub loopcnt = 8, tmp // loopcnt = 8 - tmp + sub loopcnt = 8, tmp /* loopcnt = 8 - tmp */ cmp.eq p6, p0 = tmp, r0 (p6) br.cond.sptk .str_aligned;; adds loopcnt = -1, loopcnt;; @@ -75,10 +75,10 @@ ENTRY(strchr) nop.b 0 nop.b 0 .l2: - ld8.s val2 = [ret0], 8 // don't bomb out here + ld8.s val2 = [ret0], 8 /* don't bomb out here */ czx1.r pos0 = val1 - xor tmp = val1, chrx8 // if val1 contains chr, tmp will - ;; // contain a zero in its position + xor tmp = val1, chrx8 /* if val1 contains chr, tmp will */ + ;; /* contain a zero in its position */ czx1.r poschr = tmp cmp.ne p6, p0 = 8, pos0 ;; @@ -90,21 +90,21 @@ ENTRY(strchr) mov val1 = val2 br.cond.dptk .l2 .foundit: -(p6) cmp.lt p8, p0 = pos0, poschr // we found chr and null in the word -(p8) br.cond.spnt .notfound // null was found before chr +(p6) cmp.lt p8, p0 = pos0, poschr /* we found chr and null in the word */ +(p8) br.cond.spnt .notfound /* null was found before chr */ add ret0 = ret0, poschr ;; - adds ret0 = -15, ret0 ;; // should be -16, but we decrement -.restore_and_exit: // ret0 in the next instruction - adds ret0 = -1, ret0 // ret0 was pointing 1 char too far - mov ar.lc = saved_lc // restore the loop counter + adds ret0 = -15, ret0 ;; /* should be -16, but we decrement */ +.restore_and_exit: /* ret0 in the next instruction */ + adds ret0 = -1, ret0 /* ret0 was pointing 1 char too far */ + mov ar.lc = saved_lc /* restore the loop counter */ br.ret.sptk.many b0 .notfound: - mov ret0 = r0 // return NULL if null was found + mov ret0 = r0 /* return NULL if null was found */ mov ar.lc = saved_lc br.ret.sptk.many b0 .recovery: adds ret0 = -8, ret0;; - ld8 val2 = [ret0], 8 // bomb out here + ld8 val2 = [ret0], 8 /* bomb out here */ br.cond.sptk .back END(strchr) libc_hidden_def (strchr) diff --git a/libc/string/ia64/strcmp.S b/libc/string/ia64/strcmp.S index d3b41e642..4da72fa10 100644 --- a/libc/string/ia64/strcmp.S +++ b/libc/string/ia64/strcmp.S @@ -42,7 +42,7 @@ ENTRY(strcmp) .loop: ld1 val1 = [s1], 1 ld1 val2 = [s2], 1 - cmp.eq p6, p0 = r0, r0 // set p6 + cmp.eq p6, p0 = r0, r0 /* set p6 */ ;; cmp.ne.and p6, p0 = val1, r0 cmp.ne.and p6, p0 = val2, r0 diff --git a/libc/string/ia64/strcpy.S b/libc/string/ia64/strcpy.S index e4a9915ca..7b002f661 100644 --- a/libc/string/ia64/strcpy.S +++ b/libc/string/ia64/strcpy.S @@ -27,8 +27,8 @@ In this form, it assumes little endian mode. For big endian mode, the the two shifts in .l2 must be inverted: - shl value = r[1], sh1 // value = w0 << sh1 - shr.u tmp = r[0], sh2 // tmp = w1 >> sh2 + shl value = r[1], sh1 // value = w0 << sh1 + shr.u tmp = r[0], sh2 // tmp = w1 >> sh2 */ #include "sysdep.h" @@ -53,62 +53,62 @@ ENTRY(strcpy) .prologue - alloc r2 = ar.pfs, 2, 0, 30, 32 + alloc r2 = ar.pfs, 2, 0, 30, 32 #define MEMLAT 2 .rotr r[MEMLAT + 2] .rotp p[MEMLAT + 1] - mov ret0 = in0 // return value = dest + mov ret0 = in0 /* return value = dest */ .save pr, saved_pr - mov saved_pr = pr // save the predicate registers + mov saved_pr = pr /* save the predicate registers */ .save ar.lc, saved_lc - mov saved_lc = ar.lc // save the loop counter + mov saved_lc = ar.lc /* save the loop counter */ .body - sub tmp = r0, in0 ;; // tmp = -dest - mov dest = in0 // dest - mov src = in1 // src - and loopcnt = 7, tmp ;; // loopcnt = -dest % 8 + sub tmp = r0, in0 ;; /* tmp = -dest */ + mov dest = in0 /* dest */ + mov src = in1 /* src */ + and loopcnt = 7, tmp ;; /* loopcnt = -dest % 8 */ cmp.eq p6, p0 = loopcnt, r0 - adds loopcnt = -1, loopcnt // --loopcnt + adds loopcnt = -1, loopcnt /* --loopcnt */ (p6) br.cond.sptk .dest_aligned ;; mov ar.lc = loopcnt -.l1: // copy -dest % 8 bytes - ld1 c = [src], 1 // c = *src++ +.l1: /* copy -dest % 8 bytes */ + ld1 c = [src], 1 /* c = *src++ */ ;; - st1 [dest] = c, 1 // *dest++ = c + st1 [dest] = c, 1 /* *dest++ = c */ cmp.eq p6, p0 = c, r0 (p6) br.cond.dpnt .restore_and_exit br.cloop.dptk .l1 ;; .dest_aligned: - and sh1 = 7, src // sh1 = src % 8 - mov ar.lc = -1 // "infinite" loop - and asrc = -8, src ;; // asrc = src & -OPSIZ -- align src + and sh1 = 7, src /* sh1 = src % 8 */ + mov ar.lc = -1 /* "infinite" loop */ + and asrc = -8, src ;; /* asrc = src & -OPSIZ -- align src */ sub thresh = 8, sh1 - mov pr.rot = 1 << 16 // set rotating predicates - cmp.ne p7, p0 = r0, r0 // clear p7 - shl sh1 = sh1, 3 ;; // sh1 = 8 * (src % 8) - sub sh2 = 64, sh1 // sh2 = 64 - sh1 - cmp.eq p6, p0 = sh1, r0 // is the src aligned? + mov pr.rot = 1 << 16 /* set rotating predicates */ + cmp.ne p7, p0 = r0, r0 /* clear p7 */ + shl sh1 = sh1, 3 ;; /* sh1 = 8 * (src % 8) */ + sub sh2 = 64, sh1 /* sh2 = 64 - sh1 */ + cmp.eq p6, p0 = sh1, r0 /* is the src aligned? */ (p6) br.cond.sptk .src_aligned ;; ld8 r[1] = [asrc],8 ;; .align 32 .l2: ld8.s r[0] = [asrc], 8 - shr.u value = r[1], sh1 ;; // value = w0 >> sh1 - czx1.r pos = value ;; // do we have an "early" zero - cmp.lt p7, p0 = pos, thresh // in w0 >> sh1? + shr.u value = r[1], sh1 ;; /* value = w0 >> sh1 */ + czx1.r pos = value ;; /* do we have an "early" zero */ + cmp.lt p7, p0 = pos, thresh /* in w0 >> sh1? */ (p7) br.cond.dpnt .found0 - chk.s r[0], .recovery2 // it is safe to do that only -.back2: // after the previous test - shl tmp = r[0], sh2 // tmp = w1 << sh2 + chk.s r[0], .recovery2 /* it is safe to do that only */ +.back2: /* after the previous test */ + shl tmp = r[0], sh2 /* tmp = w1 << sh2 */ ;; - or value = value, tmp ;; // value |= tmp + or value = value, tmp ;; /* value |= tmp */ czx1.r pos = value ;; cmp.ne p7, p0 = 8, pos (p7) br.cond.dpnt .found0 - st8 [dest] = value, 8 // store val to dest + st8 [dest] = value, 8 /* store val to dest */ br.ctop.dptk .l2 ;; .src_aligned: .l3: @@ -124,14 +124,14 @@ ENTRY(strcpy) .found0: mov ar.lc = pos .l4: - extr.u c = value, 0, 8 // c = value & 0xff + extr.u c = value, 0, 8 /* c = value & 0xff */ shr.u value = value, 8 ;; st1 [dest] = c, 1 br.cloop.dptk .l4 ;; .restore_and_exit: - mov ar.lc = saved_lc // restore the loop counter - mov pr = saved_pr, -1 // restore the predicate registers + mov ar.lc = saved_lc /* restore the loop counter */ + mov pr = saved_pr, -1 /* restore the predicate registers */ br.ret.sptk.many b0 .recovery2: add tmp = -8, asrc ;; diff --git a/libc/string/ia64/strlen.S b/libc/string/ia64/strlen.S index 9b27a2d1b..edbe84359 100644 --- a/libc/string/ia64/strlen.S +++ b/libc/string/ia64/strlen.S @@ -50,13 +50,13 @@ ENTRY(strlen) .prologue alloc r2 = ar.pfs, 1, 0, 0, 0 .save ar.lc, saved_lc - mov saved_lc = ar.lc // save the loop counter + mov saved_lc = ar.lc /* save the loop counter */ .body mov str = in0 - mov len = r0 // len = 0 - and tmp = 7, in0 // tmp = str % 8 + mov len = r0 /* len = 0 */ + and tmp = 7, in0 /* tmp = str % 8 */ ;; - sub loopcnt = 8, tmp // loopcnt = 8 - tmp + sub loopcnt = 8, tmp /* loopcnt = 8 - tmp */ cmp.eq p6, p0 = tmp, r0 (p6) br.cond.sptk .str_aligned;; adds loopcnt = -1, loopcnt;; @@ -69,11 +69,11 @@ ENTRY(strlen) adds len = 1, len br.cloop.dptk .l1 .str_aligned: - mov origadd = str // origadd = orig + mov origadd = str /* origadd = orig */ ld8 val1 = [str], 8;; nop.b 0 nop.b 0 -.l2: ld8.s val2 = [str], 8 // don't bomb out here +.l2: ld8.s val2 = [str], 8 /* don't bomb out here */ czx1.r pos0 = val1 ;; cmp.ne p6, p0 = 8, pos0 @@ -83,16 +83,16 @@ ENTRY(strlen) mov val1 = val2 br.cond.dptk .l2 .foundit: - sub tmp = str, origadd // tmp = crt address - orig + sub tmp = str, origadd /* tmp = crt address - orig */ add len = len, pos0;; add len = len, tmp;; adds len = -16, len .restore_and_exit: - mov ar.lc = saved_lc // restore the loop counter + mov ar.lc = saved_lc /* restore the loop counter */ br.ret.sptk.many b0 .recovery: adds str = -8, str;; - ld8 val2 = [str], 8 // bomb out here + ld8 val2 = [str], 8 /* bomb out here */ br.cond.sptk .back END(strlen) libc_hidden_def (strlen) diff --git a/libc/string/ia64/strncmp.S b/libc/string/ia64/strncmp.S index 8e0373c7f..e31f8fbd9 100644 --- a/libc/string/ia64/strncmp.S +++ b/libc/string/ia64/strncmp.S @@ -23,7 +23,7 @@ Inputs: in0: s1 in1: s2 - in2: n + in2: n Unlike memcmp(), this function is optimized for mismatches within the first few characters. */ @@ -42,13 +42,13 @@ ENTRY(strncmp) alloc r2 = ar.pfs, 3, 0, 0, 0 mov ret0 = r0 - cmp.eq p6, p0 = r0, r0 // set p6 - cmp.eq p7, p0 = n, r0 // return immediately if n == 0 + cmp.eq p6, p0 = r0, r0 /* set p6 */ + cmp.eq p7, p0 = n, r0 /* return immediately if n == 0 */ (p7) br.cond.spnt .restore_and_exit ;; .loop: ld1 val1 = [s1], 1 ld1 val2 = [s2], 1 - adds n = -1, n // n-- + adds n = -1, n /* n-- */ ;; cmp.ne.and p6, p0 = val1, r0 cmp.ne.and p6, p0 = val2, r0 @@ -58,5 +58,5 @@ ENTRY(strncmp) sub ret0 = val1, val2 .restore_and_exit: br.ret.sptk.many b0 -END(strncmp) +END(strncmp) libc_hidden_weak (strncmp) diff --git a/libc/string/ia64/strncpy.S b/libc/string/ia64/strncpy.S index 4f1129350..3f29bbd52 100644 --- a/libc/string/ia64/strncpy.S +++ b/libc/string/ia64/strncpy.S @@ -58,64 +58,64 @@ ENTRY(strncpy) .rotr r[MEMLAT + 2] .rotp p[MEMLAT + 1] - mov ret0 = in0 // return value = dest + mov ret0 = in0 /* return value = dest */ .save pr, saved_pr - mov saved_pr = pr // save the predicate registers + mov saved_pr = pr /* save the predicate registers */ .save ar.lc, saved_lc - mov saved_lc = ar.lc // save the loop counter - mov ar.ec = 0 // ec is not guaranteed to - // be zero upon function entry + mov saved_lc = ar.lc /* save the loop counter */ + mov ar.ec = 0 /* ec is not guaranteed to */ + /* be zero upon function entry */ .body cmp.geu p6, p5 = 24, in2 (p6) br.cond.spnt .short_len - sub tmp = r0, in0 ;; // tmp = -dest - mov len = in2 // len - mov dest = in0 // dest - mov src = in1 // src - and tmp = 7, tmp ;; // loopcnt = -dest % 8 + sub tmp = r0, in0 ;; /* tmp = -dest */ + mov len = in2 /* len */ + mov dest = in0 /* dest */ + mov src = in1 /* src */ + and tmp = 7, tmp ;; /* loopcnt = -dest % 8 */ cmp.eq p6, p7 = tmp, r0 - adds loopcnt = -1, tmp // --loopcnt + adds loopcnt = -1, tmp /* --loopcnt */ (p6) br.cond.sptk .dest_aligned ;; - sub len = len, tmp // len -= -dest % 8 + sub len = len, tmp /* len -= -dest % 8 */ mov ar.lc = loopcnt -.l1: // copy -dest % 8 bytes -(p5) ld1 c = [src], 1 // c = *src++ +.l1: /* copy -dest % 8 bytes */ +(p5) ld1 c = [src], 1 /* c = *src++ */ ;; - st1 [dest] = c, 1 // *dest++ = c + st1 [dest] = c, 1 /* *dest++ = c */ cmp.ne p5, p7 = c, r0 br.cloop.dptk .l1 ;; (p7) br.cond.dpnt .found0_align -.dest_aligned: // p7 should be cleared here - shr.u c = len, 3 // c = len / 8 - and sh1 = 7, src // sh1 = src % 8 - and asrc = -8, src ;; // asrc = src & -OPSIZ -- align src - adds c = (MEMLAT-1), c // c = (len / 8) + MEMLAT - 1 +.dest_aligned: /* p7 should be cleared here */ + shr.u c = len, 3 /* c = len / 8 */ + and sh1 = 7, src /* sh1 = src % 8 */ + and asrc = -8, src ;; /* asrc = src & -OPSIZ -- align src */ + adds c = (MEMLAT-1), c /* c = (len / 8) + MEMLAT - 1 */ sub thresh = 8, sh1 - mov pr.rot = 1 << 16 // set rotating predicates - shl sh1 = sh1, 3 ;; // sh1 = 8 * (src % 8) - mov ar.lc = c // "infinite" loop - sub sh2 = 64, sh1 // sh2 = 64 - sh1 - cmp.eq p6, p0 = sh1, r0 // is the src aligned? + mov pr.rot = 1 << 16 /* set rotating predicates */ + shl sh1 = sh1, 3 ;; /* sh1 = 8 * (src % 8) */ + mov ar.lc = c /* "infinite" loop */ + sub sh2 = 64, sh1 /* sh2 = 64 - sh1 */ + cmp.eq p6, p0 = sh1, r0 /* is the src aligned? */ (p6) br.cond.sptk .src_aligned - adds c = -(MEMLAT-1), c ;; // c = (len / 8) + adds c = -(MEMLAT-1), c ;; /* c = (len / 8) */ ld8 r[1] = [asrc],8 mov ar.lc = c ;; .align 32 .l2: -(p6) st8 [dest] = value, 8 // store val to dest +(p6) st8 [dest] = value, 8 /* store val to dest */ ld8.s r[0] = [asrc], 8 - shr.u value = r[1], sh1 ;; // value = w0 >> sh1 - czx1.r pos = value ;; // do we have an "early" zero - cmp.lt p7, p0 = pos, thresh // in w0 >> sh1? - adds len = -8, len // len -= 8 + shr.u value = r[1], sh1 ;; /* value = w0 >> sh1 */ + czx1.r pos = value ;; /* do we have an "early" zero */ + cmp.lt p7, p0 = pos, thresh /* in w0 >> sh1? */ + adds len = -8, len /* len -= 8 */ (p7) br.cond.dpnt .nonalign_found0 - chk.s r[0], .recovery2 // it is safe to do that only -.back2: // after the previous test - shl tmp = r[0], sh2 // tmp = w1 << sh2 + chk.s r[0], .recovery2 /* it is safe to do that only */ +.back2: /* after the previous test */ + shl tmp = r[0], sh2 /* tmp = w1 << sh2 */ ;; - or value = value, tmp ;; // value |= tmp + or value = value, tmp ;; /* value |= tmp */ czx1.r pos = value ;; cmp.ne p7, p6 = 8, pos (p7) br.cond.dpnt .nonalign_found0 @@ -137,7 +137,7 @@ ENTRY(strncpy) (p[MEMLAT]) mov value = r[MEMLAT] (p[MEMLAT]) czx1.r pos = r[MEMLAT] ;; (p[MEMLAT]) cmp.ne p7, p0 = 8, pos -(p[MEMLAT]) adds len = -8, len // len -= 8 +(p[MEMLAT]) adds len = -8, len /* len -= 8 */ (p7) br.cond.dpnt .found0 (p[MEMLAT]) st8 [dest] = r[MEMLAT], 8 br.ctop.dptk .l3 ;; @@ -152,7 +152,7 @@ ENTRY(strncpy) (p5) br.cond.dptk .restore_and_exit ;; mov ar.lc = len .l4: -(p6) extr.u c = value, 0, 8 // c = value & 0xff +(p6) extr.u c = value, 0, 8 /* c = value & 0xff */ (p6) shr.u value = value, 8 ;; st1 [dest] = c, 1 cmp.ne p6, p0 = c, r0 @@ -165,7 +165,7 @@ ENTRY(strncpy) mov value = 0 ;; .found0: shl tmp = pos, 3 - shr.u loopcnt = len, 4 // loopcnt = len / 16 + shr.u loopcnt = len, 4 /* loopcnt = len / 16 */ mov c = -1 ;; cmp.eq p6, p0 = loopcnt, r0 adds loopcnt = -1, loopcnt @@ -192,24 +192,24 @@ ENTRY(strncpy) st1 [dest] = r0, 1 br.cloop.dptk .l7 ;; .restore_and_exit: - mov ar.lc = saved_lc // restore the loop counter - mov pr = saved_pr, -1 // restore the predicate registers + mov ar.lc = saved_lc /* restore the loop counter */ + mov pr = saved_pr, -1 /* restore the predicate registers */ br.ret.sptk.many b0 .short_len: cmp.eq p5, p0 = in2, r0 adds loopcnt = -1, in2 (p5) br.cond.spnt .restore_and_exit ;; - mov ar.lc = loopcnt // p6 should be set when we get here + mov ar.lc = loopcnt /* p6 should be set when we get here */ .l8: -(p6) ld1 c = [in1], 1 // c = *src++ +(p6) ld1 c = [in1], 1 /* c = *src++ */ ;; - st1 [in0] = c, 1 // *dest++ = c + st1 [in0] = c, 1 /* *dest++ = c */ (p6) cmp.ne p6, p0 = c, r0 br.cloop.dptk .l8 ;; - mov ar.lc = saved_lc // restore the loop counter - mov pr = saved_pr, -1 // restore the predicate registers + mov ar.lc = saved_lc /* restore the loop counter */ + mov pr = saved_pr, -1 /* restore the predicate registers */ br.ret.sptk.many b0 .recovery2: add c = 8, len diff --git a/libc/string/sh64/memcpy.S b/libc/string/sh64/memcpy.S index 3c0ea0c0d..470784ecd 100644 --- a/libc/string/sh64/memcpy.S +++ b/libc/string/sh64/memcpy.S @@ -151,7 +151,7 @@ Large: add r2, r4, r5 ldlo.q r3, 0, r0 addi r5, -16, r5 - movi 64+8, r27 // could subtract r7 from that. + movi 64+8, r27 /* could subtract r7 from that. */ stlo.q r2, 0, r0 sthi.q r2, 7, r0 ldx.q r22, r6, r0 diff --git a/libc/string/sh64/memset.S b/libc/string/sh64/memset.S index f588323f0..1b8812cd6 100644 --- a/libc/string/sh64/memset.S +++ b/libc/string/sh64/memset.S @@ -32,12 +32,12 @@ memset: ptabs r18, tr2 mshflo.b r3,r3,r3 add r4, r22, r23 - mperm.w r3, r63, r3 // Fill pattern now in every byte of r3 + mperm.w r3, r63, r3 /* Fill pattern now in every byte of r3 */ movi 8, r9 - bgtu/u r23, r9, tr0 // multiquad + bgtu/u r23, r9, tr0 /* multiquad */ - beqi/u r4, 0, tr2 // Return with size 0 - ensures no mem accesses + beqi/u r4, 0, tr2 /* Return with size 0 - ensures no mem accesses */ ldlo.q r2, 0, r7 shlli r4, 2, r4 movi -1, r8 @@ -52,20 +52,21 @@ multiquad: stlo.q r2, 0, r3 shlri r23, 3, r24 add r2, r4, r5 - beqi/u r24, 1, tr0 // lastquad + beqi/u r24, 1, tr0 /* lastquad */ pta/l loop, tr1 sub r2, r22, r25 - andi r5, -8, r20 // calculate end address and - addi r20, -7*8, r8 // loop end address; This might overflow, so we need - // to use a different test before we start the loop - bge/u r24, r9, tr1 // loop + andi r5, -8, r20 /* calculate end address and */ + addi r20, -7*8, r8 /* loop end address; This might overflow, so we need + to use a different test before we start the loop + */ + bge/u r24, r9, tr1 /* loop */ st.q r25, 8, r3 st.q r20, -8, r3 shlri r24, 1, r24 - beqi/u r24, 1, tr0 // lastquad + beqi/u r24, 1, tr0 /* lastquad */ st.q r25, 16, r3 st.q r20, -16, r3 - beqi/u r24, 2, tr0 // lastquad + beqi/u r24, 2, tr0 /* lastquad */ st.q r25, 24, r3 st.q r20, -24, r3 lastquad: @@ -73,15 +74,15 @@ lastquad: blink tr2,r63 loop: -!!! alloco r25, 32 // QQQ comment out for short-term fix to SHUK #3895. - // QQQ commenting out is locically correct, but sub-optimal - // QQQ Sean McGoogan - 4th April 2003. +!!! alloco r25, 32 /* QQQ comment out for short-term fix to SHUK #3895. + QQQ commenting out is locically correct, but sub-optimal + QQQ Sean McGoogan - 4th April 2003. */ st.q r25, 8, r3 st.q r25, 16, r3 st.q r25, 24, r3 st.q r25, 32, r3 addi r25, 32, r25 - bgeu/l r8, r25, tr1 // loop + bgeu/l r8, r25, tr1 /* loop */ st.q r20, -40, r3 st.q r20, -32, r3 diff --git a/libc/string/sh64/strcpy.S b/libc/string/sh64/strcpy.S index da79d5143..f317707b7 100644 --- a/libc/string/sh64/strcpy.S +++ b/libc/string/sh64/strcpy.S @@ -31,7 +31,7 @@ strcpy: addi r2, 8, r0 mcmpeq.b r4,r63,r6 SHHI r6,r7,r6 - bnei/u r6,0,tr1 // shortstring + bnei/u r6,0,tr1 /* shortstring */ pta/l no_lddst, tr2 ori r3,-8,r23 sub r2, r23, r0 @@ -41,28 +41,28 @@ strcpy: pta/l loop, tr0 ori r2,-8,r22 mcmpeq.b r5, r63, r6 - bgt/u r22, r23, tr2 // no_lddst + bgt/u r22, r23, tr2 /* no_lddst */ - // r22 < r23 : Need to do a load from the destination. - // r22 == r23 : Doesn't actually need to load from destination, - // but still can be handled here. + /* r22 < r23 : Need to do a load from the destination. */ + /* r22 == r23 : Doesn't actually need to load from destination, */ + /* but still can be handled here. */ ldlo.q r2, 0, r9 movi -1, r8 SHLO r8, r7, r8 mcmv r4, r8, r9 stlo.q r2, 0, r9 - beqi/l r6, 0, tr0 // loop + beqi/l r6, 0, tr0 /* loop */ add r5, r63, r4 addi r0, 8, r0 - blink tr1, r63 // shortstring + blink tr1, r63 /* shortstring */ no_lddst: - // r22 > r23: note that for r22 == r23 the sthi.q would clobber - // bytes before the destination region. + /* r22 > r23: note that for r22 == r23 the sthi.q would clobber */ + /* bytes before the destination region. */ stlo.q r2, 0, r4 SHHI r4, r7, r4 sthi.q r0, -1, r4 - beqi/l r6, 0, tr0 // loop + beqi/l r6, 0, tr0 /* loop */ add r5, r63, r4 addi r0, 8, r0 @@ -77,7 +77,7 @@ shortstring2: shlri r4,8,r4 addi r0,1,r0 bnei/l r5,0,tr1 - blink tr4,r63 // return + blink tr4,r63 /* return */ .balign 8 loop: @@ -86,16 +86,16 @@ loop: addi r0, 16, r0 sthi.q r0, -9, r5 mcmpeq.b r4, r63, r6 - bnei/u r6, 0, tr1 // shortstring + bnei/u r6, 0, tr1 /* shortstring */ ldx.q r0, r21, r5 stlo.q r0, -8, r4 sthi.q r0, -1, r4 mcmpeq.b r5, r63, r6 - beqi/l r6, 0, tr0 // loop + beqi/l r6, 0, tr0 /* loop */ add r5, r63, r4 addi r0, 8, r0 - blink tr1, r63 // shortstring + blink tr1, r63 /* shortstring */ .size strcpy,.-strcpy diff --git a/libc/string/xtensa/memcpy.S b/libc/string/xtensa/memcpy.S index 19f3a6818..fc04c023e 100644 --- a/libc/string/xtensa/memcpy.S +++ b/libc/string/xtensa/memcpy.S @@ -83,7 +83,7 @@ __memcpy_aux: loopnez a4, 2f #else beqz a4, 2f - add a7, a3, a4 // a7 = end address for source + add a7, a3, a4 /* a7 = end address for source */ #endif 1: l8ui a6, a3, 0 addi a3, a3, 1 @@ -98,7 +98,7 @@ __memcpy_aux: /* Destination is unaligned. */ .align 4 -.Ldst1mod2: // dst is only byte aligned +.Ldst1mod2: /* dst is only byte aligned */ /* Do short copies byte-by-byte. */ _bltui a4, 7, .Lbytecopy @@ -113,7 +113,7 @@ __memcpy_aux: /* Return to main algorithm if dst is now aligned. */ _bbci.l a5, 1, .Ldstaligned -.Ldst2mod4: // dst has 16-bit alignment +.Ldst2mod4: /* dst has 16-bit alignment */ /* Do short copies byte-by-byte. */ _bltui a4, 6, .Lbytecopy @@ -134,7 +134,7 @@ __memcpy_aux: ENTRY (memcpy) /* a2 = dst, a3 = src, a4 = len */ - mov a5, a2 // copy dst so that a2 is return value + mov a5, a2 /* copy dst so that a2 is return value */ _bbsi.l a2, 0, .Ldst1mod2 _bbsi.l a2, 1, .Ldst2mod4 .Ldstaligned: @@ -152,7 +152,7 @@ ENTRY (memcpy) #else beqz a7, 2f slli a8, a7, 4 - add a8, a8, a3 // a8 = end of last 16B source chunk + add a8, a8, a3 /* a8 = end of last 16B source chunk */ #endif 1: l32i a6, a3, 0 l32i a7, a3, 4 @@ -218,18 +218,18 @@ ENTRY (memcpy) /* Copy 16 bytes per iteration for word-aligned dst and unaligned src. */ - ssa8 a3 // set shift amount from byte offset + ssa8 a3 /* set shift amount from byte offset */ #if UNALIGNED_ADDRESSES_CHECKED - and a11, a3, a8 // save unalignment offset for below - sub a3, a3, a11 // align a3 + and a11, a3, a8 /* save unalignment offset for below */ + sub a3, a3, a11 /* align a3 */ #endif - l32i a6, a3, 0 // load first word + l32i a6, a3, 0 /* load first word */ #if XCHAL_HAVE_LOOPS loopnez a7, 2f #else beqz a7, 2f slli a10, a7, 4 - add a10, a10, a3 // a10 = end of last 16B source chunk + add a10, a10, a3 /* a10 = end of last 16B source chunk */ #endif 1: l32i a7, a3, 4 l32i a8, a3, 8 @@ -273,7 +273,7 @@ ENTRY (memcpy) mov a6, a7 4: #if UNALIGNED_ADDRESSES_CHECKED - add a3, a3, a11 // readjust a3 with correct misalignment + add a3, a3, a11 /* readjust a3 with correct misalignment */ #endif bbsi.l a4, 1, 5f bbsi.l a4, 0, 6f diff --git a/libc/string/xtensa/memset.S b/libc/string/xtensa/memset.S index c0928825d..076b8f001 100644 --- a/libc/string/xtensa/memset.S +++ b/libc/string/xtensa/memset.S @@ -29,7 +29,7 @@ The algorithm is as follows: Create a word with c in all byte positions. - + If the destination is aligned, set 16B chunks with a loop, and then finish up with 8B, 4B, 2B, and 1B stores conditional on the length. @@ -57,7 +57,7 @@ __memset_aux: loopnez a4, 2f #else beqz a4, 2f - add a6, a5, a4 // a6 = ending address + add a6, a5, a4 /* a6 = ending address */ #endif 1: s8i a3, a5, 0 addi a5, a5, 1 @@ -71,7 +71,7 @@ __memset_aux: .align 4 -.Ldst1mod2: // dst is only byte aligned +.Ldst1mod2: /* dst is only byte aligned */ /* Do short sizes byte-by-byte. */ bltui a4, 8, .Lbyteset @@ -84,7 +84,7 @@ __memset_aux: /* Now retest if dst is aligned. */ _bbci.l a5, 1, .Ldstaligned -.Ldst2mod4: // dst has 16-bit alignment +.Ldst2mod4: /* dst has 16-bit alignment */ /* Do short sizes byte-by-byte. */ bltui a4, 8, .Lbyteset @@ -108,7 +108,7 @@ ENTRY (memset) slli a7, a3, 16 or a3, a3, a7 - mov a5, a2 // copy dst so that a2 is return value + mov a5, a2 /* copy dst so that a2 is return value */ /* Check if dst is unaligned. */ _bbsi.l a2, 0, .Ldst1mod2 @@ -124,7 +124,7 @@ ENTRY (memset) #else beqz a7, 2f slli a6, a7, 4 - add a6, a6, a5 // a6 = end of last 16B chunk + add a6, a6, a5 /* a6 = end of last 16B chunk */ #endif /* Set 16 bytes per iteration. */ 1: s32i a3, a5, 0 diff --git a/libc/string/xtensa/strcmp.S b/libc/string/xtensa/strcmp.S index 622bb27ed..ac058a2bf 100644 --- a/libc/string/xtensa/strcmp.S +++ b/libc/string/xtensa/strcmp.S @@ -45,35 +45,35 @@ ENTRY (strcmp) /* a2 = s1, a3 = s2 */ - l8ui a8, a2, 0 // byte 0 from s1 - l8ui a9, a3, 0 // byte 0 from s2 - movi a10, 3 // mask + l8ui a8, a2, 0 /* byte 0 from s1 */ + l8ui a9, a3, 0 /* byte 0 from s2 */ + movi a10, 3 /* mask */ bne a8, a9, .Lretdiff or a11, a2, a3 bnone a11, a10, .Laligned - xor a11, a2, a3 // compare low two bits of s1 and s2 - bany a11, a10, .Lunaligned // if they have different alignment + xor a11, a2, a3 /* compare low two bits of s1 and s2 */ + bany a11, a10, .Lunaligned /* if they have different alignment */ /* s1/s2 are not word-aligned. */ - addi a2, a2, 1 // advance s1 - beqz a8, .Leq // bytes equal, if zero, strings are equal - addi a3, a3, 1 // advance s2 - bnone a2, a10, .Laligned // if s1/s2 now aligned - l8ui a8, a2, 0 // byte 1 from s1 - l8ui a9, a3, 0 // byte 1 from s2 - addi a2, a2, 1 // advance s1 - bne a8, a9, .Lretdiff // if different, return difference - beqz a8, .Leq // bytes equal, if zero, strings are equal - addi a3, a3, 1 // advance s2 - bnone a2, a10, .Laligned // if s1/s2 now aligned - l8ui a8, a2, 0 // byte 2 from s1 - l8ui a9, a3, 0 // byte 2 from s2 - addi a2, a2, 1 // advance s1 - bne a8, a9, .Lretdiff // if different, return difference - beqz a8, .Leq // bytes equal, if zero, strings are equal - addi a3, a3, 1 // advance s2 + addi a2, a2, 1 /* advance s1 */ + beqz a8, .Leq /* bytes equal, if zero, strings are equal */ + addi a3, a3, 1 /* advance s2 */ + bnone a2, a10, .Laligned /* if s1/s2 now aligned */ + l8ui a8, a2, 0 /* byte 1 from s1 */ + l8ui a9, a3, 0 /* byte 1 from s2 */ + addi a2, a2, 1 /* advance s1 */ + bne a8, a9, .Lretdiff /* if different, return difference */ + beqz a8, .Leq /* bytes equal, if zero, strings are equal */ + addi a3, a3, 1 /* advance s2 */ + bnone a2, a10, .Laligned /* if s1/s2 now aligned */ + l8ui a8, a2, 0 /* byte 2 from s1 */ + l8ui a9, a3, 0 /* byte 2 from s2 */ + addi a2, a2, 1 /* advance s1 */ + bne a8, a9, .Lretdiff /* if different, return difference */ + beqz a8, .Leq /* bytes equal, if zero, strings are equal */ + addi a3, a3, 1 /* advance s2 */ j .Laligned /* s1 and s2 have different alignment. @@ -92,8 +92,8 @@ ENTRY (strcmp) /* (2 mod 4) alignment for loop instruction */ .Lunaligned: #if XCHAL_HAVE_LOOPS - _movi.n a8, 0 // set up for the maximum loop count - loop a8, .Lretdiff // loop forever (almost anyway) + _movi.n a8, 0 /* set up for the maximum loop count */ + loop a8, .Lretdiff /* loop forever (almost anyway) */ #endif .Lnextbyte: l8ui a8, a2, 0 @@ -131,32 +131,32 @@ ENTRY (strcmp) #if XCHAL_HAVE_LOOPS .Laligned: .begin no-transform - l32r a4, .Lmask0 // mask for byte 0 + l32r a4, .Lmask0 /* mask for byte 0 */ l32r a7, .Lmask4 /* Loop forever. (a4 is more than than the maximum number of iterations) */ loop a4, .Laligned_done /* First unrolled loop body. */ - l32i a8, a2, 0 // get word from s1 - l32i a9, a3, 0 // get word from s2 + l32i a8, a2, 0 /* get word from s1 */ + l32i a9, a3, 0 /* get word from s2 */ slli a5, a8, 1 bne a8, a9, .Lwne2 or a9, a8, a5 bnall a9, a7, .Lprobeq /* Second unrolled loop body. */ - l32i a8, a2, 4 // get word from s1+4 - l32i a9, a3, 4 // get word from s2+4 + l32i a8, a2, 4 /* get word from s1+4 */ + l32i a9, a3, 4 /* get word from s2+4 */ slli a5, a8, 1 bne a8, a9, .Lwne2 or a9, a8, a5 bnall a9, a7, .Lprobeq2 - addi a2, a2, 8 // advance s1 pointer - addi a3, a3, 8 // advance s2 pointer + addi a2, a2, 8 /* advance s1 pointer */ + addi a3, a3, 8 /* advance s2 pointer */ .Laligned_done: - or a1, a1, a1 // nop + or a1, a1, a1 /* nop */ .Lprobeq2: /* Adjust pointers to account for the loop unrolling. */ @@ -166,15 +166,15 @@ ENTRY (strcmp) #else /* !XCHAL_HAVE_LOOPS */ .Laligned: - movi a4, MASK0 // mask for byte 0 + movi a4, MASK0 /* mask for byte 0 */ movi a7, MASK4 j .Lfirstword .Lnextword: - addi a2, a2, 4 // advance s1 pointer - addi a3, a3, 4 // advance s2 pointer + addi a2, a2, 4 /* advance s1 pointer */ + addi a3, a3, 4 /* advance s2 pointer */ .Lfirstword: - l32i a8, a2, 0 // get word from s1 - l32i a9, a3, 0 // get word from s2 + l32i a8, a2, 0 /* get word from s1 */ + l32i a9, a3, 0 /* get word from s2 */ slli a5, a8, 1 bne a8, a9, .Lwne2 or a9, a8, a5 @@ -186,49 +186,49 @@ ENTRY (strcmp) /* Words are probably equal, but check for sure. If not, loop over the rest of string using normal algorithm. */ - bnone a8, a4, .Leq // if byte 0 is zero - l32r a5, .Lmask1 // mask for byte 1 - l32r a6, .Lmask2 // mask for byte 2 - bnone a8, a5, .Leq // if byte 1 is zero - l32r a7, .Lmask3 // mask for byte 3 - bnone a8, a6, .Leq // if byte 2 is zero - bnone a8, a7, .Leq // if byte 3 is zero - addi.n a2, a2, 4 // advance s1 pointer - addi.n a3, a3, 4 // advance s2 pointer + bnone a8, a4, .Leq /* if byte 0 is zero */ + l32r a5, .Lmask1 /* mask for byte 1 */ + l32r a6, .Lmask2 /* mask for byte 2 */ + bnone a8, a5, .Leq /* if byte 1 is zero */ + l32r a7, .Lmask3 /* mask for byte 3 */ + bnone a8, a6, .Leq /* if byte 2 is zero */ + bnone a8, a7, .Leq /* if byte 3 is zero */ + addi.n a2, a2, 4 /* advance s1 pointer */ + addi.n a3, a3, 4 /* advance s2 pointer */ #if XCHAL_HAVE_LOOPS /* align (1 mod 4) */ - loop a4, .Leq // loop forever (a4 is bigger than max iters) + loop a4, .Leq /* loop forever (a4 is bigger than max iters) */ .end no-transform - l32i a8, a2, 0 // get word from s1 - l32i a9, a3, 0 // get word from s2 - addi a2, a2, 4 // advance s1 pointer + l32i a8, a2, 0 /* get word from s1 */ + l32i a9, a3, 0 /* get word from s2 */ + addi a2, a2, 4 /* advance s1 pointer */ bne a8, a9, .Lwne - bnone a8, a4, .Leq // if byte 0 is zero - bnone a8, a5, .Leq // if byte 1 is zero - bnone a8, a6, .Leq // if byte 2 is zero - bnone a8, a7, .Leq // if byte 3 is zero - addi a3, a3, 4 // advance s2 pointer + bnone a8, a4, .Leq /* if byte 0 is zero */ + bnone a8, a5, .Leq /* if byte 1 is zero */ + bnone a8, a6, .Leq /* if byte 2 is zero */ + bnone a8, a7, .Leq /* if byte 3 is zero */ + addi a3, a3, 4 /* advance s2 pointer */ #else /* !XCHAL_HAVE_LOOPS */ j .Lfirstword2 .Lnextword2: - addi a3, a3, 4 // advance s2 pointer + addi a3, a3, 4 /* advance s2 pointer */ .Lfirstword2: - l32i a8, a2, 0 // get word from s1 - l32i a9, a3, 0 // get word from s2 - addi a2, a2, 4 // advance s1 pointer + l32i a8, a2, 0 /* get word from s1 */ + l32i a9, a3, 0 /* get word from s2 */ + addi a2, a2, 4 /* advance s1 pointer */ bne a8, a9, .Lwne - bnone a8, a4, .Leq // if byte 0 is zero - bnone a8, a5, .Leq // if byte 1 is zero - bnone a8, a6, .Leq // if byte 2 is zero - bany a8, a7, .Lnextword2 // if byte 3 is zero + bnone a8, a4, .Leq /* if byte 0 is zero */ + bnone a8, a5, .Leq /* if byte 1 is zero */ + bnone a8, a6, .Leq /* if byte 2 is zero */ + bany a8, a7, .Lnextword2 /* if byte 3 is zero */ #endif /* !XCHAL_HAVE_LOOPS */ /* Words are equal; some byte is zero. */ -.Leq: movi a2, 0 // return equal +.Leq: movi a2, 0 /* return equal */ retw .Lwne2: /* Words are not equal. On big-endian processors, if none of the @@ -243,18 +243,18 @@ ENTRY (strcmp) .Lposreturn: movi a2, 1 retw -.Lsomezero: // There is probably some zero byte. +.Lsomezero: /* There is probably some zero byte. */ #endif /* __XTENSA_EB__ */ .Lwne: /* Words are not equal. */ - xor a2, a8, a9 // get word with nonzero in byte that differs - bany a2, a4, .Ldiff0 // if byte 0 differs - movi a5, MASK1 // mask for byte 1 - bnone a8, a4, .Leq // if byte 0 is zero - bany a2, a5, .Ldiff1 // if byte 1 differs - movi a6, MASK2 // mask for byte 2 - bnone a8, a5, .Leq // if byte 1 is zero - bany a2, a6, .Ldiff2 // if byte 2 differs - bnone a8, a6, .Leq // if byte 2 is zero + xor a2, a8, a9 /* get word with nonzero in byte that differs */ + bany a2, a4, .Ldiff0 /* if byte 0 differs */ + movi a5, MASK1 /* mask for byte 1 */ + bnone a8, a4, .Leq /* if byte 0 is zero */ + bany a2, a5, .Ldiff1 /* if byte 1 differs */ + movi a6, MASK2 /* mask for byte 2 */ + bnone a8, a5, .Leq /* if byte 1 is zero */ + bany a2, a6, .Ldiff2 /* if byte 2 differs */ + bnone a8, a6, .Leq /* if byte 2 is zero */ #ifdef __XTENSA_EB__ .Ldiff3: .Ldiff2: diff --git a/libc/string/xtensa/strcpy.S b/libc/string/xtensa/strcpy.S index 108070384..dc0a15175 100644 --- a/libc/string/xtensa/strcpy.S +++ b/libc/string/xtensa/strcpy.S @@ -36,7 +36,7 @@ ENTRY (strcpy) /* a2 = dst, a3 = src */ - mov a10, a2 // leave dst in return value register + mov a10, a2 /* leave dst in return value register */ movi a4, MASK0 movi a5, MASK1 movi a6, MASK2 @@ -51,23 +51,23 @@ ENTRY (strcpy) j .Ldstunaligned -.Lsrc1mod2: // src address is odd - l8ui a8, a3, 0 // get byte 0 - addi a3, a3, 1 // advance src pointer - s8i a8, a10, 0 // store byte 0 - beqz a8, 1f // if byte 0 is zero - addi a10, a10, 1 // advance dst pointer - bbci.l a3, 1, .Lsrcaligned // if src is now word-aligned +.Lsrc1mod2: /* src address is odd */ + l8ui a8, a3, 0 /* get byte 0 */ + addi a3, a3, 1 /* advance src pointer */ + s8i a8, a10, 0 /* store byte 0 */ + beqz a8, 1f /* if byte 0 is zero */ + addi a10, a10, 1 /* advance dst pointer */ + bbci.l a3, 1, .Lsrcaligned /* if src is now word-aligned */ -.Lsrc2mod4: // src address is 2 mod 4 - l8ui a8, a3, 0 // get byte 0 +.Lsrc2mod4: /* src address is 2 mod 4 */ + l8ui a8, a3, 0 /* get byte 0 */ /* 1-cycle interlock */ - s8i a8, a10, 0 // store byte 0 - beqz a8, 1f // if byte 0 is zero - l8ui a8, a3, 1 // get byte 0 - addi a3, a3, 2 // advance src pointer - s8i a8, a10, 1 // store byte 0 - addi a10, a10, 2 // advance dst pointer + s8i a8, a10, 0 /* store byte 0 */ + beqz a8, 1f /* if byte 0 is zero */ + l8ui a8, a3, 1 /* get byte 0 */ + addi a3, a3, 2 /* advance src pointer */ + s8i a8, a10, 1 /* store byte 0 */ + addi a10, a10, 2 /* advance dst pointer */ bnez a8, .Lsrcaligned 1: retw @@ -78,28 +78,28 @@ ENTRY (strcpy) #if XCHAL_HAVE_LOOPS /* (2 mod 4) alignment for loop instruction */ .Laligned: - _movi.n a8, 0 // set up for the maximum loop count - loop a8, .Lz3 // loop forever (almost anyway) - l32i a8, a3, 0 // get word from src - addi a3, a3, 4 // advance src pointer - bnone a8, a4, .Lz0 // if byte 0 is zero - bnone a8, a5, .Lz1 // if byte 1 is zero - bnone a8, a6, .Lz2 // if byte 2 is zero - s32i a8, a10, 0 // store word to dst - bnone a8, a7, .Lz3 // if byte 3 is zero - addi a10, a10, 4 // advance dst pointer + _movi.n a8, 0 /* set up for the maximum loop count */ + loop a8, .Lz3 /* loop forever (almost anyway) */ + l32i a8, a3, 0 /* get word from src */ + addi a3, a3, 4 /* advance src pointer */ + bnone a8, a4, .Lz0 /* if byte 0 is zero */ + bnone a8, a5, .Lz1 /* if byte 1 is zero */ + bnone a8, a6, .Lz2 /* if byte 2 is zero */ + s32i a8, a10, 0 /* store word to dst */ + bnone a8, a7, .Lz3 /* if byte 3 is zero */ + addi a10, a10, 4 /* advance dst pointer */ #else /* !XCHAL_HAVE_LOOPS */ -1: addi a10, a10, 4 // advance dst pointer +1: addi a10, a10, 4 /* advance dst pointer */ .Laligned: - l32i a8, a3, 0 // get word from src - addi a3, a3, 4 // advance src pointer - bnone a8, a4, .Lz0 // if byte 0 is zero - bnone a8, a5, .Lz1 // if byte 1 is zero - bnone a8, a6, .Lz2 // if byte 2 is zero - s32i a8, a10, 0 // store word to dst - bany a8, a7, 1b // if byte 3 is zero + l32i a8, a3, 0 /* get word from src */ + addi a3, a3, 4 /* advance src pointer */ + bnone a8, a4, .Lz0 /* if byte 0 is zero */ + bnone a8, a5, .Lz1 /* if byte 1 is zero */ + bnone a8, a6, .Lz2 /* if byte 2 is zero */ + s32i a8, a10, 0 /* store word to dst */ + bany a8, a7, 1b /* if byte 3 is zero */ #endif /* !XCHAL_HAVE_LOOPS */ .Lz3: /* Byte 3 is zero. */ @@ -133,8 +133,8 @@ ENTRY (strcpy) .Ldstunaligned: #if XCHAL_HAVE_LOOPS - _movi.n a8, 0 // set up for the maximum loop count - loop a8, 2f // loop forever (almost anyway) + _movi.n a8, 0 /* set up for the maximum loop count */ + loop a8, 2f /* loop forever (almost anyway) */ #endif 1: l8ui a8, a3, 0 addi a3, a3, 1 diff --git a/libc/string/xtensa/strlen.S b/libc/string/xtensa/strlen.S index dd72c16fa..9ee4995f4 100644 --- a/libc/string/xtensa/strlen.S +++ b/libc/string/xtensa/strlen.S @@ -36,7 +36,7 @@ ENTRY (strlen) /* a2 = s */ - addi a3, a2, -4 // because we overincrement at the end + addi a3, a2, -4 /* because we overincrement at the end */ movi a4, MASK0 movi a5, MASK1 movi a6, MASK2 @@ -45,21 +45,21 @@ ENTRY (strlen) bbsi.l a2, 1, .L2mod4 j .Laligned -.L1mod2: // address is odd - l8ui a8, a3, 4 // get byte 0 - addi a3, a3, 1 // advance string pointer - beqz a8, .Lz3 // if byte 0 is zero - bbci.l a3, 1, .Laligned // if string pointer is now word-aligned +.L1mod2: /* address is odd */ + l8ui a8, a3, 4 /* get byte 0 */ + addi a3, a3, 1 /* advance string pointer */ + beqz a8, .Lz3 /* if byte 0 is zero */ + bbci.l a3, 1, .Laligned /* if string pointer is now word-aligned */ -.L2mod4: // address is 2 mod 4 - addi a3, a3, 2 // advance ptr for aligned access - l32i a8, a3, 0 // get word with first two bytes of string - bnone a8, a6, .Lz2 // if byte 2 (of word, not string) is zero - bany a8, a7, .Laligned // if byte 3 (of word, not string) is nonzero +.L2mod4: /* address is 2 mod 4 */ + addi a3, a3, 2 /* advance ptr for aligned access */ + l32i a8, a3, 0 /* get word with first two bytes of string */ + bnone a8, a6, .Lz2 /* if byte 2 (of word, not string) is zero */ + bany a8, a7, .Laligned /* if byte 3 (of word, not string) is nonzero */ /* Byte 3 is zero. */ - addi a3, a3, 3 // point to zero byte - sub a2, a3, a2 // subtract to get length + addi a3, a3, 3 /* point to zero byte */ + sub a2, a3, a2 /* subtract to get length */ retw @@ -69,36 +69,36 @@ ENTRY (strlen) /* (2 mod 4) alignment for loop instruction */ .Laligned: #if XCHAL_HAVE_LOOPS - _movi.n a8, 0 // set up for the maximum loop count - loop a8, .Lz3 // loop forever (almost anyway) + _movi.n a8, 0 /* set up for the maximum loop count */ + loop a8, .Lz3 /* loop forever (almost anyway) */ #endif -1: l32i a8, a3, 4 // get next word of string - addi a3, a3, 4 // advance string pointer - bnone a8, a4, .Lz0 // if byte 0 is zero - bnone a8, a5, .Lz1 // if byte 1 is zero - bnone a8, a6, .Lz2 // if byte 2 is zero +1: l32i a8, a3, 4 /* get next word of string */ + addi a3, a3, 4 /* advance string pointer */ + bnone a8, a4, .Lz0 /* if byte 0 is zero */ + bnone a8, a5, .Lz1 /* if byte 1 is zero */ + bnone a8, a6, .Lz2 /* if byte 2 is zero */ #if XCHAL_HAVE_LOOPS - bnone a8, a7, .Lz3 // if byte 3 is zero + bnone a8, a7, .Lz3 /* if byte 3 is zero */ #else - bany a8, a7, 1b // repeat if byte 3 is non-zero + bany a8, a7, 1b /* repeat if byte 3 is non-zero */ #endif .Lz3: /* Byte 3 is zero. */ - addi a3, a3, 3 // point to zero byte + addi a3, a3, 3 /* point to zero byte */ /* Fall through.... */ .Lz0: /* Byte 0 is zero. */ - sub a2, a3, a2 // subtract to get length + sub a2, a3, a2 /* subtract to get length */ retw .Lz1: /* Byte 1 is zero. */ - addi a3, a3, 1 // point to zero byte - sub a2, a3, a2 // subtract to get length + addi a3, a3, 1 /* point to zero byte */ + sub a2, a3, a2 /* subtract to get length */ retw .Lz2: /* Byte 2 is zero. */ - addi a3, a3, 2 // point to zero byte - sub a2, a3, a2 // subtract to get length + addi a3, a3, 2 /* point to zero byte */ + sub a2, a3, a2 /* subtract to get length */ retw libc_hidden_def (strlen) diff --git a/libc/string/xtensa/strncpy.S b/libc/string/xtensa/strncpy.S index 7ba2ef77d..fe3ec894c 100644 --- a/libc/string/xtensa/strncpy.S +++ b/libc/string/xtensa/strncpy.S @@ -41,29 +41,29 @@ .literal_position __strncpy_aux: -.Lsrc1mod2: // src address is odd - l8ui a8, a3, 0 // get byte 0 - addi a3, a3, 1 // advance src pointer - s8i a8, a10, 0 // store byte 0 - addi a4, a4, -1 // decrement n - beqz a4, .Lret // if n is zero - addi a10, a10, 1 // advance dst pointer - beqz a8, .Lfill // if byte 0 is zero - bbci.l a3, 1, .Lsrcaligned // if src is now word-aligned - -.Lsrc2mod4: // src address is 2 mod 4 - l8ui a8, a3, 0 // get byte 0 - addi a4, a4, -1 // decrement n - s8i a8, a10, 0 // store byte 0 - beqz a4, .Lret // if n is zero - addi a10, a10, 1 // advance dst pointer - beqz a8, .Lfill // if byte 0 is zero - l8ui a8, a3, 1 // get byte 0 - addi a3, a3, 2 // advance src pointer - s8i a8, a10, 0 // store byte 0 - addi a4, a4, -1 // decrement n - beqz a4, .Lret // if n is zero - addi a10, a10, 1 // advance dst pointer +.Lsrc1mod2: /* src address is odd */ + l8ui a8, a3, 0 /* get byte 0 */ + addi a3, a3, 1 /* advance src pointer */ + s8i a8, a10, 0 /* store byte 0 */ + addi a4, a4, -1 /* decrement n */ + beqz a4, .Lret /* if n is zero */ + addi a10, a10, 1 /* advance dst pointer */ + beqz a8, .Lfill /* if byte 0 is zero */ + bbci.l a3, 1, .Lsrcaligned /* if src is now word-aligned */ + +.Lsrc2mod4: /* src address is 2 mod 4 */ + l8ui a8, a3, 0 /* get byte 0 */ + addi a4, a4, -1 /* decrement n */ + s8i a8, a10, 0 /* store byte 0 */ + beqz a4, .Lret /* if n is zero */ + addi a10, a10, 1 /* advance dst pointer */ + beqz a8, .Lfill /* if byte 0 is zero */ + l8ui a8, a3, 1 /* get byte 0 */ + addi a3, a3, 2 /* advance src pointer */ + s8i a8, a10, 0 /* store byte 0 */ + addi a4, a4, -1 /* decrement n */ + beqz a4, .Lret /* if n is zero */ + addi a10, a10, 1 /* advance dst pointer */ bnez a8, .Lsrcaligned j .Lfill @@ -74,8 +74,8 @@ __strncpy_aux: ENTRY (strncpy) /* a2 = dst, a3 = src */ - mov a10, a2 // leave dst in return value register - beqz a4, .Lret // if n is zero + mov a10, a2 /* leave dst in return value register */ + beqz a4, .Lret /* if n is zero */ movi a11, MASK0 movi a5, MASK1 @@ -125,28 +125,28 @@ ENTRY (strncpy) .Lfillcleanup: /* Fill leftover (1 to 3) bytes with zero. */ - s8i a9, a10, 0 // store byte 0 - addi a4, a4, -1 // decrement n + s8i a9, a10, 0 /* store byte 0 */ + addi a4, a4, -1 /* decrement n */ addi a10, a10, 1 - bnez a4, .Lfillcleanup + bnez a4, .Lfillcleanup 2: retw - -.Lfill1mod2: // dst address is odd - s8i a9, a10, 0 // store byte 0 - addi a4, a4, -1 // decrement n - beqz a4, 2b // if n is zero - addi a10, a10, 1 // advance dst pointer - bbci.l a10, 1, .Lfillaligned // if dst is now word-aligned - -.Lfill2mod4: // dst address is 2 mod 4 - s8i a9, a10, 0 // store byte 0 - addi a4, a4, -1 // decrement n - beqz a4, 2b // if n is zero - s8i a9, a10, 1 // store byte 1 - addi a4, a4, -1 // decrement n - beqz a4, 2b // if n is zero - addi a10, a10, 2 // advance dst pointer + +.Lfill1mod2: /* dst address is odd */ + s8i a9, a10, 0 /* store byte 0 */ + addi a4, a4, -1 /* decrement n */ + beqz a4, 2b /* if n is zero */ + addi a10, a10, 1 /* advance dst pointer */ + bbci.l a10, 1, .Lfillaligned /* if dst is now word-aligned */ + +.Lfill2mod4: /* dst address is 2 mod 4 */ + s8i a9, a10, 0 /* store byte 0 */ + addi a4, a4, -1 /* decrement n */ + beqz a4, 2b /* if n is zero */ + s8i a9, a10, 1 /* store byte 1 */ + addi a4, a4, -1 /* decrement n */ + beqz a4, 2b /* if n is zero */ + addi a10, a10, 2 /* advance dst pointer */ j .Lfillaligned @@ -156,32 +156,32 @@ ENTRY (strncpy) /* (2 mod 4) alignment for loop instruction */ .Laligned: #if XCHAL_HAVE_LOOPS - _movi.n a8, 0 // set up for the maximum loop count - loop a8, 1f // loop forever (almost anyway) - blti a4, 5, .Ldstunaligned // n is near limit; do one at a time - l32i a8, a3, 0 // get word from src - addi a3, a3, 4 // advance src pointer - bnone a8, a11, .Lz0 // if byte 0 is zero - bnone a8, a5, .Lz1 // if byte 1 is zero - bnone a8, a6, .Lz2 // if byte 2 is zero - s32i a8, a10, 0 // store word to dst - addi a4, a4, -4 // decrement n - addi a10, a10, 4 // advance dst pointer - bnone a8, a7, .Lfill // if byte 3 is zero -1: + _movi.n a8, 0 /* set up for the maximum loop count */ + loop a8, 1f /* loop forever (almost anyway) */ + blti a4, 5, .Ldstunaligned /* n is near limit; do one at a time */ + l32i a8, a3, 0 /* get word from src */ + addi a3, a3, 4 /* advance src pointer */ + bnone a8, a11, .Lz0 /* if byte 0 is zero */ + bnone a8, a5, .Lz1 /* if byte 1 is zero */ + bnone a8, a6, .Lz2 /* if byte 2 is zero */ + s32i a8, a10, 0 /* store word to dst */ + addi a4, a4, -4 /* decrement n */ + addi a10, a10, 4 /* advance dst pointer */ + bnone a8, a7, .Lfill /* if byte 3 is zero */ +1: #else /* !XCHAL_HAVE_LOOPS */ -1: blti a4, 5, .Ldstunaligned // n is near limit; do one at a time - l32i a8, a3, 0 // get word from src - addi a3, a3, 4 // advance src pointer - bnone a8, a11, .Lz0 // if byte 0 is zero - bnone a8, a5, .Lz1 // if byte 1 is zero - bnone a8, a6, .Lz2 // if byte 2 is zero - s32i a8, a10, 0 // store word to dst - addi a4, a4, -4 // decrement n - addi a10, a10, 4 // advance dst pointer - bany a8, a7, 1b // no zeroes +1: blti a4, 5, .Ldstunaligned /* n is near limit; do one at a time */ + l32i a8, a3, 0 /* get word from src */ + addi a3, a3, 4 /* advance src pointer */ + bnone a8, a11, .Lz0 /* if byte 0 is zero */ + bnone a8, a5, .Lz1 /* if byte 1 is zero */ + bnone a8, a6, .Lz2 /* if byte 2 is zero */ + s32i a8, a10, 0 /* store word to dst */ + addi a4, a4, -4 /* decrement n */ + addi a10, a10, 4 /* advance dst pointer */ + bany a8, a7, 1b /* no zeroes */ #endif /* !XCHAL_HAVE_LOOPS */ j .Lfill @@ -191,8 +191,8 @@ ENTRY (strncpy) movi a8, 0 #endif s8i a8, a10, 0 - addi a4, a4, -1 // decrement n - addi a10, a10, 1 // advance dst pointer + addi a4, a4, -1 /* decrement n */ + addi a10, a10, 1 /* advance dst pointer */ j .Lfill .Lz1: /* Byte 1 is zero. */ @@ -200,8 +200,8 @@ ENTRY (strncpy) extui a8, a8, 16, 16 #endif s16i a8, a10, 0 - addi a4, a4, -2 // decrement n - addi a10, a10, 2 // advance dst pointer + addi a4, a4, -2 /* decrement n */ + addi a10, a10, 2 /* advance dst pointer */ j .Lfill .Lz2: /* Byte 2 is zero. */ @@ -211,8 +211,8 @@ ENTRY (strncpy) s16i a8, a10, 0 movi a8, 0 s8i a8, a10, 2 - addi a4, a4, -3 // decrement n - addi a10, a10, 3 // advance dst pointer + addi a4, a4, -3 /* decrement n */ + addi a10, a10, 3 /* advance dst pointer */ j .Lfill .align 4 @@ -220,8 +220,8 @@ ENTRY (strncpy) .Ldstunaligned: #if XCHAL_HAVE_LOOPS - _movi.n a8, 0 // set up for the maximum loop count - loop a8, 2f // loop forever (almost anyway) + _movi.n a8, 0 /* set up for the maximum loop count */ + loop a8, 2f /* loop forever (almost anyway) */ #endif 1: l8ui a8, a3, 0 addi a3, a3, 1 diff --git a/libc/sysdeps/linux/bfin/__longjmp.S b/libc/sysdeps/linux/bfin/__longjmp.S index 418d591e2..673cd30e8 100644 --- a/libc/sysdeps/linux/bfin/__longjmp.S +++ b/libc/sysdeps/linux/bfin/__longjmp.S @@ -15,7 +15,7 @@ ___longjmp: P0 = R0; R0 = [P0 + 0x00]; - [--SP] = R0; // Put P0 on the stack + [--SP] = R0; /* Put P0 on the stack */ P1 = [P0 + 0x04]; P2 = [P0 + 0x08]; @@ -24,12 +24,12 @@ ___longjmp: P5 = [P0 + 0x14]; FP = [P0 + 0x18]; - R0 = [SP++]; // Grab P0 from old stack - SP = [P0 + 0x1C]; // Update Stack Pointer - [--SP] = R0; // Put P0 on new stack - [--SP] = R1; // Put VAL arg on new stack + R0 = [SP++]; /* Grab P0 from old stack */ + SP = [P0 + 0x1C]; /* Update Stack Pointer */ + [--SP] = R0; /* Put P0 on new stack */ + [--SP] = R1; /* Put VAL arg on new stack */ - R0 = [P0 + 0x20]; // Data Registers + R0 = [P0 + 0x20]; /* Data Registers */ R1 = [P0 + 0x24]; R2 = [P0 + 0x28]; R3 = [P0 + 0x2C]; @@ -41,12 +41,12 @@ ___longjmp: R0 = [P0 + 0x40]; ASTAT = R0; - R0 = [P0 + 0x44]; // Loop Counters + R0 = [P0 + 0x44]; /* Loop Counters */ LC0 = R0; R0 = [P0 + 0x48]; LC1 = R0; - R0 = [P0 + 0x4C]; // Accumulators + R0 = [P0 + 0x4C]; /* Accumulators */ A0.W = R0; R0 = [P0 + 0x50]; A0.X = R0; @@ -55,7 +55,7 @@ ___longjmp: R0 = [P0 + 0x58]; A1.X = R0; - R0 = [P0 + 0x5C]; // Index Registers + R0 = [P0 + 0x5C]; /* Index Registers */ I0 = R0; R0 = [P0 + 0x60]; I1 = R0; @@ -64,7 +64,7 @@ ___longjmp: R0 = [P0 + 0x68]; I3 = R0; - R0 = [P0 + 0x6C]; // Modifier Registers + R0 = [P0 + 0x6C]; /* Modifier Registers */ M0 = R0; R0 = [P0 + 0x70]; M1 = R0; @@ -73,7 +73,7 @@ ___longjmp: R0 = [P0 + 0x78]; M3 = R0; - R0 = [P0 + 0x7C]; // Length Registers + R0 = [P0 + 0x7C]; /* Length Registers */ L0 = R0; R0 = [P0 + 0x80]; L1 = R0; @@ -82,7 +82,7 @@ ___longjmp: R0 = [P0 + 0x88]; L3 = R0; - R0 = [P0 + 0x8C]; // Base Registers + R0 = [P0 + 0x8C]; /* Base Registers */ B0 = R0; R0 = [P0 + 0x90]; B1 = R0; @@ -91,7 +91,7 @@ ___longjmp: R0 = [P0 + 0x98]; B3 = R0; - R0 = [P0 + 0x9C]; // Return Address (PC) + R0 = [P0 + 0x9C]; /* Return Address (PC) */ RETS = R0; R0 = [SP++]; diff --git a/libc/sysdeps/linux/bfin/bsd-_setjmp.S b/libc/sysdeps/linux/bfin/bsd-_setjmp.S index 8ca2bbec9..61cb53f06 100644 --- a/libc/sysdeps/linux/bfin/bsd-_setjmp.S +++ b/libc/sysdeps/linux/bfin/bsd-_setjmp.S @@ -12,20 +12,20 @@ .align 4; __setjmp: - [--SP] = P0; // Save P0 + [--SP] = P0; /* Save P0 */ P0 = R0; R0 = [SP++]; - [P0 + 0x00] = R0; // Save saved P0 + [P0 + 0x00] = R0; /* Save saved P0 */ [P0 + 0x04] = P1; [P0 + 0x08] = P2; [P0 + 0x0C] = P3; [P0 + 0x10] = P4; [P0 + 0x14] = P5; - [P0 + 0x18] = FP; // Frame Pointer - [P0 + 0x1C] = SP; // Stack Pointer + [P0 + 0x18] = FP; /* Frame Pointer */ + [P0 + 0x1C] = SP; /* Stack Pointer */ - [P0 + 0x20] = P0; // Data Registers + [P0 + 0x20] = P0; /* Data Registers */ [P0 + 0x24] = R1; [P0 + 0x28] = R2; [P0 + 0x2C] = R3; @@ -37,12 +37,12 @@ __setjmp: R0 = ASTAT; [P0 + 0x40] = R0; - R0 = LC0; // Loop Counters + R0 = LC0; /* Loop Counters */ [P0 + 0x44] = R0; R0 = LC1; [P0 + 0x48] = R0; - R0 = A0.W; // Accumulators + R0 = A0.W; /* Accumulators */ [P0 + 0x4C] = R0; R0 = A0.X; [P0 + 0x50] = R0; @@ -51,7 +51,7 @@ __setjmp: R0 = A1.X; [P0 + 0x58] = R0; - R0 = I0; // Index Registers + R0 = I0; /* Index Registers */ [P0 + 0x5C] = R0; R0 = I1; [P0 + 0x60] = R0; @@ -60,7 +60,7 @@ __setjmp: R0 = I3; [P0 + 0x68] = R0; - R0 = M0; // Modifier Registers + R0 = M0; /* Modifier Registers */ [P0 + 0x6C] = R0; R0 = M1; [P0 + 0x70] = R0; @@ -69,7 +69,7 @@ __setjmp: R0 = M3; [P0 + 0x78] = R0; - R0 = L0; // Length Registers + R0 = L0; /* Length Registers */ [P0 + 0x7c] = R0; R0 = L1; [P0 + 0x80] = R0; @@ -78,7 +78,7 @@ __setjmp: R0 = L3; [P0 + 0x88] = R0; - R0 = B0; // Base Registers + R0 = B0; /* Base Registers */ [P0 + 0x8C] = R0; R0 = B1; [P0 + 0x90] = R0; diff --git a/libc/sysdeps/linux/common/bits/uClibc_errno.h b/libc/sysdeps/linux/common/bits/uClibc_errno.h index 631e10c50..9c1561841 100644 --- a/libc/sysdeps/linux/common/bits/uClibc_errno.h +++ b/libc/sysdeps/linux/common/bits/uClibc_errno.h @@ -9,7 +9,7 @@ #ifdef IS_IN_rtld # undef errno # define errno _dl_errno -extern int _dl_errno; // attribute_hidden; +extern int _dl_errno; /* attribute_hidden; */ #elif defined __UCLIBC_HAS_THREADS__ # include <tls.h> # if defined USE___THREAD && USE___THREAD diff --git a/libc/sysdeps/linux/common/llseek.c b/libc/sysdeps/linux/common/llseek.c index 35365d8ae..e933923de 100644 --- a/libc/sysdeps/linux/common/llseek.c +++ b/libc/sysdeps/linux/common/llseek.c @@ -40,4 +40,4 @@ loff_t __libc_lseek64(int fd, loff_t offset, int whence) libc_hidden_proto(lseek64) weak_alias(__libc_lseek64,lseek64) libc_hidden_weak(lseek64) -//strong_alias(__libc_lseek64,_llseek) +/*strong_alias(__libc_lseek64,_llseek) */ diff --git a/libc/sysdeps/linux/e1/crt1.c b/libc/sysdeps/linux/e1/crt1.c index 1e1c8be8e..dd8ed6a26 100644 --- a/libc/sysdeps/linux/e1/crt1.c +++ b/libc/sysdeps/linux/e1/crt1.c @@ -26,7 +26,7 @@ * is linking when the main() function is in a static library (.a) * we can be sure that main() actually gets linked in */ extern void main(int argc,void *argv,void *envp); -//void (*mainp)(int argc,void *argv,void *envp) = main; +/* void (*mainp)(int argc,void *argv,void *envp) = main; */ void __uClibc_main(int argc,void *argv,void *envp); diff --git a/libc/sysdeps/linux/ia64/__longjmp.S b/libc/sysdeps/linux/ia64/__longjmp.S index 04c51e75e..85fe93638 100644 --- a/libc/sysdeps/linux/ia64/__longjmp.S +++ b/libc/sysdeps/linux/ia64/__longjmp.S @@ -44,18 +44,18 @@ LEAF(__longjmp) alloc r8=ar.pfs,2,1,0,0 mov r27=ar.rsc - add r2=0x98,in0 // r2 <- &jmpbuf.orig_jmp_buf_addr + add r2=0x98,in0 /* r2 <- &jmpbuf.orig_jmp_buf_addr */ ;; - ld8 r8=[r2],-16 // r8 <- orig_jmp_buf_addr + ld8 r8=[r2],-16 /* r8 <- orig_jmp_buf_addr */ mov r10=ar.bsp - and r11=~0x3,r27 // clear ar.rsc.mode + and r11=~0x3,r27 /* clear ar.rsc.mode */ ;; - flushrs // flush dirty regs to backing store (must be first in insn grp) - ld8 r23=[r2],8 // r23 <- jmpbuf.ar_bsp - sub r8=r8,in0 // r8 <- &orig_jmpbuf - &jmpbuf + flushrs /* flush dirty regs to backing store (must be first in insn grp) */ + ld8 r23=[r2],8 /* r23 <- jmpbuf.ar_bsp */ + sub r8=r8,in0 /* r8 <- &orig_jmpbuf - &jmpbuf */ ;; - ld8 r25=[r2] // r25 <- jmpbuf.ar_unat - extr.u r8=r8,3,6 // r8 <- (&orig_jmpbuf - &jmpbuf)/8 & 0x3f + ld8 r25=[r2] /* r25 <- jmpbuf.ar_unat */ + extr.u r8=r8,3,6 /* r8 <- (&orig_jmpbuf - &jmpbuf)/8 & 0x3f */ ;; cmp.lt pNeg,pPos=r8,r0 mov r2=in0 @@ -65,49 +65,49 @@ LEAF(__longjmp) (pPos) sub r17=64,r8 (pNeg) sub r17=r0,r8 ;; - mov ar.rsc=r11 // put RSE in enforced lazy mode + mov ar.rsc=r11 /* put RSE in enforced lazy mode */ shr.u r8=r25,r16 - add r3=8,in0 // r3 <- &jmpbuf.r1 + add r3=8,in0 /* r3 <- &jmpbuf.r1 */ shl r9=r25,r17 ;; or r25=r8,r9 ;; mov r26=ar.rnat - mov ar.unat=r25 // setup ar.unat (NaT bits for r1, r4-r7, and r12) + mov ar.unat=r25 /* setup ar.unat (NaT bits for r1, r4-r7, and r12) */ ;; - ld8.fill.nta sp=[r2],16 // r12 (sp) - ld8.fill.nta gp=[r3],16 // r1 (gp) - dep r11=-1,r23,3,6 // r11 <- ia64_rse_rnat_addr(jmpbuf.ar_bsp) + ld8.fill.nta sp=[r2],16 /* r12 (sp) */ + ld8.fill.nta gp=[r3],16 /* r1 (gp) */ + dep r11=-1,r23,3,6 /* r11 <- ia64_rse_rnat_addr(jmpbuf.ar_bsp) */ ;; - ld8.nta r16=[r2],16 // caller's unat - ld8.nta r17=[r3],16 // fpsr + ld8.nta r16=[r2],16 /* caller's unat */ + ld8.nta r17=[r3],16 /* fpsr */ ;; - ld8.fill.nta r4=[r2],16 // r4 - ld8.fill.nta r5=[r3],16 // r5 (gp) - cmp.geu p8,p0=r10,r11 // p8 <- (ar.bsp >= jmpbuf.ar_bsp) + ld8.fill.nta r4=[r2],16 /* r4 */ + ld8.fill.nta r5=[r3],16 /* r5 (gp) */ + cmp.geu p8,p0=r10,r11 /* p8 <- (ar.bsp >= jmpbuf.ar_bsp) */ ;; - ld8.fill.nta r6=[r2],16 // r6 - ld8.fill.nta r7=[r3],16 // r7 + ld8.fill.nta r6=[r2],16 /* r6 */ + ld8.fill.nta r7=[r3],16 /* r7 */ ;; - mov ar.unat=r16 // restore caller's unat - mov ar.fpsr=r17 // restore fpsr + mov ar.unat=r16 /* restore caller's unat */ + mov ar.fpsr=r17 /* restore fpsr */ ;; - ld8.nta r16=[r2],16 // b0 - ld8.nta r17=[r3],16 // b1 + ld8.nta r16=[r2],16 /* b0 */ + ld8.nta r17=[r3],16 /* b1 */ ;; -(p8) ld8 r26=[r11] // r26 <- *ia64_rse_rnat_addr(jmpbuf.ar_bsp) - mov ar.bspstore=r23 // restore ar.bspstore +(p8) ld8 r26=[r11] /* r26 <- *ia64_rse_rnat_addr(jmpbuf.ar_bsp) */ + mov ar.bspstore=r23 /* restore ar.bspstore */ ;; - ld8.nta r18=[r2],16 // b2 - ld8.nta r19=[r3],16 // b3 + ld8.nta r18=[r2],16 /* b2 */ + ld8.nta r19=[r3],16 /* b3 */ ;; - ld8.nta r20=[r2],16 // b4 - ld8.nta r21=[r3],16 // b5 + ld8.nta r20=[r2],16 /* b4 */ + ld8.nta r21=[r3],16 /* b5 */ ;; - ld8.nta r11=[r2],16 // ar.pfs - ld8.nta r22=[r3],56 // ar.lc + ld8.nta r11=[r2],16 /* ar.pfs */ + ld8.nta r22=[r3],56 /* ar.lc */ ;; - ld8.nta r24=[r2],32 // pr + ld8.nta r24=[r2],32 /* pr */ mov b0=r16 ;; ldf.fill.nta f2=[r2],32 @@ -149,12 +149,12 @@ LEAF(__longjmp) ldf.fill.nta f31=[r3] (p8) mov r8=1 - mov ar.rnat=r26 // restore ar.rnat + mov ar.rnat=r26 /* restore ar.rnat */ ;; - mov ar.rsc=r27 // restore ar.rsc + mov ar.rsc=r27 /* restore ar.rsc */ (p9) mov r8=in1 - invala // virt. -> phys. regnum mapping may change + invala /* virt. -> phys. regnum mapping may change */ mov pr=r24,-1 ret END(__longjmp) diff --git a/libc/sysdeps/linux/ia64/setjmp.S b/libc/sysdeps/linux/ia64/setjmp.S index 11dc0e62e..cf6c75d3d 100644 --- a/libc/sysdeps/linux/ia64/setjmp.S +++ b/libc/sysdeps/linux/ia64/setjmp.S @@ -95,15 +95,15 @@ ENTRY(__sigsetjmp) mov r2=in0 add r3=8,in0 ;; -.mem.offset 8,0; st8.spill.nta [r2]=sp,16 // r12 (sp) -.mem.offset 0,0; st8.spill.nta [r3]=gp,16 // r1 (gp) +.mem.offset 8,0; st8.spill.nta [r2]=sp,16 /* r12 (sp) */ +.mem.offset 0,0; st8.spill.nta [r3]=gp,16 /* r1 (gp) */ ;; - st8.nta [r2]=loc2,16 // save caller's unat - st8.nta [r3]=r17,16 // save fpsr + st8.nta [r2]=loc2,16 /* save caller's unat */ + st8.nta [r3]=r17,16 /* save fpsr */ add r8=0xa0,in0 ;; -.mem.offset 8,0; st8.spill.nta [r2]=r4,16 // r4 -.mem.offset 0,0; st8.spill.nta [r3]=r5,16 // r5 +.mem.offset 8,0; st8.spill.nta [r2]=r4,16 /* r4 */ +.mem.offset 0,0; st8.spill.nta [r3]=r5,16 /* r5 */ add r9=0xb0,in0 ;; stf.spill.nta [r8]=f2,32 @@ -145,39 +145,39 @@ ENTRY(__sigsetjmp) stf.spill.nta [r8]=f30 stf.spill.nta [r9]=f31 -.mem.offset 8,0; st8.spill.nta [r2]=r6,16 // r6 -.mem.offset 0,0; st8.spill.nta [r3]=r7,16 // r7 +.mem.offset 8,0; st8.spill.nta [r2]=r6,16 /* r6 */ +.mem.offset 0,0; st8.spill.nta [r3]=r7,16 /* r7 */ ;; mov r23=ar.bsp mov r25=ar.unat mov out0=in0 - st8.nta [r2]=loc0,16 // b0 - st8.nta [r3]=r17,16 // b1 + st8.nta [r2]=loc0,16 /* b0 */ + st8.nta [r3]=r17,16 /* b1 */ mov out1=in1 ;; - st8.nta [r2]=r18,16 // b2 - st8.nta [r3]=r19,16 // b3 + st8.nta [r2]=r18,16 /* b2 */ + st8.nta [r3]=r19,16 /* b3 */ ;; - st8.nta [r2]=r20,16 // b4 - st8.nta [r3]=r21,16 // b5 + st8.nta [r2]=r20,16 /* b4 */ + st8.nta [r3]=r21,16 /* b5 */ ;; - st8.nta [r2]=loc1,16 // ar.pfs - st8.nta [r3]=r22,16 // ar.lc + st8.nta [r2]=loc1,16 /* ar.pfs */ + st8.nta [r3]=r22,16 /* ar.lc */ ;; - st8.nta [r2]=r24,16 // pr - st8.nta [r3]=r23,16 // ar.bsp + st8.nta [r2]=r24,16 /* pr */ + st8.nta [r3]=r23,16 /* ar.bsp */ ;; - st8.nta [r2]=r25 // ar.unat - st8.nta [r3]=in0 // &__jmp_buf + st8.nta [r2]=r25 /* ar.unat */ + st8.nta [r3]=in0 /* &__jmp_buf */ #if defined NOT_IN_libc && defined IS_IN_rtld /* In ld.so we never save the signal mask. */ ;; #else br.call.dpnt.few rp=__sigjmp_save #endif -.ret0: // force a new bundle ::q - mov.m ar.unat=loc2 // restore caller's unat +.ret0: /* force a new bundle ::q */ + mov.m ar.unat=loc2 /* restore caller's unat */ mov rp=loc0 mov ar.pfs=loc1 mov r8=0 diff --git a/libc/sysdeps/linux/microblaze/__longjmp.S b/libc/sysdeps/linux/microblaze/__longjmp.S index fba1e9fbf..2752f0bd3 100644 --- a/libc/sysdeps/linux/microblaze/__longjmp.S +++ b/libc/sysdeps/linux/microblaze/__longjmp.S @@ -8,7 +8,7 @@ * This file is subject to the terms and conditions of the GNU Lesser * General Public License. See the file COPYING.LIB in the main * directory of this archive for more details. - * + * * Written by Miles Bader <miles@gnu.org> */ @@ -20,25 +20,25 @@ .text C_ENTRY(__longjmp): - /* load registers from memory to r5 (arg0)*/ + /* load registers from memory to r5 (arg0) */ lwi r1, r5, 0 lwi r15, r5, 4 lwi r18, r5, 8 lwi r19, r5, 12 lwi r20, r5, 16 - lwi r21, r5, 20 - lwi r22, r5, 24 + lwi r21, r5, 20 + lwi r22, r5, 24 lwi r23, r5, 28 - lwi r24, r5, 32 + lwi r24, r5, 32 lwi r25, r5, 36 lwi r26, r5, 40 lwi r27, r5, 44 lwi r28, r5, 48 lwi r29, r5, 52 lwi r30, r5, 56 - - addi r3, r0, 1 // return val - rtsd r15, 8 // normal return + + addi r3, r0, 1 /* return val */ + rtsd r15, 8 /* normal return */ nop C_END(__longjmp) diff --git a/libc/sysdeps/linux/microblaze/crt0.S b/libc/sysdeps/linux/microblaze/crt0.S index 99687b707..591c3a2f8 100644 --- a/libc/sysdeps/linux/microblaze/crt0.S +++ b/libc/sysdeps/linux/microblaze/crt0.S @@ -20,22 +20,22 @@ .text C_ENTRY(_start): - lw r5, r0, r1 // Arg 0: argc + lw r5, r0, r1 /* Arg 0: argc */ - addi r6, r1, 4 // Arg 1: argv + addi r6, r1, 4 /* Arg 1: argv */ - // Arg 2: envp - addi r3, r5, 1 // skip argc elements to get envp start - // ...plus the NULL at the end of argv - add r3, r3, r3 // Make word offset + /* Arg 2: envp */ + addi r3, r5, 1 /* skip argc elements to get envp start */ + /* ...plus the NULL at the end of argv */ + add r3, r3, r3 /* Make word offset */ add r3, r3, r3 - add r7, r6, r3 // add to argv to get offset + add r7, r6, r3 /* add to argv to get offset */ - // Load SDAs + /* Load SDAs */ la r2, r0, C_SYMBOL_NAME(_SDA_BASE_) la r13, r0, C_SYMBOL_NAME(_SDA2_BASE_) - // tail-call uclibc's startup routine + /* tail-call uclibc's startup routine */ brid C_SYMBOL_NAME(__uClibc_main) nop diff --git a/libc/sysdeps/linux/microblaze/vfork.S b/libc/sysdeps/linux/microblaze/vfork.S index 1e802ae29..42458308a 100644 --- a/libc/sysdeps/linux/microblaze/vfork.S +++ b/libc/sysdeps/linux/microblaze/vfork.S @@ -8,7 +8,7 @@ * * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. */ -/* +/* * Written by Miles Bader <miles@gnu.org> * Microblaze port by John Williams */ @@ -31,13 +31,13 @@ C_ENTRY (__vfork): addi r12, r0, SYS_vfork bralid r17, 0x08; nop - addi r4, r3, 125 // minimum err value - blti r4, 1f // is r3 < -125? - rtsd r15, 8 // normal return + addi r4, r3, 125 /* minimum err value */ + blti r4, 1f /* is r3 < -125? */ + rtsd r15, 8 /* normal return */ nop -1: sub r3, r3, r0 // r3 = -r3 +1: sub r3, r3, r0 /* r3 = -r3 */ swi r3, r0, C_SYMBOL_NAME(errno); - rtsd r15, 8 // error return + rtsd r15, 8 /* error return */ nop C_END(__vfork) weak_alias(__vfork,vfork) diff --git a/libc/sysdeps/linux/nios/bits/endian.h b/libc/sysdeps/linux/nios/bits/endian.h index 252597931..34ea91f71 100644 --- a/libc/sysdeps/linux/nios/bits/endian.h +++ b/libc/sysdeps/linux/nios/bits/endian.h @@ -4,5 +4,5 @@ # error "Never use <bits/endian.h> directly; include <endian.h> instead." #endif -//mle +/*mle */ #define __BYTE_ORDER __LITTLE_ENDIAN diff --git a/libc/sysdeps/linux/nios/crt1.S b/libc/sysdeps/linux/nios/crt1.S index 98777e831..e80a82189 100644 --- a/libc/sysdeps/linux/nios/crt1.S +++ b/libc/sysdeps/linux/nios/crt1.S @@ -35,13 +35,13 @@ Cambridge, MA 02139, USA. */ .text -_start: +_start: nop nop MOVIA %o0, main@h - lds %o1,[%sp, (REGWIN_SZ / 4) + 0] // main's argc - lds %o2,[%sp, (REGWIN_SZ / 4) + 1] // main's argv + lds %o1,[%sp, (REGWIN_SZ / 4) + 0] /* main's argc */ + lds %o2,[%sp, (REGWIN_SZ / 4) + 1] /* main's argv */ MOVIA %o3, _init@h MOVIA %o4, _fini@h diff --git a/libc/sysdeps/linux/sh/clone.S b/libc/sysdeps/linux/sh/clone.S index 386b4ceb1..9446803ba 100644 --- a/libc/sysdeps/linux/sh/clone.S +++ b/libc/sysdeps/linux/sh/clone.S @@ -63,7 +63,7 @@ clone: trapa #(__SH_SYSCALL_TRAP_BASE + 2) mov r0, r1 #ifdef __CONFIG_SH2__ -// 12 arithmetic shifts for the crappy sh2, because shad doesn't exist! +/* 12 arithmetic shifts for the crappy sh2, because shad doesn't exist! */ shar r1 shar r1 shar r1 @@ -80,8 +80,8 @@ clone: mov #-12, r2 shad r2, r1 #endif - not r1, r1 // r1=0 means r0 = -1 to -4095 - tst r1, r1 // i.e. error in linux + not r1, r1 /* r1=0 means r0 = -1 to -4095 */ + tst r1, r1 /* i.e. error in linux */ bf/s 2f tst r0, r0 bra __syscall_error diff --git a/libc/sysdeps/linux/sh/vfork.S b/libc/sysdeps/linux/sh/vfork.S index a9b440d8f..060a36b33 100644 --- a/libc/sysdeps/linux/sh/vfork.S +++ b/libc/sysdeps/linux/sh/vfork.S @@ -42,7 +42,7 @@ __vfork: trapa #__SH_SYSCALL_TRAP_BASE mov r0, r1 #ifdef __CONFIG_SH2__ -// 12 arithmetic shifts for the crappy sh2, because shad doesn't exist! +/* 12 arithmetic shifts for the crappy sh2, because shad doesn't exist! */ shar r1 shar r1 shar r1 @@ -55,13 +55,13 @@ __vfork: shar r1 shar r1 shar r1 -#else +#else mov #-12, r2 shad r2, r1 #endif - not r1, r1 // r1=0 means r0 = -1 to -4095 - tst r1, r1 // i.e. error in linux + not r1, r1 /* r1=0 means r0 = -1 to -4095 */ + tst r1, r1 /* i.e. error in linux */ bf 2f mov.w .L1, r1 cmp/eq r1, r0 @@ -73,7 +73,7 @@ __vfork: trapa #__SH_SYSCALL_TRAP_BASE mov r0, r1 #ifdef __CONFIG_SH2__ -// 12 arithmetic shifts for the crappy sh2, because shad doesn't exist! +/* 12 arithmetic shifts for the crappy sh2, because shad doesn't exist! */ shar r1 shar r1 shar r1 @@ -86,13 +86,13 @@ __vfork: shar r1 shar r1 shar r1 -#else +#else mov #-12, r2 shad r2, r1 #endif - not r1, r1 // r1=0 means r0 = -1 to -4095 - tst r1, r1 // i.e. error in linux + not r1, r1 /* r1=0 means r0 = -1 to -4095 */ + tst r1, r1 /* i.e. error in linux */ bt/s __syscall_error mov r0, r4 2: diff --git a/libc/sysdeps/linux/sparc/qp_ops.c b/libc/sysdeps/linux/sparc/qp_ops.c index 9080baaee..5336a292f 100644 --- a/libc/sysdeps/linux/sparc/qp_ops.c +++ b/libc/sysdeps/linux/sparc/qp_ops.c @@ -1,4 +1,4 @@ -// XXX add ops from glibc sysdeps/sparc/sparc64/soft-fp +/* XXX add ops from glibc sysdeps/sparc/sparc64/soft-fp */ #define fakedef(name) \ void name(void) \ diff --git a/libc/sysdeps/linux/v850/__longjmp.S b/libc/sysdeps/linux/v850/__longjmp.S index 2c470264f..fa29e0f78 100644 --- a/libc/sysdeps/linux/v850/__longjmp.S +++ b/libc/sysdeps/linux/v850/__longjmp.S @@ -7,7 +7,7 @@ * This file is subject to the terms and conditions of the GNU Lesser * General Public License. See the file COPYING.LIB in the main * directory of this archive for more details. - * + * * Written by Miles Bader <miles@gnu.org> */ @@ -35,7 +35,7 @@ C_ENTRY(__longjmp): sld.w 40[ep], r27 sld.w 44[ep], r28 sld.w 48[ep], r29 - mov 1, r10 // return val + mov 1, r10 /* return val */ jmp [lp] C_END(__longjmp) libc_hidden_def(__longjmp) diff --git a/libc/sysdeps/linux/v850/crt0.S b/libc/sysdeps/linux/v850/crt0.S index 11d7bb5aa..01e9f8309 100644 --- a/libc/sysdeps/linux/v850/crt0.S +++ b/libc/sysdeps/linux/v850/crt0.S @@ -19,25 +19,25 @@ .text C_ENTRY(start): - ld.w 0[sp], r6 // Arg 0: argc + ld.w 0[sp], r6 /* Arg 0: argc */ - addi 4, sp, r7 // Arg 1: argv + addi 4, sp, r7 /* Arg 1: argv */ - mov r7, r8 // Arg 2: envp - mov r6, r10 // skip argc elements to get envp start - add 1, r10 // ...plus the NULL at the end of argv - shl 2, r10 // Convert to byte-count to skip + mov r7, r8 /* Arg 2: envp */ + mov r6, r10 /* skip argc elements to get envp start */ + add 1, r10 /* ...plus the NULL at the end of argv */ + shl 2, r10 /* Convert to byte-count to skip */ add r10, r8 - // Load CTBP register + /* Load CTBP register */ mov hilo(C_SYMBOL_NAME(_ctbp)), r19 ldsr r19, ctbp - // Load GP + /* Load GP */ mov hilo(C_SYMBOL_NAME(_gp)), gp - // tail-call uclibc's startup routine - addi -24, sp, sp // Stack space reserved for args + /* tail-call uclibc's startup routine */ + addi -24, sp, sp /* Stack space reserved for args */ jr C_SYMBOL_NAME(__uClibc_main) diff --git a/libc/sysdeps/linux/v850/vfork.S b/libc/sysdeps/linux/v850/vfork.S index 82d127079..2533853b5 100644 --- a/libc/sysdeps/linux/v850/vfork.S +++ b/libc/sysdeps/linux/v850/vfork.S @@ -7,7 +7,7 @@ * This file is subject to the terms and conditions of the GNU Lesser * General Public License. See the file COPYING.LIB in the main * directory of this archive for more details. - * + * * Written by Miles Bader <miles@gnu.org> */ @@ -29,14 +29,14 @@ C_ENTRY (__vfork): addi SYS_vfork, r0, r12 trap 0 - addi -125, r0, r11 // minimum err value + addi -125, r0, r11 /* minimum err value */ cmp r11, r10 bh 1f - jmp [lp] // normal return + jmp [lp] /* normal return */ 1: mov hilo(C_SYMBOL_NAME(errno)), r11 subr r0, r10 st.w r10, 0[r11] - jmp [lp] // error return + jmp [lp] /* error return */ C_END(__vfork) weak_alias(__vfork,vfork) libc_hidden_weak(vfork) diff --git a/libc/sysdeps/linux/xtensa/__longjmp.S b/libc/sysdeps/linux/xtensa/__longjmp.S index 0fa939095..5d5dd2f5b 100644 --- a/libc/sysdeps/linux/xtensa/__longjmp.S +++ b/libc/sysdeps/linux/xtensa/__longjmp.S @@ -84,7 +84,7 @@ ENTRY (__longjmp) slli a4, a7, 4 sub a6, a8, a4 addi a5, a2, 16 - addi a8, a8, -16 // a8 = end of register overflow area + addi a8, a8, -16 /* a8 = end of register overflow area */ .Lljloop: l32i a7, a5, 0 l32i a4, a5, 4 @@ -105,8 +105,8 @@ ENTRY (__longjmp) case the contents were moved by an alloca after calling setjmp. This is a bit paranoid but it doesn't cost much. */ - l32i a7, a2, 4 // load the target stack pointer - addi a7, a7, -16 // find the destination save area + l32i a7, a2, 4 /* load the target stack pointer */ + addi a7, a7, -16 /* find the destination save area */ l32i a4, a2, 48 l32i a5, a2, 52 s32i a4, a7, 0 diff --git a/libc/sysdeps/linux/xtensa/setjmp.S b/libc/sysdeps/linux/xtensa/setjmp.S index 5e81460c7..cd74caf6e 100644 --- a/libc/sysdeps/linux/xtensa/setjmp.S +++ b/libc/sysdeps/linux/xtensa/setjmp.S @@ -61,13 +61,13 @@ END (setjmp) a3 = int savemask) */ ENTRY (__sigsetjmp) -1: +1: /* Flush registers. */ movi a4, __window_spill callx4 a4 /* Preserve the second argument (savemask) in a15. The selection - of a15 is arbitrary, except it's otherwise unused. There is no + of a15 is arbitrary, except it's otherwise unused. There is no risk of triggering a window overflow since we just returned from __window_spill(). */ mov a15, a3 @@ -90,7 +90,7 @@ ENTRY (__sigsetjmp) slli a4, a3, 4 sub a5, a7, a4 addi a6, a2, 16 - addi a7, a7, -16 // a7 = end of register overflow area + addi a7, a7, -16 /* a7 = end of register overflow area */ .Lsjloop: l32i a3, a5, 0 l32i a4, a5, 4 diff --git a/libc/sysdeps/linux/xtensa/vfork.S b/libc/sysdeps/linux/xtensa/vfork.S index 830a0cd4d..6e490fe45 100644 --- a/libc/sysdeps/linux/xtensa/vfork.S +++ b/libc/sysdeps/linux/xtensa/vfork.S @@ -52,19 +52,19 @@ ENTRY (__vfork) movi a6, .Ljumptable - extui a2, a0, 30, 2 // call-size: call4/8/12 = 1/2/3 - addx4 a4, a2, a6 // find return address in jumptable + extui a2, a0, 30, 2 /* call-size: call4/8/12 = 1/2/3 */ + addx4 a4, a2, a6 /* find return address in jumptable */ l32i a4, a4, 0 add a4, a4, a6 slli a2, a2, 30 - xor a3, a0, a2 // remove call-size from return address - extui a5, a4, 30, 2 // get high bits of jump target + xor a3, a0, a2 /* remove call-size from return addr */ + extui a5, a4, 30, 2 /* get high bits of jump target */ slli a5, a5, 30 - or a3, a3, a5 // stuff them into the return address - xor a4, a4, a5 // clear high bits of jump target - or a0, a4, a2 // create temporary return address - retw // "return" to .L4, .L8, or .L12 + or a3, a3, a5 /* stuff them into the return address */ + xor a4, a4, a5 /* clear high bits of jump target */ + or a0, a4, a2 /* create temporary return address */ + retw /* "return" to .L4, .L8, or .L12 */ .align 4 .Ljumptable: @@ -81,7 +81,7 @@ ENTRY (__vfork) /* Use syscall 'clone'. Set new stack pointer to the same address. */ movi a2, SYS_ify (clone) - movi a3, 0 + movi a3, 0 movi a6, CLONE_VM | CLONE_VFORK | SIGCHLD syscall @@ -95,7 +95,7 @@ ENTRY (__vfork) bgeu a6, a5, 1f jx a7 -1: call4 .Lerr // returns to original caller +1: call4 .Lerr /* returns to original caller */ /* a11: return address */ @@ -121,7 +121,7 @@ ENTRY (__vfork) bgeu a10, a9, 1f jx a11 -1: call8 .Lerr // returns to original caller +1: call8 .Lerr /* returns to original caller */ /* a15: return address */ @@ -148,18 +148,18 @@ ENTRY (__vfork) bgeu a14, a13, 1f jx a15 -1: call12 .Lerr // returns to original caller +1: call12 .Lerr /* returns to original caller */ .align 4 .Lerr: entry a1, 16 /* Restore the return address. */ - extui a4, a0, 30, 2 // get the call-size bits + extui a4, a0, 30, 2 /* get the call-size bits */ slli a4, a4, 30 - slli a3, a3, 2 // clear high bits of target address + slli a3, a3, 2 /* clear high bits of target address */ srli a3, a3, 2 - or a0, a3, a4 // combine them + or a0, a3, a4 /* combine them */ PSEUDO_END (__vfork) .Lpseudo_end: diff --git a/libc/sysdeps/linux/xtensa/windowspill.S b/libc/sysdeps/linux/xtensa/windowspill.S index a63771756..1487f079f 100644 --- a/libc/sysdeps/linux/xtensa/windowspill.S +++ b/libc/sysdeps/linux/xtensa/windowspill.S @@ -26,8 +26,8 @@ .type __window_spill, @function __window_spill: entry a1, 48 - bbci.l a0, 31, .L4 // branch if called with call4 - bbsi.l a0, 30, .L12 // branch if called with call12 + bbci.l a0, 31, .L4 /* branch if called with call4 */ + bbsi.l a0, 30, .L12 /* branch if called with call12 */ /* Called with call8: touch register NUM_REGS-12 (4/20/52) */ .L8: @@ -36,18 +36,18 @@ __window_spill: retw .align 4 -1: _entry a1, 48 // touch NUM_REGS-24 (x/8/40) +1: _entry a1, 48 /* touch NUM_REGS-24 (x/8/40) */ #if XCHAL_NUM_AREGS == 32 mov a8, a0 retw #else mov a12, a0 - _entry a1, 48 // touch NUM_REGS-36 (x/x/28) + _entry a1, 48 /* touch NUM_REGS-36 (x/x/28) */ mov a12, a0 - _entry a1, 48 // touch NUM_REGS-48 (x/x/16) + _entry a1, 48 /* touch NUM_REGS-48 (x/x/16) */ mov a12, a0 - _entry a1, 16 // touch NUM_REGS-60 (x/x/4) + _entry a1, 16 /* touch NUM_REGS-60 (x/x/4) */ #endif #endif mov a4, a0 @@ -62,14 +62,14 @@ __window_spill: retw .align 4 -1: _entry a1, 48 // touch NUM_REGS-20 (x/12/44) +1: _entry a1, 48 /* touch NUM_REGS-20 (x/12/44) */ mov a12, a0 #if XCHAL_NUM_AREGS > 32 - _entry a1, 48 // touch NUM_REGS-32 (x/x/32) + _entry a1, 48 /* touch NUM_REGS-32 (x/x/32) */ mov a12, a0 - _entry a1, 48 // touch NUM_REGS-44 (x/x/20) + _entry a1, 48 /* touch NUM_REGS-44 (x/x/20) */ mov a12, a0 - _entry a1, 48 // touch NUM_REGS-56 (x/x/8) + _entry a1, 48 /* touch NUM_REGS-56 (x/x/8) */ mov a8, a0 #endif #endif @@ -82,14 +82,14 @@ __window_spill: retw .align 4 -1: _entry a1, 48 // touch NUM_REGS-28 (x/4/36) +1: _entry a1, 48 /* touch NUM_REGS-28 (x/4/36) */ #if XCHAL_NUM_AREGS == 32 mov a4, a0 #else mov a12, a0 - _entry a1, 48 // touch NUM_REGS-40 (x/x/24) + _entry a1, 48 /* touch NUM_REGS-40 (x/x/24) */ mov a12, a0 - _entry a1, 48 // touch NUM_REGS-52 (x/x/12) + _entry a1, 48 /* touch NUM_REGS-52 (x/x/12) */ mov a12, a0 #endif #endif diff --git a/libm/e_gamma.c b/libm/e_gamma.c index bb1bb9198..05b3b86e8 100644 --- a/libm/e_gamma.c +++ b/libm/e_gamma.c @@ -23,7 +23,7 @@ libm_hidden_proto(signgam) #ifdef __STDC__ - //__private_extern__ + /* __private_extern__ */ double attribute_hidden __ieee754_gamma(double x) #else double attribute_hidden __ieee754_gamma(x) diff --git a/libm/e_gamma_r.c b/libm/e_gamma_r.c index 36b0d45d6..620f692b5 100644 --- a/libm/e_gamma_r.c +++ b/libm/e_gamma_r.c @@ -22,7 +22,7 @@ #include "math_private.h" #ifdef __STDC__ - //__private_extern__ + /* __private_extern__ */ double attribute_hidden __ieee754_gamma_r(double x, int *signgamp) #else double attribute_hidden __ieee754_gamma_r(x,signgamp) diff --git a/libm/e_lgamma.c b/libm/e_lgamma.c index af45d11f7..af7cccf54 100644 --- a/libm/e_lgamma.c +++ b/libm/e_lgamma.c @@ -23,7 +23,7 @@ libm_hidden_proto(signgam) #ifdef __STDC__ - //__private_extern__ + /* __private_extern__ */ double attribute_hidden __ieee754_lgamma(double x) #else double attribute_hidden __ieee754_lgamma(x) diff --git a/libpthread/linuxthreads.old/forward.c b/libpthread/linuxthreads.old/forward.c index eeaefd7a3..b5b91058f 100644 --- a/libpthread/linuxthreads.old/forward.c +++ b/libpthread/linuxthreads.old/forward.c @@ -23,20 +23,21 @@ /* psm: keep this before internals.h */ libc_hidden_proto(exit) -/* vda: here's why: +#if 0 +vda: here's why: In libpthread/linuxthreads.old/sysdeps/pthread/bits/libc-lock.h adding libc_hidden_proto(foo) just before weak_extern (__pthread_initialize) will not warn: - //libc_hidden_proto(foo) + /* libc_hidden_proto(foo) */ weak_extern (__pthread_initialize) - //libc_hidden_proto(foo) + /* libc_hidden_proto(foo) */ but adding after will! Which is extremely strange - weak_extern expands into just "#pragma weak __pthread_initialize". TODO: determine whether it is a gcc bug or what -(see gcc.gnu.org/bugzilla/show_bug.cgi?id=36282). +(see gcc.gnu.org/PR36282). For now, just include all headers before internals.h (they are again included in internals.h - maybe remove them there later) -*/ +#endif #include <string.h> #include <limits.h> #include <setjmp.h> diff --git a/libpthread/linuxthreads.old/pthread.c b/libpthread/linuxthreads.old/pthread.c index 35de4b731..e96f3ab6a 100644 --- a/libpthread/linuxthreads.old/pthread.c +++ b/libpthread/linuxthreads.old/pthread.c @@ -477,12 +477,12 @@ static void pthread_initialize(void) __libc_sigaction(__pthread_sig_restart, &sa, NULL); sa.sa_handler = pthread_handle_sigcancel; sigaddset(&sa.sa_mask, __pthread_sig_restart); - // sa.sa_flags = 0; + /* sa.sa_flags = 0; */ __libc_sigaction(__pthread_sig_cancel, &sa, NULL); if (__pthread_sig_debug > 0) { sa.sa_handler = pthread_handle_sigdebug; sigemptyset(&sa.sa_mask); - // sa.sa_flags = 0; + /* sa.sa_flags = 0; */ __libc_sigaction(__pthread_sig_debug, &sa, NULL); } /* Initially, block __pthread_sig_restart. Will be unblocked on demand. */ @@ -530,7 +530,7 @@ int __pthread_initialize_manager(void) __pthread_manager_thread_bos, __pthread_manager_thread_tos); #if 0 PDEBUG("initial stack: estimate bos=%p, tos=%p\n", - __pthread_initial_thread_bos, __pthread_initial_thread_tos); + __pthread_initial_thread_bos, __pthread_initial_thread_tos); #endif /* Setup pipe to communicate with thread manager */ diff --git a/libpthread/linuxthreads/pthread.c b/libpthread/linuxthreads/pthread.c index 4c123dea8..36961a1c9 100644 --- a/libpthread/linuxthreads/pthread.c +++ b/libpthread/linuxthreads/pthread.c @@ -567,12 +567,12 @@ static void pthread_initialize(void) __libc_sigaction(__pthread_sig_restart, &sa, NULL); sa.sa_handler = pthread_handle_sigcancel; sigaddset(&sa.sa_mask, __pthread_sig_restart); - // sa.sa_flags = 0; + /* sa.sa_flags = 0; */ __libc_sigaction(__pthread_sig_cancel, &sa, NULL); if (__pthread_sig_debug > 0) { sa.sa_handler = pthread_handle_sigdebug; sigemptyset(&sa.sa_mask); - // sa.sa_flags = 0; + /* sa.sa_flags = 0; */ __libc_sigaction(__pthread_sig_debug, &sa, NULL); } /* Initially, block __pthread_sig_restart. Will be unblocked on demand. */ diff --git a/libpthread/linuxthreads/sysdeps/unix/sysv/linux/sh/vfork.S b/libpthread/linuxthreads/sysdeps/unix/sysv/linux/sh/vfork.S index 6b7dfc345..e933eefde 100644 --- a/libpthread/linuxthreads/sysdeps/unix/sysv/linux/sh/vfork.S +++ b/libpthread/linuxthreads/sysdeps/unix/sysv/linux/sh/vfork.S @@ -44,8 +44,8 @@ ENTRY (__vfork) mov r0, r1 mov #-12, r2 shad r2, r1 - not r1, r1 // r1=0 means r0 = -1 to -4095 - tst r1, r1 // i.e. error in linux + not r1, r1 /* r1=0 means r0 = -1 to -4095 */ + tst r1, r1 /* i.e. error in linux */ bf .Lpseudo_end SYSCALL_ERROR_HANDLER .Lpseudo_end: @@ -64,7 +64,7 @@ ENTRY (__vfork) .long pthread_create #endif -.Lhidden_fork: +.Lhidden_fork: mov.l .L2, r1 braf r1 nop diff --git a/utils/ldd.c b/utils/ldd.c index 7818c3713..757e4fb1e 100644 --- a/utils/ldd.c +++ b/utils/ldd.c @@ -525,7 +525,7 @@ static int add_library(ElfW(Ehdr) *ehdr, ElfW(Dyn) *dynamic, int is_setuid, char tmp1++; } if (strcmp(tmp2, s) == 0) { - //printf("find_elf_interpreter is skipping '%s' (already in list)\n", cur->name); + /*printf("find_elf_interpreter is skipping '%s' (already in list)\n", cur->name); */ return 0; } } @@ -543,7 +543,7 @@ static int add_library(ElfW(Ehdr) *ehdr, ElfW(Dyn) *dynamic, int is_setuid, char /* Now try and locate where this library might be living... */ locate_library_file(ehdr, dynamic, is_setuid, newlib); - //printf("add_library is adding '%s' to '%s'\n", newlib->name, newlib->path); + /*printf("add_library is adding '%s' to '%s'\n", newlib->name, newlib->path); */ if (!lib_list) { lib_list = newlib; } else { @@ -596,7 +596,7 @@ static struct library *find_elf_interpreter(ElfW(Ehdr) *ehdr) for (cur = lib_list; cur; cur = cur->next) { /* Check if this library is already in the list */ if (strcmp(cur->name, tmp1) == 0) { - //printf("find_elf_interpreter is replacing '%s' (already in list)\n", cur->name); + /*printf("find_elf_interpreter is replacing '%s' (already in list)\n", cur->name); */ newlib = cur; free(newlib->name); if (newlib->path != not_found) { @@ -618,7 +618,7 @@ static struct library *find_elf_interpreter(ElfW(Ehdr) *ehdr) newlib->next = NULL; #if 0 - //printf("find_elf_interpreter is adding '%s' to '%s'\n", newlib->name, newlib->path); + /*printf("find_elf_interpreter is adding '%s' to '%s'\n", newlib->name, newlib->path); */ if (!lib_list) { lib_list = newlib; } else { |