Update from chromium https://crrev.com/304586

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 <linux/filter.h>
 
 #include <set>
 
 #include "base/logging.h"
 #include "sandbox/linux/seccomp-bpf/basicblock.h"
 #include "sandbox/linux/seccomp-bpf/die.h"
 #include "sandbox/linux/seccomp-bpf/instruction.h"
 
 namespace sandbox {
 
+// Unfortunately this needs to be defined out-of-line because inline
+// initializing a static member to "nullptr" requires "constexpr",
+// which is currently banned by the Chromium style guide.
+const CodeGen::Node CodeGen::kNullNode = nullptr;
+
 CodeGen::CodeGen() : compiled_(false) {}
 
 CodeGen::~CodeGen() {
   for (Instructions::iterator iter = instructions_.begin();
        iter != instructions_.end();
        ++iter) {
     delete *iter;
   }
   for (BasicBlocks::iterator iter = basic_blocks_.begin();
        iter != basic_blocks_.end();
        ++iter) {
     delete *iter;
   }
 }
 
-Instruction* CodeGen::MakeInstruction(uint16_t code,
-                                      uint32_t k,
-                                      Instruction* next) {
-  // We can handle non-jumping instructions and "always" jumps. Both of
-  // them are followed by exactly one "next" instruction.
-  // We allow callers to defer specifying "next", but then they must call
-  // "joinInstructions" later.
-  if (BPF_CLASS(code) == BPF_JMP && BPF_OP(code) != BPF_JA) {
-    SANDBOX_DIE(
-        "Must provide both \"true\" and \"false\" branch "
-        "for a BPF_JMP");
+CodeGen::Node CodeGen::MakeInstruction(uint16_t code,
+                                       uint32_t k,
+                                       Node jt,
+                                       Node jf) {
+  Node insn;
+  if (BPF_CLASS(code) == BPF_JMP) {
+    CHECK_NE(kNullNode, jt);
+    if (BPF_OP(code) == BPF_JA) {
+      CHECK_EQ(kNullNode, jf);
+    } else {
+      CHECK_NE(kNullNode, jf);
+    }
+    insn = new Instruction(code, k, jt, jf);
+  } else {
+    if (BPF_CLASS(code) == BPF_RET) {
+      CHECK_EQ(kNullNode, jt);
+    } else {
+      CHECK_NE(kNullNode, jt);
+    }
+    CHECK_EQ(kNullNode, jf);
+    insn = new Instruction(code, k, jt);
   }
-  if (next && BPF_CLASS(code) == BPF_RET) {
-    SANDBOX_DIE("Cannot append instructions after a return statement");
-  }
-  if (BPF_CLASS(code) == BPF_JMP) {
-    // "Always" jumps use the "true" branch target, only.
-    Instruction* insn = new Instruction(code, 0, next, NULL);
-    instructions_.push_back(insn);
-    return insn;
-  } else {
-    // Non-jumping instructions do not use any of the branch targets.
-    Instruction* insn = new Instruction(code, k, next);
-    instructions_.push_back(insn);
-    return insn;
-  }
-}
-
-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) {
-    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::FindBranchTargets(const Instruction& instructions,
                                 BranchTargets* branch_targets) {
   // Follow all possible paths through the "instructions" graph and compute
   // a list of branch targets. This will later be needed to compute the
   // boundaries of basic blocks.
   // We maintain a set of all instructions that we have previously seen. This
@@ skipping 516 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