Strip debugging pseudo-instructions from the Yk AOT module.

Also added a comment about the way we lower the AOT IR.

Before:
```
  bb1:
    call llvm.dbg.value(?op<i32 %0>, ?op<!31 = !DILocalVariable(name: "argc", arg: 1, scope: !23, file: !2, line: 46, type: !26)>, ?op<!DIExpression()>)
    call llvm.dbg.value(?op<ptr %1>, ?op<!32 = !DILocalVariable(name: "argv", arg: 2, scope: !23, file: !2, line: 46, type: !27)>, ?op<!DIExpression()>)
    $1_2: ptr = ptradd $0_1, 16i64
    store $1_2, GlobalDecl(shadowstack_0, tls=false)
    $1_4: ptr = call yk_mt_new(const_ptr)
    call llvm.experimental.stackmap(1i64, 0i32, $0_0, $0_1, $0_4, $0_5, $0_6, $0_7)
    br
```

After:
```
  bb1:
    $1_0: ptr = ptradd $0_1, 16i64
    store $1_0, GlobalDecl(shadowstack_0, tls=false)
    $1_2: ptr = call yk_mt_new(const_ptr)
    call llvm.experimental.stackmap(1i64, 0i32, $0_0, $0_1, $0_4, $0_5, $0_6, $0_7)
    br
```

Author: vext01

llvm/lib/YkIR/YkIRWriter.cpp

@@ -619,13 +619,46 @@ class YkIRWriter {
 
   void serialiseBlock(BasicBlock &BB, ValueLoweringMap &VLMap,
                       unsigned &BBIdx) {
+    // Keep the instruction skipping logic in one place.
+    auto ShouldSkipInstr = [](Instruction *I) {
+      // Skip non-semantic instrucitons for now.
+      //
+      // We may come back to them later if we need better debugging
+      // facilities, but for now they just clutter up our AOT module.
+      return I->isDebugOrPseudoInst();
+    };
+
+    // Count instructions.
+    //
+    // FIXME: I don't like this much:
+    //
+    //  - Assumes one LLVM instruction becomes exactly one Yk IR instruction.
+    //  - Requires a second loop to count ahead of time.
+    //
+    // Can we emit the instrucitons into a temp buffer and keep a running count
+    // of how many instructions we generated instead?
+    size_t NumInstrs = 0;
+    for (Instruction &I : BB) {
+      if (ShouldSkipInstr(&I)) {
+        continue;
+      }
+      NumInstrs++;
+    }
+
     // num_instrs:
-    OutStreamer.emitSizeT(BB.size());
+    OutStreamer.emitSizeT(NumInstrs);
     // instrs:
     unsigned InstIdx = 0;
     for (Instruction &I : BB) {
+      if (ShouldSkipInstr(&I)) {
+        continue;
+      }
       serialiseInst(&I, VLMap, BBIdx, InstIdx);
     }
+
+    // Check we emitted the number of instructions that we promised.
+    assert(InstIdx == NumInstrs);
+
     BBIdx++;
   }