Pass an optional "code" to EmitRecordWithAbbrevImpl()

[mehdi_amini]

Summary

This avoids having EmitRecord() shifts the Vals array to insert the
code at the front.

[mehdi_amini]

r247186. Thanks Teresa.

include/llvm/Bitcode/BitstreamWriter.h

case BitCodeAbbrevOp::Char6:
       break;
     }
   }
 
   /// EmitRecordWithAbbrevImpl - This is the core implementation of the record
   /// emission code.  If BlobData is non-null, then it specifies an array of
   /// data that should be emitted as part of the Blob or Array operand that is
   /// known to exist at the end of the record.
+  /// An optional Code can be passed separately as a convenience to avoid
+  /// having EmitRecord() performing a push_front on Vals.
   template <typename uintty>
   void EmitRecordWithAbbrevImpl(unsigned Abbrev, const ArrayRef<uintty> &Vals,
-                                StringRef Blob) {
+                                StringRef Blob,
+                                Optional<uintty> Code = Optional<uintty>()) {
     const char *BlobData = Blob.data();
     unsigned BlobLen = (unsigned) Blob.size();
     unsigned AbbrevNo = Abbrev-bitc::FIRST_APPLICATION_ABBREV;
     assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!");
     const BitCodeAbbrev *Abbv = CurAbbrevs[AbbrevNo].get();
 
     EmitCode(Abbrev);
 
     unsigned RecordIdx = 0;
-    for (unsigned i = 0, e = static_cast<unsigned>(Abbv->getNumOperandInfos());
-         i != e; ++i) {
+    unsigned i = 0, e = static_cast<unsigned>(Abbv->getNumOperandInfos());
+
+    // If a "Code" is passed in separately, emit it first.
+    if (Code) {
+      assert(e && "Expected non-empty abbreviation");
+      const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i++);
+      assert(!Op.getEncoding() == BitCodeAbbrevOp::Array &&
+             !Op.getEncoding() == BitCodeAbbrevOp::Blob &&
+             "Expected literal or scalar code");
+
+      if (Op.isLiteral())
+        EmitAbbreviatedLiteral(Op, Code.getValue());
+      else
+        EmitAbbreviatedField(Op, Code.getValue());
+    }
+
+    // Main loop, emitting all value in Vals.
+    for (; i != e; ++i) {
       const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
       if (Op.isLiteral()) {
         assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
         EmitAbbreviatedLiteral(Op, Vals[RecordIdx]);
         ++RecordIdx;
       } else if (Op.getEncoding() == BitCodeAbbrevOp::Array) {
         // Array case.
         assert(i+2 == e && "array op not second to last?");
if (!Abbrev) {
       EmitCode(bitc::UNABBREV_RECORD);
       EmitVBR(Code, 6);
       EmitVBR(static_cast<uint32_t>(Vals.size()), 6);
       for (unsigned i = 0, e = static_cast<unsigned>(Vals.size()); i != e; ++i)
         EmitVBR64(Vals[i], 6);
       return;
     }
 
-    // Insert the code into Vals to treat it uniformly.
-    Vals.insert(Vals.begin(), Code);
-
-    EmitRecordWithAbbrev(Abbrev, makeArrayRef(Vals));
+    EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), StringRef(),
+                             Optional<uintty>(Code));
   }
 
   /// EmitRecordWithAbbrev - Emit a record with the specified abbreviation.
   /// Unlike EmitRecord, the code for the record should be included in Vals as
   /// the first entry.
   template <typename uintty>
   void EmitRecordWithAbbrev(unsigned Abbrev, const ArrayRef<uintty> &Vals) {
     EmitRecordWithAbbrevImpl(Abbrev, Vals, StringRef());