code review 49160045: liblink: fix comments. Someone was overzealous with se...

src/liblink/asm6.c

 // Inferno utils/6l/span.c
 // http://code.google.com/p/inferno-os/source/browse/utils/6l/span.c
 //
 //      Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
 //      Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
 //      Portions Copyright © 1997-1999 Vita Nuova Limited
 //      Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
 //      Portions Copyright © 2004,2006 Bruce Ellis
 //      Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
-//      Revisions Copyright © 2000-2007 Lucent Technologies Inc. ctxt->and others
+//      Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
 //      Portions Copyright © 2009 The Go Authors.  All rights reserved.
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software ctxt->and associated documentation files (the "Software"), to deal
+// of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, ctxt->and/or sell
-// copies of the Software, ctxt->and to permit persons to whom the Software is
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
-// The above copyright notice ctxt->and this permission notice shall be included in
+// The above copyright notice and this permission notice shall be included in
 // all copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
 // Instruction layout.
 
 #include <u.h>
 #include <libc.h>
 #include <bio.h>
 #include <link.h>
 #include "../cmd/6l/6.out.h"
 #include "../pkg/runtime/stack.h"
 
 enum
 {
         MaxAlign = 32,  // max data alignment
 ········
         // Loop alignment constants:
         // want to align loop entry to LoopAlign-byte boundary,
-        // ctxt->and willing to insert at most MaxLoopPad bytes of NOP to do so.
+        // and willing to insert at most MaxLoopPad bytes of NOP to do so.
         // We define a loop entry as the target of a backward jump.
         //
         // gcc uses MaxLoopPad = 10 for its 'generic x86-64' config,
-        // ctxt->and it aligns all jump targets, not just backward jump targets.
+        // and it aligns all jump targets, not just backward jump targets.
         //
         // As of 6/1/2012, the effect of setting MaxLoopPad = 10 here
         // is very slight but negative, so the alignment is disabled by
-        // setting MaxLoopPad = 0. The code is here for reference ctxt->and
+        // setting MaxLoopPad = 0. The code is here for reference and
         // for future experiments.
         //·
         LoopAlign = 16,
         MaxLoopPad = 0,
 
         FuncAlign = 16
 };
 
 extern char *anames6[];
 
@@ skipping 686 matching lines @@
         0
 };
 static uchar    yaes2[] =
 {
         Yxm,    Yxr,    Zibm_r, 2,
         0
 };
 
 /*
  * You are doasm, holding in your hand a Prog* with p->as set to, say, ACRC32,
- * ctxt->and p->from ctxt->and p->to as operands (Addr*).  The linker scans optab to find
- * the entry with the given p->as ctxt->and then looks through the ytable for that
+ * and p->from and p->to as operands (Addr*).  The linker scans optab to find
+ * the entry with the given p->as and then looks through the ytable for that
  * instruction (the second field in the optab struct) for a line whose first
- * two values match the Ytypes of the p->from ctxt->and p->to operands.  The function
- * oclass in span.c computes the specific Ytype of an operand ctxt->and then the set
+ * two values match the Ytypes of the p->from and p->to operands.  The function
+ * oclass in span.c computes the specific Ytype of an operand and then the set
  * of more general Ytypes that it satisfies is implied by the ycover table, set
- * up in instinit.  For example, oclass distinguishes the constants 0 ctxt->and 1
+ * up in instinit.  For example, oclass distinguishes the constants 0 and 1
  * from the more general 8-bit constants, but instinit says
  *
  *        ycover[Yi0*Ymax + Ys32] = 1;
  *        ycover[Yi1*Ymax + Ys32] = 1;
  *        ycover[Yi8*Ymax + Ys32] = 1;
  *
- * which means that Yi0, Yi1, ctxt->and Yi8 all count as Ys32 (signed 32)
+ * which means that Yi0, Yi1, and Yi8 all count as Ys32 (signed 32)
  * if that's what an instruction can handle.
  *
  * In parallel with the scan through the ytable for the appropriate line, there
  * is a z pointer that starts out pointing at the strange magic byte list in
  * the Optab struct.  With each step past a non-matching ytable line, z
  * advances by the 4th entry in the line.  When a matching line is found, that
  * z pointer has the extra data to use in laying down the instruction bytes.
  * The actual bytes laid down are a function of the 3rd entry in the line (that
- * is, the Ztype) ctxt->and the z bytes.
+ * is, the Ztype) and the z bytes.
  *
  * For example, let's look at AADDL.  The optab line says:
  *        { AADDL,        yaddl,  Px, 0x83,(00),0x05,0x81,(00),0x01,0x03 },
  *
- * ctxt->and yaddl says
+ * and yaddl says
  *        uchar   yaddl[] =
  *        {
  *                Yi8,    Yml,    Zibo_m, 2,
  *                Yi32,   Yax,    Zil_,   1,
  *                Yi32,   Yml,    Zilo_m, 2,
  *                Yrl,    Yml,    Zr_m,   1,
  *                Yml,    Yrl,    Zm_r,   1,
  *                0
  *        };
  *
- * so there are 5 possible types of ADDL instruction that can be laid down, ctxt->and
- * possible states used to lay them down (Ztype ctxt->and z pointer, assuming z
+ * so there are 5 possible types of ADDL instruction that can be laid down, and
+ * possible states used to lay them down (Ztype and z pointer, assuming z
  * points at {0x83,(00),0x05,0x81,(00),0x01,0x03}) are:
  *
  *        Yi8, Yml -> Zibo_m, z (0x83, 00)
  *        Yi32, Yax -> Zil_, z+2 (0x05)
  *        Yi32, Yml -> Zilo_m, z+2+1 (0x81, 0x00)
  *        Yrl, Yml -> Zr_m, z+2+1+2 (0x01)
  *        Yml, Yrl -> Zm_r, z+2+1+2+1 (0x03)
  *
  * The Pconstant in the optab line controls the prefix bytes to emit.  That's
  * relatively straightforward as this program goes.
  *
  * The switch on t[2] in doasm implements the various Z cases.  Zibo_m, for
  * example, is an opcode byte (z[0]) then an asmando (which is some kind of
- * encoded addressing mode for the Yml arg), ctxt->and then a single immediate byte.
+ * encoded addressing mode for the Yml arg), and then a single immediate byte.
  * Zilo_m is the same but a long (32-bit) immediate.
  */
 Optab optab[] =
 /*      as, ytab, andproto, opcode */
 {
         { AXXX },
         { AAAA,         ynone,  P32, 0x37 },
         { AAAD,         ynone,  P32, 0xd5,0x0a },
         { AAAM,         ynone,  P32, 0xd4,0x0a },
         { AAAS,         ynone,  P32, 0x3f },
@@ skipping 696 matching lines @@
         { AFATVARDEF },
 
         { AEND },
         0
 };
 
 static Optab*   opindex[ALAST+1];
 static vlong    vaddr(Link*, Addr*, Reloc*);
 
 // single-instruction no-ops of various lengths.
-// constructed by hand ctxt->and disassembled with gdb to verify.
+// constructed by hand and disassembled with gdb to verify.
 // see http://www.agner.org/optimize/optimizing_assembly.pdf for discussion.
 static uchar nop[][16] = {
         {0x90},
         {0x66, 0x90},
         {0x0F, 0x1F, 0x00},
         {0x0F, 0x1F, 0x40, 0x00},
         {0x0F, 0x1F, 0x44, 0x00, 0x00},
         {0x66, 0x0F, 0x1F, 0x44, 0x00, 0x00},
         {0x0F, 0x1F, 0x80, 0x00, 0x00, 0x00, 0x00},
         {0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},
@@ skipping 1094 matching lines @@
         }
         xo = o->op[0] == 0x0f;
         for(z=0; *t; z+=t[3]+xo,t+=4)
                 if(ycover[ft+t[0]])
                 if(ycover[tt+t[1]])
                         goto found;
         goto domov;
 
 found:
         switch(o->prefix) {
-        case Pq:        /* 16 bit escape ctxt->and opcode escape */
+        case Pq:        /* 16 bit escape and opcode escape */
                 *ctxt->andptr++ = Pe;
                 *ctxt->andptr++ = Pm;
                 break;
-        case Pq3:       /* 16 bit escape, Rex.w, ctxt->and opcode escape */
+        case Pq3:       /* 16 bit escape, Rex.w, and opcode escape */
                 *ctxt->andptr++ = Pe;
                 *ctxt->andptr++ = Pw;
                 *ctxt->andptr++ = Pm;
                 break;
 
         case Pf2:       /* xmm opcode escape */
         case Pf3:
                 *ctxt->andptr++ = o->prefix;
                 *ctxt->andptr++ = Pm;
                 break;
@@ skipping 442 matching lines @@
                 if(ycover[tt+mo->tt]){
                         t = mo->op;
                         goto mfound;
                 }
 bad:
         if(p->mode != 64){
                 /*
                  * here, the assembly has failed.
                  * if its a byte instruction that has
                  * unaddressable registers, try to
-                 * exchange registers ctxt->and reissue the
+                 * exchange registers and reissue the
                  * instruction with the operands renamed.
                  */
                 pp = *p;
                 z = p->from.type;
                 if(z >= D_BP && z <= D_DI) {
                         if(isax(&p->to) || p->to.type == D_NONE) {
                                 // We certainly don't want to exchange
                                 // with AX if the op is MUL or DIV.
                                 *ctxt->andptr++ = 0x87;                 /* xchg lhs,bx */
                                 asmando(ctxt, &p->from, reg[D_BX]);
@@ skipping 131 matching lines @@
         Reloc *r;
 
         ctxt->rexflag = 0;
         ctxt->andptr = ctxt->and;
         ctxt->asmode = p->mode;
         doasm(ctxt, p);
         if(ctxt->rexflag){
                 /*
                  * as befits the whole approach of the architecture,
                  * the rex prefix must appear before the first opcode byte
-                 * (ctxt->and thus after any 66/67/f2/f3/26/2e/3e prefix bytes, but
+                 * (and thus after any 66/67/f2/f3/26/2e/3e prefix bytes, but
                  * before the 0f opcode escape!), or it might be ignored.
                  * note that the handbook often misleadingly shows 66/f2/f3 in `opcode'.
                  */
                 if(p->mode != 64)
                         ctxt->diag("asmins: illegal in mode %d: %P", p->mode, p);
                 n = ctxt->andptr - ctxt->and;
                 for(np = 0; np < n; np++) {
                         c = ctxt->and[np];
                         if(c != 0xf2 && c != 0xf3 && (c < 0x64 || c > 0x67) && c != 0x2e && c != 0x3e && c != 0x26)
                                 break;
                 }
                 memmove(ctxt->and+np+1, ctxt->and+np, n-np);
                 ctxt->and[np] = 0x40 | ctxt->rexflag;
                 ctxt->andptr++;
         }
         n = ctxt->andptr - ctxt->and;
         for(r=ctxt->cursym->r+ctxt->cursym->nr; r-- > ctxt->cursym->r; ) {
                 if(r->off < p->pc)
                         break;
                 if(ctxt->rexflag)
                         r->off++;
                 if(r->type == D_PCREL)
                         r->add -= p->pc + n - (r->off + r->siz);
         }
 }