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    * Struct_classify.shape_field_struct list
  40    * Struct_classify.content_field_struct list) list ->
  41   code
  42     (** [generate_types structures] generates the internal
  43         types used to store variants of each structure, including:
  44         - shape field structures
  45         - content field structures
  46     *)
  47
  48 (** {2 Generate offset functions}
  49
  50     [offset_of_<struct>_<field> kernel_version] functions.
  51
  52     These actually play a very minor role: We just use them when
  53     adjusting [list_head] pointers which cross between structure
  54     types, so we only generate functions for those right now.
  55 *)
  56
  57 val generate_offsets :
  58   (string * ((Pahole_parser.info * Pahole_parser.structure) list
  59              * (string * Pahole_parser.f_type) list)) list ->
  60   code
  61     (** [generate_offsets] generates the offset functions. *)
  62
  63 (** {2 Generate parsers}
  64
  65     Functions which parse the different structures from bitstrings
  66     into our internal types.
  67 *)
  68
  69 val generate_parsers : (string * Struct_classify.parser_ list) list ->
  70   code * (string, string) Hashtbl.t
  71     (** [generate_parsers] generates the parser functions.
  72
  73         We cannot generate the complete code here because we
  74         don't want camlp4 parsing this file to substitute bitmatch
  75         code yet.  So we only generate labels, which get substituted
  76         by the contents of the returned hash table in {!output_implem}.
  77     *)
  78
  79 (** {2 Generate followers}
  80
  81     The "followers" are functions which recursively follow every
  82     structure in the kernel, starting out at known root structures
  83     such as [init_task] and [init_net].  Their job is to (a) find
  84     every kernel structure, (b) ensure it is loaded into our
  85     memory map, (c) produce a map of address -> structure.
  86 *)
  87
  88 val generate_followers :
  89   (string * ((Pahole_parser.info * Pahole_parser.structure) list
  90              * Struct_classify.shape_field_struct list
  91              * Struct_classify.sfhash * Struct_classify.pahash)) list ->
  92   code
  93   (** [generate_followers] generates the follower functions. *)
  94
  95 (** {2 Output final files} *)
  96
  97 val output_interf : output_file:string ->
  98   Camlp4.PreCast.Syntax.Ast.sig_item ->
  99   Camlp4.PreCast.Syntax.Ast.sig_item ->
 100   Camlp4.PreCast.Syntax.Ast.sig_item ->
 101   Camlp4.PreCast.Syntax.Ast.sig_item ->
 102   unit
 103   (** Output the interface file. *)
 104
 105 val output_implem : output_file:string ->
 106   Camlp4.PreCast.Syntax.Ast.str_item ->
 107   Camlp4.PreCast.Syntax.Ast.str_item ->
 108   Camlp4.PreCast.Syntax.Ast.str_item ->
 109   (string, string) Hashtbl.t ->
 110   Camlp4.PreCast.Syntax.Ast.str_item ->
 111   unit
 112   (** Output the implementation file. *)