Linux sandbox: Remove CodeGen::JoinInstructions.

sandbox/linux/seccomp-bpf/codegen.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 <stdio.h>
 
 #include <set>
 
@@ skipping 163 matching lines @@
 
 Instruction* CodeGen::MakeInstruction(uint16_t code,
                                       uint32_t k,
                                       Instruction* jt,
                                       Instruction* jf) {
   // We can handle all conditional jumps. They are followed by both a
   // "true" and a "false" branch.
   if (BPF_CLASS(code) != BPF_JMP || BPF_OP(code) == BPF_JA) {
     SANDBOX_DIE("Expected a BPF_JMP instruction");
   }
-  if (!jt && !jf) {
-    // We allow callers to defer specifying exactly one of the branch
-    // targets. It must then be set later by calling "JoinInstructions".
+  if (!jt || !jf) {
     SANDBOX_DIE("Branches must jump to a valid instruction");
   }
   Instruction* insn = new Instruction(code, k, jt, jf);
   instructions_.push_back(insn);
   return insn;
 }
 
-void CodeGen::JoinInstructions(Instruction* head, Instruction* tail) {
-  // Merge two instructions, or set the branch target for an "always" jump.
-  // This function should be called, if the caller didn't initially provide
-  // a value for "next" when creating the instruction.
-  if (BPF_CLASS(head->code) == BPF_JMP) {
-    if (BPF_OP(head->code) == BPF_JA) {
-      if (head->jt_ptr) {
-        SANDBOX_DIE("Cannot append instructions in the middle of a sequence");
-      }
-      head->jt_ptr = tail;
-    } else {
-      if (!head->jt_ptr && head->jf_ptr) {
-        head->jt_ptr = tail;
-      } else if (!head->jf_ptr && head->jt_ptr) {
-        head->jf_ptr = tail;
-      } else {
-        SANDBOX_DIE("Cannot append instructions after a jump");
-      }
-    }
-  } else if (BPF_CLASS(head->code) == BPF_RET) {
-    SANDBOX_DIE("Cannot append instructions after a return statement");
-  } else if (head->next) {
-    SANDBOX_DIE("Cannot append instructions in the middle of a sequence");
-  } else {
-    head->next = tail;
-  }
-  return;
-}
-
 void CodeGen::Traverse(Instruction* instruction,
                        void (*fnc)(Instruction*, void*),
                        void* aux) {
   std::set<Instruction*> visited;
   TraverseRecursively(&visited, instruction);
   for (std::set<Instruction*>::const_iterator iter = visited.begin();
        iter != visited.end();
        ++iter) {
     fnc(*iter, aux);
   }
@@ skipping 524 matching lines @@
       CutGraphIntoBasicBlocks(instructions, branch_targets, &all_blocks);
   MergeTails(&all_blocks);
   BasicBlocks basic_blocks;
   TopoSortBasicBlocks(first_block, all_blocks, &basic_blocks);
   ComputeRelativeJumps(&basic_blocks, all_blocks);
   ConcatenateBasicBlocks(basic_blocks, program);
   return;
 }
 
 }  // namespace sandbox