gcc/data-streamer.cc

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