gcc/data-streamer.cc

   1 /* Generic streaming support for basic data types.
   2
   3    Copyright (C) 2011-2025 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 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "backend.h"
  26 #include "tree.h"
  27 #include "gimple.h"
  28 #include "cgraph.h"
  29 #include "data-streamer.h"
  30
  31 /* For offloading -- While streaming-out, host NUM_POLY_INT_COEFFS is
  32    stored at beginning of mode_table.  While streaming-in, the value is read
  33    in host_num_poly_int_coeffs.  */
  34
  35 #ifdef ACCEL_COMPILER
  36 unsigned host_num_poly_int_coeffs = 0;
  37 #endif
  38
  39 /* Pack WORK into BP in a variant of uleb format.  */
  40
  41 void
  42 bp_pack_var_len_unsigned (struct bitpack_d *bp, unsigned HOST_WIDE_INT work)
  43 {
  44   do
  45     {
  46       unsigned int half_byte = (work & 0x7);
  47       work >>= 3;
  48       if (work != 0)
  49         /* More half_bytes to follow.  */
  50         half_byte |= 0x8;
  51
  52       bp_pack_value (bp, half_byte, 4);
  53     }
  54   while (work != 0);
  55 }
  56
  57
  58 /* Pack WORK into BP in a variant of sleb format.  */
  59
  60 void
  61 bp_pack_var_len_int (struct bitpack_d *bp, HOST_WIDE_INT work)
  62 {
  63   int more, half_byte;
  64
  65   do
  66     {
  67       half_byte = (work & 0x7);
  68       /* arithmetic shift */
  69       work >>= 3;
  70       more = !((work == 0 && (half_byte & 0x4) == 0)
  71                || (work == -1 && (half_byte & 0x4) != 0));
  72       if (more)
  73         half_byte |= 0x8;
  74
  75       bp_pack_value (bp, half_byte, 4);
  76     }
  77   while (more);
  78 }
  79
  80
  81 /* Unpack VAL from BP in a variant of uleb format.  */
  82
  83 unsigned HOST_WIDE_INT
  84 bp_unpack_var_len_unsigned (struct bitpack_d *bp)
  85 {
  86   unsigned HOST_WIDE_INT result = 0;
  87   int shift = 0;
  88   unsigned HOST_WIDE_INT half_byte;
  89
  90   while (true)
  91     {
  92       half_byte = bp_unpack_value (bp, 4);
  93       result |= (half_byte & 0x7) << shift;
  94       shift += 3;
  95       if ((half_byte & 0x8) == 0)
  96         return result;
  97     }
  98 }
  99
 100
 101 /* Unpack VAL from BP in a variant of sleb format.  */
 102
 103 HOST_WIDE_INT
 104 bp_unpack_var_len_int (struct bitpack_d *bp)
 105 {
 106   HOST_WIDE_INT result = 0;
 107   int shift = 0;
 108   unsigned HOST_WIDE_INT half_byte;
 109
 110   while (true)
 111     {
 112       half_byte = bp_unpack_value (bp, 4);
 113       result |= (half_byte & 0x7) << shift;
 114       shift += 3;
 115       if ((half_byte & 0x8) == 0)
 116         {
 117           if ((shift < HOST_BITS_PER_WIDE_INT) && (half_byte & 0x4))
 118             result |= - (HOST_WIDE_INT_1U << shift);
 119
 120           return result;
 121         }
 122     }
 123 }
 124
 125 /* Pack REAL_VALUE_TYPE R into BP.  */
 126
 127 void
 128 bp_pack_real_value (struct bitpack_d *bp, const REAL_VALUE_TYPE *r)
 129 {
 130   bp_pack_value (bp, r->cl, 2);
 131   bp_pack_value (bp, r->decimal, 1);
 132   bp_pack_value (bp, r->sign, 1);
 133   bp_pack_value (bp, r->signalling, 1);
 134   bp_pack_value (bp, r->canonical, 1);
 135   bp_pack_value (bp, r->uexp, EXP_BITS);
 136   for (unsigned i = 0; i < SIGSZ; i++)
 137     bp_pack_value (bp, r->sig[i], HOST_BITS_PER_LONG);
 138 }
 139
 140 /* Unpack REAL_VALUE_TYPE R from BP.  */
 141
 142 void
 143 bp_unpack_real_value (struct bitpack_d *bp, REAL_VALUE_TYPE *r)
 144 {
 145   /* Clear all bits of the real value type so that we can later do
 146      bitwise comparisons to see if two values are the same.  */
 147   memset (r, 0, sizeof (*r));
 148   r->cl = (unsigned) bp_unpack_value (bp, 2);
 149   r->decimal = (unsigned) bp_unpack_value (bp, 1);
 150   r->sign = (unsigned) bp_unpack_value (bp, 1);
 151   r->signalling = (unsigned) bp_unpack_value (bp, 1);
 152   r->canonical = (unsigned) bp_unpack_value (bp, 1);
 153   r->uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
 154   for (unsigned i = 0; i < SIGSZ; i++)
 155     r->sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
 156 }