2 * yosys -- Yosys Open SYnthesis Suite
4 * Copyright (C) 2012 Clifford Wolf <clifford@clifford.at>
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 * The Verilog frontend.
22 * This frontend is using the AST frontend library (see frontends/ast/).
23 * Thus this frontend does not generate RTLIL code directly but creates an
24 * AST directly from the Verilog parse tree and then passes this AST to
25 * the AST frontend library.
29 * A simple lexer for Verilog code. Non-preprocessor compiler directives are
30 * handled here. The preprocessor stuff is handled in preproc.cc. Everything
31 * else is left to the bison parser (see verilog_parser.y).
38 // bison generates code using the 'register' storage class specifier
39 #pragma clang diagnostic ignored "-Wdeprecated-register"
42 #include "kernel/log.h"
43 #include "frontends/verilog/verilog_frontend.h"
44 #include "frontends/ast/ast.h"
45 #include "verilog_parser.tab.hh"
49 using namespace VERILOG_FRONTEND;
52 namespace VERILOG_FRONTEND {
53 std::vector<std::string> fn_stack;
54 std::vector<int> ln_stack;
58 #define YYSTYPE FRONTEND_VERILOG_YYSTYPE
59 #define YYLTYPE FRONTEND_VERILOG_YYLTYPE
61 #define SV_KEYWORD(_tok) \
62 if (sv_mode) return _tok; \
63 log("Lexer warning: The SystemVerilog keyword `%s' (at %s:%d) is not "\
64 "recognized unless read_verilog is called with -sv!\n", yytext, \
65 AST::current_filename.c_str(), frontend_verilog_yyget_lineno()); \
66 yylval->string = new std::string(std::string("\\") + yytext); \
69 #define NON_KEYWORD() \
70 yylval->string = new std::string(std::string("\\") + yytext); \
73 #define YY_INPUT(buf,result,max_size) \
74 result = readsome(*VERILOG_FRONTEND::lexin, buf, max_size)
76 YYLTYPE real_location;
79 #define YY_USER_ACTION \
80 old_location = real_location; \
81 real_location.first_line = real_location.last_line; \
82 real_location.first_column = real_location.last_column; \
83 for(int i = 0; yytext[i] != '\0'; ++i){ \
84 if(yytext[i] == '\n') { \
85 real_location.last_line++; \
86 real_location.last_column = 1; \
89 real_location.last_column++; \
92 (*yylloc) = real_location;
95 (*yylloc) = old_location; \
99 #define YY_BUF_SIZE 65536
101 extern int frontend_verilog_yylex(YYSTYPE *yylval_param, YYLTYPE *yyloc_param);
103 static bool isUserType(std::string &s)
105 // check current scope then outer scopes for a name
106 for (auto it = user_type_stack.rbegin(); it != user_type_stack.rend(); ++it) {
107 if ((*it)->count(s) > 0) {
119 %option bison-locations
121 %option prefix="frontend_verilog_yy"
125 %x SYNOPSYS_TRANSLATE_OFF
133 <INITIAL,SYNOPSYS_TRANSLATE_OFF>"`file_push "[^\n]* {
134 fn_stack.push_back(current_filename);
135 ln_stack.push_back(frontend_verilog_yyget_lineno());
136 current_filename = yytext+11;
137 if (!current_filename.empty() && current_filename.front() == '"')
138 current_filename = current_filename.substr(1);
139 if (!current_filename.empty() && current_filename.back() == '"')
140 current_filename = current_filename.substr(0, current_filename.size()-1);
141 frontend_verilog_yyset_lineno(0);
142 yylloc->first_line = yylloc->last_line = 0;
143 real_location.first_line = real_location.last_line = 0;
146 <INITIAL,SYNOPSYS_TRANSLATE_OFF>"`file_pop"[^\n]*\n {
147 current_filename = fn_stack.back();
149 frontend_verilog_yyset_lineno(ln_stack.back());
150 yylloc->first_line = yylloc->last_line = ln_stack.back();
151 real_location.first_line = real_location.last_line = ln_stack.back();
155 <INITIAL,SYNOPSYS_TRANSLATE_OFF>"`line"[ \t]+[^ \t\r\n]+[ \t]+\"[^ \r\n]+\"[^\r\n]*\n {
156 char *p = yytext + 5;
157 while (*p == ' ' || *p == '\t') p++;
158 frontend_verilog_yyset_lineno(atoi(p));
159 yylloc->first_line = yylloc->last_line = atoi(p);
160 real_location.first_line = real_location.last_line = atoi(p);
161 while (*p && *p != ' ' && *p != '\t') p++;
162 while (*p == ' ' || *p == '\t') p++;
163 char *q = *p ? p + 1 : p;
164 while (*q && *q != '"') q++;
165 current_filename = std::string(p).substr(1, q-p-1);
168 "`file_notfound "[^\n]* {
169 log_error("Can't open include file `%s'!\n", yytext + 15);
172 "`timescale"[ \t]+[^ \t\r\n/]+[ \t]*"/"[ \t]*[^ \t\r\n]* /* ignore timescale directive */
174 "`celldefine"[^\n]* /* ignore `celldefine */
175 "`endcelldefine"[^\n]* /* ignore `endcelldefine */
177 "`default_nettype"[ \t]+[^ \t\r\n/]+ {
179 while (*p != 0 && *p != ' ' && *p != '\t') p++;
180 while (*p == ' ' || *p == '\t') p++;
181 if (!strcmp(p, "none"))
182 VERILOG_FRONTEND::default_nettype_wire = false;
183 else if (!strcmp(p, "wire"))
184 VERILOG_FRONTEND::default_nettype_wire = true;
186 frontend_verilog_yyerror("Unsupported default nettype: %s", p);
189 "`protect"[^\n]* /* ignore `protect*/
190 "`endprotect"[^\n]* /* ignore `endprotect*/
192 "`"[a-zA-Z_$][a-zA-Z0-9_$]* {
193 frontend_verilog_yyerror("Unimplemented compiler directive or undefined macro %s.", yytext);
196 "module" { return TOK_MODULE; }
197 "endmodule" { return TOK_ENDMODULE; }
198 "function" { return TOK_FUNCTION; }
199 "endfunction" { return TOK_ENDFUNCTION; }
200 "task" { return TOK_TASK; }
201 "endtask" { return TOK_ENDTASK; }
202 "specify" { return specify_mode ? TOK_SPECIFY : TOK_IGNORED_SPECIFY; }
203 "endspecify" { return TOK_ENDSPECIFY; }
204 "specparam" { return TOK_SPECPARAM; }
205 "package" { SV_KEYWORD(TOK_PACKAGE); }
206 "endpackage" { SV_KEYWORD(TOK_ENDPACKAGE); }
207 "interface" { SV_KEYWORD(TOK_INTERFACE); }
208 "endinterface" { SV_KEYWORD(TOK_ENDINTERFACE); }
209 "modport" { SV_KEYWORD(TOK_MODPORT); }
210 "parameter" { return TOK_PARAMETER; }
211 "localparam" { return TOK_LOCALPARAM; }
212 "defparam" { return TOK_DEFPARAM; }
213 "assign" { return TOK_ASSIGN; }
214 "always" { return TOK_ALWAYS; }
215 "initial" { return TOK_INITIAL; }
216 "begin" { return TOK_BEGIN; }
217 "end" { return TOK_END; }
218 "if" { return TOK_IF; }
219 "else" { return TOK_ELSE; }
220 "for" { return TOK_FOR; }
221 "posedge" { return TOK_POSEDGE; }
222 "negedge" { return TOK_NEGEDGE; }
223 "or" { return TOK_OR; }
224 "case" { return TOK_CASE; }
225 "casex" { return TOK_CASEX; }
226 "casez" { return TOK_CASEZ; }
227 "endcase" { return TOK_ENDCASE; }
228 "default" { return TOK_DEFAULT; }
229 "generate" { return TOK_GENERATE; }
230 "endgenerate" { return TOK_ENDGENERATE; }
231 "while" { return TOK_WHILE; }
232 "repeat" { return TOK_REPEAT; }
233 "automatic" { return TOK_AUTOMATIC; }
235 "unique" { SV_KEYWORD(TOK_UNIQUE); }
236 "unique0" { SV_KEYWORD(TOK_UNIQUE); }
237 "priority" { SV_KEYWORD(TOK_PRIORITY); }
239 "always_comb" { SV_KEYWORD(TOK_ALWAYS_COMB); }
240 "always_ff" { SV_KEYWORD(TOK_ALWAYS_FF); }
241 "always_latch" { SV_KEYWORD(TOK_ALWAYS_LATCH); }
243 /* use special token for labels on assert, assume, cover, and restrict because it's insanley complex
244 to fix parsing of cells otherwise. (the current cell parser forces a reduce very early to update some
245 global state.. its a mess) */
246 [a-zA-Z_$][a-zA-Z0-9_$]*/[ \t\r\n]*:[ \t\r\n]*(assert|assume|cover|restrict)[^a-zA-Z0-9_$\.] {
247 if (!strcmp(yytext, "default"))
249 yylval->string = new std::string(std::string("\\") + yytext);
250 return TOK_SVA_LABEL;
253 "assert" { if (formal_mode) return TOK_ASSERT; SV_KEYWORD(TOK_ASSERT); }
254 "assume" { if (formal_mode) return TOK_ASSUME; SV_KEYWORD(TOK_ASSUME); }
255 "cover" { if (formal_mode) return TOK_COVER; SV_KEYWORD(TOK_COVER); }
256 "restrict" { if (formal_mode) return TOK_RESTRICT; SV_KEYWORD(TOK_RESTRICT); }
257 "property" { if (formal_mode) return TOK_PROPERTY; SV_KEYWORD(TOK_PROPERTY); }
258 "rand" { if (formal_mode) return TOK_RAND; SV_KEYWORD(TOK_RAND); }
259 "const" { if (formal_mode) return TOK_CONST; SV_KEYWORD(TOK_CONST); }
260 "checker" { if (formal_mode) return TOK_CHECKER; SV_KEYWORD(TOK_CHECKER); }
261 "endchecker" { if (formal_mode) return TOK_ENDCHECKER; SV_KEYWORD(TOK_ENDCHECKER); }
262 "final" { SV_KEYWORD(TOK_FINAL); }
263 "logic" { SV_KEYWORD(TOK_LOGIC); }
264 "var" { SV_KEYWORD(TOK_VAR); }
265 "bit" { SV_KEYWORD(TOK_REG); }
267 "eventually" { if (formal_mode) return TOK_EVENTUALLY; SV_KEYWORD(TOK_EVENTUALLY); }
268 "s_eventually" { if (formal_mode) return TOK_EVENTUALLY; SV_KEYWORD(TOK_EVENTUALLY); }
270 "input" { return TOK_INPUT; }
271 "output" { return TOK_OUTPUT; }
272 "inout" { return TOK_INOUT; }
273 "wire" { return TOK_WIRE; }
274 "wor" { return TOK_WOR; }
275 "wand" { return TOK_WAND; }
276 "reg" { return TOK_REG; }
277 "integer" { return TOK_INTEGER; }
278 "signed" { return TOK_SIGNED; }
279 "genvar" { return TOK_GENVAR; }
280 "real" { return TOK_REAL; }
282 "enum" { SV_KEYWORD(TOK_ENUM); }
283 "typedef" { SV_KEYWORD(TOK_TYPEDEF); }
286 yylval->string = new std::string(yytext);
291 yylval->string = new std::string(yytext);
292 return TOK_UNBASED_UNSIZED_CONSTVAL;
297 yylval->string = new std::string(yytext);
301 <BASED_CONST>[0-9a-fA-FzxZX?][0-9a-fA-FzxZX?_]* {
303 yylval->string = new std::string(yytext);
304 return TOK_BASED_CONSTVAL;
307 [0-9][0-9_]*\.[0-9][0-9_]*([eE][-+]?[0-9_]+)? {
308 yylval->string = new std::string(yytext);
312 [0-9][0-9_]*[eE][-+]?[0-9_]+ {
313 yylval->string = new std::string(yytext);
317 \" { BEGIN(STRING); }
318 <STRING>\\. { yymore(); real_location = old_location; }
321 char *yystr = strdup(yytext);
322 yystr[strlen(yytext) - 1] = 0;
325 if (yystr[i] == '\\' && yystr[i + 1]) {
329 else if (yystr[i] == 'f')
331 else if (yystr[i] == 'n')
333 else if (yystr[i] == 'r')
335 else if (yystr[i] == 't')
337 else if (yystr[i] == 'v')
339 else if ('0' <= yystr[i] && yystr[i] <= '7') {
340 yystr[i] = yystr[i] - '0';
341 if ('0' <= yystr[i + 1] && yystr[i + 1] <= '7') {
342 yystr[i + 1] = yystr[i] * 8 + yystr[i + 1] - '0';
345 if ('0' <= yystr[i + 1] && yystr[i + 1] <= '7') {
346 yystr[i + 1] = yystr[i] * 8 + yystr[i + 1] - '0';
351 yystr[j++] = yystr[i++];
354 yylval->string = new std::string(yystr, j);
358 <STRING>. { yymore(); real_location = old_location; }
360 and|nand|or|nor|xor|xnor|not|buf|bufif0|bufif1|notif0|notif1 {
361 yylval->string = new std::string(yytext);
362 return TOK_PRIMITIVE;
365 supply0 { return TOK_SUPPLY0; }
366 supply1 { return TOK_SUPPLY1; }
368 "$"(display|write|strobe|monitor|time|stop|finish|dumpfile|dumpvars|dumpon|dumpoff|dumpall) {
369 yylval->string = new std::string(yytext);
373 "$"(setup|hold|setuphold|removal|recovery|recrem|skew|timeskew|fullskew|nochange) {
374 if (!specify_mode) REJECT;
375 yylval->string = new std::string(yytext);
379 "$"(info|warning|error|fatal) {
380 yylval->string = new std::string(yytext);
381 return TOK_MSG_TASKS;
384 "$signed" { return TOK_TO_SIGNED; }
385 "$unsigned" { return TOK_TO_UNSIGNED; }
387 [a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_$][a-zA-Z0-9_$]* {
389 auto s = std::string("\\") + yytext;
390 if (pkg_user_types.count(s) > 0) {
391 // package qualified typedefed name
392 yylval->string = new std::string(s);
393 return TOK_PKG_USER_TYPE;
396 // backup before :: just return first part
397 size_t len = strchr(yytext, ':') - yytext;
399 yylval->string = new std::string(std::string("\\") + yytext);
404 [a-zA-Z_$][a-zA-Z0-9_$]* {
405 auto s = std::string("\\") + yytext;
407 // previously typedefed name
408 yylval->string = new std::string(s);
409 return TOK_USER_TYPE;
412 yylval->string = new std::string(std::string("\\") + yytext);
417 [a-zA-Z_$][a-zA-Z0-9_$\.]* {
418 yylval->string = new std::string(std::string("\\") + yytext);
422 "/*"[ \t]*(synopsys|synthesis)[ \t]*translate_off[ \t]*"*/" {
423 static bool printed_warning = false;
424 if (!printed_warning) {
425 log_warning("Found one of those horrible `(synopsys|synthesis) translate_off' comments.\n"
426 "Yosys does support them but it is recommended to use `ifdef constructs instead!\n");
427 printed_warning = true;
429 BEGIN(SYNOPSYS_TRANSLATE_OFF);
431 <SYNOPSYS_TRANSLATE_OFF>. /* ignore synopsys translate_off body */
432 <SYNOPSYS_TRANSLATE_OFF>\n /* ignore synopsys translate_off body */
433 <SYNOPSYS_TRANSLATE_OFF>"/*"[ \t]*(synopsys|synthesis)[ \t]*"translate_on"[ \t]*"*/" { BEGIN(0); }
435 "/*"[ \t]*(synopsys|synthesis)[ \t]+ {
436 BEGIN(SYNOPSYS_FLAGS);
438 <SYNOPSYS_FLAGS>full_case {
439 static bool printed_warning = false;
440 if (!printed_warning) {
441 log_warning("Found one of those horrible `(synopsys|synthesis) full_case' comments.\n"
442 "Yosys does support them but it is recommended to use Verilog `full_case' attributes instead!\n");
443 printed_warning = true;
445 return TOK_SYNOPSYS_FULL_CASE;
447 <SYNOPSYS_FLAGS>parallel_case {
448 static bool printed_warning = false;
449 if (!printed_warning) {
450 log_warning("Found one of those horrible `(synopsys|synthesis) parallel_case' comments.\n"
451 "Yosys does support them but it is recommended to use Verilog `parallel_case' attributes instead!\n");
452 printed_warning = true;
454 return TOK_SYNOPSYS_PARALLEL_CASE;
456 <SYNOPSYS_FLAGS>. /* ignore everything else */
457 <SYNOPSYS_FLAGS>"*/" { BEGIN(0); }
459 import[ \t\r\n]+\"(DPI|DPI-C)\"[ \t\r\n]+function[ \t\r\n]+ {
461 return TOK_DPI_FUNCTION;
464 <IMPORT_DPI>[a-zA-Z_$][a-zA-Z0-9_$]* {
465 yylval->string = new std::string(std::string("\\") + yytext);
469 <IMPORT_DPI>[ \t\r\n] /* ignore whitespaces */
481 yylval->string = new std::string(yytext);
485 "(*" { return ATTR_BEGIN; }
486 "*)" { return ATTR_END; }
488 "{*" { return DEFATTR_BEGIN; }
489 "*}" { return DEFATTR_END; }
491 "**" { return OP_POW; }
492 "||" { return OP_LOR; }
493 "&&" { return OP_LAND; }
494 "==" { return OP_EQ; }
495 "!=" { return OP_NE; }
496 "<=" { return OP_LE; }
497 ">=" { return OP_GE; }
499 "===" { return OP_EQX; }
500 "!==" { return OP_NEX; }
502 "~&" { return OP_NAND; }
503 "~|" { return OP_NOR; }
504 "~^" { return OP_XNOR; }
505 "^~" { return OP_XNOR; }
507 "<<" { return OP_SHL; }
508 ">>" { return OP_SHR; }
509 "<<<" { return OP_SSHL; }
510 ">>>" { return OP_SSHR; }
512 "::" { return TOK_PACKAGESEP; }
513 "++" { return TOK_INCREMENT; }
514 "--" { return TOK_DECREMENT; }
516 "+:" { return TOK_POS_INDEXED; }
517 "-:" { return TOK_NEG_INDEXED; }
519 ".*" { return TOK_WILDCARD_CONNECT; }
522 if (!specify_mode) REJECT;
523 yylval->string = new std::string(yytext);
524 return TOK_SPECIFY_OPER;
528 if (!specify_mode) return TOK_IGNORED_SPECIFY_AND;
529 return TOK_SPECIFY_AND;
532 <INITIAL,BASED_CONST>"/*" { comment_caller=YY_START; BEGIN(COMMENT); }
533 <COMMENT>. /* ignore comment body */
534 <COMMENT>\n /* ignore comment body */
535 <COMMENT>"*/" { BEGIN(comment_caller); }
537 <INITIAL,BASED_CONST>[ \t\r\n] /* ignore whitespaces */
538 <INITIAL,BASED_CONST>\\[\r\n] /* ignore continuation sequence */
539 <INITIAL,BASED_CONST>"//"[^\r\n]* /* ignore one-line comments */
541 <INITIAL>. { return *yytext; }
542 <*>. { BEGIN(0); return *yytext; }
546 // this is a hack to avoid the 'yyinput defined but not used' error msgs
547 void *frontend_verilog_avoid_input_warnings() {
548 return (void*)&yyinput;