extract/codegen/code_generation.mli

   1 (** Code generation. *)
   2 (* Memory info command for virtual domains.
   3    (C) Copyright 2008 Richard W.M. Jones, Red Hat Inc.
   4    http://libvirt.org/
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  *)
  20
  21 (**
  22    This module is concerned with actually generating code
  23    for types, parsers, etc.
  24
  25    We generate two output files, [kernel.mli] is the interface
  26    to the kernel structures, and [kernel.ml] is the implementation.
  27 *)
  28
  29 type code =
  30     Camlp4.PreCast.Syntax.Ast.str_item * Camlp4.PreCast.Syntax.Ast.sig_item
  31
  32 (** {2 Generate types}
  33
  34     Our internal types, representing kernel structures.
  35 *)
  36
  37 val generate_types :
  38   (string
  39    * (string * (Pahole_parser.f_type * bool)) list) list ->
  40   code
  41     (** [generate_types structures] generates the
  42         types used to store each structure.
  43     *)
  44
  45 (** {2 Generate offset functions}
  46
  47     [offset_of_<struct>_<field> kernel_version] functions.
  48
  49     These actually play a very minor role: We just use them when
  50     adjusting [list_head] pointers which cross between structure
  51     types, so we only generate functions for those right now.
  52 *)
  53
  54 val generate_offsets :
  55   (string * ((Pahole_parser.info * Pahole_parser.structure) list
  56              * (string * (Pahole_parser.f_type * bool)) list)) list ->
  57   code
  58     (** [generate_offsets] generates the offset functions. *)
  59
  60 (** {2 Generate parsers}
  61
  62     Functions which parse the different structures from bitstrings
  63     into our internal types.
  64 *)
  65
  66 val generate_parsers :
  67   (string * ((string * (Pahole_parser.f_type * bool)) list
  68              * Minimizer.parser_ list)) list ->
  69   code * (string, string) Hashtbl.t
  70     (** [generate_parsers] generates the parser functions.
  71
  72         We cannot generate the complete code here because we
  73         don't want camlp4 parsing this file to substitute bitmatch
  74         code yet.  So we only generate labels, which get substituted
  75         by the contents of the returned hash table in {!output_implem}.
  76     *)
  77
  78 (** {2 Generate version maps}
  79
  80     The version maps are functions such as [size_of_<struct> kernel_version]
  81     which return some aspects of the structures and fields that
  82     depend at runtime on the kernel version.
  83 *)
  84
  85 val generate_version_maps :
  86   (string * ((Pahole_parser.info * Pahole_parser.structure) list
  87              * (string, Minimizer.parser_) Hashtbl.t)) list ->
  88   code
  89
  90 (** {2 Generate followers}
  91
  92     The "followers" are functions which recursively follow every
  93     structure in the kernel, starting out at known root structures
  94     such as [init_task] and [init_net].  Their job is to (a) find
  95     every kernel structure, (b) ensure it is loaded into our
  96     memory map, (c) produce a map of address -> structure.
  97 *)
  98
  99 val generate_followers :
 100   string list ->
 101   (string * (string * (Pahole_parser.f_type * bool)) list) list ->
 102   code
 103   (** [generate_followers] generates the follower functions. *)
 104
 105 (** {2 Output final files} *)
 106
 107 val output_interf : output_file:string ->
 108   Camlp4.PreCast.Syntax.Ast.sig_item ->
 109   Camlp4.PreCast.Syntax.Ast.sig_item ->
 110   Camlp4.PreCast.Syntax.Ast.sig_item ->
 111   Camlp4.PreCast.Syntax.Ast.sig_item ->
 112   Camlp4.PreCast.Syntax.Ast.sig_item ->
 113   unit
 114   (** Output the interface file. *)
 115
 116 val output_implem : output_file:string ->
 117   Camlp4.PreCast.Syntax.Ast.str_item ->
 118   Camlp4.PreCast.Syntax.Ast.str_item ->
 119   Camlp4.PreCast.Syntax.Ast.str_item ->
 120   (string, string) Hashtbl.t ->
 121   Camlp4.PreCast.Syntax.Ast.str_item ->
 122   Camlp4.PreCast.Syntax.Ast.str_item ->
 123   unit
 124   (** Output the implementation file. *)