GCC Wikia
Advertisement

このページを編集する際は,編集に関する方針に従ってください.[]

概要[]

  • gcc-4.1.0/gcc/langhooks.hにて定義
  • hook とは,特定の場面で呼び出される関数 (へのポインタ) を格納した変数のこと.

lhd_* は,langhooks-def.h のプリフィックス.

そこで定義された関数 lhd_foo へのポインタを格納する構造体.

実装[]

 203 /* Language-specific hooks.  See langhooks-def.h for defaults.  */
204 
205 struct lang_hooks
206 {
 207   /* String identifying the front end.  e.g. "GNU C++".  */
208   const char *name;
209 
 210   /* sizeof (struct lang_identifier), so make_node () creates
 211      identifier nodes long enough for the language-specific slots.  */
212   size_t identifier_size;
213 
 214   /* Determines the size of any language-specific tcc_constant or
 215      tcc_exceptional nodes.  Since it is called from make_node, the
 216      only information available is the tree code.  Expected to die
 217      on unrecognized codes.  */
218   size_t (*tree_size) (enum tree_code);
219 
 220   /* The first callback made to the front end, for simple
 221      initialization needed before any calls to handle_option.  Return
 222      the language mask to filter the switch array with.  */
223   unsigned int (*init_options) (unsigned int argc, const char **argv);
224 
 225   /* Callback used to perform language-specific initialization for the
 226      global diagnostic context structure.  */
227   void (*initialize_diagnostics) (struct diagnostic_context *);
228 
 229   /* Handle the switch CODE, which has real type enum opt_code from
 230      options.h.  If the switch takes an argument, it is passed in ARG
 231      which points to permanent storage.  The handler is responsible for
 232      checking whether ARG is NULL, which indicates that no argument
 233      was in fact supplied.  For -f and -W switches, VALUE is 1 or 0
 234      for the positive and negative forms respectively.
 235 
 236      Return 1 if the switch is valid, 0 if invalid, and -1 if it's
 237      valid and should not be treated as language-independent too.  */
238   int (*handle_option) (size_t code, const char *arg, int value);
239 
 240   /* Return false to use the default complaint about a missing
 241      argument, otherwise output a complaint and return true.  */
242   bool (*missing_argument) (const char *opt, size_t code);
243 
 244   /* Called when all command line options have been parsed to allow
 245      further processing and initialization
 246 
 247      Should return true to indicate that a compiler back-end is
 248      not required, such as with the -E option.
 249 
 250      If errorcount is nonzero after this call the compiler exits
 251      immediately and the finish hook is not called.  */
252   bool (*post_options) (const char **);
253 

* 言語固有の初期化を行う lang_dependent_init 関数から呼ばれる.

 254   /* Called after post_options to initialize the front end.  Return
 255      false to indicate that no further compilation be performed, in
 256      which case the finish hook is called immediately.  */
257   bool (*init) (void);
258 
 259   /* Called at the end of compilation, as a finalizer.  */
260   void (*finish) (void);
261 

* compile_file 関数で呼び出される.非ゼロの時デバッグ情報を出力.

 262   /* Parses the entire file.  The argument is nonzero to cause bison
 263      parsers to dump debugging information during parsing.  */
264   void (*parse_file) (int);
265 

* compile_file 関数で呼び出される.

 266   /* Called immediately after parsing to clear the binding stack.  */
267   void (*clear_binding_stack) (void);
268 
 269   /* Called to obtain the alias set to be used for an expression or type.
 270      Returns -1 if the language does nothing special for it.  */
271   HOST_WIDE_INT (*get_alias_set) (tree);
272 
 273   /* Called with an expression that is to be processed as a constant.
 274      Returns either the same expression or a language-independent
 275      constant equivalent to its input.  */
276   tree (*expand_constant) (tree);
277 
 278   /* Called by expand_expr for language-specific tree codes.
 279      Fourth argument is actually an enum expand_modifier.  */
280   rtx (*expand_expr) (tree, rtx, enum machine_mode, int, rtx *);
281 
 282   /* Called by expand_expr to generate the definition of a decl.  Returns
 283      1 if handled, 0 otherwise.  */
284   int (*expand_decl) (tree);
285 
 286   /* Hook called by safe_from_p for language-specific tree codes.  It is
 287      up to the language front-end to install a hook if it has any such
 288      codes that safe_from_p needs to know about.  Since same_from_p will
 289      recursively explore the TREE_OPERANDs of an expression, this hook
 290      should not reexamine those pieces.  This routine may recursively
 291      call safe_from_p; it should always pass `0' as the TOP_P
 292      parameter.  */
293   int (*safe_from_p) (rtx, tree);
294 
 295   /* Function to finish handling an incomplete decl at the end of
 296      compilation.  Default hook is does nothing.  */
297   void (*finish_incomplete_decl) (tree);
298 
 299   /* Mark EXP saying that we need to be able to take the address of
 300      it; it should not be allocated in a register.  Return true if
 301      successful.  */
302   bool (*mark_addressable) (tree);
303 
 304   /* Hook called by staticp for language-specific tree codes.  */
305   tree (*staticp) (tree);
306 
 307   /* Replace the DECL_LANG_SPECIFIC data, which may be NULL, of the
 308      DECL_NODE with a newly GC-allocated copy.  */
309   void (*dup_lang_specific_decl) (tree);
310 
 311   /* Set the DECL_ASSEMBLER_NAME for a node.  If it is the sort of
 312      thing that the assembler should talk about, set
 313      DECL_ASSEMBLER_NAME to an appropriate IDENTIFIER_NODE.
 314      Otherwise, set it to the ERROR_MARK_NODE to ensure that the
 315      assembler does not talk about it.  */
316   void (*set_decl_assembler_name) (tree);
317 
 318   /* Return nonzero if fold-const is free to use bit-field
 319      optimizations, for instance in fold_truthop().  */
320   bool (*can_use_bit_fields_p) (void);
321 
 322   /* Nonzero if operations on types narrower than their mode should
 323      have their results reduced to the precision of the type.  */
324   bool reduce_bit_field_operations;
325 
 326   /* Nonzero if this front end does not generate a dummy BLOCK between
 327      the outermost scope of the function and the FUNCTION_DECL.  See
 328      is_body_block in stmt.c, and its callers.  */
329   bool no_body_blocks;
330 
 331   /* The front end can add its own statistics to -fmem-report with
 332      this hook.  It should output to stderr.  */
333   void (*print_statistics) (void);
334 
 335   /* Called by print_tree when there is a tree of class tcc_exceptional
 336      that it doesn't know how to display.  */
337   lang_print_tree_hook print_xnode;
338 
 339   /* Called to print language-dependent parts of tcc_decl, tcc_type,
 340      and IDENTIFIER_NODE nodes.  */
341   lang_print_tree_hook print_decl;
342   lang_print_tree_hook print_type;
343   lang_print_tree_hook print_identifier;
344 
 345   /* Computes the name to use to print a declaration.  DECL is the
 346      non-NULL declaration in question.  VERBOSITY determines what
 347      information will be printed: 0: DECL_NAME, demangled as
 348      necessary.  1: and scope information.  2: and any other
 349      information that might be interesting, such as function parameter
 350      types in C++.  */
351   const char *(*decl_printable_name) (tree decl, int verbosity);
352 
 353   /* This compares two types for equivalence ("compatible" in C-based languages).
 354      This routine should only return 1 if it is sure.  It should not be used
 355      in contexts where erroneously returning 0 causes problems.  */
356   int (*types_compatible_p) (tree x, tree y);
357 
 358   /* Given a CALL_EXPR, return a function decl that is its target.  */
359   tree (*lang_get_callee_fndecl) (tree);
360 
 361   /* Called by report_error_function to print out function name.  */
362   void (*print_error_function) (struct diagnostic_context *, const char *);
363 
 364   /* Called from expr_size to calculate the size of the value of an
 365      expression in a language-dependent way.  Returns a tree for the size
 366      in bytes.  A frontend can call lhd_expr_size to get the default
 367      semantics in cases that it doesn't want to handle specially.  */
368   tree (*expr_size) (tree);
369 
 370   /* Convert a character from the host's to the target's character
 371      set.  The character should be in what C calls the "basic source
 372      character set" (roughly, the set of characters defined by plain
 373      old ASCII).  The default is to return the character unchanged,
 374      which is correct in most circumstances.  Note that both argument
 375      and result should be sign-extended under -fsigned-char,
 376      zero-extended under -fno-signed-char.  */
377   HOST_WIDE_INT (*to_target_charset) (HOST_WIDE_INT);
378 
 379   /* Pointers to machine-independent attribute tables, for front ends
 380      using attribs.c.  If one is NULL, it is ignored.  Respectively, a
 381      table of attributes specific to the language, a table of
 382      attributes common to two or more languages (to allow easy
 383      sharing), and a table of attributes for checking formats.  */
384   const struct attribute_spec *attribute_table;
385   const struct attribute_spec *common_attribute_table;
386   const struct attribute_spec *format_attribute_table;
387 
 388   /* Function-related language hooks.  */
389   struct lang_hooks_for_functions function;
390 
391   struct lang_hooks_for_tree_inlining tree_inlining;
392 
393   struct lang_hooks_for_callgraph callgraph;
394 
395   struct lang_hooks_for_tree_dump tree_dump;
396 

* compile_file 関数で呼び出される.

397   struct lang_hooks_for_decls decls;
398 
399   struct lang_hooks_for_types types;
400 
 401   /* Perform language-specific gimplification on the argument.  Returns an
 402      enum gimplify_status, though we can't see that type here.  */
403   int (*gimplify_expr) (tree *, tree *, tree *);
404 
 405   /* Fold an OBJ_TYPE_REF expression to the address of a function.
 406      KNOWN_TYPE carries the true type of the OBJ_TYPE_REF_OBJECT.  */
407   tree (*fold_obj_type_ref) (tree, tree);
408 
 409   /* Return a definition for a builtin function named NAME and whose data type
 410      is TYPE.  TYPE should be a function type with argument types.
 411      FUNCTION_CODE tells later passes how to compile calls to this function.
 412      See tree.h for its possible values.
 413 
 414      If LIBRARY_NAME is nonzero, use that for DECL_ASSEMBLER_NAME,
 415      the name to be called if we can't opencode the function.  If
 416      ATTRS is nonzero, use that for the function's attribute list.  */
417   tree (*builtin_function) (const char *name, tree type, int function_code,
418                             enum built_in_class bt_class,
419                             const char *library_name, tree attrs);
420 
 421   /* Used to set up the tree_contains_structure array for a frontend. */
422   void (*init_ts) (void);
423 

*recompute_tree_invarant_for_addr_expr関数から呼ばれる

 424   /* Called by recompute_tree_invarant_for_addr_expr to go from EXPR
 425      to a contained expression or DECL, possibly updating *TC, *TI or
 426      *SE if in the process TREE_CONSTANT, TREE_INVARIANT or
 427      TREE_SIDE_EFFECTS need updating.  */
428   tree (*expr_to_decl) (tree expr, bool *tc, bool *ti, bool *se);
429 
 430   /* Whenever you add entries here, make sure you adjust langhooks-def.h
 431      and langhooks.c accordingly.  */
432 };



リンク元

Advertisement