code review 4650072: hash/crc32: add SSE4.2 support

src/cmd/6l/optab.c

 // Inferno utils/6l/optab.c
 // http://code.google.com/p/inferno-os/source/browse/utils/6l/optab.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. and others
@@ skipping 516 matching lines @@
 {
         Yxr,    Yrl,    Zm_r_xm,        2,
         Ymr,    Yrl,    Zm_r_xm,        1,
         0
 };
 uchar   ycrc32l[] =
 {
         Yml,    Yrl,    Zlitm_r,        0,
 };
 
-/* You are doasm, holding in your hand a Prog* with p->as set to, say, ACRC32,
+/*
+ * You are doasm, holding in your hand a Prog* with p->as set to, say, ACRC32,
  * and p->from and p->to as operands (Adr*).  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 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 and 1
  * from the more general 8-bit constants, but instinit says
  *
  *        ycover[Yi0*Ymax + Ys32] = 1;
@@ skipping 34 matching lines @@
  *        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), and then a single immediate byte.
- * Zilo_m is the same but a long (32-bit) immediate. */
+ * 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 },
         { AADCB,        yxorb,  Pb, 0x14,0x80,(02),0x10,0x10 },
         { AADCL,        yxorl,  Px, 0x83,(02),0x15,0x81,(02),0x11,0x13 },
@@ skipping 650 matching lines @@
         { ASYSRET,      ynone,  Pm, 0x07 },
         { AWBINVD,      ynone,  Pm, 0x09 },
         { AWRMSR,       ynone,  Pm, 0x30 },
 
         { AXADDB,       yrb_mb, Pb, 0x0f,0xc0 },
         { AXADDL,       yrl_ml, Px, 0x0f,0xc1 },
         { AXADDQ,       yrl_ml, Pw, 0x0f,0xc1 },
         { AXADDW,       yrl_ml, Pe, 0x0f,0xc1 },
 
         { ACRC32B,       ycrc32l,Px, 0xf2,0x0f,0x38,0xf0,0},
-        /* Note that the REX.W prefix encoded in the next line limits
-         * the registers that this instruction can use. */
-        { ACRC32Q,       ycrc32l,Px, 0xf2,0x48,0x0f,0x38,0xf1,0},
+        { ACRC32Q,       ycrc32l,Pw, 0xf2,0x0f,0x38,0xf1,0},
 
         { AEND },
         0
 };
 
 Optab*  opindex[ALAST+1];
 
 /*
 AMOVD   0f 6e/r mmx,reg/mem32[mem64-rex?]
 AMOVD   0f 7e/r reg/mem32[64],mmx       STORE
 AMOVQ   0f 6f/r mmx1,mmx2/mem64
 AMOVQ   0f 7f/r mmx1/mem64,mmx2
 */