1 /* Marshalling and unmarshalling of C++-specific types. 2 Copyright (C) 2014-2022 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #ifndef CC1_PLUGIN_MARSHALL_CXX_HH 21 #define CC1_PLUGIN_MARSHALL_CXX_HH 22 23 #include "marshall.hh" 24 #include "gcc-cp-interface.h" 25 #include "deleter.hh" 26 27 namespace cc1_plugin 28 { 29 template<> 30 struct deleter<gcc_vbase_array> 31 { operator ()cc1_plugin::deleter32 void operator() (gcc_vbase_array *p) 33 { 34 delete[] p->flags; 35 delete[] p->elements; 36 delete p; 37 } 38 }; 39 40 template<> 41 struct deleter<gcc_cp_template_args> 42 { operator ()cc1_plugin::deleter43 void operator() (gcc_cp_template_args *p) 44 { 45 delete[] p->elements; 46 delete[] p->kinds; 47 delete p; 48 } 49 }; 50 51 template<> 52 struct deleter<gcc_cp_function_args> 53 { operator ()cc1_plugin::deleter54 void operator() (gcc_cp_function_args *p) 55 { 56 delete[] p->elements; 57 delete p; 58 } 59 }; 60 61 // Send a gcc_vbase_array marker followed by the array. 62 status marshall(connection * conn,const gcc_vbase_array * a)63 marshall (connection *conn, const gcc_vbase_array *a) 64 { 65 size_t len; 66 67 if (a) 68 len = a->n_elements; 69 else 70 len = (size_t)-1; 71 72 if (!marshall_array_start (conn, 'v', len)) 73 return FAIL; 74 75 if (!a) 76 return OK; 77 78 if (!marshall_array_elmts (conn, len * sizeof (a->elements[0]), 79 a->elements)) 80 return FAIL; 81 82 return marshall_array_elmts (conn, len * sizeof (a->flags[0]), 83 a->flags); 84 } 85 86 // Read a gcc_vbase_array marker, followed by a gcc_vbase_array. The 87 // resulting array must be freed by the caller, using 'delete[]' on 88 // elements and virtualp, and 'delete' on the array object itself. 89 status unmarshall(connection * conn,struct gcc_vbase_array ** result)90 unmarshall (connection *conn, struct gcc_vbase_array **result) 91 { 92 size_t len; 93 94 if (!unmarshall_array_start (conn, 'v', &len)) 95 return FAIL; 96 97 if (len == (size_t)-1) 98 { 99 *result = NULL; 100 return OK; 101 } 102 103 cc1_plugin::unique_ptr<gcc_vbase_array> gva (new gcc_vbase_array {}); 104 105 gva->n_elements = len; 106 gva->elements = new gcc_type[len]; 107 108 if (!unmarshall_array_elmts (conn, 109 len * sizeof (gva->elements[0]), 110 gva->elements)) 111 return FAIL; 112 113 gva->flags = new enum gcc_cp_symbol_kind[len]; 114 115 if (!unmarshall_array_elmts (conn, 116 len * sizeof (gva->flags[0]), 117 gva->flags)) 118 return FAIL; 119 120 *result = gva.release (); 121 return OK; 122 } 123 124 // Send a gcc_cp_template_args marker followed by the array. 125 status marshall(connection * conn,const gcc_cp_template_args * a)126 marshall (connection *conn, const gcc_cp_template_args *a) 127 { 128 size_t len; 129 130 if (a) 131 len = a->n_elements; 132 else 133 len = (size_t)-1; 134 135 if (!marshall_array_start (conn, 't', len)) 136 return FAIL; 137 138 if (!a) 139 return OK; 140 141 if (!marshall_array_elmts (conn, len * sizeof (a->kinds[0]), 142 a->kinds)) 143 return FAIL; 144 145 return marshall_array_elmts (conn, len * sizeof (a->elements[0]), 146 a->elements); 147 } 148 149 // Read a gcc_vbase_array marker, followed by a gcc_vbase_array. The 150 // resulting array must be freed by the caller, using 'delete[]' on 151 // elements and virtualp, and 'delete' on the array object itself. 152 status unmarshall(connection * conn,struct gcc_cp_template_args ** result)153 unmarshall (connection *conn, struct gcc_cp_template_args **result) 154 { 155 size_t len; 156 157 if (!unmarshall_array_start (conn, 't', &len)) 158 return FAIL; 159 160 if (len == (size_t)-1) 161 { 162 *result = NULL; 163 return OK; 164 } 165 166 cc1_plugin::unique_ptr<gcc_cp_template_args> gva 167 (new gcc_cp_template_args {}); 168 169 gva->n_elements = len; 170 gva->kinds = new char[len]; 171 172 if (!unmarshall_array_elmts (conn, 173 len * sizeof (gva->kinds[0]), 174 gva->kinds)) 175 return FAIL; 176 177 gva->elements = new gcc_cp_template_arg[len]; 178 179 if (!unmarshall_array_elmts (conn, 180 len * sizeof (gva->elements[0]), 181 gva->elements)) 182 return FAIL; 183 184 *result = gva.release (); 185 return OK; 186 } 187 188 // Send a gcc_cp_function_args marker followed by the array. 189 status marshall(connection * conn,const gcc_cp_function_args * a)190 marshall (connection *conn, const gcc_cp_function_args *a) 191 { 192 size_t len; 193 194 if (a) 195 len = a->n_elements; 196 else 197 len = (size_t)-1; 198 199 if (!marshall_array_start (conn, 'd', len)) 200 return FAIL; 201 202 if (!a) 203 return OK; 204 205 return marshall_array_elmts (conn, len * sizeof (a->elements[0]), 206 a->elements); 207 } 208 209 // Read a gcc_cp_function_args marker, followed by a 210 // gcc_cp_function_args. The resulting array must be freed 211 // by the caller, using 'delete[]' on elements and virtualp, and 212 // 'delete' on the array object itself. 213 status unmarshall(connection * conn,struct gcc_cp_function_args ** result)214 unmarshall (connection *conn, struct gcc_cp_function_args **result) 215 { 216 size_t len; 217 218 if (!unmarshall_array_start (conn, 'd', &len)) 219 return FAIL; 220 221 if (len == (size_t)-1) 222 { 223 *result = NULL; 224 return OK; 225 } 226 227 cc1_plugin::unique_ptr<gcc_cp_function_args> gva 228 (new gcc_cp_function_args {}); 229 230 gva->n_elements = len; 231 gva->elements = new gcc_expr[len]; 232 233 if (!unmarshall_array_elmts (conn, 234 len * sizeof (gva->elements[0]), 235 gva->elements)) 236 return FAIL; 237 238 *result = gva.release (); 239 240 return OK; 241 } 242 } 243 244 #endif // CC1_PLUGIN_MARSHALL_CP_HH 245