Home | History | Annotate | Download | only in PerfectShuffle
      1 //===-- PerfectShuffle.cpp - Perfect Shuffle Generator --------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file computes an optimal sequence of instructions for doing all shuffles
     11 // of two 4-element vectors.  With a release build and when configured to emit
     12 // an altivec instruction table, this takes about 30s to run on a 2.7Ghz
     13 // PowerPC G5.
     14 //
     15 //===----------------------------------------------------------------------===//
     16 
     17 #include <cassert>
     18 #include <cstdlib>
     19 #include <iomanip>
     20 #include <iostream>
     21 #include <vector>
     22 struct Operator;
     23 
     24 // Masks are 4-nibble hex numbers.  Values 0-7 in any nibble means that it takes
     25 // an element from that value of the input vectors.  A value of 8 means the
     26 // entry is undefined.
     27 
     28 // Mask manipulation functions.
     29 static inline unsigned short MakeMask(unsigned V0, unsigned V1,
     30                                       unsigned V2, unsigned V3) {
     31   return (V0 << (3*4)) | (V1 << (2*4)) | (V2 << (1*4)) | (V3 << (0*4));
     32 }
     33 
     34 /// getMaskElt - Return element N of the specified mask.
     35 static unsigned getMaskElt(unsigned Mask, unsigned Elt) {
     36   return (Mask >> ((3-Elt)*4)) & 0xF;
     37 }
     38 
     39 static unsigned setMaskElt(unsigned Mask, unsigned Elt, unsigned NewVal) {
     40   unsigned FieldShift = ((3-Elt)*4);
     41   return (Mask & ~(0xF << FieldShift)) | (NewVal << FieldShift);
     42 }
     43 
     44 // Reject elements where the values are 9-15.
     45 static bool isValidMask(unsigned short Mask) {
     46   unsigned short UndefBits = Mask & 0x8888;
     47   return (Mask & ((UndefBits >> 1)|(UndefBits>>2)|(UndefBits>>3))) == 0;
     48 }
     49 
     50 /// hasUndefElements - Return true if any of the elements in the mask are undefs
     51 ///
     52 static bool hasUndefElements(unsigned short Mask) {
     53   return (Mask & 0x8888) != 0;
     54 }
     55 
     56 /// isOnlyLHSMask - Return true if this mask only refers to its LHS, not
     57 /// including undef values..
     58 static bool isOnlyLHSMask(unsigned short Mask) {
     59   return (Mask & 0x4444) == 0;
     60 }
     61 
     62 /// getLHSOnlyMask - Given a mask that refers to its LHS and RHS, modify it to
     63 /// refer to the LHS only (for when one argument value is passed into the same
     64 /// function twice).
     65 #if 0
     66 static unsigned short getLHSOnlyMask(unsigned short Mask) {
     67   return Mask & 0xBBBB;  // Keep only LHS and Undefs.
     68 }
     69 #endif
     70 
     71 /// getCompressedMask - Turn a 16-bit uncompressed mask (where each elt uses 4
     72 /// bits) into a compressed 13-bit mask, where each elt is multiplied by 9.
     73 static unsigned getCompressedMask(unsigned short Mask) {
     74   return getMaskElt(Mask, 0)*9*9*9 + getMaskElt(Mask, 1)*9*9 +
     75          getMaskElt(Mask, 2)*9     + getMaskElt(Mask, 3);
     76 }
     77 
     78 static void PrintMask(unsigned i, std::ostream &OS) {
     79   OS << "<" << (char)(getMaskElt(i, 0) == 8 ? 'u' : ('0'+getMaskElt(i, 0)))
     80      << "," << (char)(getMaskElt(i, 1) == 8 ? 'u' : ('0'+getMaskElt(i, 1)))
     81      << "," << (char)(getMaskElt(i, 2) == 8 ? 'u' : ('0'+getMaskElt(i, 2)))
     82      << "," << (char)(getMaskElt(i, 3) == 8 ? 'u' : ('0'+getMaskElt(i, 3)))
     83      << ">";
     84 }
     85 
     86 /// ShuffleVal - This represents a shufflevector operation.
     87 struct ShuffleVal {
     88   unsigned Cost;  // Number of instrs used to generate this value.
     89   Operator *Op;   // The Operation used to generate this value.
     90   unsigned short Arg0, Arg1;  // Input operands for this value.
     91 
     92   ShuffleVal() : Cost(1000000) {}
     93 };
     94 
     95 
     96 /// ShufTab - This is the actual shuffle table that we are trying to generate.
     97 ///
     98 static ShuffleVal ShufTab[65536];
     99 
    100 /// TheOperators - All of the operators that this target supports.
    101 static std::vector<Operator*> TheOperators;
    102 
    103 /// Operator - This is a vector operation that is available for use.
    104 struct Operator {
    105   unsigned short ShuffleMask;
    106   unsigned short OpNum;
    107   const char *Name;
    108   unsigned Cost;
    109 
    110   Operator(unsigned short shufflemask, const char *name, unsigned opnum,
    111            unsigned cost = 1)
    112     : ShuffleMask(shufflemask), OpNum(opnum), Name(name), Cost(cost) {
    113     TheOperators.push_back(this);
    114   }
    115   ~Operator() {
    116     assert(TheOperators.back() == this);
    117     TheOperators.pop_back();
    118   }
    119 
    120   bool isOnlyLHSOperator() const {
    121     return isOnlyLHSMask(ShuffleMask);
    122   }
    123 
    124   const char *getName() const { return Name; }
    125   unsigned getCost() const { return Cost; }
    126 
    127   unsigned short getTransformedMask(unsigned short LHSMask, unsigned RHSMask) {
    128     // Extract the elements from LHSMask and RHSMask, as appropriate.
    129     unsigned Result = 0;
    130     for (unsigned i = 0; i != 4; ++i) {
    131       unsigned SrcElt = (ShuffleMask >> (4*i)) & 0xF;
    132       unsigned ResElt;
    133       if (SrcElt < 4)
    134         ResElt = getMaskElt(LHSMask, SrcElt);
    135       else if (SrcElt < 8)
    136         ResElt = getMaskElt(RHSMask, SrcElt-4);
    137       else {
    138         assert(SrcElt == 8 && "Bad src elt!");
    139         ResElt = 8;
    140       }
    141       Result |= ResElt << (4*i);
    142     }
    143     return Result;
    144   }
    145 };
    146 
    147 static const char *getZeroCostOpName(unsigned short Op) {
    148   if (ShufTab[Op].Arg0 == 0x0123)
    149     return "LHS";
    150   else if (ShufTab[Op].Arg0 == 0x4567)
    151     return "RHS";
    152   else {
    153     assert(0 && "bad zero cost operation");
    154     abort();
    155   }
    156 }
    157 
    158 static void PrintOperation(unsigned ValNo, unsigned short Vals[]) {
    159   unsigned short ThisOp = Vals[ValNo];
    160   std::cerr << "t" << ValNo;
    161   PrintMask(ThisOp, std::cerr);
    162   std::cerr << " = " << ShufTab[ThisOp].Op->getName() << "(";
    163 
    164   if (ShufTab[ShufTab[ThisOp].Arg0].Cost == 0) {
    165     std::cerr << getZeroCostOpName(ShufTab[ThisOp].Arg0);
    166     PrintMask(ShufTab[ThisOp].Arg0, std::cerr);
    167   } else {
    168     // Figure out what tmp # it is.
    169     for (unsigned i = 0; ; ++i)
    170       if (Vals[i] == ShufTab[ThisOp].Arg0) {
    171         std::cerr << "t" << i;
    172         break;
    173       }
    174   }
    175 
    176   if (!ShufTab[Vals[ValNo]].Op->isOnlyLHSOperator()) {
    177     std::cerr << ", ";
    178     if (ShufTab[ShufTab[ThisOp].Arg1].Cost == 0) {
    179       std::cerr << getZeroCostOpName(ShufTab[ThisOp].Arg1);
    180       PrintMask(ShufTab[ThisOp].Arg1, std::cerr);
    181     } else {
    182       // Figure out what tmp # it is.
    183       for (unsigned i = 0; ; ++i)
    184         if (Vals[i] == ShufTab[ThisOp].Arg1) {
    185           std::cerr << "t" << i;
    186           break;
    187         }
    188     }
    189   }
    190   std::cerr << ")  ";
    191 }
    192 
    193 static unsigned getNumEntered() {
    194   unsigned Count = 0;
    195   for (unsigned i = 0; i != 65536; ++i)
    196     Count += ShufTab[i].Cost < 100;
    197   return Count;
    198 }
    199 
    200 static void EvaluateOps(unsigned short Elt, unsigned short Vals[],
    201                         unsigned &NumVals) {
    202   if (ShufTab[Elt].Cost == 0) return;
    203 
    204   // If this value has already been evaluated, it is free.  FIXME: match undefs.
    205   for (unsigned i = 0, e = NumVals; i != e; ++i)
    206     if (Vals[i] == Elt) return;
    207 
    208   // Otherwise, get the operands of the value, then add it.
    209   unsigned Arg0 = ShufTab[Elt].Arg0, Arg1 = ShufTab[Elt].Arg1;
    210   if (ShufTab[Arg0].Cost)
    211     EvaluateOps(Arg0, Vals, NumVals);
    212   if (Arg0 != Arg1 && ShufTab[Arg1].Cost)
    213     EvaluateOps(Arg1, Vals, NumVals);
    214 
    215   Vals[NumVals++] = Elt;
    216 }
    217 
    218 
    219 int main() {
    220   // Seed the table with accesses to the LHS and RHS.
    221   ShufTab[0x0123].Cost = 0;
    222   ShufTab[0x0123].Op = 0;
    223   ShufTab[0x0123].Arg0 = 0x0123;
    224   ShufTab[0x4567].Cost = 0;
    225   ShufTab[0x4567].Op = 0;
    226   ShufTab[0x4567].Arg0 = 0x4567;
    227 
    228   // Seed the first-level of shuffles, shuffles whose inputs are the input to
    229   // the vectorshuffle operation.
    230   bool MadeChange = true;
    231   unsigned OpCount = 0;
    232   while (MadeChange) {
    233     MadeChange = false;
    234     ++OpCount;
    235     std::cerr << "Starting iteration #" << OpCount << " with "
    236               << getNumEntered() << " entries established.\n";
    237 
    238     // Scan the table for two reasons: First, compute the maximum cost of any
    239     // operation left in the table.  Second, make sure that values with undefs
    240     // have the cheapest alternative that they match.
    241     unsigned MaxCost = ShufTab[0].Cost;
    242     for (unsigned i = 1; i != 0x8889; ++i) {
    243       if (!isValidMask(i)) continue;
    244       if (ShufTab[i].Cost > MaxCost)
    245         MaxCost = ShufTab[i].Cost;
    246 
    247       // If this value has an undef, make it be computed the cheapest possible
    248       // way of any of the things that it matches.
    249       if (hasUndefElements(i)) {
    250         // This code is a little bit tricky, so here's the idea: consider some
    251         // permutation, like 7u4u.  To compute the lowest cost for 7u4u, we
    252         // need to take the minimum cost of all of 7[0-8]4[0-8], 81 entries.  If
    253         // there are 3 undefs, the number rises to 729 entries we have to scan,
    254         // and for the 4 undef case, we have to scan the whole table.
    255         //
    256         // Instead of doing this huge amount of scanning, we process the table
    257         // entries *in order*, and use the fact that 'u' is 8, larger than any
    258         // valid index.  Given an entry like 7u4u then, we only need to scan
    259         // 7[0-7]4u - 8 entries.  We can get away with this, because we already
    260         // know that each of 704u, 714u, 724u, etc contain the minimum value of
    261         // all of the 704[0-8], 714[0-8] and 724[0-8] entries respectively.
    262         unsigned UndefIdx;
    263         if (i & 0x8000)
    264           UndefIdx = 0;
    265         else if (i & 0x0800)
    266           UndefIdx = 1;
    267         else if (i & 0x0080)
    268           UndefIdx = 2;
    269         else if (i & 0x0008)
    270           UndefIdx = 3;
    271         else
    272           abort();
    273 
    274         unsigned MinVal  = i;
    275         unsigned MinCost = ShufTab[i].Cost;
    276 
    277         // Scan the 8 entries.
    278         for (unsigned j = 0; j != 8; ++j) {
    279           unsigned NewElt = setMaskElt(i, UndefIdx, j);
    280           if (ShufTab[NewElt].Cost < MinCost) {
    281             MinCost = ShufTab[NewElt].Cost;
    282             MinVal = NewElt;
    283           }
    284         }
    285 
    286         // If we found something cheaper than what was here before, use it.
    287         if (i != MinVal) {
    288           MadeChange = true;
    289           ShufTab[i] = ShufTab[MinVal];
    290         }
    291       }
    292     }
    293 
    294     for (unsigned LHS = 0; LHS != 0x8889; ++LHS) {
    295       if (!isValidMask(LHS)) continue;
    296       if (ShufTab[LHS].Cost > 1000) continue;
    297 
    298       // If nothing involving this operand could possibly be cheaper than what
    299       // we already have, don't consider it.
    300       if (ShufTab[LHS].Cost + 1 >= MaxCost)
    301         continue;
    302 
    303       for (unsigned opnum = 0, e = TheOperators.size(); opnum != e; ++opnum) {
    304         Operator *Op = TheOperators[opnum];
    305 
    306         // Evaluate op(LHS,LHS)
    307         unsigned ResultMask = Op->getTransformedMask(LHS, LHS);
    308 
    309         unsigned Cost = ShufTab[LHS].Cost + Op->getCost();
    310         if (Cost < ShufTab[ResultMask].Cost) {
    311           ShufTab[ResultMask].Cost = Cost;
    312           ShufTab[ResultMask].Op = Op;
    313           ShufTab[ResultMask].Arg0 = LHS;
    314           ShufTab[ResultMask].Arg1 = LHS;
    315           MadeChange = true;
    316         }
    317 
    318         // If this is a two input instruction, include the op(x,y) cases.  If
    319         // this is a one input instruction, skip this.
    320         if (Op->isOnlyLHSOperator()) continue;
    321 
    322         for (unsigned RHS = 0; RHS != 0x8889; ++RHS) {
    323           if (!isValidMask(RHS)) continue;
    324           if (ShufTab[RHS].Cost > 1000) continue;
    325 
    326           // If nothing involving this operand could possibly be cheaper than
    327           // what we already have, don't consider it.
    328           if (ShufTab[RHS].Cost + 1 >= MaxCost)
    329             continue;
    330 
    331 
    332           // Evaluate op(LHS,RHS)
    333           unsigned ResultMask = Op->getTransformedMask(LHS, RHS);
    334 
    335           if (ShufTab[ResultMask].Cost <= OpCount ||
    336               ShufTab[ResultMask].Cost <= ShufTab[LHS].Cost ||
    337               ShufTab[ResultMask].Cost <= ShufTab[RHS].Cost)
    338             continue;
    339 
    340           // Figure out the cost to evaluate this, knowing that CSE's only need
    341           // to be evaluated once.
    342           unsigned short Vals[30];
    343           unsigned NumVals = 0;
    344           EvaluateOps(LHS, Vals, NumVals);
    345           EvaluateOps(RHS, Vals, NumVals);
    346 
    347           unsigned Cost = NumVals + Op->getCost();
    348           if (Cost < ShufTab[ResultMask].Cost) {
    349             ShufTab[ResultMask].Cost = Cost;
    350             ShufTab[ResultMask].Op = Op;
    351             ShufTab[ResultMask].Arg0 = LHS;
    352             ShufTab[ResultMask].Arg1 = RHS;
    353             MadeChange = true;
    354           }
    355         }
    356       }
    357     }
    358   }
    359 
    360   std::cerr << "Finished Table has " << getNumEntered()
    361             << " entries established.\n";
    362 
    363   unsigned CostArray[10] = { 0 };
    364 
    365   // Compute a cost histogram.
    366   for (unsigned i = 0; i != 65536; ++i) {
    367     if (!isValidMask(i)) continue;
    368     if (ShufTab[i].Cost > 9)
    369       ++CostArray[9];
    370     else
    371       ++CostArray[ShufTab[i].Cost];
    372   }
    373 
    374   for (unsigned i = 0; i != 9; ++i)
    375     if (CostArray[i])
    376       std::cout << "// " << CostArray[i] << " entries have cost " << i << "\n";
    377   if (CostArray[9])
    378     std::cout << "// " << CostArray[9] << " entries have higher cost!\n";
    379 
    380 
    381   // Build up the table to emit.
    382   std::cout << "\n// This table is 6561*4 = 26244 bytes in size.\n";
    383   std::cout << "static const unsigned PerfectShuffleTable[6561+1] = {\n";
    384 
    385   for (unsigned i = 0; i != 0x8889; ++i) {
    386     if (!isValidMask(i)) continue;
    387 
    388     // CostSat - The cost of this operation saturated to two bits.
    389     unsigned CostSat = ShufTab[i].Cost;
    390     if (CostSat > 4) CostSat = 4;
    391     if (CostSat == 0) CostSat = 1;
    392     --CostSat;  // Cost is now between 0-3.
    393 
    394     unsigned OpNum = ShufTab[i].Op ? ShufTab[i].Op->OpNum : 0;
    395     assert(OpNum < 16 && "Too few bits to encode operation!");
    396 
    397     unsigned LHS = getCompressedMask(ShufTab[i].Arg0);
    398     unsigned RHS = getCompressedMask(ShufTab[i].Arg1);
    399 
    400     // Encode this as 2 bits of saturated cost, 4 bits of opcodes, 13 bits of
    401     // LHS, and 13 bits of RHS = 32 bits.
    402     unsigned Val = (CostSat << 30) | (OpNum << 26) | (LHS << 13) | RHS;
    403 
    404     std::cout << "  " << std::setw(10) << Val << "U, // ";
    405     PrintMask(i, std::cout);
    406     std::cout << ": Cost " << ShufTab[i].Cost;
    407     std::cout << " " << (ShufTab[i].Op ? ShufTab[i].Op->getName() : "copy");
    408     std::cout << " ";
    409     if (ShufTab[ShufTab[i].Arg0].Cost == 0) {
    410       std::cout << getZeroCostOpName(ShufTab[i].Arg0);
    411     } else {
    412       PrintMask(ShufTab[i].Arg0, std::cout);
    413     }
    414 
    415     if (ShufTab[i].Op && !ShufTab[i].Op->isOnlyLHSOperator()) {
    416       std::cout << ", ";
    417       if (ShufTab[ShufTab[i].Arg1].Cost == 0) {
    418         std::cout << getZeroCostOpName(ShufTab[i].Arg1);
    419       } else {
    420         PrintMask(ShufTab[i].Arg1, std::cout);
    421       }
    422     }
    423     std::cout << "\n";
    424   }
    425   std::cout << "  0\n};\n";
    426 
    427   if (0) {
    428     // Print out the table.
    429     for (unsigned i = 0; i != 0x8889; ++i) {
    430       if (!isValidMask(i)) continue;
    431       if (ShufTab[i].Cost < 1000) {
    432         PrintMask(i, std::cerr);
    433         std::cerr << " - Cost " << ShufTab[i].Cost << " - ";
    434 
    435         unsigned short Vals[30];
    436         unsigned NumVals = 0;
    437         EvaluateOps(i, Vals, NumVals);
    438 
    439         for (unsigned j = 0, e = NumVals; j != e; ++j)
    440           PrintOperation(j, Vals);
    441         std::cerr << "\n";
    442       }
    443     }
    444   }
    445 }
    446 
    447 
    448 #ifdef GENERATE_ALTIVEC
    449 
    450 ///===---------------------------------------------------------------------===//
    451 /// The altivec instruction definitions.  This is the altivec-specific part of
    452 /// this file.
    453 ///===---------------------------------------------------------------------===//
    454 
    455 // Note that the opcode numbers here must match those in the PPC backend.
    456 enum {
    457   OP_COPY = 0,   // Copy, used for things like <u,u,u,3> to say it is <0,1,2,3>
    458   OP_VMRGHW,
    459   OP_VMRGLW,
    460   OP_VSPLTISW0,
    461   OP_VSPLTISW1,
    462   OP_VSPLTISW2,
    463   OP_VSPLTISW3,
    464   OP_VSLDOI4,
    465   OP_VSLDOI8,
    466   OP_VSLDOI12
    467 };
    468 
    469 struct vmrghw : public Operator {
    470   vmrghw() : Operator(0x0415, "vmrghw", OP_VMRGHW) {}
    471 } the_vmrghw;
    472 
    473 struct vmrglw : public Operator {
    474   vmrglw() : Operator(0x2637, "vmrglw", OP_VMRGLW) {}
    475 } the_vmrglw;
    476 
    477 template<unsigned Elt>
    478 struct vspltisw : public Operator {
    479   vspltisw(const char *N, unsigned Opc)
    480     : Operator(MakeMask(Elt, Elt, Elt, Elt), N, Opc) {}
    481 };
    482 
    483 vspltisw<0> the_vspltisw0("vspltisw0", OP_VSPLTISW0);
    484 vspltisw<1> the_vspltisw1("vspltisw1", OP_VSPLTISW1);
    485 vspltisw<2> the_vspltisw2("vspltisw2", OP_VSPLTISW2);
    486 vspltisw<3> the_vspltisw3("vspltisw3", OP_VSPLTISW3);
    487 
    488 template<unsigned N>
    489 struct vsldoi : public Operator {
    490   vsldoi(const char *Name, unsigned Opc)
    491     : Operator(MakeMask(N&7, (N+1)&7, (N+2)&7, (N+3)&7), Name, Opc) {
    492   }
    493 };
    494 
    495 vsldoi<1> the_vsldoi1("vsldoi4" , OP_VSLDOI4);
    496 vsldoi<2> the_vsldoi2("vsldoi8" , OP_VSLDOI8);
    497 vsldoi<3> the_vsldoi3("vsldoi12", OP_VSLDOI12);
    498 
    499 #endif
    500 
    501 #define GENERATE_NEON
    502 
    503 #ifdef GENERATE_NEON
    504 enum {
    505   OP_COPY = 0,   // Copy, used for things like <u,u,u,3> to say it is <0,1,2,3>
    506   OP_VREV,
    507   OP_VDUP0,
    508   OP_VDUP1,
    509   OP_VDUP2,
    510   OP_VDUP3,
    511   OP_VEXT1,
    512   OP_VEXT2,
    513   OP_VEXT3,
    514   OP_VUZPL, // VUZP, left result
    515   OP_VUZPR, // VUZP, right result
    516   OP_VZIPL, // VZIP, left result
    517   OP_VZIPR, // VZIP, right result
    518   OP_VTRNL, // VTRN, left result
    519   OP_VTRNR  // VTRN, right result
    520 };
    521 
    522 struct vrev : public Operator {
    523   vrev() : Operator(0x1032, "vrev", OP_VREV) {}
    524 } the_vrev;
    525 
    526 template<unsigned Elt>
    527 struct vdup : public Operator {
    528   vdup(const char *N, unsigned Opc)
    529     : Operator(MakeMask(Elt, Elt, Elt, Elt), N, Opc) {}
    530 };
    531 
    532 vdup<0> the_vdup0("vdup0", OP_VDUP0);
    533 vdup<1> the_vdup1("vdup1", OP_VDUP1);
    534 vdup<2> the_vdup2("vdup2", OP_VDUP2);
    535 vdup<3> the_vdup3("vdup3", OP_VDUP3);
    536 
    537 template<unsigned N>
    538 struct vext : public Operator {
    539   vext(const char *Name, unsigned Opc)
    540     : Operator(MakeMask(N&7, (N+1)&7, (N+2)&7, (N+3)&7), Name, Opc) {
    541   }
    542 };
    543 
    544 vext<1> the_vext1("vext1", OP_VEXT1);
    545 vext<2> the_vext2("vext2", OP_VEXT2);
    546 vext<3> the_vext3("vext3", OP_VEXT3);
    547 
    548 struct vuzpl : public Operator {
    549   vuzpl() : Operator(0x0246, "vuzpl", OP_VUZPL, 2) {}
    550 } the_vuzpl;
    551 
    552 struct vuzpr : public Operator {
    553   vuzpr() : Operator(0x1357, "vuzpr", OP_VUZPR, 2) {}
    554 } the_vuzpr;
    555 
    556 struct vzipl : public Operator {
    557   vzipl() : Operator(0x0415, "vzipl", OP_VZIPL, 2) {}
    558 } the_vzipl;
    559 
    560 struct vzipr : public Operator {
    561   vzipr() : Operator(0x2637, "vzipr", OP_VZIPR, 2) {}
    562 } the_vzipr;
    563 
    564 struct vtrnl : public Operator {
    565   vtrnl() : Operator(0x0426, "vtrnl", OP_VTRNL, 2) {}
    566 } the_vtrnl;
    567 
    568 struct vtrnr : public Operator {
    569   vtrnr() : Operator(0x1537, "vtrnr", OP_VTRNR, 2) {}
    570 } the_vtrnr;
    571 
    572 #endif
    573