|
111
|
1 /* read-rtl-function.c - Reader for RTL function dumps
|
|
|
2 Copyright (C) 2016-2017 Free Software Foundation, Inc.
|
|
|
3
|
|
|
4 This file is part of GCC.
|
|
|
5
|
|
|
6 GCC is free software; you can redistribute it and/or modify it under
|
|
|
7 the terms of the GNU General Public License as published by the Free
|
|
|
8 Software Foundation; either version 3, or (at your option) any later
|
|
|
9 version.
|
|
|
10
|
|
|
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
14 for more details.
|
|
|
15
|
|
|
16 You should have received a copy of the GNU General Public License
|
|
|
17 along with GCC; see the file COPYING3. If not see
|
|
|
18 <http://www.gnu.org/licenses/>. */
|
|
|
19
|
|
|
20 #include "config.h"
|
|
|
21 #include "system.h"
|
|
|
22 #include "coretypes.h"
|
|
|
23 #include "target.h"
|
|
|
24 #include "tree.h"
|
|
|
25 #include "diagnostic.h"
|
|
|
26 #include "read-md.h"
|
|
|
27 #include "rtl.h"
|
|
|
28 #include "cfghooks.h"
|
|
|
29 #include "stringpool.h"
|
|
|
30 #include "function.h"
|
|
|
31 #include "tree-cfg.h"
|
|
|
32 #include "cfg.h"
|
|
|
33 #include "basic-block.h"
|
|
|
34 #include "cfgrtl.h"
|
|
|
35 #include "memmodel.h"
|
|
|
36 #include "emit-rtl.h"
|
|
|
37 #include "cgraph.h"
|
|
|
38 #include "tree-pass.h"
|
|
|
39 #include "toplev.h"
|
|
|
40 #include "varasm.h"
|
|
|
41 #include "read-rtl-function.h"
|
|
|
42 #include "selftest.h"
|
|
|
43 #include "selftest-rtl.h"
|
|
|
44
|
|
|
45 /* Forward decls. */
|
|
|
46 class function_reader;
|
|
|
47 class fixup;
|
|
|
48
|
|
|
49 /* Edges are recorded when parsing the "insn-chain" directive,
|
|
|
50 and created at the end when all the blocks ought to exist.
|
|
|
51 This struct records an "edge-from" or "edge-to" directive seen
|
|
|
52 at LOC, which will be turned into an actual CFG edge once
|
|
|
53 the "insn-chain" is fully parsed. */
|
|
|
54
|
|
|
55 struct deferred_edge
|
|
|
56 {
|
|
|
57 deferred_edge (file_location loc, int src_bb_idx, int dest_bb_idx, int flags)
|
|
|
58 : m_loc (loc), m_src_bb_idx (src_bb_idx), m_dest_bb_idx (dest_bb_idx),
|
|
|
59 m_flags (flags)
|
|
|
60 {}
|
|
|
61
|
|
|
62 file_location m_loc;
|
|
|
63 int m_src_bb_idx;
|
|
|
64 int m_dest_bb_idx;
|
|
|
65 int m_flags;
|
|
|
66 };
|
|
|
67
|
|
|
68 /* Subclass of rtx_reader for reading function dumps. */
|
|
|
69
|
|
|
70 class function_reader : public rtx_reader
|
|
|
71 {
|
|
|
72 public:
|
|
|
73 function_reader ();
|
|
|
74 ~function_reader ();
|
|
|
75
|
|
|
76 /* Overridden vfuncs of class md_reader. */
|
|
|
77 void handle_unknown_directive (file_location, const char *) FINAL OVERRIDE;
|
|
|
78
|
|
|
79 /* Overridden vfuncs of class rtx_reader. */
|
|
|
80 rtx read_rtx_operand (rtx x, int idx) FINAL OVERRIDE;
|
|
|
81 void handle_any_trailing_information (rtx x) FINAL OVERRIDE;
|
|
|
82 rtx postprocess (rtx) FINAL OVERRIDE;
|
|
|
83 const char *finalize_string (char *stringbuf) FINAL OVERRIDE;
|
|
|
84
|
|
|
85 rtx_insn **get_insn_by_uid (int uid);
|
|
|
86 tree parse_mem_expr (const char *desc);
|
|
|
87
|
|
|
88 private:
|
|
|
89 void parse_function ();
|
|
|
90 void create_function ();
|
|
|
91 void parse_param ();
|
|
|
92 void parse_insn_chain ();
|
|
|
93 void parse_block ();
|
|
|
94 int parse_bb_idx ();
|
|
|
95 void parse_edge (basic_block block, bool from);
|
|
|
96 rtx_insn *parse_insn (file_location loc, const char *name);
|
|
|
97 void parse_cfg (file_location loc);
|
|
|
98 void parse_crtl (file_location loc);
|
|
|
99 void create_edges ();
|
|
|
100
|
|
|
101 int parse_enum_value (int num_values, const char *const *strings);
|
|
|
102
|
|
|
103 void read_rtx_operand_u (rtx x, int idx);
|
|
|
104 void read_rtx_operand_i_or_n (rtx x, int idx, char format_char);
|
|
|
105 rtx read_rtx_operand_r (rtx x);
|
|
|
106 rtx extra_parsing_for_operand_code_0 (rtx x, int idx);
|
|
|
107
|
|
|
108 void add_fixup_insn_uid (file_location loc, rtx insn, int operand_idx,
|
|
|
109 int insn_uid);
|
|
|
110
|
|
|
111 void add_fixup_note_insn_basic_block (file_location loc, rtx insn,
|
|
|
112 int operand_idx, int bb_idx);
|
|
|
113
|
|
|
114 void add_fixup_source_location (file_location loc, rtx_insn *insn,
|
|
|
115 const char *filename, int lineno);
|
|
|
116
|
|
|
117 void add_fixup_expr (file_location loc, rtx x,
|
|
|
118 const char *desc);
|
|
|
119
|
|
|
120 rtx consolidate_singletons (rtx x);
|
|
|
121 rtx parse_rtx ();
|
|
|
122 void maybe_read_location (rtx_insn *insn);
|
|
|
123
|
|
|
124 void handle_insn_uids ();
|
|
|
125 void apply_fixups ();
|
|
|
126
|
|
|
127 private:
|
|
|
128 struct uid_hash : int_hash <int, -1, -2> {};
|
|
|
129 hash_map<uid_hash, rtx_insn *> m_insns_by_uid;
|
|
|
130 auto_vec<fixup *> m_fixups;
|
|
|
131 rtx_insn *m_first_insn;
|
|
|
132 auto_vec<tree> m_fake_scope;
|
|
|
133 char *m_name;
|
|
|
134 bool m_have_crtl_directive;
|
|
|
135 basic_block m_bb_to_insert_after;
|
|
|
136 auto_vec <deferred_edge> m_deferred_edges;
|
|
|
137 int m_highest_bb_idx;
|
|
|
138 };
|
|
|
139
|
|
|
140 /* Abstract base class for recording post-processing steps that must be
|
|
|
141 done after reading a .rtl file. */
|
|
|
142
|
|
|
143 class fixup
|
|
|
144 {
|
|
|
145 public:
|
|
|
146 /* Constructor for a fixup at LOC affecting X. */
|
|
|
147 fixup (file_location loc, rtx x)
|
|
|
148 : m_loc (loc), m_rtx (x)
|
|
|
149 {}
|
|
|
150 virtual ~fixup () {}
|
|
|
151
|
|
|
152 virtual void apply (function_reader *reader) const = 0;
|
|
|
153
|
|
|
154 protected:
|
|
|
155 file_location m_loc;
|
|
|
156 rtx m_rtx;
|
|
|
157 };
|
|
|
158
|
|
|
159 /* An abstract subclass of fixup for post-processing steps that
|
|
|
160 act on a specific operand of a specific instruction. */
|
|
|
161
|
|
|
162 class operand_fixup : public fixup
|
|
|
163 {
|
|
|
164 public:
|
|
|
165 /* Constructor for a fixup at LOC affecting INSN's operand
|
|
|
166 with index OPERAND_IDX. */
|
|
|
167 operand_fixup (file_location loc, rtx insn, int operand_idx)
|
|
|
168 : fixup (loc, insn), m_operand_idx (operand_idx)
|
|
|
169 {}
|
|
|
170
|
|
|
171 protected:
|
|
|
172 int m_operand_idx;
|
|
|
173 };
|
|
|
174
|
|
|
175 /* A concrete subclass of operand_fixup: fixup an rtx_insn *
|
|
|
176 field based on an integer UID. */
|
|
|
177
|
|
|
178 class fixup_insn_uid : public operand_fixup
|
|
|
179 {
|
|
|
180 public:
|
|
|
181 /* Constructor for a fixup at LOC affecting INSN's operand
|
|
|
182 with index OPERAND_IDX. Record INSN_UID as the uid. */
|
|
|
183 fixup_insn_uid (file_location loc, rtx insn, int operand_idx, int insn_uid)
|
|
|
184 : operand_fixup (loc, insn, operand_idx),
|
|
|
185 m_insn_uid (insn_uid)
|
|
|
186 {}
|
|
|
187
|
|
|
188 void apply (function_reader *reader) const;
|
|
|
189
|
|
|
190 private:
|
|
|
191 int m_insn_uid;
|
|
|
192 };
|
|
|
193
|
|
|
194 /* A concrete subclass of operand_fixup: fix up a
|
|
|
195 NOTE_INSN_BASIC_BLOCK based on an integer block ID. */
|
|
|
196
|
|
|
197 class fixup_note_insn_basic_block : public operand_fixup
|
|
|
198 {
|
|
|
199 public:
|
|
|
200 fixup_note_insn_basic_block (file_location loc, rtx insn, int operand_idx,
|
|
|
201 int bb_idx)
|
|
|
202 : operand_fixup (loc, insn, operand_idx),
|
|
|
203 m_bb_idx (bb_idx)
|
|
|
204 {}
|
|
|
205
|
|
|
206 void apply (function_reader *reader) const;
|
|
|
207
|
|
|
208 private:
|
|
|
209 int m_bb_idx;
|
|
|
210 };
|
|
|
211
|
|
|
212 /* A concrete subclass of fixup (not operand_fixup): fix up
|
|
|
213 the expr of an rtx (REG or MEM) based on a textual dump. */
|
|
|
214
|
|
|
215 class fixup_expr : public fixup
|
|
|
216 {
|
|
|
217 public:
|
|
|
218 fixup_expr (file_location loc, rtx x, const char *desc)
|
|
|
219 : fixup (loc, x),
|
|
|
220 m_desc (xstrdup (desc))
|
|
|
221 {}
|
|
|
222
|
|
|
223 ~fixup_expr () { free (m_desc); }
|
|
|
224
|
|
|
225 void apply (function_reader *reader) const;
|
|
|
226
|
|
|
227 private:
|
|
|
228 char *m_desc;
|
|
|
229 };
|
|
|
230
|
|
|
231 /* Return a textual description of the operand of INSN with
|
|
|
232 index OPERAND_IDX. */
|
|
|
233
|
|
|
234 static const char *
|
|
|
235 get_operand_name (rtx insn, int operand_idx)
|
|
|
236 {
|
|
|
237 gcc_assert (is_a <rtx_insn *> (insn));
|
|
|
238 switch (operand_idx)
|
|
|
239 {
|
|
|
240 case 0:
|
|
|
241 return "PREV_INSN";
|
|
|
242 case 1:
|
|
|
243 return "NEXT_INSN";
|
|
|
244 default:
|
|
|
245 return NULL;
|
|
|
246 }
|
|
|
247 }
|
|
|
248
|
|
|
249 /* Fixup an rtx_insn * field based on an integer UID, as read by READER. */
|
|
|
250
|
|
|
251 void
|
|
|
252 fixup_insn_uid::apply (function_reader *reader) const
|
|
|
253 {
|
|
|
254 rtx_insn **insn_from_uid = reader->get_insn_by_uid (m_insn_uid);
|
|
|
255 if (insn_from_uid)
|
|
|
256 XEXP (m_rtx, m_operand_idx) = *insn_from_uid;
|
|
|
257 else
|
|
|
258 {
|
|
|
259 const char *op_name = get_operand_name (m_rtx, m_operand_idx);
|
|
|
260 if (op_name)
|
|
|
261 error_at (m_loc,
|
|
|
262 "insn with UID %i not found for operand %i (`%s') of insn %i",
|
|
|
263 m_insn_uid, m_operand_idx, op_name, INSN_UID (m_rtx));
|
|
|
264 else
|
|
|
265 error_at (m_loc,
|
|
|
266 "insn with UID %i not found for operand %i of insn %i",
|
|
|
267 m_insn_uid, m_operand_idx, INSN_UID (m_rtx));
|
|
|
268 }
|
|
|
269 }
|
|
|
270
|
|
|
271 /* Fix up a NOTE_INSN_BASIC_BLOCK based on an integer block ID. */
|
|
|
272
|
|
|
273 void
|
|
|
274 fixup_note_insn_basic_block::apply (function_reader *) const
|
|
|
275 {
|
|
|
276 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, m_bb_idx);
|
|
|
277 gcc_assert (bb);
|
|
|
278 NOTE_BASIC_BLOCK (m_rtx) = bb;
|
|
|
279 }
|
|
|
280
|
|
|
281 /* Fix up the expr of an rtx (REG or MEM) based on a textual dump
|
|
|
282 read by READER. */
|
|
|
283
|
|
|
284 void
|
|
|
285 fixup_expr::apply (function_reader *reader) const
|
|
|
286 {
|
|
|
287 tree expr = reader->parse_mem_expr (m_desc);
|
|
|
288 switch (GET_CODE (m_rtx))
|
|
|
289 {
|
|
|
290 case REG:
|
|
|
291 set_reg_attrs_for_decl_rtl (expr, m_rtx);
|
|
|
292 break;
|
|
|
293 case MEM:
|
|
|
294 set_mem_expr (m_rtx, expr);
|
|
|
295 break;
|
|
|
296 default:
|
|
|
297 gcc_unreachable ();
|
|
|
298 }
|
|
|
299 }
|
|
|
300
|
|
|
301 /* Strip trailing whitespace from DESC. */
|
|
|
302
|
|
|
303 static void
|
|
|
304 strip_trailing_whitespace (char *desc)
|
|
|
305 {
|
|
|
306 char *terminator = desc + strlen (desc);
|
|
|
307 while (desc < terminator)
|
|
|
308 {
|
|
|
309 terminator--;
|
|
|
310 if (ISSPACE (*terminator))
|
|
|
311 *terminator = '\0';
|
|
|
312 else
|
|
|
313 break;
|
|
|
314 }
|
|
|
315 }
|
|
|
316
|
|
|
317 /* Return the numeric value n for GET_NOTE_INSN_NAME (n) for STRING,
|
|
|
318 or fail if STRING isn't recognized. */
|
|
|
319
|
|
|
320 static int
|
|
|
321 parse_note_insn_name (const char *string)
|
|
|
322 {
|
|
|
323 for (int i = 0; i < NOTE_INSN_MAX; i++)
|
|
|
324 if (0 == strcmp (string, GET_NOTE_INSN_NAME (i)))
|
|
|
325 return i;
|
|
|
326 fatal_with_file_and_line ("unrecognized NOTE_INSN name: `%s'", string);
|
|
|
327 }
|
|
|
328
|
|
|
329 /* Return the register number for NAME, or return -1 if it isn't
|
|
|
330 recognized. */
|
|
|
331
|
|
|
332 static int
|
|
|
333 lookup_reg_by_dump_name (const char *name)
|
|
|
334 {
|
|
|
335 for (int i = 0; i < FIRST_PSEUDO_REGISTER; i++)
|
|
|
336 if (reg_names[i][0]
|
|
|
337 && ! strcmp (name, reg_names[i]))
|
|
|
338 return i;
|
|
|
339
|
|
|
340 /* Also lookup virtuals. */
|
|
|
341 if (!strcmp (name, "virtual-incoming-args"))
|
|
|
342 return VIRTUAL_INCOMING_ARGS_REGNUM;
|
|
|
343 if (!strcmp (name, "virtual-stack-vars"))
|
|
|
344 return VIRTUAL_STACK_VARS_REGNUM;
|
|
|
345 if (!strcmp (name, "virtual-stack-dynamic"))
|
|
|
346 return VIRTUAL_STACK_DYNAMIC_REGNUM;
|
|
|
347 if (!strcmp (name, "virtual-outgoing-args"))
|
|
|
348 return VIRTUAL_OUTGOING_ARGS_REGNUM;
|
|
|
349 if (!strcmp (name, "virtual-cfa"))
|
|
|
350 return VIRTUAL_CFA_REGNUM;
|
|
|
351 if (!strcmp (name, "virtual-preferred-stack-boundary"))
|
|
|
352 return VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM;
|
|
|
353 /* TODO: handle "virtual-reg-%d". */
|
|
|
354
|
|
|
355 /* In compact mode, pseudos are printed with '< and '>' wrapping the regno,
|
|
|
356 offseting it by (LAST_VIRTUAL_REGISTER + 1), so that the
|
|
|
357 first non-virtual pseudo is dumped as "<0>". */
|
|
|
358 if (name[0] == '<' && name[strlen (name) - 1] == '>')
|
|
|
359 {
|
|
|
360 int dump_num = atoi (name + 1);
|
|
|
361 return dump_num + LAST_VIRTUAL_REGISTER + 1;
|
|
|
362 }
|
|
|
363
|
|
|
364 /* Not found. */
|
|
|
365 return -1;
|
|
|
366 }
|
|
|
367
|
|
|
368 /* class function_reader : public rtx_reader */
|
|
|
369
|
|
|
370 /* function_reader's constructor. */
|
|
|
371
|
|
|
372 function_reader::function_reader ()
|
|
|
373 : rtx_reader (true),
|
|
|
374 m_first_insn (NULL),
|
|
|
375 m_name (NULL),
|
|
|
376 m_have_crtl_directive (false),
|
|
|
377 m_bb_to_insert_after (NULL),
|
|
|
378 m_highest_bb_idx (EXIT_BLOCK)
|
|
|
379 {
|
|
|
380 }
|
|
|
381
|
|
|
382 /* function_reader's destructor. */
|
|
|
383
|
|
|
384 function_reader::~function_reader ()
|
|
|
385 {
|
|
|
386 int i;
|
|
|
387 fixup *f;
|
|
|
388 FOR_EACH_VEC_ELT (m_fixups, i, f)
|
|
|
389 delete f;
|
|
|
390
|
|
|
391 free (m_name);
|
|
|
392 }
|
|
|
393
|
|
|
394 /* Implementation of rtx_reader::handle_unknown_directive,
|
|
|
395 for parsing the remainder of a directive with name NAME
|
|
|
396 seen at START_LOC.
|
|
|
397
|
|
|
398 Require a top-level "function" directive, as emitted by
|
|
|
399 print_rtx_function, and parse it. */
|
|
|
400
|
|
|
401 void
|
|
|
402 function_reader::handle_unknown_directive (file_location start_loc,
|
|
|
403 const char *name)
|
|
|
404 {
|
|
|
405 if (strcmp (name, "function"))
|
|
|
406 fatal_at (start_loc, "expected 'function'");
|
|
|
407
|
|
|
408 if (flag_lto)
|
|
|
409 error ("%<__RTL%> function cannot be compiled with %<-flto%>");
|
|
|
410
|
|
|
411 parse_function ();
|
|
|
412 }
|
|
|
413
|
|
|
414 /* Parse the output of print_rtx_function (or hand-written data in the
|
|
|
415 same format), having already parsed the "(function" heading, and
|
|
|
416 finishing immediately before the final ")".
|
|
|
417
|
|
|
418 The "param" and "crtl" clauses are optional. */
|
|
|
419
|
|
|
420 void
|
|
|
421 function_reader::parse_function ()
|
|
|
422 {
|
|
|
423 m_name = xstrdup (read_string (0));
|
|
|
424
|
|
|
425 create_function ();
|
|
|
426
|
|
|
427 while (1)
|
|
|
428 {
|
|
|
429 int c = read_skip_spaces ();
|
|
|
430 if (c == ')')
|
|
|
431 {
|
|
|
432 unread_char (c);
|
|
|
433 break;
|
|
|
434 }
|
|
|
435 unread_char (c);
|
|
|
436 require_char ('(');
|
|
|
437 file_location loc = get_current_location ();
|
|
|
438 struct md_name directive;
|
|
|
439 read_name (&directive);
|
|
|
440 if (strcmp (directive.string, "param") == 0)
|
|
|
441 parse_param ();
|
|
|
442 else if (strcmp (directive.string, "insn-chain") == 0)
|
|
|
443 parse_insn_chain ();
|
|
|
444 else if (strcmp (directive.string, "crtl") == 0)
|
|
|
445 parse_crtl (loc);
|
|
|
446 else
|
|
|
447 fatal_with_file_and_line ("unrecognized directive: %s",
|
|
|
448 directive.string);
|
|
|
449 }
|
|
|
450
|
|
|
451 handle_insn_uids ();
|
|
|
452
|
|
|
453 apply_fixups ();
|
|
|
454
|
|
|
455 /* Rebuild the JUMP_LABEL field of any JUMP_INSNs in the chain, and the
|
|
|
456 LABEL_NUSES of any CODE_LABELs.
|
|
|
457
|
|
|
458 This has to happen after apply_fixups, since only after then do
|
|
|
459 LABEL_REFs have their label_ref_label set up. */
|
|
|
460 rebuild_jump_labels (get_insns ());
|
|
|
461
|
|
|
462 crtl->init_stack_alignment ();
|
|
|
463 }
|
|
|
464
|
|
|
465 /* Set up state for the function *before* fixups are applied.
|
|
|
466
|
|
|
467 Create "cfun" and a decl for the function.
|
|
|
468 By default, every function decl is hardcoded as
|
|
|
469 int test_1 (int i, int j, int k);
|
|
|
470 Set up various other state:
|
|
|
471 - the cfg and basic blocks (edges are created later, *after* fixups
|
|
|
472 are applied).
|
|
|
473 - add the function to the callgraph. */
|
|
|
474
|
|
|
475 void
|
|
|
476 function_reader::create_function ()
|
|
|
477 {
|
|
|
478 /* We start in cfgrtl mode, rather than cfglayout mode. */
|
|
|
479 rtl_register_cfg_hooks ();
|
|
|
480
|
|
|
481 /* When run from selftests or "rtl1", cfun is NULL.
|
|
|
482 When run from "cc1" for a C function tagged with __RTL, cfun is the
|
|
|
483 tagged function. */
|
|
|
484 if (!cfun)
|
|
|
485 {
|
|
|
486 tree fn_name = get_identifier (m_name ? m_name : "test_1");
|
|
|
487 tree int_type = integer_type_node;
|
|
|
488 tree return_type = int_type;
|
|
|
489 tree arg_types[3] = {int_type, int_type, int_type};
|
|
|
490 tree fn_type = build_function_type_array (return_type, 3, arg_types);
|
|
|
491 tree fndecl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL, fn_name, fn_type);
|
|
|
492 tree resdecl = build_decl (UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE,
|
|
|
493 return_type);
|
|
|
494 DECL_ARTIFICIAL (resdecl) = 1;
|
|
|
495 DECL_IGNORED_P (resdecl) = 1;
|
|
|
496 DECL_RESULT (fndecl) = resdecl;
|
|
|
497 allocate_struct_function (fndecl, false);
|
|
|
498 /* This sets cfun. */
|
|
|
499 current_function_decl = fndecl;
|
|
|
500 }
|
|
|
501
|
|
|
502 gcc_assert (cfun);
|
|
|
503 gcc_assert (current_function_decl);
|
|
|
504 tree fndecl = current_function_decl;
|
|
|
505
|
|
|
506 /* Mark this function as being specified as __RTL. */
|
|
|
507 cfun->curr_properties |= PROP_rtl;
|
|
|
508
|
|
|
509 /* cc1 normally inits DECL_INITIAL (fndecl) to be error_mark_node.
|
|
|
510 Create a dummy block for it. */
|
|
|
511 DECL_INITIAL (fndecl) = make_node (BLOCK);
|
|
|
512
|
|
|
513 cfun->curr_properties = (PROP_cfg | PROP_rtl);
|
|
|
514
|
|
|
515 /* Do we need this to force cgraphunit.c to output the function? */
|
|
|
516 DECL_EXTERNAL (fndecl) = 0;
|
|
|
517 DECL_PRESERVE_P (fndecl) = 1;
|
|
|
518
|
|
|
519 /* Add to cgraph. */
|
|
|
520 cgraph_node::finalize_function (fndecl, false);
|
|
|
521
|
|
|
522 /* Create bare-bones cfg. This creates the entry and exit blocks. */
|
|
|
523 init_empty_tree_cfg_for_function (cfun);
|
|
|
524 ENTRY_BLOCK_PTR_FOR_FN (cfun)->flags |= BB_RTL;
|
|
|
525 EXIT_BLOCK_PTR_FOR_FN (cfun)->flags |= BB_RTL;
|
|
|
526 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun));
|
|
|
527 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun));
|
|
|
528 m_bb_to_insert_after = ENTRY_BLOCK_PTR_FOR_FN (cfun);
|
|
|
529
|
|
|
530 }
|
|
|
531
|
|
|
532 /* Look within the the params of FNDECL for a param named NAME.
|
|
|
533 Return NULL_TREE if one isn't found. */
|
|
|
534
|
|
|
535 static tree
|
|
|
536 find_param_by_name (tree fndecl, const char *name)
|
|
|
537 {
|
|
|
538 for (tree arg = DECL_ARGUMENTS (fndecl); arg; arg = TREE_CHAIN (arg))
|
|
|
539 if (id_equal (DECL_NAME (arg), name))
|
|
|
540 return arg;
|
|
|
541 return NULL_TREE;
|
|
|
542 }
|
|
|
543
|
|
|
544 /* Parse the content of a "param" directive, having already parsed the
|
|
|
545 "(param". Consume the trailing ')'. */
|
|
|
546
|
|
|
547 void
|
|
|
548 function_reader::parse_param ()
|
|
|
549 {
|
|
|
550 require_char_ws ('"');
|
|
|
551 file_location loc = get_current_location ();
|
|
|
552 char *name = read_quoted_string ();
|
|
|
553
|
|
|
554 /* Lookup param by name. */
|
|
|
555 tree t_param = find_param_by_name (cfun->decl, name);
|
|
|
556 if (!t_param)
|
|
|
557 fatal_at (loc, "param not found: %s", name);
|
|
|
558
|
|
|
559 /* Parse DECL_RTL. */
|
|
|
560 require_char_ws ('(');
|
|
|
561 require_word_ws ("DECL_RTL");
|
|
|
562 DECL_WRTL_CHECK (t_param)->decl_with_rtl.rtl = parse_rtx ();
|
|
|
563 require_char_ws (')');
|
|
|
564
|
|
|
565 /* Parse DECL_RTL_INCOMING. */
|
|
|
566 require_char_ws ('(');
|
|
|
567 require_word_ws ("DECL_RTL_INCOMING");
|
|
|
568 DECL_INCOMING_RTL (t_param) = parse_rtx ();
|
|
|
569 require_char_ws (')');
|
|
|
570
|
|
|
571 require_char_ws (')');
|
|
|
572 }
|
|
|
573
|
|
|
574 /* Parse zero or more child insn elements within an
|
|
|
575 "insn-chain" element. Consume the trailing ')'. */
|
|
|
576
|
|
|
577 void
|
|
|
578 function_reader::parse_insn_chain ()
|
|
|
579 {
|
|
|
580 while (1)
|
|
|
581 {
|
|
|
582 int c = read_skip_spaces ();
|
|
|
583 file_location loc = get_current_location ();
|
|
|
584 if (c == ')')
|
|
|
585 break;
|
|
|
586 else if (c == '(')
|
|
|
587 {
|
|
|
588 struct md_name directive;
|
|
|
589 read_name (&directive);
|
|
|
590 if (strcmp (directive.string, "block") == 0)
|
|
|
591 parse_block ();
|
|
|
592 else
|
|
|
593 parse_insn (loc, directive.string);
|
|
|
594 }
|
|
|
595 else
|
|
|
596 fatal_at (loc, "expected '(' or ')'");
|
|
|
597 }
|
|
|
598
|
|
|
599 create_edges ();
|
|
|
600 }
|
|
|
601
|
|
|
602 /* Parse zero or more child directives (edges and insns) within a
|
|
|
603 "block" directive, having already parsed the "(block " heading.
|
|
|
604 Consume the trailing ')'. */
|
|
|
605
|
|
|
606 void
|
|
|
607 function_reader::parse_block ()
|
|
|
608 {
|
|
|
609 /* Parse the index value from the dump. This will be an integer;
|
|
|
610 we don't support "entry" or "exit" here (unlike for edges). */
|
|
|
611 struct md_name name;
|
|
|
612 read_name (&name);
|
|
|
613 int bb_idx = atoi (name.string);
|
|
|
614
|
|
|
615 /* The term "index" has two meanings for basic blocks in a CFG:
|
|
|
616 (a) the "index" field within struct basic_block_def.
|
|
|
617 (b) the index of a basic_block within the cfg's x_basic_block_info
|
|
|
618 vector, as accessed via BASIC_BLOCK_FOR_FN.
|
|
|
619
|
|
|
620 These can get out-of-sync when basic blocks are optimized away.
|
|
|
621 They get back in sync by "compact_blocks".
|
|
|
622 We reconstruct cfun->cfg->x_basic_block_info->m_vecdata with NULL
|
|
|
623 values in it for any missing basic blocks, so that (a) == (b) for
|
|
|
624 all of the blocks we create. The doubly-linked list of basic
|
|
|
625 blocks (next_bb/prev_bb) skips over these "holes". */
|
|
|
626
|
|
|
627 if (m_highest_bb_idx < bb_idx)
|
|
|
628 m_highest_bb_idx = bb_idx;
|
|
|
629
|
|
|
630 size_t new_size = m_highest_bb_idx + 1;
|
|
|
631 if (basic_block_info_for_fn (cfun)->length () < new_size)
|
|
|
632 vec_safe_grow_cleared (basic_block_info_for_fn (cfun), new_size);
|
|
|
633
|
|
|
634 last_basic_block_for_fn (cfun) = new_size;
|
|
|
635
|
|
|
636 /* Create the basic block.
|
|
|
637
|
|
|
638 We can't call create_basic_block and use the regular RTL block-creation
|
|
|
639 hooks, since this creates NOTE_INSN_BASIC_BLOCK instances. We don't
|
|
|
640 want to do that; we want to use the notes we were provided with. */
|
|
|
641 basic_block bb = alloc_block ();
|
|
|
642 init_rtl_bb_info (bb);
|
|
|
643 bb->index = bb_idx;
|
|
|
644 bb->flags = BB_NEW | BB_RTL;
|
|
|
645 link_block (bb, m_bb_to_insert_after);
|
|
|
646 m_bb_to_insert_after = bb;
|
|
|
647
|
|
|
648 n_basic_blocks_for_fn (cfun)++;
|
|
|
649 SET_BASIC_BLOCK_FOR_FN (cfun, bb_idx, bb);
|
|
|
650 BB_SET_PARTITION (bb, BB_UNPARTITIONED);
|
|
|
651
|
|
|
652 /* Handle insns, edge-from and edge-to directives. */
|
|
|
653 while (1)
|
|
|
654 {
|
|
|
655 int c = read_skip_spaces ();
|
|
|
656 file_location loc = get_current_location ();
|
|
|
657 if (c == ')')
|
|
|
658 break;
|
|
|
659 else if (c == '(')
|
|
|
660 {
|
|
|
661 struct md_name directive;
|
|
|
662 read_name (&directive);
|
|
|
663 if (strcmp (directive.string, "edge-from") == 0)
|
|
|
664 parse_edge (bb, true);
|
|
|
665 else if (strcmp (directive.string, "edge-to") == 0)
|
|
|
666 parse_edge (bb, false);
|
|
|
667 else
|
|
|
668 {
|
|
|
669 rtx_insn *insn = parse_insn (loc, directive.string);
|
|
|
670 set_block_for_insn (insn, bb);
|
|
|
671 if (!BB_HEAD (bb))
|
|
|
672 BB_HEAD (bb) = insn;
|
|
|
673 BB_END (bb) = insn;
|
|
|
674 }
|
|
|
675 }
|
|
|
676 else
|
|
|
677 fatal_at (loc, "expected '(' or ')'");
|
|
|
678 }
|
|
|
679 }
|
|
|
680
|
|
|
681 /* Subroutine of function_reader::parse_edge.
|
|
|
682 Parse a basic block index, handling "entry" and "exit". */
|
|
|
683
|
|
|
684 int
|
|
|
685 function_reader::parse_bb_idx ()
|
|
|
686 {
|
|
|
687 struct md_name name;
|
|
|
688 read_name (&name);
|
|
|
689 if (strcmp (name.string, "entry") == 0)
|
|
|
690 return ENTRY_BLOCK;
|
|
|
691 if (strcmp (name.string, "exit") == 0)
|
|
|
692 return EXIT_BLOCK;
|
|
|
693 return atoi (name.string);
|
|
|
694 }
|
|
|
695
|
|
|
696 /* Subroutine of parse_edge_flags.
|
|
|
697 Parse TOK, a token such as "FALLTHRU", converting to the flag value.
|
|
|
698 Issue an error if the token is unrecognized. */
|
|
|
699
|
|
|
700 static int
|
|
|
701 parse_edge_flag_token (const char *tok)
|
|
|
702 {
|
|
|
703 #define DEF_EDGE_FLAG(NAME,IDX) \
|
|
|
704 do { \
|
|
|
705 if (strcmp (tok, #NAME) == 0) \
|
|
|
706 return EDGE_##NAME; \
|
|
|
707 } while (0);
|
|
|
708 #include "cfg-flags.def"
|
|
|
709 #undef DEF_EDGE_FLAG
|
|
|
710 error ("unrecognized edge flag: '%s'", tok);
|
|
|
711 return 0;
|
|
|
712 }
|
|
|
713
|
|
|
714 /* Subroutine of function_reader::parse_edge.
|
|
|
715 Parse STR and convert to a flag value (or issue an error).
|
|
|
716 The parser uses strtok and hence modifiers STR in-place. */
|
|
|
717
|
|
|
718 static int
|
|
|
719 parse_edge_flags (char *str)
|
|
|
720 {
|
|
|
721 int result = 0;
|
|
|
722
|
|
|
723 char *tok = strtok (str, "| ");
|
|
|
724 while (tok)
|
|
|
725 {
|
|
|
726 result |= parse_edge_flag_token (tok);
|
|
|
727 tok = strtok (NULL, "| ");
|
|
|
728 }
|
|
|
729
|
|
|
730 return result;
|
|
|
731 }
|
|
|
732
|
|
|
733 /* Parse an "edge-from" or "edge-to" directive within the "block"
|
|
|
734 directive for BLOCK, having already parsed the "(edge" heading.
|
|
|
735 Consume the final ")". Record the edge within m_deferred_edges.
|
|
|
736 FROM is true for an "edge-from" directive, false for an "edge-to"
|
|
|
737 directive. */
|
|
|
738
|
|
|
739 void
|
|
|
740 function_reader::parse_edge (basic_block block, bool from)
|
|
|
741 {
|
|
|
742 gcc_assert (block);
|
|
|
743 int this_bb_idx = block->index;
|
|
|
744 file_location loc = get_current_location ();
|
|
|
745 int other_bb_idx = parse_bb_idx ();
|
|
|
746
|
|
|
747 /* "(edge-from 2)" means src = 2, dest = this_bb_idx, whereas
|
|
|
748 "(edge-to 3)" means src = this_bb_idx, dest = 3. */
|
|
|
749 int src_idx = from ? other_bb_idx : this_bb_idx;
|
|
|
750 int dest_idx = from ? this_bb_idx : other_bb_idx;
|
|
|
751
|
|
|
752 /* Optional "(flags)". */
|
|
|
753 int flags = 0;
|
|
|
754 int c = read_skip_spaces ();
|
|
|
755 if (c == '(')
|
|
|
756 {
|
|
|
757 require_word_ws ("flags");
|
|
|
758 require_char_ws ('"');
|
|
|
759 char *str = read_quoted_string ();
|
|
|
760 flags = parse_edge_flags (str);
|
|
|
761 require_char_ws (')');
|
|
|
762 }
|
|
|
763 else
|
|
|
764 unread_char (c);
|
|
|
765
|
|
|
766 require_char_ws (')');
|
|
|
767
|
|
|
768 /* This BB already exists, but the other BB might not yet.
|
|
|
769 For now, save the edges, and create them at the end of insn-chain
|
|
|
770 processing. */
|
|
|
771 /* For now, only process the (edge-from) to this BB, and (edge-to)
|
|
|
772 that go to the exit block.
|
|
|
773 FIXME: we don't yet verify that the edge-from and edge-to directives
|
|
|
774 are consistent. */
|
|
|
775 if (from || dest_idx == EXIT_BLOCK)
|
|
|
776 m_deferred_edges.safe_push (deferred_edge (loc, src_idx, dest_idx, flags));
|
|
|
777 }
|
|
|
778
|
|
|
779 /* Parse an rtx instruction, having parsed the opening and parenthesis, and
|
|
|
780 name NAME, seen at START_LOC, by calling read_rtx_code, calling
|
|
|
781 set_first_insn and set_last_insn as appropriate, and
|
|
|
782 adding the insn to the insn chain.
|
|
|
783 Consume the trailing ')'. */
|
|
|
784
|
|
|
785 rtx_insn *
|
|
|
786 function_reader::parse_insn (file_location start_loc, const char *name)
|
|
|
787 {
|
|
|
788 rtx x = read_rtx_code (name);
|
|
|
789 if (!x)
|
|
|
790 fatal_at (start_loc, "expected insn type; got '%s'", name);
|
|
|
791 rtx_insn *insn = dyn_cast <rtx_insn *> (x);
|
|
|
792 if (!insn)
|
|
|
793 fatal_at (start_loc, "expected insn type; got '%s'", name);
|
|
|
794
|
|
|
795 /* Consume the trailing ')'. */
|
|
|
796 require_char_ws (')');
|
|
|
797
|
|
|
798 rtx_insn *last_insn = get_last_insn ();
|
|
|
799
|
|
|
800 /* Add "insn" to the insn chain. */
|
|
|
801 if (last_insn)
|
|
|
802 {
|
|
|
803 gcc_assert (NEXT_INSN (last_insn) == NULL);
|
|
|
804 SET_NEXT_INSN (last_insn) = insn;
|
|
|
805 }
|
|
|
806 SET_PREV_INSN (insn) = last_insn;
|
|
|
807
|
|
|
808 /* Add it to the sequence. */
|
|
|
809 set_last_insn (insn);
|
|
|
810 if (!m_first_insn)
|
|
|
811 {
|
|
|
812 m_first_insn = insn;
|
|
|
813 set_first_insn (insn);
|
|
|
814 }
|
|
|
815
|
|
|
816 if (rtx_code_label *label = dyn_cast <rtx_code_label *> (insn))
|
|
|
817 maybe_set_max_label_num (label);
|
|
|
818
|
|
|
819 return insn;
|
|
|
820 }
|
|
|
821
|
|
|
822 /* Postprocessing subroutine for parse_insn_chain: all the basic blocks
|
|
|
823 should have been created by now; create the edges that were seen. */
|
|
|
824
|
|
|
825 void
|
|
|
826 function_reader::create_edges ()
|
|
|
827 {
|
|
|
828 int i;
|
|
|
829 deferred_edge *de;
|
|
|
830 FOR_EACH_VEC_ELT (m_deferred_edges, i, de)
|
|
|
831 {
|
|
|
832 /* The BBs should already have been created by parse_block. */
|
|
|
833 basic_block src = BASIC_BLOCK_FOR_FN (cfun, de->m_src_bb_idx);
|
|
|
834 if (!src)
|
|
|
835 fatal_at (de->m_loc, "error: block index %i not found",
|
|
|
836 de->m_src_bb_idx);
|
|
|
837 basic_block dst = BASIC_BLOCK_FOR_FN (cfun, de->m_dest_bb_idx);
|
|
|
838 if (!dst)
|
|
|
839 fatal_at (de->m_loc, "error: block with index %i not found",
|
|
|
840 de->m_dest_bb_idx);
|
|
|
841 unchecked_make_edge (src, dst, de->m_flags);
|
|
|
842 }
|
|
|
843 }
|
|
|
844
|
|
|
845 /* Parse a "crtl" directive, having already parsed the "(crtl" heading
|
|
|
846 at location LOC.
|
|
|
847 Consume the final ")". */
|
|
|
848
|
|
|
849 void
|
|
|
850 function_reader::parse_crtl (file_location loc)
|
|
|
851 {
|
|
|
852 if (m_have_crtl_directive)
|
|
|
853 error_at (loc, "more than one 'crtl' directive");
|
|
|
854 m_have_crtl_directive = true;
|
|
|
855
|
|
|
856 /* return_rtx. */
|
|
|
857 require_char_ws ('(');
|
|
|
858 require_word_ws ("return_rtx");
|
|
|
859 crtl->return_rtx = parse_rtx ();
|
|
|
860 require_char_ws (')');
|
|
|
861
|
|
|
862 require_char_ws (')');
|
|
|
863 }
|
|
|
864
|
|
|
865 /* Parse operand IDX of X, returning X, or an equivalent rtx
|
|
|
866 expression (for consolidating singletons).
|
|
|
867 This is an overridden implementation of rtx_reader::read_rtx_operand for
|
|
|
868 function_reader, handling various extra data printed by print_rtx,
|
|
|
869 and sometimes calling the base class implementation. */
|
|
|
870
|
|
|
871 rtx
|
|
|
872 function_reader::read_rtx_operand (rtx x, int idx)
|
|
|
873 {
|
|
|
874 RTX_CODE code = GET_CODE (x);
|
|
|
875 const char *format_ptr = GET_RTX_FORMAT (code);
|
|
|
876 const char format_char = format_ptr[idx];
|
|
|
877 struct md_name name;
|
|
|
878
|
|
|
879 /* Override the regular parser for some format codes. */
|
|
|
880 switch (format_char)
|
|
|
881 {
|
|
|
882 case 'e':
|
|
|
883 if (idx == 7 && CALL_P (x))
|
|
|
884 {
|
|
|
885 m_in_call_function_usage = true;
|
|
|
886 return rtx_reader::read_rtx_operand (x, idx);
|
|
|
887 m_in_call_function_usage = false;
|
|
|
888 }
|
|
|
889 else
|
|
|
890 return rtx_reader::read_rtx_operand (x, idx);
|
|
|
891 break;
|
|
|
892
|
|
|
893 case 'u':
|
|
|
894 read_rtx_operand_u (x, idx);
|
|
|
895 /* Don't run regular parser for 'u'. */
|
|
|
896 return x;
|
|
|
897
|
|
|
898 case 'i':
|
|
|
899 case 'n':
|
|
|
900 read_rtx_operand_i_or_n (x, idx, format_char);
|
|
|
901 /* Don't run regular parser for these codes. */
|
|
|
902 return x;
|
|
|
903
|
|
|
904 case 'B':
|
|
|
905 gcc_assert (is_compact ());
|
|
|
906 /* Compact mode doesn't store BBs. */
|
|
|
907 /* Don't run regular parser. */
|
|
|
908 return x;
|
|
|
909
|
|
|
910 case 'r':
|
|
|
911 /* Don't run regular parser for 'r'. */
|
|
|
912 return read_rtx_operand_r (x);
|
|
|
913
|
|
|
914 default:
|
|
|
915 break;
|
|
|
916 }
|
|
|
917
|
|
|
918 /* Call base class implementation. */
|
|
|
919 x = rtx_reader::read_rtx_operand (x, idx);
|
|
|
920
|
|
|
921 /* Handle any additional parsing needed to handle what the dump
|
|
|
922 could contain. */
|
|
|
923 switch (format_char)
|
|
|
924 {
|
|
|
925 case '0':
|
|
|
926 x = extra_parsing_for_operand_code_0 (x, idx);
|
|
|
927 break;
|
|
|
928
|
|
|
929 case 'w':
|
|
|
930 if (!is_compact ())
|
|
|
931 {
|
|
|
932 /* Strip away the redundant hex dump of the value. */
|
|
|
933 require_char_ws ('[');
|
|
|
934 read_name (&name);
|
|
|
935 require_char_ws (']');
|
|
|
936 }
|
|
|
937 break;
|
|
|
938
|
|
|
939 default:
|
|
|
940 break;
|
|
|
941 }
|
|
|
942
|
|
|
943 return x;
|
|
|
944 }
|
|
|
945
|
|
|
946 /* Parse operand IDX of X, of code 'u', when reading function dumps.
|
|
|
947
|
|
|
948 The RTL file recorded the ID of an insn (or 0 for NULL); we
|
|
|
949 must store this as a pointer, but the insn might not have
|
|
|
950 been loaded yet. Store the ID away for now, via a fixup. */
|
|
|
951
|
|
|
952 void
|
|
|
953 function_reader::read_rtx_operand_u (rtx x, int idx)
|
|
|
954 {
|
|
|
955 /* In compact mode, the PREV/NEXT insn uids are not dumped, so skip
|
|
|
956 the "uu" when reading. */
|
|
|
957 if (is_compact () && GET_CODE (x) != LABEL_REF)
|
|
|
958 return;
|
|
|
959
|
|
|
960 struct md_name name;
|
|
|
961 file_location loc = read_name (&name);
|
|
|
962 int insn_id = atoi (name.string);
|
|
|
963 if (insn_id)
|
|
|
964 add_fixup_insn_uid (loc, x, idx, insn_id);
|
|
|
965 }
|
|
|
966
|
|
|
967 /* Read a name, looking for a match against a string found in array
|
|
|
968 STRINGS of size NUM_VALUES.
|
|
|
969 Return the index of the the matched string, or emit an error. */
|
|
|
970
|
|
|
971 int
|
|
|
972 function_reader::parse_enum_value (int num_values, const char *const *strings)
|
|
|
973 {
|
|
|
974 struct md_name name;
|
|
|
975 read_name (&name);
|
|
|
976 for (int i = 0; i < num_values; i++)
|
|
|
977 {
|
|
|
978 if (strcmp (name.string, strings[i]) == 0)
|
|
|
979 return i;
|
|
|
980 }
|
|
|
981 error ("unrecognized enum value: '%s'", name.string);
|
|
|
982 return 0;
|
|
|
983 }
|
|
|
984
|
|
|
985 /* Parse operand IDX of X, of code 'i' or 'n' (as specified by FORMAT_CHAR).
|
|
|
986 Special-cased handling of these, for reading function dumps. */
|
|
|
987
|
|
|
988 void
|
|
|
989 function_reader::read_rtx_operand_i_or_n (rtx x, int idx,
|
|
|
990 char format_char)
|
|
|
991 {
|
|
|
992 /* Handle some of the extra information that print_rtx
|
|
|
993 can write out for these cases. */
|
|
|
994 /* print_rtx only writes out operand 5 for notes
|
|
|
995 for NOTE_KIND values NOTE_INSN_DELETED_LABEL
|
|
|
996 and NOTE_INSN_DELETED_DEBUG_LABEL. */
|
|
|
997 if (idx == 5 && NOTE_P (x))
|
|
|
998 return;
|
|
|
999
|
|
|
1000 if (idx == 4 && INSN_P (x))
|
|
|
1001 {
|
|
|
1002 maybe_read_location (as_a <rtx_insn *> (x));
|
|
|
1003 return;
|
|
|
1004 }
|
|
|
1005
|
|
|
1006 /* INSN_CODEs aren't printed in compact mode, so don't attempt to
|
|
|
1007 parse them. */
|
|
|
1008 if (is_compact ()
|
|
|
1009 && INSN_P (x)
|
|
|
1010 && &INSN_CODE (x) == &XINT (x, idx))
|
|
|
1011 {
|
|
|
1012 INSN_CODE (x) = -1;
|
|
|
1013 return;
|
|
|
1014 }
|
|
|
1015
|
|
|
1016 /* Handle UNSPEC and UNSPEC_VOLATILE's operand 1. */
|
|
|
1017 #if !defined(GENERATOR_FILE) && NUM_UNSPECV_VALUES > 0
|
|
|
1018 if (idx == 1
|
|
|
1019 && GET_CODE (x) == UNSPEC_VOLATILE)
|
|
|
1020 {
|
|
|
1021 XINT (x, 1)
|
|
|
1022 = parse_enum_value (NUM_UNSPECV_VALUES, unspecv_strings);
|
|
|
1023 return;
|
|
|
1024 }
|
|
|
1025 #endif
|
|
|
1026 #if !defined(GENERATOR_FILE) && NUM_UNSPEC_VALUES > 0
|
|
|
1027 if (idx == 1
|
|
|
1028 && (GET_CODE (x) == UNSPEC
|
|
|
1029 || GET_CODE (x) == UNSPEC_VOLATILE))
|
|
|
1030 {
|
|
|
1031 XINT (x, 1)
|
|
|
1032 = parse_enum_value (NUM_UNSPEC_VALUES, unspec_strings);
|
|
|
1033 return;
|
|
|
1034 }
|
|
|
1035 #endif
|
|
|
1036
|
|
|
1037 struct md_name name;
|
|
|
1038 read_name (&name);
|
|
|
1039 int value;
|
|
|
1040 if (format_char == 'n')
|
|
|
1041 value = parse_note_insn_name (name.string);
|
|
|
1042 else
|
|
|
1043 value = atoi (name.string);
|
|
|
1044 XINT (x, idx) = value;
|
|
|
1045 }
|
|
|
1046
|
|
|
1047 /* Parse the 'r' operand of X, returning X, or an equivalent rtx
|
|
|
1048 expression (for consolidating singletons).
|
|
|
1049 Special-cased handling of code 'r' for reading function dumps. */
|
|
|
1050
|
|
|
1051 rtx
|
|
|
1052 function_reader::read_rtx_operand_r (rtx x)
|
|
|
1053 {
|
|
|
1054 struct md_name name;
|
|
|
1055 file_location loc = read_name (&name);
|
|
|
1056 int regno = lookup_reg_by_dump_name (name.string);
|
|
|
1057 if (regno == -1)
|
|
|
1058 fatal_at (loc, "unrecognized register: '%s'", name.string);
|
|
|
1059
|
|
|
1060 set_regno_raw (x, regno, 1);
|
|
|
1061
|
|
|
1062 /* Consolidate singletons. */
|
|
|
1063 x = consolidate_singletons (x);
|
|
|
1064
|
|
|
1065 ORIGINAL_REGNO (x) = regno;
|
|
|
1066
|
|
|
1067 /* Parse extra stuff at end of 'r'.
|
|
|
1068 We may have zero, one, or two sections marked by square
|
|
|
1069 brackets. */
|
|
|
1070 int ch = read_skip_spaces ();
|
|
|
1071 bool expect_original_regno = false;
|
|
|
1072 if (ch == '[')
|
|
|
1073 {
|
|
|
1074 file_location loc = get_current_location ();
|
|
|
1075 char *desc = read_until ("]", true);
|
|
|
1076 strip_trailing_whitespace (desc);
|
|
|
1077 const char *desc_start = desc;
|
|
|
1078 /* If ORIGINAL_REGNO (rtx) != regno, we will have:
|
|
|
1079 "orig:%i", ORIGINAL_REGNO (rtx).
|
|
|
1080 Consume it, we don't set ORIGINAL_REGNO, since we can
|
|
|
1081 get that from the 2nd copy later. */
|
|
|
1082 if (0 == strncmp (desc, "orig:", 5))
|
|
|
1083 {
|
|
|
1084 expect_original_regno = true;
|
|
|
1085 desc_start += 5;
|
|
|
1086 /* Skip to any whitespace following the integer. */
|
|
|
1087 const char *space = strchr (desc_start, ' ');
|
|
|
1088 if (space)
|
|
|
1089 desc_start = space + 1;
|
|
|
1090 }
|
|
|
1091 /* Any remaining text may be the REG_EXPR. Alternatively we have
|
|
|
1092 no REG_ATTRS, and instead we have ORIGINAL_REGNO. */
|
|
|
1093 if (ISDIGIT (*desc_start))
|
|
|
1094 {
|
|
|
1095 /* Assume we have ORIGINAL_REGNO. */
|
|
|
1096 ORIGINAL_REGNO (x) = atoi (desc_start);
|
|
|
1097 }
|
|
|
1098 else
|
|
|
1099 {
|
|
|
1100 /* Assume we have REG_EXPR. */
|
|
|
1101 add_fixup_expr (loc, x, desc_start);
|
|
|
1102 }
|
|
|
1103 free (desc);
|
|
|
1104 }
|
|
|
1105 else
|
|
|
1106 unread_char (ch);
|
|
|
1107 if (expect_original_regno)
|
|
|
1108 {
|
|
|
1109 require_char_ws ('[');
|
|
|
1110 char *desc = read_until ("]", true);
|
|
|
1111 ORIGINAL_REGNO (x) = atoi (desc);
|
|
|
1112 free (desc);
|
|
|
1113 }
|
|
|
1114
|
|
|
1115 return x;
|
|
|
1116 }
|
|
|
1117
|
|
|
1118 /* Additional parsing for format code '0' in dumps, handling a variety
|
|
|
1119 of special-cases in print_rtx, when parsing operand IDX of X.
|
|
|
1120 Return X, or possibly a reallocated copy of X. */
|
|
|
1121
|
|
|
1122 rtx
|
|
|
1123 function_reader::extra_parsing_for_operand_code_0 (rtx x, int idx)
|
|
|
1124 {
|
|
|
1125 RTX_CODE code = GET_CODE (x);
|
|
|
1126 int c;
|
|
|
1127 struct md_name name;
|
|
|
1128
|
|
|
1129 if (idx == 1 && code == SYMBOL_REF)
|
|
|
1130 {
|
|
|
1131 /* Possibly wrote " [flags %#x]", SYMBOL_REF_FLAGS (in_rtx). */
|
|
|
1132 c = read_skip_spaces ();
|
|
|
1133 if (c == '[')
|
|
|
1134 {
|
|
|
1135 file_location loc = read_name (&name);
|
|
|
1136 if (strcmp (name.string, "flags"))
|
|
|
1137 error_at (loc, "was expecting `%s'", "flags");
|
|
|
1138 read_name (&name);
|
|
|
1139 SYMBOL_REF_FLAGS (x) = strtol (name.string, NULL, 16);
|
|
|
1140
|
|
|
1141 /* The standard RTX_CODE_SIZE (SYMBOL_REF) used when allocating
|
|
|
1142 x doesn't have space for the block_symbol information, so
|
|
|
1143 we must reallocate it if this flag is set. */
|
|
|
1144 if (SYMBOL_REF_HAS_BLOCK_INFO_P (x))
|
|
|
1145 {
|
|
|
1146 /* Emulate the allocation normally done by
|
|
|
1147 varasm.c:create_block_symbol. */
|
|
|
1148 unsigned int size = RTX_HDR_SIZE + sizeof (struct block_symbol);
|
|
|
1149 rtx new_x = (rtx) ggc_internal_alloc (size);
|
|
|
1150
|
|
|
1151 /* Copy data over from the smaller SYMBOL_REF. */
|
|
|
1152 memcpy (new_x, x, RTX_CODE_SIZE (SYMBOL_REF));
|
|
|
1153 x = new_x;
|
|
|
1154
|
|
|
1155 /* We can't reconstruct SYMBOL_REF_BLOCK; set it to NULL. */
|
|
|
1156 SYMBOL_REF_BLOCK (x) = NULL;
|
|
|
1157
|
|
|
1158 /* Zero the offset. */
|
|
|
1159 SYMBOL_REF_BLOCK_OFFSET (x) = 0;
|
|
|
1160 }
|
|
|
1161
|
|
|
1162 require_char (']');
|
|
|
1163 }
|
|
|
1164 else
|
|
|
1165 unread_char (c);
|
|
|
1166
|
|
|
1167 /* If X had a non-NULL SYMBOL_REF_DECL,
|
|
|
1168 rtx_writer::print_rtx_operand_code_0 would have dumped it
|
|
|
1169 using print_node_brief.
|
|
|
1170 Skip the content for now. */
|
|
|
1171 c = read_skip_spaces ();
|
|
|
1172 if (c == '<')
|
|
|
1173 {
|
|
|
1174 while (1)
|
|
|
1175 {
|
|
|
1176 char ch = read_char ();
|
|
|
1177 if (ch == '>')
|
|
|
1178 break;
|
|
|
1179 }
|
|
|
1180 }
|
|
|
1181 else
|
|
|
1182 unread_char (c);
|
|
|
1183 }
|
|
|
1184 else if (idx == 3 && code == NOTE)
|
|
|
1185 {
|
|
|
1186 /* Note-specific data appears for operand 3, which annoyingly
|
|
|
1187 is before the enum specifying which kind of note we have
|
|
|
1188 (operand 4). */
|
|
|
1189 c = read_skip_spaces ();
|
|
|
1190 if (c == '[')
|
|
|
1191 {
|
|
|
1192 /* Possibly data for a NOTE_INSN_BASIC_BLOCK, of the form:
|
|
|
1193 [bb %d]. */
|
|
|
1194 file_location bb_loc = read_name (&name);
|
|
|
1195 if (strcmp (name.string, "bb"))
|
|
|
1196 error_at (bb_loc, "was expecting `%s'", "bb");
|
|
|
1197 read_name (&name);
|
|
|
1198 int bb_idx = atoi (name.string);
|
|
|
1199 add_fixup_note_insn_basic_block (bb_loc, x, idx,
|
|
|
1200 bb_idx);
|
|
|
1201 require_char_ws (']');
|
|
|
1202 }
|
|
|
1203 else
|
|
|
1204 unread_char (c);
|
|
|
1205 }
|
|
|
1206
|
|
|
1207 return x;
|
|
|
1208 }
|
|
|
1209
|
|
|
1210 /* Implementation of rtx_reader::handle_any_trailing_information.
|
|
|
1211 Handle the various additional information that print-rtl.c can
|
|
|
1212 write after the regular fields, when parsing X. */
|
|
|
1213
|
|
|
1214 void
|
|
|
1215 function_reader::handle_any_trailing_information (rtx x)
|
|
|
1216 {
|
|
|
1217 struct md_name name;
|
|
|
1218
|
|
|
1219 switch (GET_CODE (x))
|
|
|
1220 {
|
|
|
1221 case MEM:
|
|
|
1222 {
|
|
|
1223 int ch;
|
|
|
1224 require_char_ws ('[');
|
|
|
1225 read_name (&name);
|
|
|
1226 set_mem_alias_set (x, atoi (name.string));
|
|
|
1227 /* We have either a MEM_EXPR, or a space. */
|
|
|
1228 if (peek_char () != ' ')
|
|
|
1229 {
|
|
|
1230 file_location loc = get_current_location ();
|
|
|
1231 char *desc = read_until (" +", false);
|
|
|
1232 add_fixup_expr (loc, consolidate_singletons (x), desc);
|
|
|
1233 free (desc);
|
|
|
1234 }
|
|
|
1235 else
|
|
|
1236 read_char ();
|
|
|
1237
|
|
|
1238 /* We may optionally have '+' for MEM_OFFSET_KNOWN_P. */
|
|
|
1239 ch = read_skip_spaces ();
|
|
|
1240 if (ch == '+')
|
|
|
1241 {
|
|
|
1242 read_name (&name);
|
|
|
1243 set_mem_offset (x, atoi (name.string));
|
|
|
1244 }
|
|
|
1245 else
|
|
|
1246 unread_char (ch);
|
|
|
1247
|
|
|
1248 /* Handle optional " S" for MEM_SIZE. */
|
|
|
1249 ch = read_skip_spaces ();
|
|
|
1250 if (ch == 'S')
|
|
|
1251 {
|
|
|
1252 read_name (&name);
|
|
|
1253 set_mem_size (x, atoi (name.string));
|
|
|
1254 }
|
|
|
1255 else
|
|
|
1256 unread_char (ch);
|
|
|
1257
|
|
|
1258 /* Handle optional " A" for MEM_ALIGN. */
|
|
|
1259 ch = read_skip_spaces ();
|
|
|
1260 if (ch == 'A' && peek_char () != 'S')
|
|
|
1261 {
|
|
|
1262 read_name (&name);
|
|
|
1263 set_mem_align (x, atoi (name.string));
|
|
|
1264 }
|
|
|
1265 else
|
|
|
1266 unread_char (ch);
|
|
|
1267
|
|
|
1268 /* Handle optional " AS" for MEM_ADDR_SPACE. */
|
|
|
1269 ch = read_skip_spaces ();
|
|
|
1270 if (ch == 'A' && peek_char () == 'S')
|
|
|
1271 {
|
|
|
1272 read_char ();
|
|
|
1273 read_name (&name);
|
|
|
1274 set_mem_addr_space (x, atoi (name.string));
|
|
|
1275 }
|
|
|
1276 else
|
|
|
1277 unread_char (ch);
|
|
|
1278
|
|
|
1279 require_char (']');
|
|
|
1280 }
|
|
|
1281 break;
|
|
|
1282
|
|
|
1283 case CODE_LABEL:
|
|
|
1284 /* Assume that LABEL_NUSES was not dumped. */
|
|
|
1285 /* TODO: parse LABEL_KIND. */
|
|
|
1286 /* For now, skip until closing ')'. */
|
|
|
1287 do
|
|
|
1288 {
|
|
|
1289 char ch = read_char ();
|
|
|
1290 if (ch == ')')
|
|
|
1291 {
|
|
|
1292 unread_char (ch);
|
|
|
1293 break;
|
|
|
1294 }
|
|
|
1295 }
|
|
|
1296 while (1);
|
|
|
1297 break;
|
|
|
1298
|
|
|
1299 default:
|
|
|
1300 break;
|
|
|
1301 }
|
|
|
1302 }
|
|
|
1303
|
|
|
1304 /* Parse a tree dump for a MEM_EXPR in DESC and turn it back into a tree.
|
|
|
1305 We handle "<retval>" and param names within cfun, but for anything else
|
|
|
1306 we "cheat" by building a global VAR_DECL of type "int" with that name
|
|
|
1307 (returning the same global for a name if we see the same name more
|
|
|
1308 than once). */
|
|
|
1309
|
|
|
1310 tree
|
|
|
1311 function_reader::parse_mem_expr (const char *desc)
|
|
|
1312 {
|
|
|
1313 tree fndecl = cfun->decl;
|
|
|
1314
|
|
|
1315 if (0 == strcmp (desc, "<retval>"))
|
|
|
1316 return DECL_RESULT (fndecl);
|
|
|
1317
|
|
|
1318 tree param = find_param_by_name (fndecl, desc);
|
|
|
1319 if (param)
|
|
|
1320 return param;
|
|
|
1321
|
|
|
1322 /* Search within decls we already created.
|
|
|
1323 FIXME: use a hash rather than linear search. */
|
|
|
1324 int i;
|
|
|
1325 tree t;
|
|
|
1326 FOR_EACH_VEC_ELT (m_fake_scope, i, t)
|
|
|
1327 if (id_equal (DECL_NAME (t), desc))
|
|
|
1328 return t;
|
|
|
1329
|
|
|
1330 /* Not found? Create it.
|
|
|
1331 This allows mimicking of real data but avoids having to specify
|
|
|
1332 e.g. names of locals, params etc.
|
|
|
1333 Though this way we don't know if we have a PARM_DECL vs a VAR_DECL,
|
|
|
1334 and we don't know the types. Fake it by making everything be
|
|
|
1335 a VAR_DECL of "int" type. */
|
|
|
1336 t = build_decl (UNKNOWN_LOCATION, VAR_DECL,
|
|
|
1337 get_identifier (desc),
|
|
|
1338 integer_type_node);
|
|
|
1339 m_fake_scope.safe_push (t);
|
|
|
1340 return t;
|
|
|
1341 }
|
|
|
1342
|
|
|
1343 /* Record that at LOC we saw an insn uid INSN_UID for the operand with index
|
|
|
1344 OPERAND_IDX within INSN, so that the pointer value can be fixed up in
|
|
|
1345 later post-processing. */
|
|
|
1346
|
|
|
1347 void
|
|
|
1348 function_reader::add_fixup_insn_uid (file_location loc, rtx insn, int operand_idx,
|
|
|
1349 int insn_uid)
|
|
|
1350 {
|
|
|
1351 m_fixups.safe_push (new fixup_insn_uid (loc, insn, operand_idx, insn_uid));
|
|
|
1352 }
|
|
|
1353
|
|
|
1354 /* Record that at LOC we saw an basic block index BB_IDX for the operand with index
|
|
|
1355 OPERAND_IDX within INSN, so that the pointer value can be fixed up in
|
|
|
1356 later post-processing. */
|
|
|
1357
|
|
|
1358 void
|
|
|
1359 function_reader::add_fixup_note_insn_basic_block (file_location loc, rtx insn,
|
|
|
1360 int operand_idx, int bb_idx)
|
|
|
1361 {
|
|
|
1362 m_fixups.safe_push (new fixup_note_insn_basic_block (loc, insn, operand_idx,
|
|
|
1363 bb_idx));
|
|
|
1364 }
|
|
|
1365
|
|
|
1366 /* Placeholder hook for recording source location information seen in a dump.
|
|
|
1367 This is empty for now. */
|
|
|
1368
|
|
|
1369 void
|
|
|
1370 function_reader::add_fixup_source_location (file_location, rtx_insn *,
|
|
|
1371 const char *, int)
|
|
|
1372 {
|
|
|
1373 }
|
|
|
1374
|
|
|
1375 /* Record that at LOC we saw textual description DESC of the MEM_EXPR or REG_EXPR
|
|
|
1376 of INSN, so that the fields can be fixed up in later post-processing. */
|
|
|
1377
|
|
|
1378 void
|
|
|
1379 function_reader::add_fixup_expr (file_location loc, rtx insn,
|
|
|
1380 const char *desc)
|
|
|
1381 {
|
|
|
1382 gcc_assert (desc);
|
|
|
1383 /* Fail early if the RTL reader erroneously hands us an int. */
|
|
|
1384 gcc_assert (!ISDIGIT (desc[0]));
|
|
|
1385
|
|
|
1386 m_fixups.safe_push (new fixup_expr (loc, insn, desc));
|
|
|
1387 }
|
|
|
1388
|
|
|
1389 /* Helper function for consolidate_reg. Return the global rtx for
|
|
|
1390 the register with regno REGNO. */
|
|
|
1391
|
|
|
1392 static rtx
|
|
|
1393 lookup_global_register (int regno)
|
|
|
1394 {
|
|
|
1395 /* We can't use a switch here, as some of the REGNUMs might not be constants
|
|
|
1396 for some targets. */
|
|
|
1397 if (regno == STACK_POINTER_REGNUM)
|
|
|
1398 return stack_pointer_rtx;
|
|
|
1399 else if (regno == FRAME_POINTER_REGNUM)
|
|
|
1400 return frame_pointer_rtx;
|
|
|
1401 else if (regno == HARD_FRAME_POINTER_REGNUM)
|
|
|
1402 return hard_frame_pointer_rtx;
|
|
|
1403 else if (regno == ARG_POINTER_REGNUM)
|
|
|
1404 return arg_pointer_rtx;
|
|
|
1405 else if (regno == VIRTUAL_INCOMING_ARGS_REGNUM)
|
|
|
1406 return virtual_incoming_args_rtx;
|
|
|
1407 else if (regno == VIRTUAL_STACK_VARS_REGNUM)
|
|
|
1408 return virtual_stack_vars_rtx;
|
|
|
1409 else if (regno == VIRTUAL_STACK_DYNAMIC_REGNUM)
|
|
|
1410 return virtual_stack_dynamic_rtx;
|
|
|
1411 else if (regno == VIRTUAL_OUTGOING_ARGS_REGNUM)
|
|
|
1412 return virtual_outgoing_args_rtx;
|
|
|
1413 else if (regno == VIRTUAL_CFA_REGNUM)
|
|
|
1414 return virtual_cfa_rtx;
|
|
|
1415 else if (regno == VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM)
|
|
|
1416 return virtual_preferred_stack_boundary_rtx;
|
|
|
1417 #ifdef return_ADDRESS_POINTER_REGNUM
|
|
|
1418 else if (regno == RETURN_ADDRESS_POINTER_REGNUM)
|
|
|
1419 return return_address_pointer_rtx;
|
|
|
1420 #endif
|
|
|
1421
|
|
|
1422 return NULL;
|
|
|
1423 }
|
|
|
1424
|
|
|
1425 /* Ensure that the backend can cope with a REG with regno REGNO.
|
|
|
1426 Normally REG instances are created by gen_reg_rtx which updates
|
|
|
1427 regno_reg_rtx, growing it as necessary.
|
|
|
1428 The REG instances created from the dumpfile weren't created this
|
|
|
1429 way, so we need to manually update regno_reg_rtx. */
|
|
|
1430
|
|
|
1431 static void
|
|
|
1432 ensure_regno (int regno)
|
|
|
1433 {
|
|
|
1434 if (reg_rtx_no < regno + 1)
|
|
|
1435 reg_rtx_no = regno + 1;
|
|
|
1436
|
|
|
1437 crtl->emit.ensure_regno_capacity ();
|
|
|
1438 gcc_assert (regno < crtl->emit.regno_pointer_align_length);
|
|
|
1439 }
|
|
|
1440
|
|
|
1441 /* Helper function for consolidate_singletons, for handling REG instances.
|
|
|
1442 Given REG instance X of some regno, return the singleton rtx for that
|
|
|
1443 regno, if it exists, or X. */
|
|
|
1444
|
|
|
1445 static rtx
|
|
|
1446 consolidate_reg (rtx x)
|
|
|
1447 {
|
|
|
1448 gcc_assert (GET_CODE (x) == REG);
|
|
|
1449
|
|
|
1450 unsigned int regno = REGNO (x);
|
|
|
1451
|
|
|
1452 ensure_regno (regno);
|
|
|
1453
|
|
|
1454 /* Some register numbers have their rtx created in init_emit_regs
|
|
|
1455 e.g. stack_pointer_rtx for STACK_POINTER_REGNUM.
|
|
|
1456 Consolidate on this. */
|
|
|
1457 rtx global_reg = lookup_global_register (regno);
|
|
|
1458 if (global_reg)
|
|
|
1459 return global_reg;
|
|
|
1460
|
|
|
1461 /* Populate regno_reg_rtx if necessary. */
|
|
|
1462 if (regno_reg_rtx[regno] == NULL)
|
|
|
1463 regno_reg_rtx[regno] = x;
|
|
|
1464 /* Use it. */
|
|
|
1465 gcc_assert (GET_CODE (regno_reg_rtx[regno]) == REG);
|
|
|
1466 gcc_assert (REGNO (regno_reg_rtx[regno]) == regno);
|
|
|
1467 if (GET_MODE (x) == GET_MODE (regno_reg_rtx[regno]))
|
|
|
1468 return regno_reg_rtx[regno];
|
|
|
1469
|
|
|
1470 return x;
|
|
|
1471 }
|
|
|
1472
|
|
|
1473 /* When reading RTL function dumps, we must consolidate some
|
|
|
1474 rtx so that we use singletons where singletons are expected
|
|
|
1475 (e.g. we don't want multiple "(const_int 0 [0])" rtx, since
|
|
|
1476 these are tested via pointer equality against const0_rtx.
|
|
|
1477
|
|
|
1478 Return the equivalent singleton rtx for X, if any, otherwise X. */
|
|
|
1479
|
|
|
1480 rtx
|
|
|
1481 function_reader::consolidate_singletons (rtx x)
|
|
|
1482 {
|
|
|
1483 if (!x)
|
|
|
1484 return x;
|
|
|
1485
|
|
|
1486 switch (GET_CODE (x))
|
|
|
1487 {
|
|
|
1488 case PC: return pc_rtx;
|
|
|
1489 case RETURN: return ret_rtx;
|
|
|
1490 case SIMPLE_RETURN: return simple_return_rtx;
|
|
|
1491 case CC0: return cc0_rtx;
|
|
|
1492
|
|
|
1493 case REG:
|
|
|
1494 return consolidate_reg (x);
|
|
|
1495
|
|
|
1496 case CONST_INT:
|
|
|
1497 return gen_rtx_CONST_INT (GET_MODE (x), INTVAL (x));
|
|
|
1498
|
|
|
1499 default:
|
|
|
1500 break;
|
|
|
1501 }
|
|
|
1502
|
|
|
1503 return x;
|
|
|
1504 }
|
|
|
1505
|
|
|
1506 /* Parse an rtx directive, including both the opening/closing parentheses,
|
|
|
1507 and the name. */
|
|
|
1508
|
|
|
1509 rtx
|
|
|
1510 function_reader::parse_rtx ()
|
|
|
1511 {
|
|
|
1512 require_char_ws ('(');
|
|
|
1513 struct md_name directive;
|
|
|
1514 read_name (&directive);
|
|
|
1515 rtx result
|
|
|
1516 = consolidate_singletons (read_rtx_code (directive.string));
|
|
|
1517 require_char_ws (')');
|
|
|
1518
|
|
|
1519 return result;
|
|
|
1520 }
|
|
|
1521
|
|
|
1522 /* Implementation of rtx_reader::postprocess for reading function dumps.
|
|
|
1523 Return the equivalent singleton rtx for X, if any, otherwise X. */
|
|
|
1524
|
|
|
1525 rtx
|
|
|
1526 function_reader::postprocess (rtx x)
|
|
|
1527 {
|
|
|
1528 return consolidate_singletons (x);
|
|
|
1529 }
|
|
|
1530
|
|
|
1531 /* Implementation of rtx_reader::finalize_string for reading function dumps.
|
|
|
1532 Make a GC-managed copy of STRINGBUF. */
|
|
|
1533
|
|
|
1534 const char *
|
|
|
1535 function_reader::finalize_string (char *stringbuf)
|
|
|
1536 {
|
|
|
1537 return ggc_strdup (stringbuf);
|
|
|
1538 }
|
|
|
1539
|
|
|
1540 /* Attempt to parse optional location information for insn INSN, as
|
|
|
1541 potentially written out by rtx_writer::print_rtx_operand_code_i.
|
|
|
1542 We look for a quoted string followed by a colon. */
|
|
|
1543
|
|
|
1544 void
|
|
|
1545 function_reader::maybe_read_location (rtx_insn *insn)
|
|
|
1546 {
|
|
|
1547 file_location loc = get_current_location ();
|
|
|
1548
|
|
|
1549 /* Attempt to parse a quoted string. */
|
|
|
1550 int ch = read_skip_spaces ();
|
|
|
1551 if (ch == '"')
|
|
|
1552 {
|
|
|
1553 char *filename = read_quoted_string ();
|
|
|
1554 require_char (':');
|
|
|
1555 struct md_name line_num;
|
|
|
1556 read_name (&line_num);
|
|
|
1557 add_fixup_source_location (loc, insn, filename, atoi (line_num.string));
|
|
|
1558 }
|
|
|
1559 else
|
|
|
1560 unread_char (ch);
|
|
|
1561 }
|
|
|
1562
|
|
|
1563 /* Postprocessing subroutine of function_reader::parse_function.
|
|
|
1564 Populate m_insns_by_uid. */
|
|
|
1565
|
|
|
1566 void
|
|
|
1567 function_reader::handle_insn_uids ()
|
|
|
1568 {
|
|
|
1569 /* Locate the currently assigned INSN_UID values, storing
|
|
|
1570 them in m_insns_by_uid. */
|
|
|
1571 int max_uid = 0;
|
|
|
1572 for (rtx_insn *insn = get_insns (); insn; insn = NEXT_INSN (insn))
|
|
|
1573 {
|
|
|
1574 if (m_insns_by_uid.get (INSN_UID (insn)))
|
|
|
1575 error ("duplicate insn UID: %i", INSN_UID (insn));
|
|
|
1576 m_insns_by_uid.put (INSN_UID (insn), insn);
|
|
|
1577 if (INSN_UID (insn) > max_uid)
|
|
|
1578 max_uid = INSN_UID (insn);
|
|
|
1579 }
|
|
|
1580
|
|
|
1581 /* Ensure x_cur_insn_uid is 1 more than the biggest insn UID seen.
|
|
|
1582 This is normally updated by the various make_*insn_raw functions. */
|
|
|
1583 crtl->emit.x_cur_insn_uid = max_uid + 1;
|
|
|
1584 }
|
|
|
1585
|
|
|
1586 /* Apply all of the recorded fixups. */
|
|
|
1587
|
|
|
1588 void
|
|
|
1589 function_reader::apply_fixups ()
|
|
|
1590 {
|
|
|
1591 int i;
|
|
|
1592 fixup *f;
|
|
|
1593 FOR_EACH_VEC_ELT (m_fixups, i, f)
|
|
|
1594 f->apply (this);
|
|
|
1595 }
|
|
|
1596
|
|
|
1597 /* Given a UID value, try to locate a pointer to the corresponding
|
|
|
1598 rtx_insn *, or NULL if if can't be found. */
|
|
|
1599
|
|
|
1600 rtx_insn **
|
|
|
1601 function_reader::get_insn_by_uid (int uid)
|
|
|
1602 {
|
|
|
1603 return m_insns_by_uid.get (uid);
|
|
|
1604 }
|
|
|
1605
|
|
|
1606 /* Run the RTL dump parser, parsing a dump located at PATH.
|
|
|
1607 Return true iff the file was successfully parsed. */
|
|
|
1608
|
|
|
1609 bool
|
|
|
1610 read_rtl_function_body (const char *path)
|
|
|
1611 {
|
|
|
1612 initialize_rtl ();
|
|
|
1613 init_emit ();
|
|
|
1614 init_varasm_status ();
|
|
|
1615
|
|
|
1616 function_reader reader;
|
|
|
1617 if (!reader.read_file (path))
|
|
|
1618 return false;
|
|
|
1619
|
|
|
1620 return true;
|
|
|
1621 }
|
|
|
1622
|
|
|
1623 /* Run the RTL dump parser on the range of lines between START_LOC and
|
|
|
1624 END_LOC (including those lines). */
|
|
|
1625
|
|
|
1626 bool
|
|
|
1627 read_rtl_function_body_from_file_range (location_t start_loc,
|
|
|
1628 location_t end_loc)
|
|
|
1629 {
|
|
|
1630 expanded_location exploc_start = expand_location (start_loc);
|
|
|
1631 expanded_location exploc_end = expand_location (end_loc);
|
|
|
1632
|
|
|
1633 if (exploc_start.file != exploc_end.file)
|
|
|
1634 {
|
|
|
1635 error_at (end_loc, "start/end of RTL fragment are in different files");
|
|
|
1636 return false;
|
|
|
1637 }
|
|
|
1638 if (exploc_start.line >= exploc_end.line)
|
|
|
1639 {
|
|
|
1640 error_at (end_loc,
|
|
|
1641 "start of RTL fragment must be on an earlier line than end");
|
|
|
1642 return false;
|
|
|
1643 }
|
|
|
1644
|
|
|
1645 initialize_rtl ();
|
|
|
1646 init_emit ();
|
|
|
1647 init_varasm_status ();
|
|
|
1648
|
|
|
1649 function_reader reader;
|
|
|
1650 if (!reader.read_file_fragment (exploc_start.file, exploc_start.line,
|
|
|
1651 exploc_end.line - 1))
|
|
|
1652 return false;
|
|
|
1653
|
|
|
1654 return true;
|
|
|
1655 }
|
|
|
1656
|
|
|
1657 #if CHECKING_P
|
|
|
1658
|
|
|
1659 namespace selftest {
|
|
|
1660
|
|
|
1661 /* Verify that parse_edge_flags works. */
|
|
|
1662
|
|
|
1663 static void
|
|
|
1664 test_edge_flags ()
|
|
|
1665 {
|
|
|
1666 /* parse_edge_flags modifies its input (due to strtok), so we must make
|
|
|
1667 a copy of the literals. */
|
|
|
1668 #define ASSERT_PARSE_EDGE_FLAGS(EXPECTED, STR) \
|
|
|
1669 do { \
|
|
|
1670 char *str = xstrdup (STR); \
|
|
|
1671 ASSERT_EQ (EXPECTED, parse_edge_flags (str)); \
|
|
|
1672 free (str); \
|
|
|
1673 } while (0)
|
|
|
1674
|
|
|
1675 ASSERT_PARSE_EDGE_FLAGS (0, "");
|
|
|
1676 ASSERT_PARSE_EDGE_FLAGS (EDGE_FALLTHRU, "FALLTHRU");
|
|
|
1677 ASSERT_PARSE_EDGE_FLAGS (EDGE_ABNORMAL_CALL, "ABNORMAL_CALL");
|
|
|
1678 ASSERT_PARSE_EDGE_FLAGS (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL,
|
|
|
1679 "ABNORMAL | ABNORMAL_CALL");
|
|
|
1680
|
|
|
1681 #undef ASSERT_PARSE_EDGE_FLAGS
|
|
|
1682 }
|
|
|
1683
|
|
|
1684 /* Verify that lookup_reg_by_dump_name works. */
|
|
|
1685
|
|
|
1686 static void
|
|
|
1687 test_parsing_regnos ()
|
|
|
1688 {
|
|
|
1689 ASSERT_EQ (-1, lookup_reg_by_dump_name ("this is not a register"));
|
|
|
1690
|
|
|
1691 /* Verify lookup of virtual registers. */
|
|
|
1692 ASSERT_EQ (VIRTUAL_INCOMING_ARGS_REGNUM,
|
|
|
1693 lookup_reg_by_dump_name ("virtual-incoming-args"));
|
|
|
1694 ASSERT_EQ (VIRTUAL_STACK_VARS_REGNUM,
|
|
|
1695 lookup_reg_by_dump_name ("virtual-stack-vars"));
|
|
|
1696 ASSERT_EQ (VIRTUAL_STACK_DYNAMIC_REGNUM,
|
|
|
1697 lookup_reg_by_dump_name ("virtual-stack-dynamic"));
|
|
|
1698 ASSERT_EQ (VIRTUAL_OUTGOING_ARGS_REGNUM,
|
|
|
1699 lookup_reg_by_dump_name ("virtual-outgoing-args"));
|
|
|
1700 ASSERT_EQ (VIRTUAL_CFA_REGNUM,
|
|
|
1701 lookup_reg_by_dump_name ("virtual-cfa"));
|
|
|
1702 ASSERT_EQ (VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM,
|
|
|
1703 lookup_reg_by_dump_name ("virtual-preferred-stack-boundary"));
|
|
|
1704
|
|
|
1705 /* Verify lookup of non-virtual pseudos. */
|
|
|
1706 ASSERT_EQ (LAST_VIRTUAL_REGISTER + 1, lookup_reg_by_dump_name ("<0>"));
|
|
|
1707 ASSERT_EQ (LAST_VIRTUAL_REGISTER + 2, lookup_reg_by_dump_name ("<1>"));
|
|
|
1708 }
|
|
|
1709
|
|
|
1710 /* Verify that edge E is as expected, with the src and dest basic blocks
|
|
|
1711 having indices EXPECTED_SRC_IDX and EXPECTED_DEST_IDX respectively, and
|
|
|
1712 the edge having flags equal to EXPECTED_FLAGS.
|
|
|
1713 Use LOC as the effective location when reporting failures. */
|
|
|
1714
|
|
|
1715 static void
|
|
|
1716 assert_edge_at (const location &loc, edge e, int expected_src_idx,
|
|
|
1717 int expected_dest_idx, int expected_flags)
|
|
|
1718 {
|
|
|
1719 ASSERT_EQ_AT (loc, expected_src_idx, e->src->index);
|
|
|
1720 ASSERT_EQ_AT (loc, expected_dest_idx, e->dest->index);
|
|
|
1721 ASSERT_EQ_AT (loc, expected_flags, e->flags);
|
|
|
1722 }
|
|
|
1723
|
|
|
1724 /* Verify that edge EDGE is as expected, with the src and dest basic blocks
|
|
|
1725 having indices EXPECTED_SRC_IDX and EXPECTED_DEST_IDX respectively, and
|
|
|
1726 the edge having flags equal to EXPECTED_FLAGS. */
|
|
|
1727
|
|
|
1728 #define ASSERT_EDGE(EDGE, EXPECTED_SRC_IDX, EXPECTED_DEST_IDX, \
|
|
|
1729 EXPECTED_FLAGS) \
|
|
|
1730 assert_edge_at (SELFTEST_LOCATION, EDGE, EXPECTED_SRC_IDX, \
|
|
|
1731 EXPECTED_DEST_IDX, EXPECTED_FLAGS)
|
|
|
1732
|
|
|
1733 /* Verify that we can load RTL dumps. */
|
|
|
1734
|
|
|
1735 static void
|
|
|
1736 test_loading_dump_fragment_1 ()
|
|
|
1737 {
|
|
|
1738 // TODO: filter on target?
|
|
|
1739 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("asr_div1.rtl"));
|
|
|
1740
|
|
|
1741 /* Verify that the insns were loaded correctly. */
|
|
|
1742 rtx_insn *insn_1 = get_insns ();
|
|
|
1743 ASSERT_TRUE (insn_1);
|
|
|
1744 ASSERT_EQ (1, INSN_UID (insn_1));
|
|
|
1745 ASSERT_EQ (INSN, GET_CODE (insn_1));
|
|
|
1746 ASSERT_EQ (SET, GET_CODE (PATTERN (insn_1)));
|
|
|
1747 ASSERT_EQ (NULL, PREV_INSN (insn_1));
|
|
|
1748
|
|
|
1749 rtx_insn *insn_2 = NEXT_INSN (insn_1);
|
|
|
1750 ASSERT_TRUE (insn_2);
|
|
|
1751 ASSERT_EQ (2, INSN_UID (insn_2));
|
|
|
1752 ASSERT_EQ (INSN, GET_CODE (insn_2));
|
|
|
1753 ASSERT_EQ (insn_1, PREV_INSN (insn_2));
|
|
|
1754 ASSERT_EQ (NULL, NEXT_INSN (insn_2));
|
|
|
1755
|
|
|
1756 /* Verify that registers were loaded correctly. */
|
|
|
1757 rtx insn_1_dest = SET_DEST (PATTERN (insn_1));
|
|
|
1758 ASSERT_EQ (REG, GET_CODE (insn_1_dest));
|
|
|
1759 ASSERT_EQ ((LAST_VIRTUAL_REGISTER + 1) + 2, REGNO (insn_1_dest));
|
|
|
1760 rtx insn_1_src = SET_SRC (PATTERN (insn_1));
|
|
|
1761 ASSERT_EQ (LSHIFTRT, GET_CODE (insn_1_src));
|
|
|
1762 rtx reg = XEXP (insn_1_src, 0);
|
|
|
1763 ASSERT_EQ (REG, GET_CODE (reg));
|
|
|
1764 ASSERT_EQ (LAST_VIRTUAL_REGISTER + 1, REGNO (reg));
|
|
|
1765
|
|
|
1766 /* Verify that get_insn_by_uid works. */
|
|
|
1767 ASSERT_EQ (insn_1, get_insn_by_uid (1));
|
|
|
1768 ASSERT_EQ (insn_2, get_insn_by_uid (2));
|
|
|
1769
|
|
|
1770 /* Verify that basic blocks were created. */
|
|
|
1771 ASSERT_EQ (2, BLOCK_FOR_INSN (insn_1)->index);
|
|
|
1772 ASSERT_EQ (2, BLOCK_FOR_INSN (insn_2)->index);
|
|
|
1773
|
|
|
1774 /* Verify that the CFG was recreated. */
|
|
|
1775 ASSERT_TRUE (cfun);
|
|
|
1776 verify_three_block_rtl_cfg (cfun);
|
|
|
1777 basic_block bb2 = BASIC_BLOCK_FOR_FN (cfun, 2);
|
|
|
1778 ASSERT_TRUE (bb2 != NULL);
|
|
|
1779 ASSERT_EQ (BB_RTL, bb2->flags & BB_RTL);
|
|
|
1780 ASSERT_EQ (2, bb2->index);
|
|
|
1781 ASSERT_EQ (insn_1, BB_HEAD (bb2));
|
|
|
1782 ASSERT_EQ (insn_2, BB_END (bb2));
|
|
|
1783 }
|
|
|
1784
|
|
|
1785 /* Verify loading another RTL dump. */
|
|
|
1786
|
|
|
1787 static void
|
|
|
1788 test_loading_dump_fragment_2 ()
|
|
|
1789 {
|
|
|
1790 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("simple-cse.rtl"));
|
|
|
1791
|
|
|
1792 rtx_insn *insn_1 = get_insn_by_uid (1);
|
|
|
1793 rtx_insn *insn_2 = get_insn_by_uid (2);
|
|
|
1794 rtx_insn *insn_3 = get_insn_by_uid (3);
|
|
|
1795
|
|
|
1796 rtx set1 = single_set (insn_1);
|
|
|
1797 ASSERT_NE (NULL, set1);
|
|
|
1798 rtx set2 = single_set (insn_2);
|
|
|
1799 ASSERT_NE (NULL, set2);
|
|
|
1800 rtx set3 = single_set (insn_3);
|
|
|
1801 ASSERT_NE (NULL, set3);
|
|
|
1802
|
|
|
1803 rtx src1 = SET_SRC (set1);
|
|
|
1804 ASSERT_EQ (PLUS, GET_CODE (src1));
|
|
|
1805
|
|
|
1806 rtx src2 = SET_SRC (set2);
|
|
|
1807 ASSERT_EQ (PLUS, GET_CODE (src2));
|
|
|
1808
|
|
|
1809 /* Both src1 and src2 refer to "(reg:SI %0)".
|
|
|
1810 Verify that we have pointer equality. */
|
|
|
1811 rtx lhs1 = XEXP (src1, 0);
|
|
|
1812 rtx lhs2 = XEXP (src2, 0);
|
|
|
1813 ASSERT_EQ (lhs1, lhs2);
|
|
|
1814
|
|
|
1815 /* Verify that the CFG was recreated. */
|
|
|
1816 ASSERT_TRUE (cfun);
|
|
|
1817 verify_three_block_rtl_cfg (cfun);
|
|
|
1818 }
|
|
|
1819
|
|
|
1820 /* Verify that CODE_LABEL insns are loaded correctly. */
|
|
|
1821
|
|
|
1822 static void
|
|
|
1823 test_loading_labels ()
|
|
|
1824 {
|
|
|
1825 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("example-labels.rtl"));
|
|
|
1826
|
|
|
1827 rtx_insn *insn_100 = get_insn_by_uid (100);
|
|
|
1828 ASSERT_EQ (CODE_LABEL, GET_CODE (insn_100));
|
|
|
1829 ASSERT_EQ (100, INSN_UID (insn_100));
|
|
|
1830 ASSERT_EQ (NULL, LABEL_NAME (insn_100));
|
|
|
1831 ASSERT_EQ (0, LABEL_NUSES (insn_100));
|
|
|
1832 ASSERT_EQ (30, CODE_LABEL_NUMBER (insn_100));
|
|
|
1833
|
|
|
1834 rtx_insn *insn_200 = get_insn_by_uid (200);
|
|
|
1835 ASSERT_EQ (CODE_LABEL, GET_CODE (insn_200));
|
|
|
1836 ASSERT_EQ (200, INSN_UID (insn_200));
|
|
|
1837 ASSERT_STREQ ("some_label_name", LABEL_NAME (insn_200));
|
|
|
1838 ASSERT_EQ (0, LABEL_NUSES (insn_200));
|
|
|
1839 ASSERT_EQ (40, CODE_LABEL_NUMBER (insn_200));
|
|
|
1840
|
|
|
1841 /* Ensure that the presence of CODE_LABEL_NUMBER == 40
|
|
|
1842 means that the next label num to be handed out will be 41. */
|
|
|
1843 ASSERT_EQ (41, max_label_num ());
|
|
|
1844
|
|
|
1845 /* Ensure that label names read from a dump are GC-managed
|
|
|
1846 and are found through the insn. */
|
|
|
1847 forcibly_ggc_collect ();
|
|
|
1848 ASSERT_TRUE (ggc_marked_p (insn_200));
|
|
|
1849 ASSERT_TRUE (ggc_marked_p (LABEL_NAME (insn_200)));
|
|
|
1850 }
|
|
|
1851
|
|
|
1852 /* Verify that the loader copes with an insn with a mode. */
|
|
|
1853
|
|
|
1854 static void
|
|
|
1855 test_loading_insn_with_mode ()
|
|
|
1856 {
|
|
|
1857 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("insn-with-mode.rtl"));
|
|
|
1858 rtx_insn *insn = get_insns ();
|
|
|
1859 ASSERT_EQ (INSN, GET_CODE (insn));
|
|
|
1860
|
|
|
1861 /* Verify that the "TI" mode was set from "insn:TI". */
|
|
|
1862 ASSERT_EQ (TImode, GET_MODE (insn));
|
|
|
1863 }
|
|
|
1864
|
|
|
1865 /* Verify that the loader copes with a jump_insn to a label_ref. */
|
|
|
1866
|
|
|
1867 static void
|
|
|
1868 test_loading_jump_to_label_ref ()
|
|
|
1869 {
|
|
|
1870 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("jump-to-label-ref.rtl"));
|
|
|
1871
|
|
|
1872 rtx_insn *jump_insn = get_insn_by_uid (1);
|
|
|
1873 ASSERT_EQ (JUMP_INSN, GET_CODE (jump_insn));
|
|
|
1874
|
|
|
1875 rtx_insn *barrier = get_insn_by_uid (2);
|
|
|
1876 ASSERT_EQ (BARRIER, GET_CODE (barrier));
|
|
|
1877
|
|
|
1878 rtx_insn *code_label = get_insn_by_uid (100);
|
|
|
1879 ASSERT_EQ (CODE_LABEL, GET_CODE (code_label));
|
|
|
1880
|
|
|
1881 /* Verify the jump_insn. */
|
|
|
1882 ASSERT_EQ (4, BLOCK_FOR_INSN (jump_insn)->index);
|
|
|
1883 ASSERT_EQ (SET, GET_CODE (PATTERN (jump_insn)));
|
|
|
1884 /* Ensure that the "(pc)" is using the global singleton. */
|
|
|
1885 ASSERT_RTX_PTR_EQ (pc_rtx, SET_DEST (PATTERN (jump_insn)));
|
|
|
1886 rtx label_ref = SET_SRC (PATTERN (jump_insn));
|
|
|
1887 ASSERT_EQ (LABEL_REF, GET_CODE (label_ref));
|
|
|
1888 ASSERT_EQ (code_label, label_ref_label (label_ref));
|
|
|
1889 ASSERT_EQ (code_label, JUMP_LABEL (jump_insn));
|
|
|
1890
|
|
|
1891 /* Verify the code_label. */
|
|
|
1892 ASSERT_EQ (5, BLOCK_FOR_INSN (code_label)->index);
|
|
|
1893 ASSERT_EQ (NULL, LABEL_NAME (code_label));
|
|
|
1894 ASSERT_EQ (1, LABEL_NUSES (code_label));
|
|
|
1895
|
|
|
1896 /* Verify the generated CFG. */
|
|
|
1897
|
|
|
1898 /* Locate blocks. */
|
|
|
1899 basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (cfun);
|
|
|
1900 ASSERT_TRUE (entry != NULL);
|
|
|
1901 ASSERT_EQ (ENTRY_BLOCK, entry->index);
|
|
|
1902
|
|
|
1903 basic_block exit = EXIT_BLOCK_PTR_FOR_FN (cfun);
|
|
|
1904 ASSERT_TRUE (exit != NULL);
|
|
|
1905 ASSERT_EQ (EXIT_BLOCK, exit->index);
|
|
|
1906
|
|
|
1907 basic_block bb4 = (*cfun->cfg->x_basic_block_info)[4];
|
|
|
1908 basic_block bb5 = (*cfun->cfg->x_basic_block_info)[5];
|
|
|
1909 ASSERT_EQ (4, bb4->index);
|
|
|
1910 ASSERT_EQ (5, bb5->index);
|
|
|
1911
|
|
|
1912 /* Entry block. */
|
|
|
1913 ASSERT_EQ (NULL, entry->preds);
|
|
|
1914 ASSERT_EQ (1, entry->succs->length ());
|
|
|
1915 ASSERT_EDGE ((*entry->succs)[0], 0, 4, EDGE_FALLTHRU);
|
|
|
1916
|
|
|
1917 /* bb4. */
|
|
|
1918 ASSERT_EQ (1, bb4->preds->length ());
|
|
|
1919 ASSERT_EDGE ((*bb4->preds)[0], 0, 4, EDGE_FALLTHRU);
|
|
|
1920 ASSERT_EQ (1, bb4->succs->length ());
|
|
|
1921 ASSERT_EDGE ((*bb4->succs)[0], 4, 5, 0x0);
|
|
|
1922
|
|
|
1923 /* bb5. */
|
|
|
1924 ASSERT_EQ (1, bb5->preds->length ());
|
|
|
1925 ASSERT_EDGE ((*bb5->preds)[0], 4, 5, 0x0);
|
|
|
1926 ASSERT_EQ (1, bb5->succs->length ());
|
|
|
1927 ASSERT_EDGE ((*bb5->succs)[0], 5, 1, EDGE_FALLTHRU);
|
|
|
1928
|
|
|
1929 /* Exit block. */
|
|
|
1930 ASSERT_EQ (1, exit->preds->length ());
|
|
|
1931 ASSERT_EDGE ((*exit->preds)[0], 5, 1, EDGE_FALLTHRU);
|
|
|
1932 ASSERT_EQ (NULL, exit->succs);
|
|
|
1933 }
|
|
|
1934
|
|
|
1935 /* Verify that the loader copes with a jump_insn to a label_ref
|
|
|
1936 marked "return". */
|
|
|
1937
|
|
|
1938 static void
|
|
|
1939 test_loading_jump_to_return ()
|
|
|
1940 {
|
|
|
1941 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("jump-to-return.rtl"));
|
|
|
1942
|
|
|
1943 rtx_insn *jump_insn = get_insn_by_uid (1);
|
|
|
1944 ASSERT_EQ (JUMP_INSN, GET_CODE (jump_insn));
|
|
|
1945 ASSERT_RTX_PTR_EQ (ret_rtx, JUMP_LABEL (jump_insn));
|
|
|
1946 }
|
|
|
1947
|
|
|
1948 /* Verify that the loader copes with a jump_insn to a label_ref
|
|
|
1949 marked "simple_return". */
|
|
|
1950
|
|
|
1951 static void
|
|
|
1952 test_loading_jump_to_simple_return ()
|
|
|
1953 {
|
|
|
1954 rtl_dump_test t (SELFTEST_LOCATION,
|
|
|
1955 locate_file ("jump-to-simple-return.rtl"));
|
|
|
1956
|
|
|
1957 rtx_insn *jump_insn = get_insn_by_uid (1);
|
|
|
1958 ASSERT_EQ (JUMP_INSN, GET_CODE (jump_insn));
|
|
|
1959 ASSERT_RTX_PTR_EQ (simple_return_rtx, JUMP_LABEL (jump_insn));
|
|
|
1960 }
|
|
|
1961
|
|
|
1962 /* Verify that the loader copes with a NOTE_INSN_BASIC_BLOCK. */
|
|
|
1963
|
|
|
1964 static void
|
|
|
1965 test_loading_note_insn_basic_block ()
|
|
|
1966 {
|
|
|
1967 rtl_dump_test t (SELFTEST_LOCATION,
|
|
|
1968 locate_file ("note_insn_basic_block.rtl"));
|
|
|
1969
|
|
|
1970 rtx_insn *note = get_insn_by_uid (1);
|
|
|
1971 ASSERT_EQ (NOTE, GET_CODE (note));
|
|
|
1972 ASSERT_EQ (2, BLOCK_FOR_INSN (note)->index);
|
|
|
1973
|
|
|
1974 ASSERT_EQ (NOTE_INSN_BASIC_BLOCK, NOTE_KIND (note));
|
|
|
1975 ASSERT_EQ (2, NOTE_BASIC_BLOCK (note)->index);
|
|
|
1976 ASSERT_EQ (BASIC_BLOCK_FOR_FN (cfun, 2), NOTE_BASIC_BLOCK (note));
|
|
|
1977 }
|
|
|
1978
|
|
|
1979 /* Verify that the loader copes with a NOTE_INSN_DELETED. */
|
|
|
1980
|
|
|
1981 static void
|
|
|
1982 test_loading_note_insn_deleted ()
|
|
|
1983 {
|
|
|
1984 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("note-insn-deleted.rtl"));
|
|
|
1985
|
|
|
1986 rtx_insn *note = get_insn_by_uid (1);
|
|
|
1987 ASSERT_EQ (NOTE, GET_CODE (note));
|
|
|
1988 ASSERT_EQ (NOTE_INSN_DELETED, NOTE_KIND (note));
|
|
|
1989 }
|
|
|
1990
|
|
|
1991 /* Verify that the const_int values are consolidated, since
|
|
|
1992 pointer equality corresponds to value equality.
|
|
|
1993 TODO: do this for all in CASE_CONST_UNIQUE. */
|
|
|
1994
|
|
|
1995 static void
|
|
|
1996 test_loading_const_int ()
|
|
|
1997 {
|
|
|
1998 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("const-int.rtl"));
|
|
|
1999
|
|
|
2000 /* Verify that const_int values below MAX_SAVED_CONST_INT use
|
|
|
2001 the global values. */
|
|
|
2002 ASSERT_EQ (const0_rtx, SET_SRC (PATTERN (get_insn_by_uid (1))));
|
|
|
2003 ASSERT_EQ (const1_rtx, SET_SRC (PATTERN (get_insn_by_uid (2))));
|
|
|
2004 ASSERT_EQ (constm1_rtx, SET_SRC (PATTERN (get_insn_by_uid (3))));
|
|
|
2005
|
|
|
2006 /* Verify that other const_int values are consolidated. */
|
|
|
2007 rtx int256 = gen_rtx_CONST_INT (SImode, 256);
|
|
|
2008 ASSERT_EQ (int256, SET_SRC (PATTERN (get_insn_by_uid (4))));
|
|
|
2009 }
|
|
|
2010
|
|
|
2011 /* Verify that the loader copes with a SYMBOL_REF. */
|
|
|
2012
|
|
|
2013 static void
|
|
|
2014 test_loading_symbol_ref ()
|
|
|
2015 {
|
|
|
2016 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("symbol-ref.rtl"));
|
|
|
2017
|
|
|
2018 rtx_insn *insn = get_insns ();
|
|
|
2019
|
|
|
2020 rtx high = SET_SRC (PATTERN (insn));
|
|
|
2021 ASSERT_EQ (HIGH, GET_CODE (high));
|
|
|
2022
|
|
|
2023 rtx symbol_ref = XEXP (high, 0);
|
|
|
2024 ASSERT_EQ (SYMBOL_REF, GET_CODE (symbol_ref));
|
|
|
2025
|
|
|
2026 /* Verify that "[flags 0xc0]" was parsed. */
|
|
|
2027 ASSERT_EQ (0xc0, SYMBOL_REF_FLAGS (symbol_ref));
|
|
|
2028 /* TODO: we don't yet load SYMBOL_REF_DECL. */
|
|
|
2029 }
|
|
|
2030
|
|
|
2031 /* Verify that the loader can rebuild a CFG. */
|
|
|
2032
|
|
|
2033 static void
|
|
|
2034 test_loading_cfg ()
|
|
|
2035 {
|
|
|
2036 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("cfg-test.rtl"));
|
|
|
2037
|
|
|
2038 ASSERT_STREQ ("cfg_test", IDENTIFIER_POINTER (DECL_NAME (cfun->decl)));
|
|
|
2039
|
|
|
2040 ASSERT_TRUE (cfun);
|
|
|
2041
|
|
|
2042 ASSERT_TRUE (cfun->cfg != NULL);
|
|
|
2043 ASSERT_EQ (6, n_basic_blocks_for_fn (cfun));
|
|
|
2044 ASSERT_EQ (6, n_edges_for_fn (cfun));
|
|
|
2045
|
|
|
2046 /* The "fake" basic blocks. */
|
|
|
2047 basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (cfun);
|
|
|
2048 ASSERT_TRUE (entry != NULL);
|
|
|
2049 ASSERT_EQ (ENTRY_BLOCK, entry->index);
|
|
|
2050
|
|
|
2051 basic_block exit = EXIT_BLOCK_PTR_FOR_FN (cfun);
|
|
|
2052 ASSERT_TRUE (exit != NULL);
|
|
|
2053 ASSERT_EQ (EXIT_BLOCK, exit->index);
|
|
|
2054
|
|
|
2055 /* The "real" basic blocks. */
|
|
|
2056 basic_block bb2 = (*cfun->cfg->x_basic_block_info)[2];
|
|
|
2057 basic_block bb3 = (*cfun->cfg->x_basic_block_info)[3];
|
|
|
2058 basic_block bb4 = (*cfun->cfg->x_basic_block_info)[4];
|
|
|
2059 basic_block bb5 = (*cfun->cfg->x_basic_block_info)[5];
|
|
|
2060
|
|
|
2061 ASSERT_EQ (2, bb2->index);
|
|
|
2062 ASSERT_EQ (3, bb3->index);
|
|
|
2063 ASSERT_EQ (4, bb4->index);
|
|
|
2064 ASSERT_EQ (5, bb5->index);
|
|
|
2065
|
|
|
2066 /* Verify connectivity. */
|
|
|
2067
|
|
|
2068 /* Entry block. */
|
|
|
2069 ASSERT_EQ (NULL, entry->preds);
|
|
|
2070 ASSERT_EQ (1, entry->succs->length ());
|
|
|
2071 ASSERT_EDGE ((*entry->succs)[0], 0, 2, EDGE_FALLTHRU);
|
|
|
2072
|
|
|
2073 /* bb2. */
|
|
|
2074 ASSERT_EQ (1, bb2->preds->length ());
|
|
|
2075 ASSERT_EDGE ((*bb2->preds)[0], 0, 2, EDGE_FALLTHRU);
|
|
|
2076 ASSERT_EQ (2, bb2->succs->length ());
|
|
|
2077 ASSERT_EDGE ((*bb2->succs)[0], 2, 3, EDGE_TRUE_VALUE);
|
|
|
2078 ASSERT_EDGE ((*bb2->succs)[1], 2, 4, EDGE_FALSE_VALUE);
|
|
|
2079
|
|
|
2080 /* bb3. */
|
|
|
2081 ASSERT_EQ (1, bb3->preds->length ());
|
|
|
2082 ASSERT_EDGE ((*bb3->preds)[0], 2, 3, EDGE_TRUE_VALUE);
|
|
|
2083 ASSERT_EQ (1, bb3->succs->length ());
|
|
|
2084 ASSERT_EDGE ((*bb3->succs)[0], 3, 5, EDGE_FALLTHRU);
|
|
|
2085
|
|
|
2086 /* bb4. */
|
|
|
2087 ASSERT_EQ (1, bb4->preds->length ());
|
|
|
2088 ASSERT_EDGE ((*bb4->preds)[0], 2, 4, EDGE_FALSE_VALUE);
|
|
|
2089 ASSERT_EQ (1, bb4->succs->length ());
|
|
|
2090 ASSERT_EDGE ((*bb4->succs)[0], 4, 5, EDGE_FALLTHRU);
|
|
|
2091
|
|
|
2092 /* bb5. */
|
|
|
2093 ASSERT_EQ (2, bb5->preds->length ());
|
|
|
2094 ASSERT_EDGE ((*bb5->preds)[0], 3, 5, EDGE_FALLTHRU);
|
|
|
2095 ASSERT_EDGE ((*bb5->preds)[1], 4, 5, EDGE_FALLTHRU);
|
|
|
2096 ASSERT_EQ (1, bb5->succs->length ());
|
|
|
2097 ASSERT_EDGE ((*bb5->succs)[0], 5, 1, EDGE_FALLTHRU);
|
|
|
2098
|
|
|
2099 /* Exit block. */
|
|
|
2100 ASSERT_EQ (1, exit->preds->length ());
|
|
|
2101 ASSERT_EDGE ((*exit->preds)[0], 5, 1, EDGE_FALLTHRU);
|
|
|
2102 ASSERT_EQ (NULL, exit->succs);
|
|
|
2103 }
|
|
|
2104
|
|
|
2105 /* Verify that the loader copes with sparse block indices.
|
|
|
2106 This testcase loads a file with a "(block 42)". */
|
|
|
2107
|
|
|
2108 static void
|
|
|
2109 test_loading_bb_index ()
|
|
|
2110 {
|
|
|
2111 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("bb-index.rtl"));
|
|
|
2112
|
|
|
2113 ASSERT_STREQ ("test_bb_index", IDENTIFIER_POINTER (DECL_NAME (cfun->decl)));
|
|
|
2114
|
|
|
2115 ASSERT_TRUE (cfun);
|
|
|
2116
|
|
|
2117 ASSERT_TRUE (cfun->cfg != NULL);
|
|
|
2118 ASSERT_EQ (3, n_basic_blocks_for_fn (cfun));
|
|
|
2119 ASSERT_EQ (43, basic_block_info_for_fn (cfun)->length ());
|
|
|
2120 ASSERT_EQ (2, n_edges_for_fn (cfun));
|
|
|
2121
|
|
|
2122 ASSERT_EQ (NULL, (*cfun->cfg->x_basic_block_info)[41]);
|
|
|
2123 basic_block bb42 = (*cfun->cfg->x_basic_block_info)[42];
|
|
|
2124 ASSERT_NE (NULL, bb42);
|
|
|
2125 ASSERT_EQ (42, bb42->index);
|
|
|
2126 }
|
|
|
2127
|
|
|
2128 /* Verify that function_reader::handle_any_trailing_information correctly
|
|
|
2129 parses all the possible items emitted for a MEM. */
|
|
|
2130
|
|
|
2131 static void
|
|
|
2132 test_loading_mem ()
|
|
|
2133 {
|
|
|
2134 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("mem.rtl"));
|
|
|
2135
|
|
|
2136 ASSERT_STREQ ("test_mem", IDENTIFIER_POINTER (DECL_NAME (cfun->decl)));
|
|
|
2137 ASSERT_TRUE (cfun);
|
|
|
2138
|
|
|
2139 /* Verify parsing of "[42 i+17 S8 A128 AS5]". */
|
|
|
2140 rtx_insn *insn_1 = get_insn_by_uid (1);
|
|
|
2141 rtx set1 = single_set (insn_1);
|
|
|
2142 rtx mem1 = SET_DEST (set1);
|
|
|
2143 ASSERT_EQ (42, MEM_ALIAS_SET (mem1));
|
|
|
2144 /* "+17". */
|
|
|
2145 ASSERT_TRUE (MEM_OFFSET_KNOWN_P (mem1));
|
|
|
2146 ASSERT_EQ (17, MEM_OFFSET (mem1));
|
|
|
2147 /* "S8". */
|
|
|
2148 ASSERT_EQ (8, MEM_SIZE (mem1));
|
|
|
2149 /* "A128. */
|
|
|
2150 ASSERT_EQ (128, MEM_ALIGN (mem1));
|
|
|
2151 /* "AS5. */
|
|
|
2152 ASSERT_EQ (5, MEM_ADDR_SPACE (mem1));
|
|
|
2153
|
|
|
2154 /* Verify parsing of "43 i+18 S9 AS6"
|
|
|
2155 (an address space without an alignment). */
|
|
|
2156 rtx_insn *insn_2 = get_insn_by_uid (2);
|
|
|
2157 rtx set2 = single_set (insn_2);
|
|
|
2158 rtx mem2 = SET_DEST (set2);
|
|
|
2159 ASSERT_EQ (43, MEM_ALIAS_SET (mem2));
|
|
|
2160 /* "+18". */
|
|
|
2161 ASSERT_TRUE (MEM_OFFSET_KNOWN_P (mem2));
|
|
|
2162 ASSERT_EQ (18, MEM_OFFSET (mem2));
|
|
|
2163 /* "S9". */
|
|
|
2164 ASSERT_EQ (9, MEM_SIZE (mem2));
|
|
|
2165 /* "AS6. */
|
|
|
2166 ASSERT_EQ (6, MEM_ADDR_SPACE (mem2));
|
|
|
2167 }
|
|
|
2168
|
|
|
2169 /* Run all of the selftests within this file. */
|
|
|
2170
|
|
|
2171 void
|
|
|
2172 read_rtl_function_c_tests ()
|
|
|
2173 {
|
|
|
2174 test_edge_flags ();
|
|
|
2175 test_parsing_regnos ();
|
|
|
2176 test_loading_dump_fragment_1 ();
|
|
|
2177 test_loading_dump_fragment_2 ();
|
|
|
2178 test_loading_labels ();
|
|
|
2179 test_loading_insn_with_mode ();
|
|
|
2180 test_loading_jump_to_label_ref ();
|
|
|
2181 test_loading_jump_to_return ();
|
|
|
2182 test_loading_jump_to_simple_return ();
|
|
|
2183 test_loading_note_insn_basic_block ();
|
|
|
2184 test_loading_note_insn_deleted ();
|
|
|
2185 test_loading_const_int ();
|
|
|
2186 test_loading_symbol_ref ();
|
|
|
2187 test_loading_cfg ();
|
|
|
2188 test_loading_bb_index ();
|
|
|
2189 test_loading_mem ();
|
|
|
2190 }
|
|
|
2191
|
|
|
2192 } // namespace selftest
|
|
|
2193
|
|
|
2194 #endif /* #if CHECKING_P */
|
