LCOV - code coverage report
Current view: top level - gcc/go/gofrontend - import.h (source / functions) Coverage Total Hit
Test: gcc.info Lines: 87.1 % 139 121
Test Date: 2024-03-23 14:05:01 Functions: 82.9 % 35 29
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : // import.h -- Go frontend import declarations.     -*- C++ -*-
       2                 :             : 
       3                 :             : // Copyright 2009 The Go Authors. All rights reserved.
       4                 :             : // Use of this source code is governed by a BSD-style
       5                 :             : // license that can be found in the LICENSE file.
       6                 :             : 
       7                 :             : #ifndef GO_IMPORT_H
       8                 :             : #define GO_IMPORT_H
       9                 :             : 
      10                 :             : #include "export.h"
      11                 :             : #include "go-linemap.h"
      12                 :             : 
      13                 :             : class Gogo;
      14                 :             : class Block;
      15                 :             : class Package;
      16                 :             : class Type;
      17                 :             : class Named_object;
      18                 :             : class Named_type;
      19                 :             : class Expression;
      20                 :             : class Import_function_body;
      21                 :             : class Temporary_statement;
      22                 :             : class Unnamed_label;
      23                 :             : class Finalize_methods;
      24                 :             : 
      25                 :             : // Expressions can be imported either directly from import data (for
      26                 :             : // simple constant expressions that can appear in a const declaration
      27                 :             : // or as an array length in a type definition) or from an exported
      28                 :             : // function body (for an inlinable function).  These two cases happen
      29                 :             : // at different points in the compilation and have different
      30                 :             : // requirements, so it's not easy to unify them.  Import_expression is
      31                 :             : // an abstract interface that permits the expression import code to
      32                 :             : // work at either point.  When importing expressions that only occur
      33                 :             : // for an inlinable function, the ifb method is available to get the
      34                 :             : // full Import_function_body.
      35                 :             : 
      36                 :       34055 : class Import_expression
      37                 :             : {
      38                 :             :  public:
      39                 :             :   // Return the import function body.  This should only be called for
      40                 :             :   // expressions that can not appear outside of an inlinable function
      41                 :             :   // body.
      42                 :             :   virtual Import_function_body*
      43                 :             :   ifb() = 0;
      44                 :             : 
      45                 :             :   // The location to report in an error message.
      46                 :             :   virtual Location
      47                 :             :   location() const = 0;
      48                 :             : 
      49                 :             :   // Peek at the next character in the input, returning a value from 0
      50                 :             :   // to 0xff.  Returns -1 at end of stream.
      51                 :             :   virtual int
      52                 :             :   peek_char() = 0;
      53                 :             : 
      54                 :             :   // Return the next character and advance.
      55                 :             :   virtual int
      56                 :             :   get_char() = 0;
      57                 :             : 
      58                 :             :   // Return true if the next bytes match STR.
      59                 :             :   virtual bool
      60                 :             :   match_c_string(const char* str) = 0;
      61                 :             : 
      62                 :             :   // Require that the next bytes match STR.
      63                 :             :   virtual void
      64                 :             :   require_c_string(const char* str) = 0;
      65                 :             : 
      66                 :             :   // Advance the stream SKIP bytes.
      67                 :             :   virtual void
      68                 :             :   advance(size_t skip) = 0;
      69                 :             : 
      70                 :             :   // Read an identifier.
      71                 :             :   virtual std::string
      72                 :             :   read_identifier() = 0;
      73                 :             : 
      74                 :             :   // Read a type.
      75                 :             :   virtual Type*
      76                 :             :   read_type() = 0;
      77                 :             : 
      78                 :             :   // Return the maximum valid package index.
      79                 :             :   virtual size_t
      80                 :             :   max_package_index() const = 0;
      81                 :             : 
      82                 :             :   // Return the package for a package index.
      83                 :             :   virtual Package*
      84                 :             :   package_at_index(int index) = 0;
      85                 :             : 
      86                 :             :   // Return the version number of the export data we're reading.
      87                 :             :   virtual Export_data_version
      88                 :             :   version() const = 0;
      89                 :             : };
      90                 :             : 
      91                 :             : // This class manages importing Go declarations.
      92                 :             : 
      93                 :             : class Import : public Import_expression
      94                 :             : {
      95                 :             :  public:
      96                 :             :   // The Stream class is an interface used to read the data.  The
      97                 :             :   // caller should instantiate a child of this class.
      98                 :             :   class Stream
      99                 :             :   {
     100                 :             :    public:
     101                 :             :     Stream();
     102                 :             :     virtual ~Stream();
     103                 :             : 
     104                 :             :     // Set the position, for error messages.
     105                 :             :     void
     106                 :     1975892 :     set_pos(int pos)
     107                 :     1975892 :     { this->pos_ = pos; }
     108                 :             : 
     109                 :             :     // Return whether we have seen an error.
     110                 :             :     bool
     111                 :     2488926 :     saw_error() const
     112                 :     2488926 :     { return this->saw_error_; }
     113                 :             : 
     114                 :             :     // Record that we've seen an error.
     115                 :             :     void
     116                 :           0 :     set_saw_error()
     117                 :           0 :     { this->saw_error_ = true; }
     118                 :             : 
     119                 :             :     // Return the next character (a value from 0 to 0xff) without
     120                 :             :     // advancing.  Returns -1 at end of stream.
     121                 :             :     int
     122                 :             :     peek_char();
     123                 :             : 
     124                 :             :     // Look for LENGTH characters, setting *BYTES to point to them.
     125                 :             :     // Returns false if the bytes are not available.  Does not
     126                 :             :     // advance.
     127                 :             :     bool
     128                 :    10312029 :     peek(size_t length, const char** bytes)
     129                 :    10312029 :     { return this->do_peek(length, bytes); }
     130                 :             : 
     131                 :             :     // Return the next character (a value from 0 to 0xff) and advance
     132                 :             :     // the read position by 1.  Returns -1 at end of stream.
     133                 :             :     int
     134                 :    66222916 :     get_char()
     135                 :             :     {
     136                 :    66222916 :       int c = this->peek_char();
     137                 :   132445832 :       this->advance(1);
     138                 :    66222916 :       return c;
     139                 :             :     }
     140                 :             : 
     141                 :             :     // Return true if at the end of the stream.
     142                 :             :     bool
     143                 :     6647293 :     at_eof()
     144                 :     6647293 :     { return this->peek_char() == -1; }
     145                 :             : 
     146                 :             :     // Return true if the next bytes match STR.
     147                 :             :     bool
     148                 :    60739157 :     match_c_string(const char* str)
     149                 :    60739157 :     { return this->match_bytes(str, strlen(str)); }
     150                 :             : 
     151                 :             :     // Return true if the next LENGTH bytes match BYTES.
     152                 :             :     bool
     153                 :             :     match_bytes(const char* bytes, size_t length);
     154                 :             : 
     155                 :             :     // Give an error if the next bytes do not match STR.  Advance the
     156                 :             :     // read position by the length of STR.
     157                 :             :     void
     158                 :    74432418 :     require_c_string(Location location, const char* str)
     159                 :    74432418 :     { this->require_bytes(location, str, strlen(str)); }
     160                 :             : 
     161                 :             :     // Given an error if the next LENGTH bytes do not match BYTES.
     162                 :             :     // Advance the read position by LENGTH.
     163                 :             :     void
     164                 :             :     require_bytes(Location, const char* bytes, size_t length);
     165                 :             : 
     166                 :             :     // Advance the read position by SKIP bytes.
     167                 :             :     void
     168                 :   290455833 :     advance(size_t skip)
     169                 :             :     {
     170                 :   284913001 :       this->do_advance(skip);
     171                 :   223404959 :       this->pos_ += skip;
     172                 :   136626709 :     }
     173                 :             : 
     174                 :             :     // Return the current read position.  This returns int because it
     175                 :             :     // is more convenient in error reporting.  FIXME.
     176                 :             :     int
     177                 :    12345360 :     pos()
     178                 :    12345360 :     { return static_cast<int>(this->pos_); }
     179                 :             : 
     180                 :             :    protected:
     181                 :             :     // This function should set *BYTES to point to a buffer holding
     182                 :             :     // the LENGTH bytes at the current read position.  It should
     183                 :             :     // return false if the bytes are not available.  This should not
     184                 :             :     // change the current read position.
     185                 :             :     virtual bool
     186                 :             :     do_peek(size_t length, const char** bytes) = 0;
     187                 :             : 
     188                 :             :     // This function should advance the current read position LENGTH
     189                 :             :     // bytes.
     190                 :             :     virtual void
     191                 :             :     do_advance(size_t skip) = 0;
     192                 :             : 
     193                 :             :    private:
     194                 :             :     // The current read position.
     195                 :             :     size_t pos_;
     196                 :             :     // True if we've seen an error reading from this stream.
     197                 :             :     bool saw_error_;
     198                 :             :   };
     199                 :             : 
     200                 :             :   // Find import data.  This searches the file system for FILENAME and
     201                 :             :   // returns a pointer to a Stream object to read the data that it
     202                 :             :   // exports.  LOCATION is the location of the import statement.
     203                 :             :   // RELATIVE_IMPORT_PATH is used as a prefix for a relative import.
     204                 :             :   static Stream*
     205                 :             :   open_package(const std::string& filename, Location location,
     206                 :             :                const std::string& relative_import_path);
     207                 :             : 
     208                 :             :   // Constructor.
     209                 :             :   Import(Stream*, Location);
     210                 :             : 
     211                 :             :   // Register the builtin types.
     212                 :             :   void
     213                 :             :   register_builtin_types(Gogo*);
     214                 :             : 
     215                 :             :   // Import everything defined in the stream.  LOCAL_NAME is the local
     216                 :             :   // name to be used for bindings; if it is the string "." then
     217                 :             :   // bindings should be inserted in the global scope.  If LOCAL_NAME
     218                 :             :   // is the empty string then the name of the package itself is the
     219                 :             :   // local name.  This returns the imported package, or NULL on error.
     220                 :             :   Package*
     221                 :             :   import(Gogo*, const std::string& local_name, bool is_local_name_exported);
     222                 :             : 
     223                 :             :   // The location of the import statement.
     224                 :             :   Location
     225                 :    12545982 :   location() const
     226                 :    12545982 :   { return this->location_; }
     227                 :             : 
     228                 :             :   // Return the package we are importing.
     229                 :             :   Package*
     230                 :       65117 :   package() const
     231                 :       65117 :   { return this->package_; }
     232                 :             : 
     233                 :             :   // Return the next character.
     234                 :             :   int
     235                 :    26679393 :   peek_char()
     236                 :    26679393 :   { return this->stream_->peek_char(); }
     237                 :             : 
     238                 :             :   // Return the next character and advance.
     239                 :             :   int
     240                 :     2071503 :   get_char()
     241                 :     2071503 :   { return this->stream_->get_char(); }
     242                 :             : 
     243                 :             :   // Read LENGTH characters into *OUT and advance past them.  On
     244                 :             :   // EOF reports an error and sets *OUT to an empty string.
     245                 :             :   void
     246                 :             :   read(size_t length, std::string* out);
     247                 :             : 
     248                 :             :   // Return true at the end of the stream.
     249                 :             :   bool
     250                 :             :   at_eof()
     251                 :             :   { return this->stream_->at_eof(); }
     252                 :             : 
     253                 :             :   // Return whether the next bytes match STR.
     254                 :             :   bool
     255                 :    49521626 :   match_c_string(const char* str)
     256                 :    49521626 :   { return this->stream_->match_c_string(str); }
     257                 :             : 
     258                 :             :   // Require that the next bytes match STR.
     259                 :             :   void
     260                 :    74432418 :   require_c_string(const char* str)
     261                 :    74432418 :   { this->stream_->require_c_string(this->location_, str); }
     262                 :             : 
     263                 :             :   // Advance the stream SKIP bytes.
     264                 :             :   void
     265                 :     5848215 :   advance(size_t skip)
     266                 :     5848215 :   { this->stream_->advance(skip); }
     267                 :             : 
     268                 :             :   // Stream position, for error reporting.
     269                 :             :   int
     270                 :           0 :   pos()
     271                 :           0 :   { return this->stream_->pos(); }
     272                 :             : 
     273                 :             :   // Return the version number of the export data we're reading.
     274                 :             :   Export_data_version
     275                 :     1285858 :   version() const { return this->version_; }
     276                 :             : 
     277                 :             :   // Skip a semicolon if using an older version.
     278                 :             :   void
     279                 :     3998856 :   require_semicolon_if_old_version()
     280                 :             :   {
     281                 :     3998856 :     if (this->version_ == EXPORT_FORMAT_V1
     282                 :     3998856 :         || this->version_ == EXPORT_FORMAT_V2)
     283                 :           0 :       this->require_c_string(";");
     284                 :     3998856 :   }
     285                 :             : 
     286                 :             :   // Read an identifier.
     287                 :             :   std::string
     288                 :             :   read_identifier();
     289                 :             : 
     290                 :             :   // Read a name.  This is like read_identifier, except that a "?" is
     291                 :             :   // returned as an empty string.  This matches Export::write_name.
     292                 :             :   std::string
     293                 :             :   read_name();
     294                 :             : 
     295                 :             :   // Return the maximum valid package index.  This is the size of
     296                 :             :   // packages_ because we will subtract 1 in package_at_index.
     297                 :             :   size_t
     298                 :      246618 :   max_package_index() const
     299                 :      246618 :   { return this->packages_.size(); }
     300                 :             : 
     301                 :             :   // Return the package at an index.  (We subtract 1 because package
     302                 :             :   // index 0 is not used.)
     303                 :             :   Package*
     304                 :      246618 :   package_at_index(int index)
     305                 :      246618 :   { return this->packages_.at(index - 1); }
     306                 :             : 
     307                 :             :   // Read a type.
     308                 :             :   Type*
     309                 :             :   read_type();
     310                 :             : 
     311                 :             :   // Return the type for a type index.  INPUT_NAME and INPUT_OFFSET
     312                 :             :   // are only for error reporting.  PARSED is set to whether we parsed
     313                 :             :   // the type information for a new type.
     314                 :             :   Type*
     315                 :             :   type_for_index(int index, const std::string& input_name,
     316                 :             :                  size_t input_offset, bool* parsed);
     317                 :             : 
     318                 :             :   // Read an escape note.
     319                 :             :   std::string
     320                 :             :   read_escape();
     321                 :             : 
     322                 :             :   // Clear the stream when it is no longer accessible.
     323                 :             :   void
     324                 :       21808 :   clear_stream()
     325                 :       21808 :   { this->stream_ = NULL; }
     326                 :             : 
     327                 :             :   // Just so that Import implements Import_expression.
     328                 :             :   Import_function_body*
     329                 :           0 :   ifb()
     330                 :           0 :   { return NULL; }
     331                 :             : 
     332                 :             :   // Read a qualified identifier from an Import_expression.  Sets
     333                 :             :   // *NAME, *PKG, and *IS_EXPORTED, and reports whether it succeeded.
     334                 :             :   static bool
     335                 :             :   read_qualified_identifier(Import_expression*, std::string* name,
     336                 :             :                             Package** pkg, bool* is_exported);
     337                 :             : 
     338                 :             :  private:
     339                 :             :   static Stream*
     340                 :             :   try_package_in_directory(const std::string&, Location);
     341                 :             : 
     342                 :             :   static int
     343                 :             :   try_suffixes(std::string*);
     344                 :             : 
     345                 :             :   static Stream*
     346                 :             :   find_export_data(const std::string& filename, int fd, Location);
     347                 :             : 
     348                 :             :   static Stream*
     349                 :             :   find_object_export_data(const std::string& filename, int fd,
     350                 :             :                           off_t offset, Location);
     351                 :             : 
     352                 :             :   static const int archive_magic_len = 8;
     353                 :             : 
     354                 :             :   static bool
     355                 :             :   is_archive_magic(const char*);
     356                 :             : 
     357                 :             :   static Stream*
     358                 :             :   find_archive_export_data(const std::string& filename, int fd,
     359                 :             :                            Location);
     360                 :             : 
     361                 :             :   // Read a package line.
     362                 :             :   void
     363                 :             :   read_one_package();
     364                 :             : 
     365                 :             :   // Read an import line.
     366                 :             :   void
     367                 :             :   read_one_import();
     368                 :             : 
     369                 :             :   // Read an indirectimport line.
     370                 :             :   void
     371                 :             :   read_one_indirect_import();
     372                 :             : 
     373                 :             :   // Read the import control functions and init graph.
     374                 :             :   void
     375                 :             :   read_import_init_fns(Gogo*);
     376                 :             : 
     377                 :             :   // Read the types.
     378                 :             :   bool
     379                 :             :   read_types();
     380                 :             : 
     381                 :             :   // Import a constant.
     382                 :             :   void
     383                 :             :   import_const();
     384                 :             : 
     385                 :             :   // Import a type.
     386                 :             :   void
     387                 :             :   import_type();
     388                 :             : 
     389                 :             :   // Import a variable.
     390                 :             :   void
     391                 :             :   import_var();
     392                 :             : 
     393                 :             :   // Import a function.
     394                 :             :   void
     395                 :             :   import_func(Package*);
     396                 :             : 
     397                 :             :   // Parse a type definition.
     398                 :             :   bool
     399                 :             :   parse_type(int index);
     400                 :             : 
     401                 :             :   // Read a named type and store it at this->type_[index].
     402                 :             :   Type*
     403                 :             :   read_named_type(int index);
     404                 :             : 
     405                 :             :   // Register a single builtin type.
     406                 :             :   void
     407                 :             :   register_builtin_type(Gogo*, const char* name, Builtin_code);
     408                 :             : 
     409                 :             :   // Get an integer from a string.
     410                 :             :   bool
     411                 :             :   string_to_int(const std::string&, bool is_neg_ok, int* ret);
     412                 :             : 
     413                 :             :   // Get an unsigned integer from a string.
     414                 :             :   bool
     415                 :     6605358 :   string_to_unsigned(const std::string& s, unsigned* ret)
     416                 :             :   {
     417                 :     6605358 :     int ivalue;
     418                 :     6605358 :     if (!this->string_to_int(s, false, &ivalue))
     419                 :             :       return false;
     420                 :     6605358 :     *ret = static_cast<unsigned>(ivalue);
     421                 :     6605358 :     return true;
     422                 :             :   }
     423                 :             : 
     424                 :             :   // Finalize methods for newly imported types.
     425                 :             :   void
     426                 :             :   finalize_methods();
     427                 :             : 
     428                 :             :   // The general IR.
     429                 :             :   Gogo* gogo_;
     430                 :             :   // The stream from which to read import data.
     431                 :             :   Stream* stream_;
     432                 :             :   // The location of the import statement we are processing.
     433                 :             :   Location location_;
     434                 :             :   // The package we are importing.
     435                 :             :   Package* package_;
     436                 :             :   // Whether to add new objects to the global scope, rather than to a
     437                 :             :   // package scope.
     438                 :             :   bool add_to_globals_;
     439                 :             :   // Mapping from package index to package.
     440                 :             :   std::vector<Package*> packages_;
     441                 :             :   // All type data.
     442                 :             :   std::string type_data_;
     443                 :             :   // Position of type data in the stream.
     444                 :             :   int type_pos_;
     445                 :             :   // Mapping from type code to offset/length in type_data_.
     446                 :             :   std::vector<std::pair<size_t, size_t> > type_offsets_;
     447                 :             :   // Mapping from negated builtin type codes to Type structures.
     448                 :             :   std::vector<Named_type*> builtin_types_;
     449                 :             :   // Mapping from exported type codes to Type structures.
     450                 :             :   std::vector<Type*> types_;
     451                 :             :   // Version of export data we're reading.
     452                 :             :   Export_data_version version_;
     453                 :             : };
     454                 :             : 
     455                 :             : // Read import data from a string.
     456                 :             : 
     457                 :             : class Stream_from_string : public Import::Stream
     458                 :             : {
     459                 :             :  public:
     460                 :           0 :   Stream_from_string(const std::string& str)
     461                 :           0 :     : str_(str), pos_(0)
     462                 :           0 :   { }
     463                 :             : 
     464                 :             :  protected:
     465                 :             :   bool
     466                 :           0 :   do_peek(size_t length, const char** bytes)
     467                 :             :   {
     468                 :           0 :     if (this->pos_ + length > this->str_.length())
     469                 :             :       return false;
     470                 :           0 :     *bytes = this->str_.data() + this->pos_;
     471                 :           0 :     return true;
     472                 :             :   }
     473                 :             : 
     474                 :             :   void
     475                 :           0 :   do_advance(size_t len)
     476                 :           0 :   { this->pos_ += len; }
     477                 :             : 
     478                 :             :  private:
     479                 :             :   // The string of data we are reading.
     480                 :             :   std::string str_;
     481                 :             :   // The current position within the string.
     482                 :             :   size_t pos_;
     483                 :             : };
     484                 :             : 
     485                 :             : // Read import data from a buffer allocated using malloc.
     486                 :             : 
     487                 :             : class Stream_from_buffer : public Import::Stream
     488                 :             : {
     489                 :             :  public:
     490                 :       21808 :   Stream_from_buffer(char* buf, size_t length)
     491                 :       21808 :     : buf_(buf), length_(length), pos_(0)
     492                 :             :   { }
     493                 :             : 
     494                 :       43616 :   ~Stream_from_buffer()
     495                 :       43616 :   { free(this->buf_); }
     496                 :             : 
     497                 :             :  protected:
     498                 :             :   bool
     499                 :   194013306 :   do_peek(size_t length, const char** bytes)
     500                 :             :   {
     501                 :   194013306 :     if (this->pos_ + length > this->length_)
     502                 :             :       return false;
     503                 :   193991498 :     *bytes = this->buf_ + this->pos_;
     504                 :   193991498 :     return true;
     505                 :             :   }
     506                 :             : 
     507                 :             :   void
     508                 :   129727760 :   do_advance(size_t len)
     509                 :   129727760 :   { this->pos_ += len; }
     510                 :             : 
     511                 :             :  private:
     512                 :             :   // The data we are reading.
     513                 :             :   char* buf_;
     514                 :             :   // The length of the buffer.
     515                 :             :   size_t length_;
     516                 :             :   // The current position within the buffer.
     517                 :             :   size_t pos_;
     518                 :             : };
     519                 :             : 
     520                 :             : // Read import data from an open file descriptor.
     521                 :             : 
     522                 :             : class Stream_from_file : public Import::Stream
     523                 :             : {
     524                 :             :  public:
     525                 :             :   Stream_from_file(int fd);
     526                 :             : 
     527                 :             :   ~Stream_from_file();
     528                 :             : 
     529                 :             :  protected:
     530                 :             :   bool
     531                 :             :   do_peek(size_t, const char**);
     532                 :             : 
     533                 :             :   void
     534                 :             :   do_advance(size_t);
     535                 :             : 
     536                 :             :  private:
     537                 :             :   // No copying.
     538                 :             :   Stream_from_file(const Stream_from_file&);
     539                 :             :   Stream_from_file& operator=(const Stream_from_file&);
     540                 :             : 
     541                 :             :   // The file descriptor.
     542                 :             :   int fd_;
     543                 :             :   // Data read from the file.
     544                 :             :   std::string data_;
     545                 :             : };
     546                 :             : 
     547                 :             : // Read import data from an offset into a std::string.  This uses a
     548                 :             : // reference to the string, to avoid copying, so the string must be
     549                 :             : // kept alive through some other mechanism.
     550                 :             : 
     551                 :             : class Stream_from_string_ref : public Import::Stream
     552                 :             : {
     553                 :             :  public:
     554                 :     1975892 :   Stream_from_string_ref(const std::string& str, size_t offset, size_t length)
     555                 :     1975892 :     : str_(str), pos_(offset), end_(offset + length)
     556                 :             :   { }
     557                 :             : 
     558                 :     1975892 :   ~Stream_from_string_ref()
     559                 :     1975892 :   {}
     560                 :             : 
     561                 :             :  protected:
     562                 :             :   bool
     563                 :   208592879 :   do_peek(size_t length, const char** bytes)
     564                 :             :   {
     565                 :   208592879 :     if (this->pos_ + length > this->end_)
     566                 :             :       return false;
     567                 :   207768302 :     *bytes = &this->str_[this->pos_];
     568                 :   207768302 :     return true;
     569                 :             :   }
     570                 :             : 
     571                 :             :   void
     572                 :   154124396 :   do_advance(size_t length)
     573                 :   154124396 :   { this->pos_ += length; }
     574                 :             : 
     575                 :             :  private:
     576                 :             :   // A reference to the string we are reading from.
     577                 :             :   const std::string& str_;
     578                 :             :   // The current offset into the string.
     579                 :             :   size_t pos_;
     580                 :             :   // The index after the last byte we can read.
     581                 :             :   size_t end_;
     582                 :             : };
     583                 :             : 
     584                 :             : // Class to manage importing a function body.  This is passed around
     585                 :             : // to Statements and Expressions.  It parses the function into the IR.
     586                 :             : 
     587                 :             : class Import_function_body : public Import_expression
     588                 :             : {
     589                 :             :  public:
     590                 :             :   Import_function_body(Gogo* gogo, Import* imp, Named_object* named_object,
     591                 :             :                        const std::string& body, size_t off, Block* block,
     592                 :             :                        int indent);
     593                 :             :   ~Import_function_body();
     594                 :             : 
     595                 :             :   // The IR.
     596                 :             :   Gogo*
     597                 :      198401 :   gogo()
     598                 :      102453 :   { return this->gogo_; }
     599                 :             : 
     600                 :             :   // The location to report in an error message.
     601                 :             :   Location
     602                 :       38869 :   location() const
     603                 :       38869 :   { return this->imp_->location(); }
     604                 :             : 
     605                 :             :   // The function we are importing.
     606                 :             :   Named_object*
     607                 :       28767 :   function() const
     608                 :       28767 :   { return this->named_object_; }
     609                 :             : 
     610                 :             :   // A reference to the body we are reading.
     611                 :             :   const std::string&
     612                 :       65491 :   body() const
     613                 :       65491 :   { return this->body_; }
     614                 :             : 
     615                 :             :   // The current offset into the body.
     616                 :             :   size_t
     617                 :      134817 :   off()
     618                 :      134817 :   { return this->off_; }
     619                 :             : 
     620                 :             :   // Update the offset into the body.
     621                 :             :   void
     622                 :      134817 :   set_off(size_t off)
     623                 :      134817 :   { this->off_ = off; }
     624                 :             : 
     625                 :             :   // Advance the offset by SKIP bytes.
     626                 :             :   void
     627                 :      296744 :   advance(size_t skip)
     628                 :      296744 :   { this->off_ += skip; }
     629                 :             : 
     630                 :             :   // The current block.
     631                 :             :   Block*
     632                 :       93158 :   block()
     633                 :       93158 :   { return this->blocks_.back(); }
     634                 :             : 
     635                 :             :   // Begin importing a new block BLOCK nested within the current block.
     636                 :             :   void
     637                 :       26622 :   begin_block(Block *block)
     638                 :       26622 :   { this->blocks_.push_back(block); }
     639                 :             : 
     640                 :             :   // Record the fact that we're done importing the current block.
     641                 :             :   void
     642                 :       26622 :   finish_block()
     643                 :       26622 :   { this->blocks_.pop_back(); }
     644                 :             : 
     645                 :             :   // The current indentation.
     646                 :             :   int
     647                 :       95948 :   indent() const
     648                 :       95948 :   { return this->indent_; }
     649                 :             : 
     650                 :             :   // Increment the indentation level.
     651                 :             :   void
     652                 :       26622 :   increment_indent()
     653                 :       26622 :   { ++this->indent_; }
     654                 :             : 
     655                 :             :   // Decrement the indentation level.
     656                 :             :   void
     657                 :       26622 :   decrement_indent()
     658                 :       26622 :   { --this->indent_; }
     659                 :             : 
     660                 :             :   // The name of the function we are parsing.
     661                 :             :   const std::string&
     662                 :             :   name() const;
     663                 :             : 
     664                 :             :   // Return the next character in the input stream, or -1 at the end.
     665                 :             :   int
     666                 :      152242 :   peek_char()
     667                 :             :   {
     668                 :      152242 :     if (this->body_.length() <= this->off_)
     669                 :             :       return -1;
     670                 :      152242 :     return static_cast<unsigned char>(this->body_[this->off_]);
     671                 :             :   }
     672                 :             : 
     673                 :             :   // Return the next character and advance.
     674                 :             :   int
     675                 :      151368 :   get_char()
     676                 :             :   {
     677                 :      151368 :     if (this->body_.length() <= this->off_)
     678                 :             :       return -1;
     679                 :      151368 :     int c = static_cast<unsigned char>(this->body_[this->off_]);
     680                 :      151368 :     this->off_++;
     681                 :      151368 :     return c;
     682                 :             :   }
     683                 :             : 
     684                 :             :   // Return whether the C string matches the current body position.
     685                 :             :   bool
     686                 :     1881747 :   match_c_string(const char* str)
     687                 :             :   {
     688                 :     1881747 :     size_t len = strlen(str);
     689                 :     1881747 :     return (this->body_.length() >= this->off_ + len
     690                 :     1881747 :             && this->body_.compare(this->off_, len, str) == 0);
     691                 :             :   }
     692                 :             : 
     693                 :             :   // Give an error if the next bytes do not match STR.  Advance the
     694                 :             :   // offset by the length of STR.
     695                 :             :   void
     696                 :             :   require_c_string(const char* str);
     697                 :             : 
     698                 :             :   // Read an identifier.
     699                 :             :   std::string
     700                 :             :   read_identifier();
     701                 :             : 
     702                 :             :   // Read a type.
     703                 :             :   Type*
     704                 :             :   read_type();
     705                 :             : 
     706                 :             :   Export_data_version
     707                 :      287492 :   version() const
     708                 :      287492 :   { return this->imp_->version(); }
     709                 :             : 
     710                 :             :   // Record the index of a temporary statement.
     711                 :             :   void
     712                 :             :   record_temporary(Temporary_statement*, unsigned int);
     713                 :             : 
     714                 :             :   // Return a temporary statement given an index.
     715                 :             :   Temporary_statement*
     716                 :             :   temporary_statement(unsigned int);
     717                 :             : 
     718                 :             :   // Return an unnamed label given an index, defining the label if we
     719                 :             :   // haven't seen it already.
     720                 :             :   Unnamed_label*
     721                 :             :   unnamed_label(unsigned int, Location);
     722                 :             : 
     723                 :             :   // Implement Import_expression.
     724                 :             :   Import_function_body*
     725                 :       76294 :   ifb()
     726                 :       76294 :   { return this; }
     727                 :             : 
     728                 :             :   // Return the maximum valid package index.
     729                 :             :   size_t
     730                 :        3874 :   max_package_index() const
     731                 :        3874 :   { return this->imp_->max_package_index(); }
     732                 :             : 
     733                 :             :   // Return the package at an index.
     734                 :             :   Package*
     735                 :        3874 :   package_at_index(int index)
     736                 :        3874 :   { return this->imp_->package_at_index(index); }
     737                 :             : 
     738                 :             :   // Return whether we have seen an error.
     739                 :             :   bool
     740                 :       76294 :   saw_error() const
     741                 :       76294 :   { return this->saw_error_; }
     742                 :             : 
     743                 :             :   // Record that we have seen an error.
     744                 :             :   void
     745                 :           0 :   set_saw_error()
     746                 :           0 :   { this->saw_error_ = true; }
     747                 :             : 
     748                 :             :  private:
     749                 :             :   static size_t
     750                 :             :   next_size(size_t);
     751                 :             : 
     752                 :             :   // The IR.
     753                 :             :   Gogo* gogo_;
     754                 :             :   // The importer.
     755                 :             :   Import* imp_;
     756                 :             :   // The function we are parsing.
     757                 :             :   Named_object* named_object_;
     758                 :             :   // The exported data we are parsing.  Note that this is a reference;
     759                 :             :   // the body string must laster longer than this object.
     760                 :             :   const std::string& body_;
     761                 :             :   // The current offset into body_.
     762                 :             :   size_t off_;
     763                 :             :   // Stack to record nesting of blocks being imported.
     764                 :             :   std::vector<Block *> blocks_;
     765                 :             :   // Current expected indentation level.
     766                 :             :   int indent_;
     767                 :             :   // Temporary statements by index.
     768                 :             :   std::vector<Temporary_statement*> temporaries_;
     769                 :             :   // Unnamed labels by index.
     770                 :             :   std::vector<Unnamed_label*> labels_;
     771                 :             :   // Whether we've seen an error.  Used to avoid reporting excess
     772                 :             :   // errors.
     773                 :             :   bool saw_error_;
     774                 :             : };
     775                 :             : 
     776                 :             : #endif // !defined(GO_IMPORT_H)
        

Generated by: LCOV version 2.0-1

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.