CodeGen: refactor API [1/3]

sandbox/linux/seccomp-bpf/codegen.h

 // 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.
 
 #ifndef SANDBOX_LINUX_SECCOMP_BPF_CODEGEN_H__
 #define SANDBOX_LINUX_SECCOMP_BPF_CODEGEN_H__
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 16 matching lines @@
 // The code generator instantiates a basic compiler that can convert a
 // graph of BPF instructions into a well-formed stream of BPF instructions.
 // Most notably, it ensures that jumps are always forward and don't exceed
 // the limit of 255 instructions imposed by the instruction set.
 //
 // Callers would typically create a new CodeGen object and then use it to
 // build a DAG of Instructions. They'll eventually call Compile() to convert
 // this DAG to a Program.
 //
 //   CodeGen gen;
-//   Instruction *allow, *branch, *dag;
+//   CodeGen::Addr allow, branch, dag;
 //
 //   allow =
 //     gen.MakeInstruction(BPF_RET+BPF_K,
 //                         ErrorCode(ErrorCode::ERR_ALLOWED).err()));
 //   branch =
 //     gen.MakeInstruction(BPF_JMP+BPF_EQ+BPF_K, __NR_getpid,
 //                         Trap(GetPidHandler, NULL), allow);
 //   dag =
 //     gen.MakeInstruction(BPF_LD+BPF_W+BPF_ABS,
 //                         offsetof(struct arch_seccomp_data, nr), branch);
 //
 //   // Simplified code follows; in practice, it is important to avoid calling
 //   // any C++ destructors after starting the sandbox.
 //   CodeGen::Program program;
 //   gen.Compile(dag, program);
 //   const struct sock_fprog prog = {
 //     static_cast<unsigned short>(program->size()), &program[0] };
 //   prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog);
 //
 class SANDBOX_EXPORT CodeGen {
  public:
   // A vector of BPF instructions that need to be installed as a filter
   // program in the kernel.
   typedef std::vector<struct sock_filter> Program;
 
+  // Addr represents a logical location within the program being compiled.
+  // Identical code suffixes may be collapsed to a single location.
+  using Addr = Instruction*;

[mdempsky, 2014/11/04 01:31:15]

(As a side note: I'm not particularly attached to this name, if you have
suggestions for an alternative.  I've also been considering "Loc[ation]" and
"Node".)

+
+  // kNullAddr represents the "null" address value; i.e., the reserved
+  // address value guaranteed to not equal any actual address values.
+  static const Addr kNullAddr;
+
   CodeGen();
   ~CodeGen();
 
   // Create a new instruction. Instructions form a DAG. The instruction objects
   // are owned by the CodeGen object. They do not need to be explicitly
   // deleted.
   // For details on the possible parameters refer to <linux/filter.h>
-  Instruction* MakeInstruction(uint16_t code,
-                               uint32_t k,
-                               Instruction* next = nullptr);
-  Instruction* MakeInstruction(uint16_t code,
-                               uint32_t k,
-                               Instruction* jt,
-                               Instruction* jf);
+  Addr MakeInstruction(uint16_t code,
+                       uint32_t k,
+                       Addr jt = kNullAddr,
+                       Addr jf = kNullAddr);

[jln (very slow on Chromium), 2014/11/11 08:40:48]

These are normally illegal. Overload are better tolerated when they don't have
the same number of arguments.

This is fine with me though since you're modifying existing code, but you could
consider emulating the default arguments with an overload. (Yeah, it seems a bit
silly :/)

[mdempsky, 2014/11/17 22:11:07]

I've decided to just add a TODO to reconsider the default arguments for now.
There are a few ways I can see to address this, and I'll have an easier way
deciding which one is best once these three CLs have landed.

 
   // Compiles the graph of instructions into a BPF program that can be passed
   // to the kernel. Please note that this function modifies the graph in place
   // and must therefore only be called once per graph.
-  void Compile(Instruction* instructions, Program* program);
+  void Compile(Addr head, Program* program);
 
  private:
   friend class CodeGenUnittestHelper;
 
   // Find all the instructions that are the target of BPF_JMPs.
   void FindBranchTargets(const Instruction& instructions,
                          BranchTargets* branch_targets);
 
   // Combine instructions between "head" and "tail" into a new basic block.
   // Basic blocks are defined as sequences of instructions whose only branch
@@ skipping 46 matching lines @@
   BasicBlocks basic_blocks_;
 
   // Compile() must only ever be called once as it makes destructive changes
   // to the DAG.
   bool compiled_;
 };
 
 }  // namespace sandbox
 
 #endif  // SANDBOX_LINUX_SECCOMP_BPF_CODEGEN_H__