utils/PerfectShuffle/PerfectShuffle.cpp

   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   Operator *Op;   // The Operation used to generate this value.
  89   unsigned Cost;  // Number of instrs 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   const char *Name;
 106   unsigned short ShuffleMask;
 107   unsigned short OpNum;
 108   unsigned Cost;
 109
 110   Operator(unsigned short shufflemask, const char *name, unsigned opnum,
 111            unsigned cost = 1)
 112     :  Name(name), ShuffleMask(shufflemask), OpNum(opnum),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 = nullptr;
 223   ShufTab[0x0123].Arg0 = 0x0123;
 224   ShufTab[0x4567].Cost = 0;
 225   ShufTab[0x4567].Op = nullptr;
 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