#include "bconfig.h"
#include "system.h"
#include "coretypes.h"
#include "hashtab.h"
#include "errors.h"
#include "read-md.h"

Include dependency graph for read-md.c:

Data Structures
struct	ptr_loc
struct	file_name_list

Functions
static void	handle_file (directive_handler_t)
hashval_t	leading_string_hash ()
int	leading_string_eq_p ()
static hashval_t	leading_ptr_hash ()
static int	leading_ptr_eq_p ()
static void	set_md_ptr_loc ()
static struct ptr_loc *	get_md_ptr_loc ()
void	copy_md_ptr_loc ()
void	fprint_md_ptr_loc ()
void	print_md_ptr_loc ()
const char *	join_c_conditions ()
void	fprint_c_condition ()
void	print_c_condition ()
static void	ATTRIBUTE_PRINTF (2, 0)
void	message_with_line ()
void	error_with_line ()
void	fatal_with_file_and_line ()
void	fatal_expected_char ()
int	read_skip_spaces ()
void	read_name ()
static void	read_escape ()
char *	read_quoted_string ()
static char *	read_braced_string ()
char *	read_string ()
void	read_skip_construct ()
int	n_comma_elts ()
const char *	scan_comma_elt ()
void	upcase_string ()
static struct md_constant *	add_constant (htab_t defs, char name, char value, struct enum_type *parent_enum)
static void	handle_constants ()
void	traverse_md_constants ()
static char *	decimal_string ()
static void	handle_enum ()
struct enum_type *	lookup_enum_type ()
void	traverse_enum_types ()
static void	handle_include ()
static void	handle_file ()
static void	handle_toplevel_file ()
static void	parse_include ()
bool	read_md_files (int argc, char *argv, bool(parse_opt)(const char *), directive_handler_t handle_directive)

Variables
struct obstack	string_obstack
static htab_t	ptr_locs
static struct obstack	ptr_loc_obstack
static htab_t	joined_conditions
static struct obstack	joined_conditions_obstack
FILE *	read_md_file
const char *	read_md_filename
int	read_md_lineno
const char *	in_fname
static char *	base_dir
static struct file_name_list *	first_dir_md_include
static struct file_name_list **	last_dir_md_include_ptr = &first_dir_md_include
void(*	include_callback )(const char *)
static size_t	max_include_len
static htab_t	md_constants
static htab_t	enum_types

Function Documentation

static struct md_constant* add_constant	(	htab_t	defs,
		char *	name,
		char *	value,
		struct enum_type *	parent_enum
	)

staticread

Add a NAME = VALUE definition to md_constants-style hash table DEFS, where both NAME and VALUE are malloc()ed strings. PARENT_ENUM is the enum to which NAME belongs, or null if NAME is a stand-alone constant.

static void ATTRIBUTE_PRINTF	(	2	,
		0
	)

static

A vfprintf-like function for reporting an error against line LINENO of the current MD file.

void copy_md_ptr_loc ( )

Associate NEW_PTR with the same file position as OLD_PTR.

static char* decimal_string ( )

static

Return a malloc()ed decimal string that represents number NUMBER.

A safe overestimate. +1 for sign, +1 for null terminator.

void error_with_line ( )

Like message_with_line, but treat the condition as an error.

References unread_char().

Referenced by handle_constants(), lookup_enum_type(), n_occurrences(), nodes_identical_1(), process_template(), read_string(), traverse_md_constants(), and valid_predicate_name_p().

void fatal_expected_char ( )

Report that we found character ACTUAL when we expected to find character EXPECTED.

References fatal_with_file_and_line(), and unread_char().

Referenced by handle_constants(), and read_rtx_code().

void fatal_with_file_and_line ( )

A printf-like function for reporting an error against the current position in the MD file.

Gather some following context.

Referenced by fatal_expected_char().

void fprint_c_condition ( )

Print condition COND to OUTF, wrapped in brackets. If COND was created by join_c_conditions, recursively invoke this function for the original conditions and join the result with "&&". Otherwise print a #line directive for COND if its original file position is known.

References read_md_filename.

Referenced by join_c_conditions().

void fprint_md_ptr_loc ( )

If PTR is associated with a known file position, print a #line directive for it to OUTF.

Referenced by get_md_ptr_loc(), and join_c_conditions().

static struct ptr_loc* get_md_ptr_loc ( )

staticread

Return the position associated with pointer PTR. Return null if no position was set.

References fprint_md_ptr_loc().

Referenced by set_md_ptr_loc().

static void handle_constants ( )

static

Process a define_constants directive, starting with the optional space after the "define_constants".

Disable constant expansion during definition processing.

References enum_types, error_with_line(), fatal_expected_char(), enum_type::md_p, enum_type::name, enum_type::num_values, read_skip_spaces(), read_string(), enum_type::tail_ptr, and enum_type::values.

static void handle_enum ( )

static

Process a define_enum or define_c_enum directive, starting with the optional space after the "define_enum". LINENO is the line number on which the directive started and MD_P is true if the directive is a define_enum rather than a define_c_enum.

static void handle_file ( directive_handler_t )

static

static void handle_file ( )

static

Process the current file, assuming that read_md_file and read_md_filename are valid. Use HANDLE_DIRECTIVE to handle unknown directives.

References enum_types, joined_conditions, joined_conditions_obstack, leading_ptr_eq_p(), leading_ptr_hash(), leading_string_eq_p(), leading_string_hash(), md_constants, ptr_loc_obstack, ptr_locs, and string_obstack.

static void handle_include ( )

static

Process an "include" directive, starting with the optional space after the "include". Read in the file and use HANDLE_DIRECTIVE to process each unknown directive. LINENO is the line number on which the "include" occurred.

 If the specified file name is absolute, skip the include stack.

     Search the directory path, trying to open the file.

 If we haven't managed to open the file yet, try combining the
 filename with BASE_DIR.

 Save the old cursor.  Note that the LINENO argument to this
 function is the beginning of the include statement, while
 read_md_lineno has already been advanced.

 Restore the old cursor.

 Do not free the pathname.  It is attached to the various rtx
 queue elements.

static void handle_toplevel_file ( )

static

Like handle_file, but for top-level files. Set up in_fname and base_dir accordingly.

References fatal(), and parse_include().

const char* join_c_conditions ( )

Return a condition that satisfies both COND1 and COND2. Either string may be null or empty.

References fprint_c_condition(), fprint_md_ptr_loc(), and joined_conditions.

Referenced by add_current_iterators(), and alter_constraints().

static int leading_ptr_eq_p ( )

static

Return true if DEF1 and DEF2 are pointers to the same pointer.

References ptr_locs.

Referenced by handle_file().

static hashval_t leading_ptr_hash ( )

static

Return a hash value for the pointer pointed to by DEF.

Referenced by handle_file().

int leading_string_eq_p ( )

Given two objects that start with char * name fields, return true if they have the same name.

References ptr_loc_obstack.

Referenced by handle_file().

hashval_t leading_string_hash ( )

Given an object that starts with a char * name field, return a hash code for its name.

Referenced by handle_file().

struct enum_type* lookup_enum_type ( )

read

Try to find the definition of the given enum. Return null on failure.

References error_with_line().

void message_with_line ( )

A printf-like function for reporting an error against line LINENO in the current MD file.

Referenced by gen_insn(), nodes_identical_1(), process_template(), and validate_exp().

int n_comma_elts ( )

Given a string, return the number of comma-separated elements in it. Return 0 for the null string.

static void parse_include ( )

static

Parse a -I option with argument ARG.

Referenced by handle_toplevel_file().

void print_c_condition ( )

Special fprint_c_condition for writing to STDOUT.

References have_error.

void print_md_ptr_loc ( )

Special fprint_md_ptr_loc for writing to STDOUT.

static char* read_braced_string ( )

static

Read a braced string (a la Tcl) onto the string obstack. Caller has scanned the leading brace. Note that unlike quoted strings, the outermost braces are included in the string constant.

static void read_escape ( )

static

Subroutine of the string readers. Handles backslash escapes. Caller has read the backslash, but not placed it into the obstack.

     Backslash-newline is replaced by nothing, as in C.

     \" \' \\ are replaced by the second character.

     Standard C string escapes:
     \a \b \f \n \r \t \v
     \[0-7] \x
     all are passed through to the output string unmolested.
     In normal use these wind up in a string constant processed
     by the C compiler, which will translate them appropriately.
     We do not bother checking that \[0-7] are followed by up to
     two octal digits, or that \x is followed by N hex digits.
     \? \u \U are left out because they are not in traditional C.

     \; makes stuff for a C string constant containing
     newline and tab.

     pass anything else through, but issue a warning.

bool read_md_files	(	int	argc,
		char **	argv,
		bool()(const char )	parse_opt,
		directive_handler_t	handle_directive
	)

The main routine for reading .md files. Try to process all the .md files specified on the command line and return true if no error occurred.

ARGC and ARGV are the arguments to main.

PARSE_OPT, if nonnull, is passed all unknown command-line arguments. It should return true if it recognizes the argument or false if a generic error should be reported.

If HANDLE_DIRECTIVE is nonnull, the parser calls it for each unknown directive, otherwise it just skips such directives. See the comment above the directive_handler_t definition for details about the callback's interface.

 Initialize global data.

 Unlock the stdio streams.

 First we loop over all the options.

       An argument consisting of exactly one dash is a request to
       read stdin.  This will be handled in the second loop.

       An argument consisting of just two dashes causes option
       parsing to cease.

       The program may have provided a callback so it can
       accept its own options.

 Now loop over all input files.

             Read stdin.

             No further arguments are to be treated as options.

     If we get here we are looking at a non-option argument, i.e.
     a file to be processed.

 If we get to this point without having seen any files to process,
 read the standard input now.

Referenced by gen_mnemonic_attr(), and main().

void read_name ( )

Read an rtx code name into NAME. It is terminated by any of the punctuation chars of rtx printed syntax.

Do constant expansion.

References md_constants, md_constant::name, md_name::string, and md_constant::value.

Referenced by traverse_md_constants().

char* read_quoted_string ( void )

Read a double-quoted string onto the obstack. Caller has scanned the leading quote.

void read_skip_construct ( )

Skip the rest of a construct that started at line LINENO and that is currently nested by DEPTH levels of parentheses.

int read_skip_spaces ( void )

Read chars from the MD file until a non-whitespace char and return that. Comments, both Lisp style and C style, are treated as whitespace.

Referenced by handle_constants().

char* read_string ( )

Read some kind of string constant. This is the high-level routine used by read_rtx. It handles surrounding parentheses, leading star, and dispatch to the appropriate string constant reader.

References error_with_line().

Referenced by handle_constants().

const char* scan_comma_elt ( )

Given a pointer to a (char *), return a pointer to the beginning of the next comma-separated element in the string. Advance the pointer given to the end of that element. Return NULL if at end of string. Caller is responsible for copying the string if necessary. White space between a comma and an element is ignored.

Referenced by gen_attr(), gen_mnemonic_setattr(), and write_extract_subexp().

static void set_md_ptr_loc ( )

static

Associate PTR with the file position given by FILENAME and LINENO.

References ptr_loc::filename, get_md_ptr_loc(), and ptr_loc::lineno.

void traverse_enum_types ( )

For every enum definition, call CALLBACK with two arguments: a pointer to the constant definition and INFO. Stop when CALLBACK returns zero.

void traverse_md_constants ( )

For every constant definition, call CALLBACK with two arguments: a pointer a pointer to the constant definition and INFO. Stop when CALLBACK returns zero.

References error_with_line(), read_name(), and unread_char().

void upcase_string ( )

Convert STRING to uppercase.

Variable Documentation

char* base_dir

static

The directory part of IN_FNAME. NULL if IN_FNAME is a bare filename.

htab_t enum_types

static

A table of enum_type structures, hashed by name.

Referenced by handle_constants(), and handle_file().

struct file_name_list* first_dir_md_include

static

The first directory to search.

const char* in_fname

The name of the toplevel file that indirectly included READ_MD_FILE.

Referenced by write_insn_constraint_len().

void(* include_callback)(const char *)

This callback will be invoked whenever an md include directive is processed. To be used for creation of the dependency file.

Referenced by main().

htab_t joined_conditions

static

A hash table of triples (A, B, C), where each of A, B and C is a condition and A is equivalent to "B && C". This is used to keep track of the source of conditions that are made up of separate MD strings (such as the split condition of a define_insn_and_split).

Referenced by handle_file(), and join_c_conditions().

struct obstack joined_conditions_obstack

static

An obstack for allocating joined_conditions entries.

Referenced by handle_file().

struct file_name_list** last_dir_md_include_ptr = &first_dir_md_include

static

A pointer to the null terminator of the md include chain.

size_t max_include_len

static

The current maximum length of directory names in the search path for include files. (Altered as we get more of them.)

htab_t md_constants