gdb/regformats/regdat.sh - gdb

Functions defined

Source code

  1. #!/bin/sh -u

  3. # Register protocol definitions for GDB, the GNU debugger.
  4. # Copyright (C) 2001-2015 Free Software Foundation, Inc.
  5. #
  6. # This file is part of GDB.
  7. #
  8. # This program is free software; you can redistribute it and/or modify
  9. # it under the terms of the GNU General Public License as published by
  10. # the Free Software Foundation; either version 3 of the License, or
  11. # (at your option) any later version.
  12. #
  13. # This program is distributed in the hope that it will be useful,
  14. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. # GNU General Public License for more details.
  17. #
  18. # You should have received a copy of the GNU General Public License
  19. # along with this program.  If not, see <http://www.gnu.org/licenses/>.

  21. # Format of the input files
  22. read="type entry"

  24. ‌do_read ()
  25. {
  26.     type=""
  27.     entry=""
  28.     while read line
  29.     do
  30.         if test "${line}" = ""
  31.         then
  32.             continue
  33.         elif test "${line}" = "#" -a "${comment}" = ""
  34.         then
  35.             continue
  36.         elif expr "${line}" : "#" > /dev/null
  37.         then
  38.             comment="${comment}
  39. ${line}"
  40.         else

  42.             # The semantics of IFS varies between different SH's.  Some
  43.             # treat ``::' as three fields while some treat it as just too.
  44.             # Work around this by eliminating ``::'' ....
  45.             line="`echo "${line}" | sed -e 's/::/: :/g' -e 's/::/: :/g'`"

  47.             OFS="${IFS}" ; IFS="[:]"
  48.             eval read ${read} <<EOF
  49. ${line}
  50. EOF
  51.             IFS="${OFS}"

  53.             # .... and then going back through each field and strip out those
  54.             # that ended up with just that space character.
  55.             for r in ${read}
  56.             do
  57.                 if eval test \"\${${r}}\" = \"\ \"
  58.                 then
  59.                     eval ${r}=""
  60.                 fi
  61.             done

  63.             break
  64.         fi
  65.     done
  66.     if [ -n "${type}" ]
  67.     then
  68.         true
  69.     else
  70.         false
  71.     fi
  72. }

  74. if test ! -r $1; then
  75.   echo "$0: Could not open $1." 1>&2
  76.   exit 1
  77. fi

  79. ‌copyright ()
  80. {
  81. cat <<EOF
  82. /* *INDENT-OFF* */ /* THIS FILE IS GENERATED */

  84. /* A register protocol for GDB, the GNU debugger.
  85.    Copyright (C) 2001-2013 Free Software Foundation, Inc.

  87.    This file is part of GDB.

  89.    This program is free software; you can redistribute it and/or modify
  90.    it under the terms of the GNU General Public License as published by
  91.    the Free Software Foundation; either version 3 of the License, or
  92.    (at your option) any later version.

  94.    This program is distributed in the hope that it will be useful,
  95.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  96.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  97.    GNU General Public License for more details.

  99.    You should have received a copy of the GNU General Public License
  100.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  102. /* This file was created with the aid of \`\`regdat.sh'' and \`\`$1''.  */

  104. EOF
  105. }


  108. exec > new-$2
  109. copyright $1
  110. echo '#include "server.h"'
  111. echo '#include "regdef.h"'
  112. echo '#include "tdesc.h"'
  113. echo
  114. offset=0
  115. i=0
  116. name=x
  117. xmltarget=x
  118. xmlarch=x
  119. xmlosabi=x
  120. expedite=x
  121. exec < $1
  122. while do_read
  123. do
  124.   if test "${type}" = "name"; then
  125.     name="${entry}"
  126.     echo "static struct reg regs_${name}[] = {"
  127.     continue
  128.   elif test "${type}" = "xmltarget"; then
  129.     xmltarget="${entry}"
  130.     continue
  131.   elif test "${type}" = "xmlarch"; then
  132.     xmlarch="${entry}"
  133.     continue
  134.   elif test "${type}" = "osabi"; then
  135.     xmlosabi="${entry}"
  136.     continue
  137.   elif test "${type}" = "expedite"; then
  138.     expedite="${entry}"
  139.     continue
  140.   elif test "${name}" = x; then
  141.     echo "$0: $1 does not specify \`\`name''." 1>&2
  142.     exit 1
  143.   else
  144.     echo "  { \"${entry}\", ${offset}, ${type} },"
  145.     offset=`expr ${offset} + ${type}`
  146.     i=`expr $i + 1`
  147.   fi
  148. done

  150. echo "};"
  151. echo
  152. echo "static const char *expedite_regs_${name}[] = { \"`echo ${expedite} | sed 's/,/", "/g'`\", 0 };"
  153. if test "${xmltarget}" = x; then
  154.   if test "${xmlarch}" = x && test "${xmlosabi}" = x; then
  155.     echo "static const char *xmltarget_${name} = 0;"
  156.   else
  157.     echo "static const char *xmltarget_${name} = \"@<target>\\"
  158.     if test "${xmlarch}" != x; then
  159.       echo "<architecture>${xmlarch}</architecture>\\"
  160.     fi
  161.     if test "${xmlosabi}" != x; then
  162.       echo "<osabi>${xmlosabi}</osabi>\\"
  163.     fi
  164.     echo "</target>\";"
  165.   fi
  166. else
  167.   echo "static const char *xmltarget_${name} = \"${xmltarget}\";"
  168. fi
  169. echo

  171. cat <<EOF
  172. const struct target_desc *tdesc_${name};

  174. void
  175. init_registers_${name} (void)
  176. {
  177.   static struct target_desc tdesc_${name}_s;
  178.   struct target_desc *result = &tdesc_${name}_s;

  180.   result->reg_defs = regs_${name};
  181.   result->num_registers = sizeof (regs_${name}) / sizeof (regs_${name}[0]);
  182.   result->expedite_regs = expedite_regs_${name};
  183.   result->xmltarget = xmltarget_${name};

  185.   init_target_desc (result);

  187.   tdesc_${name} = result;
  188. }
  189. EOF

  191. # close things off
  192. exec 1>&2
  193. mv -- "new-$2" "$2"