diff --git a/src/main/java/com/android/tools/r8/graph/DefaultInstanceInitializerCode.java b/src/main/java/com/android/tools/r8/graph/DefaultInstanceInitializerCode.java
index 9b11e7e..d2f05df 100644
--- a/src/main/java/com/android/tools/r8/graph/DefaultInstanceInitializerCode.java
+++ b/src/main/java/com/android/tools/r8/graph/DefaultInstanceInitializerCode.java
@@ -22,7 +22,6 @@
 import com.android.tools.r8.ir.analysis.type.Nullability;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.IRMetadata;
 import com.android.tools.r8.ir.code.InvokeDirect;
 import com.android.tools.r8.ir.code.NumberGenerator;
 import com.android.tools.r8.ir.code.Position;
@@ -393,7 +392,6 @@
             method.getDefinition().isD8R8Synthesized(),
             strategy,
             appView.options())
-        .setMetadata(IRMetadata.unknown())
         .addArgument(0, false)
         .addInvokeDirect(invokedMethod, ImmutableList.of(receiver), false)
         .addReturnVoid()
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index 79d8789..e71bb97 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -37,7 +37,6 @@
 import com.android.tools.r8.graph.lens.GraphLens;
 import com.android.tools.r8.graph.proto.ArgumentInfoCollection;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
-import com.android.tools.r8.ir.code.IRMetadata;
 import com.android.tools.r8.ir.code.NumericType;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.code.ValueType;
@@ -997,8 +996,7 @@
     LirEncodingStrategy<Value, Integer> strategy =
         LirStrategy.getDefaultStrategy().getEncodingStrategy();
     LirBuilder<Value, Integer> lirBuilder =
-        LirCode.builder(getReference(), isD8R8Synthesized(), strategy, appView.options())
-            .setMetadata(IRMetadata.unknown());
+        LirCode.builder(getReference(), isD8R8Synthesized(), strategy, appView.options());
     int instructionIndex = 0;
     for (; instructionIndex < getNumberOfArguments(); instructionIndex++) {
       DexType argumentType = getArgumentType(instructionIndex);
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/IncompleteMergedInstanceInitializerCode.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/IncompleteMergedInstanceInitializerCode.java
index 6bd8269..9ee8dcf 100644
--- a/src/main/java/com/android/tools/r8/horizontalclassmerging/IncompleteMergedInstanceInitializerCode.java
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/IncompleteMergedInstanceInitializerCode.java
@@ -33,7 +33,6 @@
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.analysis.value.SingleConstValue;
 import com.android.tools.r8.ir.analysis.value.SingleDexItemBasedStringValue;
-import com.android.tools.r8.ir.code.IRMetadata;
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.Position.SyntheticPosition;
 import com.android.tools.r8.ir.code.Value;
@@ -199,11 +198,10 @@
         LirStrategy.getDefaultStrategy().getEncodingStrategy();
     LirBuilder<Value, Integer> lirBuilder =
         LirCode.builder(
-                method.getReference(),
-                method.getDefinition().isD8R8Synthesized(),
-                strategy,
-                appView.options())
-            .setMetadata(IRMetadata.unknown());
+            method.getReference(),
+            method.getDefinition().isD8R8Synthesized(),
+            strategy,
+            appView.options());
 
     int instructionIndex = 0;
     List<Value> argumentValues = new ArrayList<>();
diff --git a/src/main/java/com/android/tools/r8/lightir/IR2LirConverter.java b/src/main/java/com/android/tools/r8/lightir/IR2LirConverter.java
index 4c78283..a207282 100644
--- a/src/main/java/com/android/tools/r8/lightir/IR2LirConverter.java
+++ b/src/main/java/com/android/tools/r8/lightir/IR2LirConverter.java
@@ -44,7 +44,6 @@
                 irCode.context().getDefinition().isD8R8Synthesized(),
                 strategy,
                 options)
-            .setMetadata(irCode.metadata())
             .prepareForBytecodeInstructionMetadata(bytecodeMetadataProvider.size());
   }
 
diff --git a/src/main/java/com/android/tools/r8/lightir/Lir2IRConverter.java b/src/main/java/com/android/tools/r8/lightir/Lir2IRConverter.java
index d7ee8d3..e8deff4 100644
--- a/src/main/java/com/android/tools/r8/lightir/Lir2IRConverter.java
+++ b/src/main/java/com/android/tools/r8/lightir/Lir2IRConverter.java
@@ -47,6 +47,7 @@
 import com.android.tools.r8.ir.code.Div;
 import com.android.tools.r8.ir.code.Goto;
 import com.android.tools.r8.ir.code.IRCode;
+import com.android.tools.r8.ir.code.IRMetadata;
 import com.android.tools.r8.ir.code.If;
 import com.android.tools.r8.ir.code.IfType;
 import com.android.tools.r8.ir.code.InitClass;
@@ -171,6 +172,7 @@
     private final RewrittenPrototypeDescription protoChanges;
 
     private final Int2ReferenceMap<BasicBlock> blocks = new Int2ReferenceOpenHashMap<>();
+    private final IRMetadata irMetadata = new IRMetadata();
 
     private BasicBlock currentBlock = null;
     private int nextInstructionIndex = 0;
@@ -352,7 +354,7 @@
           blockList,
           strategy.getValueNumberGenerator(),
           basicBlockNumberGenerator,
-          code.getMetadataForIR(),
+          irMetadata,
           conversionOptions);
     }
 
@@ -429,6 +431,7 @@
       advanceInstructionState();
       instruction.setPosition(currentPosition);
       currentBlock.getInstructions().add(instruction);
+      irMetadata.record(instruction);
       instruction.setBlock(currentBlock);
       int[] debugEndIndices = code.getDebugLocalEnds(index);
       if (debugEndIndices != null) {
@@ -475,6 +478,7 @@
       Argument argument = new Argument(dest, currentBlock.size(), isBooleanType);
       argument.setPosition(currentPosition);
       currentBlock.getInstructions().add(argument);
+      irMetadata.record(argument);
       argument.setBlock(currentBlock);
       return argument;
     }
diff --git a/src/main/java/com/android/tools/r8/lightir/LirBuilder.java b/src/main/java/com/android/tools/r8/lightir/LirBuilder.java
index c243c7b..7fbec5b 100644
--- a/src/main/java/com/android/tools/r8/lightir/LirBuilder.java
+++ b/src/main/java/com/android/tools/r8/lightir/LirBuilder.java
@@ -24,7 +24,6 @@
 import com.android.tools.r8.ir.code.CatchHandlers;
 import com.android.tools.r8.ir.code.Cmp;
 import com.android.tools.r8.ir.code.Cmp.Bias;
-import com.android.tools.r8.ir.code.IRMetadata;
 import com.android.tools.r8.ir.code.IfType;
 import com.android.tools.r8.ir.code.MemberType;
 import com.android.tools.r8.ir.code.MonitorType;
@@ -75,7 +74,6 @@
   private final List<PositionEntry> positionTable;
   private int argumentCount = 0;
   private int instructionCount = 0;
-  private IRMetadata metadata = null;
 
   private final LirEncodingStrategy<V, EV> strategy;
 
@@ -416,11 +414,6 @@
     ByteUtils.writeEncodedInt(index, writer::writeOperand);
   }
 
-  public LirBuilder<V, EV> setMetadata(IRMetadata metadata) {
-    this.metadata = metadata;
-    return this;
-  }
-
   public LirBuilder<V, EV> setDebugValue(DebugLocalInfo debugInfo, EV valueIndex) {
     DebugLocalInfo old = debugLocals.put(valueIndex, debugInfo);
     assert old == null;
@@ -924,7 +917,6 @@
   }
 
   public LirCode<EV> build() {
-    assert metadata != null;
     int constantsCount = constants.size();
     LirConstant[] constantTable = new LirConstant[constantsCount];
     constants.forEach((item, index) -> constantTable[index] = item);
@@ -933,7 +925,6 @@
     TryCatchTable tryCatchTable =
         tryCatchRanges.isEmpty() ? null : new TryCatchTable(tryCatchRanges);
     return new LirCode<>(
-        metadata,
         constantTable,
         positionTable.toArray(new PositionEntry[positionTable.size()]),
         argumentCount,
diff --git a/src/main/java/com/android/tools/r8/lightir/LirCode.java b/src/main/java/com/android/tools/r8/lightir/LirCode.java
index 91a85d7..0158379 100644
--- a/src/main/java/com/android/tools/r8/lightir/LirCode.java
+++ b/src/main/java/com/android/tools/r8/lightir/LirCode.java
@@ -25,7 +25,6 @@
 import com.android.tools.r8.ir.code.CanonicalPositions;
 import com.android.tools.r8.ir.code.CatchHandlers;
 import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.IRMetadata;
 import com.android.tools.r8.ir.code.NumberGenerator;
 import com.android.tools.r8.ir.code.Position;
 import com.android.tools.r8.ir.code.Position.SourcePosition;
@@ -344,8 +343,6 @@
 
   private final boolean useDexEstimationStrategy;
 
-  private final IRMetadata irMetadata;
-
   /** Constant pool of items. */
   private final LirConstant[] constants;
 
@@ -380,8 +377,7 @@
   private static <EV> void specify(StructuralSpecification<LirCode<EV>, ?> spec) {
     // strategyInfo is compiler meta-data (constant for a given compilation unit).
     // useDexEstimationStrategy is compiler meta-data (constant for a given compilation unit).
-    spec.withItem(c -> c.irMetadata)
-        .withCustomItemArray(c -> c.constants, LirConstantStructuralAcceptor.getInstance())
+    spec.withCustomItemArray(c -> c.constants, LirConstantStructuralAcceptor.getInstance())
         .withItemArray(c -> c.positionTable)
         .withInt(c -> c.argumentCount)
         .withByteArray(c -> c.instructions)
@@ -393,7 +389,6 @@
 
   protected LirCode(LirCode<EV> code) {
     this(
-        code.irMetadata,
         code.constants,
         code.positionTable,
         code.argumentCount,
@@ -408,7 +403,6 @@
 
   /** Should be constructed using {@link LirBuilder}. */
   LirCode(
-      IRMetadata irMetadata,
       LirConstant[] constants,
       PositionEntry[] positionTable,
       int argumentCount,
@@ -420,7 +414,6 @@
       boolean useDexEstimationStrategy,
       Int2ReferenceMap<BytecodeInstructionMetadata> metadataMap) {
     assert positionTable != null;
-    this.irMetadata = irMetadata;
     this.constants = constants;
     this.positionTable = positionTable;
     this.argumentCount = argumentCount;
@@ -482,10 +475,6 @@
     return instructionCount;
   }
 
-  public IRMetadata getMetadataForIR() {
-    return irMetadata;
-  }
-
   public LirConstant getConstantItem(int index) {
     return constants[index];
   }
@@ -740,7 +729,6 @@
       return this;
     }
     return new LirCode<>(
-        irMetadata,
         constants,
         newPositionTable,
         argumentCount,
@@ -789,7 +777,6 @@
       return this;
     }
     return new LirCode<>(
-        irMetadata,
         rewrittenConstants,
         positionTable,
         argumentCount,
@@ -807,7 +794,6 @@
       return this;
     }
     return new LirCode<>(
-        irMetadata,
         constants,
         positionTable,
         argumentCount,
@@ -836,9 +822,8 @@
   }
 
   public LirCode<EV> copyWithNewConstantsAndInstructions(
-      IRMetadata irMetadata, LirConstant[] constants, byte[] instructions) {
+      LirConstant[] constants, byte[] instructions) {
     return new LirCode<>(
-        irMetadata,
         constants,
         positionTable,
         argumentCount,
diff --git a/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java b/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java
index e0112c3..a12f88c 100644
--- a/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/lightir/LirLensCodeRewriter.java
@@ -24,8 +24,6 @@
 import com.android.tools.r8.graph.proto.RewrittenPrototypeDescription;
 import com.android.tools.r8.horizontalclassmerging.HorizontalClassMergerGraphLens;
 import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.IRMetadata;
-import com.android.tools.r8.ir.code.IROpcodeUtils;
 import com.android.tools.r8.ir.code.InvokeType;
 import com.android.tools.r8.ir.conversion.IRToLirFinalizer;
 import com.android.tools.r8.ir.conversion.LensCodeRewriter;
@@ -443,7 +441,6 @@
       }
     }
 
-    IRMetadata irMetadata = code.getMetadataForIR();
     ByteArrayWriter byteWriter = new ByteArrayWriter();
     LirWriter lirWriter = new LirWriter(byteWriter);
     List<LirConstant> methodsToAppend = new ArrayList<>(numberOfInvokeOpcodeChanges);
@@ -475,9 +472,6 @@
       int newOpcode = newType.getLirOpcode(newIsInterface);
       if (newOpcode != opcode) {
         --numberOfInvokeOpcodeChanges;
-        if (newType != type) {
-          irMetadata.record(IROpcodeUtils.fromLirInvokeOpcode(newOpcode));
-        }
         constantIndex =
             methodIndices.computeIfAbsent(
                 result.getReference(),
@@ -500,7 +494,6 @@
     // building IR again, it is just a small and size overhead.
     LirCode<EV> newCode =
         code.copyWithNewConstantsAndInstructions(
-            irMetadata,
             ArrayUtils.appendElements(code.getConstantPool(), methodsToAppend),
             byteWriter.toByteArray());
     return newCode;
diff --git a/src/main/java/com/android/tools/r8/utils/DequeUtils.java b/src/main/java/com/android/tools/r8/utils/DequeUtils.java
index 986a6a2..d08bca1 100644
--- a/src/main/java/com/android/tools/r8/utils/DequeUtils.java
+++ b/src/main/java/com/android/tools/r8/utils/DequeUtils.java
@@ -16,6 +16,7 @@
     return deque;
   }
 
+  @SafeVarargs
   public static <T> Deque<T> newArrayDeque(T... elements) {
     Deque<T> deque = new ArrayDeque<>();
     Collections.addAll(deque, elements);
diff --git a/src/main/java/com/android/tools/r8/verticalclassmerging/IncompleteVerticalClassMergerBridgeCode.java b/src/main/java/com/android/tools/r8/verticalclassmerging/IncompleteVerticalClassMergerBridgeCode.java
index ffe892f..e732306 100644
--- a/src/main/java/com/android/tools/r8/verticalclassmerging/IncompleteVerticalClassMergerBridgeCode.java
+++ b/src/main/java/com/android/tools/r8/verticalclassmerging/IncompleteVerticalClassMergerBridgeCode.java
@@ -19,7 +19,6 @@
 import com.android.tools.r8.graph.UseRegistry;
 import com.android.tools.r8.ir.analysis.type.TypeElement;
 import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.code.IRMetadata;
 import com.android.tools.r8.ir.code.InvokeType;
 import com.android.tools.r8.ir.code.Value;
 import com.android.tools.r8.ir.conversion.MethodConversionOptions.MutableMethodConversionOptions;
@@ -104,8 +103,7 @@
     LirEncodingStrategy<Value, Integer> strategy =
         LirStrategy.getDefaultStrategy().getEncodingStrategy();
     LirBuilder<Value, Integer> lirBuilder =
-        LirCode.builder(method, isD8R8Synthesized, strategy, appView.options())
-            .setMetadata(IRMetadata.unknown());
+        LirCode.builder(method, isD8R8Synthesized, strategy, appView.options());
 
     // Add all arguments.
     List<Value> argumentValues = new ArrayList<>();
diff --git a/src/test/java/com/android/tools/r8/lightir/LirBasicCallbackTest.java b/src/test/java/com/android/tools/r8/lightir/LirBasicCallbackTest.java
index a6cc50b..9ba26e1 100644
--- a/src/test/java/com/android/tools/r8/lightir/LirBasicCallbackTest.java
+++ b/src/test/java/com/android/tools/r8/lightir/LirBasicCallbackTest.java
@@ -81,7 +81,6 @@
             .createMethod(Reference.methodFromDescriptor("LFoo;", "bar", "()V"));
     LirCode<?> code =
         LirCode.builder(method, false, new ThrowingStrategy(), options)
-            .setMetadata(IRMetadata.unknown())
             .addConstNull()
             .addConstInt(42)
             .build();
