gdb/reply_mig_hack.awk

   1 # Reply server mig-output massager
   2 #
   3 #   Copyright (C) 1995-2020 Free Software Foundation, Inc.
   4 #
   5 #   Written by Miles Bader <miles@gnu.ai.mit.edu>
   6 #
   7 #   This program is free software; you can redistribute it and/or
   8 #   modify it under the terms of the GNU General Public License as
   9 #   published by the Free Software Foundation; either version 3, or (at
  10 #   your option) any later version.
  11 #
  12 #   This program is distributed in the hope that it will be useful, but
  13 #   WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 #   General Public License for more details.
  16 #
  17 #   You should have received a copy of the GNU General Public License
  18 #   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 # This awk script hacks the output of mig-generated reply server code
  21 # so that it allows replies with just the error-code in them (as this is
  22 # how mig returns errors).
  23 #
  24 # It is highly, highly, dependent on the exact format of mig output.  Ick.
  25 #
  26
  27 BEGIN { parse_phase = 0; }
  28
  29 /^}/ { parse_phase = 0; }
  30
  31 parse_phase == 0 && /^mig_internal void _X[a-zA-Z0-9_]*_reply/ {
  32   # The start of a mig server routine.  Reset everything.  Note that we only
  33   # mess with rpcs that have the suffix `_reply'.
  34   num_args = 0;
  35   num_checks = 0;
  36   parse_phase = 1;
  37   print; next;
  38 }
  39
  40 parse_phase == 1 && /^[\t ]*typedef struct/ {
  41   # The first structure in the server routine should describe the arguments
  42   parse_phase = 2;
  43   print; next;
  44 }
  45
  46 parse_phase == 2 {
  47   # The message header field in the args structure, which skip.
  48   parse_phase = 3;
  49   print; next;
  50 }
  51
  52 parse_phase == 3 && /} Request/ {
  53   # The args structure is over.
  54   if (num_args > 1)
  55     parse_phase = 5;
  56   else
  57     # There's no extra args that could screw up the normal mechanism for
  58     # error returns, so we don't have to insert any new code.
  59     parse_phase = 0;
  60   print; next;
  61 }
  62
  63 parse_phase == 3 && num_args == 0 {
  64   # The type field for an argument.
  65   # This won't be accurate in case of unions being used in the Request struct,
  66   # but that doesn't matter, as we'll only be looking at arg_type_code_name[0],
  67   # which will not be a union type.
  68   arg_type_code_name[num_args] = $2;
  69   sub (/;$/, "", arg_type_code_name[num_args]) # Get rid of the semi-colon
  70   parse_phase = 4;
  71   print; next;
  72 }
  73
  74 parse_phase == 3 && num_args == 1 {
  75   # We've got more than one argument (but we don't care what it is).
  76   num_args++;
  77   print; next;
  78 }
  79
  80 parse_phase == 3 {
  81   # We've know everything we need; now just wait for the end of the Request
  82   # struct.
  83   print; next;
  84 }
  85
  86 parse_phase == 4 {
  87   # The value field for an argument.
  88   # This won't be accurate in case of unions being used in the Request struct,
  89   # but that doesn't matter, as we'll only be looking at arg_name[0], which
  90   # will not be a union type.
  91   arg_name[num_args] = $2;
  92   sub (/;$/, "", arg_name[num_args]) # Get rid of the semi-colon
  93   num_args++;
  94   parse_phase = 3;
  95   print; next;
  96 }
  97
  98 parse_phase == 5 && /^[ \t]*(auto |static )?const mach_msg_type_t/ {
  99   # The type check structure for an argument.
 100   arg_check_name[num_checks] = $(NF - 2);
 101   num_checks++;
 102   print; next;
 103 }
 104
 105 parse_phase == 5 && /^[ \t]*mig_external kern_return_t/ {
 106   # The declaration of the user server function for this rpc.
 107   user_function_name = $3;
 108   print; next;
 109 }
 110
 111 parse_phase == 5 && /^#if[ \t]TypeCheck/ {
 112   # Keep going if we have not yet collected the type check structures.
 113   if (num_checks == 0)
 114     {
 115       print; next;
 116     }
 117
 118   # The first args type checking statement; we need to insert our chunk of
 119   # code that bypasses all the type checks if this is an error return, after
 120   # which we're done until we get to the next function.  Handily, the size
 121   # of mig's Reply structure is also the size of the alternate Request
 122   # structure that we want to check for.
 123   print "\tif (In0P->Head.msgh_size == sizeof (Reply)";
 124   print "\t    && ! (In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX)";
 125   print "\t    && ! BAD_TYPECHECK(&In0P->" arg_type_code_name[0] ", &" arg_check_name[0] ")";
 126   print "\t    && In0P->" arg_name[0] " != 0)";
 127   print "\t  /* Error return, only the error code argument is passed.  */";
 128   print "\t  {";
 129   # Force the function user_function_name into a type that only takes the first
 130   # two arguments.
 131   # This is possibly bogus, but easier than supplying bogus values for all
 132   # the other args (we can't just pass 0 for them, as they might not be scalar).
 133   print "\t    OutP->RetCode = (*(kern_return_t (*)(mach_port_t, kern_return_t)) " user_function_name ") (In0P->Head.msgh_request_port, In0P->" arg_name[0] ");";
 134   print "\t    return;";
 135   print "\t  }";
 136   print "";
 137   parse_phase = 0;
 138   print; next;
 139 }
 140
 141 { print; }