visus
/
toolchain-gcc-arm-embedded
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
Tree: 898a39b5ab
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '898a39b5ab'
${ noResults }
toolchain-gcc-arm-embedded/lib/gcc/arm-none-eabi/10.2.1/plugin/include/tree-streamer.h

125 lines
4.4KB
Raw Blame History 

  1. /* Data structures and functions for streaming trees.

  2. 

  3.    Copyright (C) 2011-2020 Free Software Foundation, Inc.

  4.    Contributed by Diego Novillo <dnovillo@google.com>

  5. 

  6. This file is part of GCC.

  7. 

  8. GCC is free software; you can redistribute it and/or modify it under

  9. the terms of the GNU General Public License as published by the Free

  10. Software Foundation; either version 3, or (at your option) any later

  11. version.

  12. 

  13. GCC is distributed in the hope that it will be useful, but WITHOUT ANY

  14. WARRANTY; without even the implied warranty of MERCHANTABILITY or

  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  16. for more details.

  17. 

  18. You should have received a copy of the GNU General Public License

  19. along with GCC; see the file COPYING3.  If not see

  20. <http://www.gnu.org/licenses/>.  */

  21. 

  22. #ifndef GCC_TREE_STREAMER_H

  23. #define GCC_TREE_STREAMER_H

  24. 

  25. #include "streamer-hooks.h"

  26. #include "data-streamer.h"

  27. 

  28. /* Cache of pickled nodes.  Used to avoid writing the same node more

  29.    than once.  The first time a tree node is streamed out, it is

  30.    entered in this cache.  Subsequent references to the same node are

  31.    resolved by looking it up in this cache.

  32. 

  33.    This is used in two ways:

  34. 

  35.    - On the writing side, the first time T is added to STREAMER_CACHE,

  36.      a new reference index is created for T and T is emitted on the

  37.      stream.  If T needs to be emitted again to the stream, instead of

  38.      pickling it again, the reference index is emitted.

  39. 

  40.    - On the reading side, the first time T is read from the stream, it

  41.      is reconstructed in memory and a new reference index created for

  42.      T.  The reconstructed T is inserted in some array so that when

  43.      the reference index for T is found in the input stream, it can be

  44.      used to look up into the array to get the reconstructed T.  */

  45. 

  46. struct streamer_tree_cache_d

  47. {

  48.   /* The mapping between tree nodes and slots into the nodes array.  */

  49.   hash_map<tree, unsigned> *node_map;

  50. 

  51.   /* The nodes pickled so far.  */

  52.   vec<tree> nodes;

  53.   /* The node hashes (if available).  */

  54.   vec<hashval_t> hashes;

  55. 

  56.   /* Next index to assign.  */

  57.   unsigned next_idx;

  58. };

  59. 

  60. /* In tree-streamer-in.c.  */

  61. tree streamer_read_string_cst (class data_in *, class lto_input_block *);

  62. tree streamer_read_chain (class lto_input_block *, class data_in *);

  63. tree streamer_alloc_tree (class lto_input_block *, class data_in *,

  64. 		          enum LTO_tags);

  65. void streamer_read_tree_body (class lto_input_block *, class data_in *, tree);

  66. tree streamer_get_pickled_tree (class lto_input_block *, class data_in *);

  67. void streamer_read_tree_bitfields (class lto_input_block *,

  68. 				   class data_in *, tree);

  69. 

  70. /* In tree-streamer-out.c.  */

  71. void streamer_write_string_cst (struct output_block *,

  72. 				struct lto_output_stream *, tree);

  73. void streamer_write_chain (struct output_block *, tree, bool);

  74. void streamer_write_tree_header (struct output_block *, tree);

  75. void streamer_write_tree_bitfields (struct output_block *, tree);

  76. void streamer_write_tree_body (struct output_block *, tree, bool);

  77. void streamer_write_integer_cst (struct output_block *, tree, bool);

  78. 

  79. /* In tree-streamer.c.  */

  80. extern unsigned char streamer_mode_table[1 << 8];

  81. void streamer_check_handled_ts_structures (void);

  82. bool streamer_tree_cache_insert (struct streamer_tree_cache_d *, tree,

  83. 				 hashval_t, unsigned *);

  84. void streamer_tree_cache_replace_tree (struct streamer_tree_cache_d *, tree,

  85. 				       unsigned);

  86. void streamer_tree_cache_append (struct streamer_tree_cache_d *, tree,

  87. 				 hashval_t);

  88. bool streamer_tree_cache_lookup (struct streamer_tree_cache_d *, tree,

  89. 				 unsigned *);

  90. struct streamer_tree_cache_d *streamer_tree_cache_create (bool, bool, bool);

  91. void streamer_tree_cache_delete (struct streamer_tree_cache_d *);

  92. 

  93. /* Return the tree node at slot IX in CACHE.  */

  94. 

  95. static inline tree

  96. streamer_tree_cache_get_tree (struct streamer_tree_cache_d *cache, unsigned ix)

  97. {

  98.   return cache->nodes[ix];

  99. }

  100. 

  101. /* Return the tree hash value at slot IX in CACHE.  */

  102. 

  103. static inline hashval_t

  104. streamer_tree_cache_get_hash (struct streamer_tree_cache_d *cache, unsigned ix)

  105. {

  106.   return cache->hashes[ix];

  107. }

  108. 

  109. static inline void

  110. bp_pack_machine_mode (struct bitpack_d *bp, machine_mode mode)

  111. {

  112.   streamer_mode_table[mode] = 1;

  113.   bp_pack_enum (bp, machine_mode, 1 << 8, mode);

  114. }

  115. 

  116. static inline machine_mode

  117. bp_unpack_machine_mode (struct bitpack_d *bp)

  118. {

  119.   return (machine_mode)

  120. 	   ((class lto_input_block *)

  121. 	    bp->stream)->mode_table[bp_unpack_enum (bp, machine_mode, 1 << 8)];

  122. }

  123. 

  124. #endif  /* GCC_TREE_STREAMER_H  */