Linux sandbox: Remove CodeGen::JoinInstructions.

sandbox/linux/seccomp-bpf/codegen_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sandbox/linux/seccomp-bpf/codegen.h"
 
 #include <errno.h>
 #include <linux/filter.h>
 
 #include <set>
@@ skipping 66 matching lines @@
   Instruction* ret = codegen->MakeInstruction(
       BPF_RET + BPF_K, 0);
   return codegen->MakeInstruction(BPF_JMP + BPF_JEQ + BPF_K, 42, ret, ret);
 }
 
 Instruction* SampleProgramComplex(CodeGen* codegen, int* flags) {
   // Creates a basic BPF program that we'll use to test some of the code:
   //    JUMP if eq 42 the $0 else $1     (insn6)
   // 0: LD 23                            (insn5)
   // 1: JUMP if eq 42 then $2 else $4    (insn4)
-  // 2: JUMP to $3                       (insn1)
-  // 3: LD 42                            (insn0)
-  //    RET 42                           (insn2)
+  // 2: JUMP to $3                       (insn2)
+  // 3: LD 42                            (insn1)
+  //    RET 42                           (insn0)
   // 4: LD 42                            (insn3)
   //    RET 42                           (insn3+)
   *flags = HAS_MERGEABLE_TAILS;
 
-  Instruction* insn0 = codegen->MakeInstruction(BPF_LD + BPF_W + BPF_ABS, 42);
+  Instruction* insn0 = codegen->MakeInstruction(BPF_RET + BPF_K, 42);
   SANDBOX_ASSERT(insn0);
-  SANDBOX_ASSERT(insn0->code == BPF_LD + BPF_W + BPF_ABS);
-  SANDBOX_ASSERT(insn0->k == 42);
+  SANDBOX_ASSERT(insn0->code == BPF_RET + BPF_K);
   SANDBOX_ASSERT(insn0->next == NULL);
 
-  Instruction* insn1 = codegen->MakeInstruction(BPF_JMP + BPF_JA, 0, insn0);
+  Instruction* insn1 =
+      codegen->MakeInstruction(BPF_LD + BPF_W + BPF_ABS, 42, insn0);
   SANDBOX_ASSERT(insn1);
-  SANDBOX_ASSERT(insn1->code == BPF_JMP + BPF_JA);
-  SANDBOX_ASSERT(insn1->jt_ptr == insn0);
+  SANDBOX_ASSERT(insn1->code == BPF_LD + BPF_W + BPF_ABS);
+  SANDBOX_ASSERT(insn1->k == 42);
+  SANDBOX_ASSERT(insn1->next == insn0);
 
-  Instruction* insn2 = codegen->MakeInstruction(BPF_RET + BPF_K, 42);
+  Instruction* insn2 = codegen->MakeInstruction(BPF_JMP + BPF_JA, 0, insn1);
   SANDBOX_ASSERT(insn2);
-  SANDBOX_ASSERT(insn2->code == BPF_RET + BPF_K);
-  SANDBOX_ASSERT(insn2->next == NULL);
+  SANDBOX_ASSERT(insn2->code == BPF_JMP + BPF_JA);
+  SANDBOX_ASSERT(insn2->jt_ptr == insn1);
 
   // We explicitly duplicate instructions so that MergeTails() can coalesce
   // them later.
   Instruction* insn3 = codegen->MakeInstruction(
       BPF_LD + BPF_W + BPF_ABS,
       42,
       codegen->MakeInstruction(BPF_RET + BPF_K, 42));
 
   Instruction* insn4 =
-      codegen->MakeInstruction(BPF_JMP + BPF_JEQ + BPF_K, 42, insn1, insn3);
+      codegen->MakeInstruction(BPF_JMP + BPF_JEQ + BPF_K, 42, insn2, insn3);
   SANDBOX_ASSERT(insn4);
   SANDBOX_ASSERT(insn4->code == BPF_JMP + BPF_JEQ + BPF_K);
   SANDBOX_ASSERT(insn4->k == 42);
-  SANDBOX_ASSERT(insn4->jt_ptr == insn1);
+  SANDBOX_ASSERT(insn4->jt_ptr == insn2);
   SANDBOX_ASSERT(insn4->jf_ptr == insn3);
 
-  codegen->JoinInstructions(insn0, insn2);
-  SANDBOX_ASSERT(insn0->next == insn2);
-
   Instruction* insn5 =
       codegen->MakeInstruction(BPF_LD + BPF_W + BPF_ABS, 23, insn4);
   SANDBOX_ASSERT(insn5);
   SANDBOX_ASSERT(insn5->code == BPF_LD + BPF_W + BPF_ABS);
   SANDBOX_ASSERT(insn5->k == 23);
   SANDBOX_ASSERT(insn5->next == insn4);
 
   // Force a basic block that ends in neither a jump instruction nor a return
   // instruction. It only contains "insn5". This exercises one of the less
   // common code paths in the topo-sort algorithm.
@@ skipping 394 matching lines @@
     assembly.append(reinterpret_cast<char*>(&insn.k), sizeof(insn.k));
   }
   SANDBOX_ASSERT(source == assembly);
 }
 
 SANDBOX_TEST(CodeGen, All) {
   ForAllPrograms(CompileAndCompare);
 }
 
 }  // namespace sandbox