asm/directiv.pl

   1 #!/usr/bin/perl
   2 ## --------------------------------------------------------------------------
   3 ##
   4 ##   Copyright 1996-2017 The NASM Authors - All Rights Reserved
   5 ##   See the file AUTHORS included with the NASM distribution for
   6 ##   the specific copyright holders.
   7 ##
   8 ##   Redistribution and use in source and binary forms, with or without
   9 ##   modification, are permitted provided that the following
  10 ##   conditions are met:
  11 ##
  12 ##   * Redistributions of source code must retain the above copyright
  13 ##     notice, this list of conditions and the following disclaimer.
  14 ##   * Redistributions in binary form must reproduce the above
  15 ##     copyright notice, this list of conditions and the following
  16 ##     disclaimer in the documentation and/or other materials provided
  17 ##     with the distribution.
  18 ##
  19 ##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  20 ##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  21 ##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  22 ##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  23 ##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  24 ##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25 ##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26 ##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  27 ##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28 ##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29 ##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  30 ##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  31 ##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32 ##
  33 ## --------------------------------------------------------------------------
  34
  35 #
  36 # Generate a perfect hash for directive parsing
  37 #
  38 # Usage:
  39 #      directiv.pl h directiv.dat directiv.h (to generate C header)
  40 #      directiv.pl c directiv.dat directbl.c (to generate C source)
  41 #
  42
  43 require 'phash.ph';
  44
  45 my($output, $directives_dat, $outfile) = @ARGV;
  46
  47 @directives = ();
  48
  49 # Special values for enum directives.  Note that D_none must be first
  50 # so D_none == 0.
  51 @specials   = ('none', 'unknown', 'corrupt');
  52
  53 open(DD, "< ${directives_dat}\0")
  54     or die "$0: cannot open: ${directives_dat}: $!\n";
  55 while (defined($line = <DD>)) {
  56     chomp $line;
  57     if ($line =~ /^\s*([[:alnum:]]+)\s*(|[\;\#].*)$/) {
  58         push(@directives, $1);
  59     }
  60 }
  61 close(DD);
  62
  63 if ($output eq 'h') {
  64     open(H, "> ${outfile}\0")
  65         or die "$0: cannot create: ${outfile}: $!\n";
  66
  67     print H "/*\n";
  68     print H " * This     file is generated from directiv.dat\n";
  69     print H " * by directiv.pl; do not edit.\n";
  70     print H " */\n";
  71     print H "\n";
  72
  73     print H "#ifndef NASM_DIRECTIV_H\n";
  74     print H "#define NASM_DIRECTIV_H\n";
  75     print H "\n";
  76
  77     $c = '{';
  78     print H "enum directives ";
  79     foreach $d (@specials) {
  80         print H "$c\n    D_$d";
  81         $c = ',';
  82     }
  83     foreach $d (@directives) {
  84         print H "$c\n    D_\U$d";
  85         $c = ',';
  86     }
  87     print H "\n};\n\n";
  88     printf H "extern const char * const directives[%d];\n",
  89         scalar(@directives)+scalar(@specials);
  90     print H "enum directives find_directive(const char *token);\n\n";
  91     print H "enum directives process_directives(char *line); /* in asm/directiv.c */\n";
  92     print H "#endif /* NASM_DIRECTIV_H */\n";
  93 } elsif ($output eq 'c') {
  94     %directive = ();
  95     $n = 0;
  96     foreach $d (@directives) {
  97         if (exists($directive{$d})) {
  98             die "$0: $directives_dat: duplicate directive: $d\n";
  99         }
 100         $directive{$d} = $n++;  # This is zero-based, unlike the enum!
 101     }
 102
 103     @hashinfo = gen_perfect_hash(\%directive);
 104     if (!@hashinfo) {
 105         die "$0: no hash found\n";
 106     }
 107
 108     # Paranoia...
 109     verify_hash_table(\%directive, \@hashinfo);
 110
 111     ($n, $sv, $g) = @hashinfo;
 112
 113     die if ($n & ($n-1));
 114
 115     open(C, "> ${outfile}\0")
 116         or die "$0: cannot create: ${directives_c}: $!\n";
 117
 118     print C "/*\n";
 119     print C " * This file is generated from directiv.dat\n";
 120     print C " * by directiv.pl; do not edit.\n";
 121     print C " */\n";
 122     print C "\n";
 123
 124     print C "#include \"compiler.h\"\n";
 125     print C "#include <string.h>\n";
 126     print C "#include \"nasm.h\"\n";
 127     print C "#include \"hashtbl.h\"\n";
 128     print C "#include \"directiv.h\"\n";
 129     print C "\n";
 130
 131     printf C "const char * const directives[%d] =\n",
 132         scalar(@directives)+scalar(@specials);
 133     $c = '{';
 134     foreach $d (@specials) {
 135         print C "$c\n    NULL";
 136         $c = ',';
 137     }
 138     foreach $d (@directives) {
 139         print C "$c\n    \"$d\"";
 140         $c = ',';
 141     }
 142     print C "\n};\n\n";
 143
 144     print C "enum directives find_directive(const char *token)\n";
 145     print C "{\n";
 146
 147     # Put a large value in unused slots.  This makes it extremely unlikely
 148     # that any combination that involves unused slot will pass the range test.
 149     # This speeds up rejection of unrecognized tokens, i.e. identifiers.
 150     print C "#define UNUSED (65535/3)\n";
 151
 152     print C "    static const int16_t hash1[$n] = {\n";
 153     for ($i = 0; $i < $n; $i++) {
 154         my $h = ${$g}[$i*2+0];
 155         print C "        ", defined($h) ? $h : 'UNUSED', ",\n";
 156     }
 157     print C "    };\n";
 158
 159     print C "    static const int16_t hash2[$n] = {\n";
 160     for ($i = 0; $i < $n; $i++) {
 161         my $h = ${$g}[$i*2+1];
 162         print C "        ", defined($h) ? $h : 'UNUSED', ",\n";
 163     }
 164     print C "    };\n";
 165
 166     print C  "    uint32_t k1, k2;\n";
 167     print C  "    uint64_t crc;\n";
 168     # For correct overflow behavior, "ix" should be unsigned of the same
 169     # width as the hash arrays.
 170     print C  "    uint16_t ix;\n";
 171     print C  "\n";
 172     printf C "    crc = crc64i(UINT64_C(0x%08x%08x), token);\n",
 173         $$sv[0], $$sv[1];
 174     print C  "    k1 = (uint32_t)crc;\n";
 175     print C  "    k2 = (uint32_t)(crc >> 32);\n";
 176     print C  "\n";
 177     printf C "    ix = hash1[k1 & 0x%x] + hash2[k2 & 0x%x];\n", $n-1, $n-1;
 178     printf C "    if (ix >= %d)\n", scalar(@directives);
 179     print C  "        return D_unknown;\n";
 180     print C  "\n";
 181     printf C "    ix += %d;\n", scalar(@specials);
 182     print C  "    if (nasm_stricmp(token, directives[ix]))\n";
 183     print C  "        return D_unknown;\n";
 184     print C  "\n";
 185     print C  "    return ix;\n";
 186     print C  "}\n";
 187 }