Line data Source code
1 : // Copyright (C) 2020-2026 Free Software Foundation, Inc.
2 :
3 : // This file is part of GCC.
4 :
5 : // GCC is free software; you can redistribute it and/or modify it under
6 : // the terms of the GNU General Public License as published by the Free
7 : // Software Foundation; either version 3, or (at your option) any later
8 : // version.
9 :
10 : // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11 : // WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 : // for more details.
14 :
15 : // You should have received a copy of the GNU General Public License
16 : // along with GCC; see the file COPYING3. If not see
17 : // <http://www.gnu.org/licenses/>.
18 :
19 : #include "rust-mangle.h"
20 : #include "optional.h"
21 : #include "rust-base62.h"
22 : #include "rust-diagnostics.h"
23 : #include "rust-system.h"
24 : #include "rust-tyty.h"
25 : #include "rust-unicode.h"
26 : #include "rust-punycode.h"
27 : #include "rust-compile-type.h"
28 :
29 : namespace Rust {
30 : namespace Compile {
31 :
32 : struct V0Path
33 : {
34 : std::string prefix = "";
35 : // Used for "N"
36 : std::string ns = "";
37 : std::string path = "";
38 : // Used for "N" and "C"
39 : std::string ident = "";
40 : std::string disambiguator = "";
41 : // Used for "M" and "X"
42 : std::string impl_path = "";
43 : std::string impl_type = "";
44 : std::string trait_type = "";
45 : // Used for generic types
46 : std::string generic_postfix = "";
47 : std::string generic_prefix = "";
48 :
49 57 : std::string as_string () const
50 : {
51 57 : if (prefix == "N")
52 64 : return generic_prefix + prefix + ns + path + disambiguator + ident
53 64 : + generic_postfix;
54 25 : else if (prefix == "M")
55 0 : return prefix + impl_path + impl_type;
56 25 : else if (prefix == "X")
57 0 : return prefix + impl_type + trait_type;
58 25 : else if (prefix == "C")
59 25 : return prefix + disambiguator + ident;
60 : else
61 0 : rust_unreachable ();
62 : }
63 : };
64 :
65 : static std::string v0_path (Rust::Compile::Context *ctx,
66 : const TyTy::BaseType *ty,
67 : const Resolver::CanonicalPath &path);
68 :
69 : static std::string
70 0 : v0_tuple_prefix (const TyTy::BaseType *ty)
71 : {
72 0 : if (ty->is_unit ())
73 0 : return "u";
74 :
75 : // FIXME: ARTHUR: Add rest of algorithm
76 0 : return "";
77 : }
78 :
79 : static std::string
80 8 : v0_numeric_prefix (const TyTy::BaseType *ty)
81 : {
82 8 : static const std::map<std::string, std::string> num_prefixes = {
83 : {"i8", "a"}, {"u8", "h"}, {"i16", "s"}, {"u16", "t"},
84 : {"i32", "l"}, {"u32", "m"}, {"i64", "x"}, {"u64", "y"},
85 : {"isize", "i"}, {"usize", "j"}, {"f32", "f"}, {"f64", "d"},
86 21 : };
87 :
88 8 : auto ty_kind = ty->get_kind ();
89 8 : auto ty_str = ty->as_string ();
90 8 : auto numeric_iter = num_prefixes.end ();
91 :
92 : // Special numeric types
93 8 : if (ty_kind == TyTy::TypeKind::ISIZE)
94 0 : return "i";
95 8 : else if (ty_kind == TyTy::TypeKind::USIZE)
96 2 : return "j";
97 :
98 6 : numeric_iter = num_prefixes.find (ty_str);
99 6 : if (numeric_iter != num_prefixes.end ())
100 6 : return numeric_iter->second;
101 :
102 0 : rust_unreachable ();
103 8 : }
104 :
105 : static std::string
106 10 : v0_simple_type_prefix (const TyTy::BaseType *ty)
107 : {
108 10 : switch (ty->get_kind ())
109 : {
110 0 : case TyTy::TypeKind::BOOL:
111 0 : return "b";
112 0 : case TyTy::TypeKind::CHAR:
113 0 : return "c";
114 0 : case TyTy::TypeKind::STR:
115 0 : return "e";
116 0 : case TyTy::TypeKind::NEVER:
117 0 : return "z";
118 :
119 : // Placeholder types
120 0 : case TyTy::TypeKind::ERROR: // Fallthrough
121 0 : case TyTy::TypeKind::INFER: // Fallthrough
122 0 : case TyTy::TypeKind::PLACEHOLDER: // Fallthrough
123 0 : case TyTy::TypeKind::PARAM:
124 : // FIXME: TyTy::TypeKind::BOUND is also a valid variant in rustc
125 0 : return "p";
126 :
127 0 : case TyTy::TypeKind::TUPLE:
128 0 : return v0_tuple_prefix (ty);
129 :
130 8 : case TyTy::TypeKind::UINT: // Fallthrough
131 8 : case TyTy::TypeKind::INT: // Fallthrough
132 8 : case TyTy::TypeKind::FLOAT: // Fallthrough
133 8 : case TyTy::TypeKind::ISIZE: // Fallthrough
134 8 : case TyTy::TypeKind::USIZE:
135 8 : return v0_numeric_prefix (ty);
136 :
137 2 : default:
138 2 : return "";
139 : }
140 :
141 : rust_unreachable ();
142 : }
143 :
144 : static std::string
145 2 : v0_complex_type_prefix (Context *ctx, const TyTy::BaseType *ty)
146 : {
147 : // FIXME: ref, slice, dyn, etc.
148 : // TODO: generics
149 2 : switch (ty->get_kind ())
150 : {
151 2 : case TyTy::TypeKind::ADT:
152 2 : {
153 2 : const TyTy::ADTType *adt = static_cast<const TyTy::ADTType *> (ty);
154 2 : return v0_path (ctx, ty, adt->get_ident ().path);
155 : }
156 0 : break;
157 0 : default:
158 0 : return "";
159 : }
160 : }
161 :
162 : // Returns an underscore-terminated base62 integer.
163 : // This corresponds to the `<base-62-number>` grammar in the v0 mangling RFC:
164 : // - 0 is encoded as "_"
165 : // - any other value is encoded as itself minus one in base 62, followed by
166 : // "_"
167 : static std::string
168 1 : v0_integer_62 (uint64_t x)
169 : {
170 1 : std::stringstream s;
171 1 : if (x > 0)
172 2 : s << base62_integer (x - 1);
173 :
174 1 : s << "_";
175 1 : return s.str ();
176 1 : }
177 :
178 : // Returns a tag-prefixed base62 integer when the
179 : // integer is greater than 0:
180 : // - 0 is encoded as "" (nothing)
181 : // - any other value is encoded as <tag> + v0_integer_62(itself), that is
182 : // <tag> + base62(itself - 1) + '_'
183 : static std::string
184 26 : v0_opt_integer_62 (std::string tag, uint64_t x)
185 : {
186 26 : if (x > 0)
187 : {
188 1 : return tag + v0_integer_62 (x);
189 : }
190 25 : return "";
191 : }
192 :
193 : static std::string
194 26 : v0_disambiguator (uint64_t dis)
195 : {
196 26 : return v0_opt_integer_62 ("s", dis);
197 : }
198 :
199 : static std::string
200 10 : v0_type_prefix (Context *ctx, const TyTy::BaseType *ty)
201 : {
202 10 : std::string ty_prefix;
203 :
204 10 : ty_prefix = v0_simple_type_prefix (ty);
205 10 : if (!ty_prefix.empty ())
206 : return ty_prefix;
207 :
208 2 : ty_prefix = v0_complex_type_prefix (ctx, ty);
209 2 : if (!ty_prefix.empty ())
210 : return ty_prefix;
211 :
212 0 : rust_unreachable ();
213 : }
214 :
215 : static std::string
216 6 : v0_generic_args (Context *ctx, const TyTy::BaseType *ty)
217 : {
218 6 : std::stringstream ss;
219 6 : const TyTy::FnType *fnty = static_cast<const TyTy::FnType *> (ty);
220 6 : TyTy::SubstitutionArgumentMappings &subst_ref
221 6 : = const_cast<TyTy::FnType *> (fnty)->get_substitution_arguments ();
222 16 : for (TyTy::SubstitutionArg &map : subst_ref.get_mappings ())
223 : {
224 20 : ss << v0_type_prefix (ctx, map.get_tyty ());
225 : }
226 6 : return ss.str ();
227 6 : }
228 :
229 : // Returns an mangled identifier. This corresponds to the
230 : // `<identifier>` grammar in the v0 mangling RFC.
231 : static std::string
232 56 : v0_identifier (const std::string &identifier)
233 : {
234 56 : std::stringstream mangled;
235 : // The grammar for unicode identifier is contained in
236 : // <undisambiguated-identifier>, right under the <identifier> one. If the
237 : // identifier contains unicode values, then an extra "u" needs to be added to
238 : // the mangling string and `punycode` must be used to encode the characters.
239 :
240 56 : if (!is_ascii_only (identifier))
241 6 : mangled << "u";
242 :
243 56 : tl::optional<Utf8String> uident_opt
244 56 : = Utf8String::make_utf8_string (identifier);
245 56 : rust_assert (uident_opt.has_value ());
246 56 : tl::optional<std::string> punycode_opt
247 56 : = encode_punycode (uident_opt.value ());
248 56 : rust_assert (punycode_opt.has_value ());
249 :
250 56 : std::string punycode = punycode_opt.value ();
251 :
252 : // remove a tailing hyphen
253 56 : if (punycode.back () == '-')
254 50 : punycode.pop_back ();
255 :
256 : // replace a hyphen in punycode with a underscore
257 56 : std::replace (punycode.begin (), punycode.end (), '-', '_');
258 :
259 112 : mangled << std::to_string (punycode.size ());
260 :
261 : // Add extra '_'
262 56 : if (punycode[0] == '_' || ('0' <= punycode[0] && punycode[0] <= '9'))
263 6 : mangled << "_";
264 :
265 56 : mangled << punycode;
266 56 : return mangled.str ();
267 168 : }
268 :
269 : static V0Path
270 2 : v0_type_path (V0Path path, std::string ident)
271 : {
272 2 : V0Path v0path;
273 2 : v0path.prefix = "N";
274 2 : v0path.ns = "t";
275 2 : v0path.path = path.as_string ();
276 2 : v0path.ident = ident;
277 : // TODO: Need <generic-arg>?
278 2 : return v0path;
279 : }
280 :
281 : static V0Path
282 23 : v0_function_path (
283 : V0Path path, Rust::Compile::Context *ctx, const TyTy::BaseType *ty,
284 : const std::vector<std::unique_ptr<HIR::GenericParam>> &generic_params,
285 : std::string ident)
286 : {
287 23 : V0Path v0path;
288 23 : v0path.prefix = "N";
289 23 : v0path.ns = "v";
290 23 : v0path.path = path.as_string ();
291 23 : v0path.ident = ident;
292 23 : if (!generic_params.empty ())
293 : {
294 6 : v0path.generic_prefix = "I";
295 12 : v0path.generic_postfix = v0_generic_args (ctx, ty) + "E";
296 : }
297 23 : return v0path;
298 : }
299 :
300 : static V0Path
301 6 : v0_scope_path (V0Path path, std::string ident, std::string ns)
302 : {
303 6 : V0Path v0path;
304 6 : v0path.prefix = "N";
305 6 : v0path.ns = ns;
306 6 : v0path.path = path.as_string ();
307 6 : v0path.ident = ident;
308 6 : return v0path;
309 : }
310 :
311 : static V0Path
312 25 : v0_crate_path (CrateNum crate_num, std::string ident)
313 : {
314 25 : V0Path v0path;
315 25 : v0path.prefix = "C";
316 25 : v0path.disambiguator = v0_disambiguator (crate_num);
317 25 : v0path.ident = ident;
318 25 : return v0path;
319 : }
320 :
321 : static V0Path
322 0 : v0_inherent_or_trait_impl_path (Rust::Compile::Context *ctx,
323 : HIR::ImplBlock *impl_block)
324 : {
325 0 : V0Path v0path;
326 0 : bool ok;
327 :
328 : // lookup impl type
329 0 : TyTy::BaseType *impl_ty = nullptr;
330 0 : ok = ctx->get_tyctx ()->lookup_type (
331 0 : impl_block->get_type ().get_mappings ().get_hirid (), &impl_ty);
332 0 : rust_assert (ok);
333 :
334 : // FIXME: dummy value for now
335 0 : v0path.impl_path = "C5crate";
336 0 : v0path.impl_type = v0_type_prefix (ctx, impl_ty);
337 :
338 0 : if (impl_block->has_trait_ref ())
339 : {
340 : // trait impl: X <impl-path> <type> <path>
341 0 : v0path.prefix = "X";
342 :
343 0 : TyTy::BaseType *trait_ty = nullptr;
344 0 : ok = ctx->get_tyctx ()->lookup_type (
345 0 : impl_block->get_trait_ref ().get_mappings ().get_hirid (), &trait_ty);
346 0 : rust_assert (ok);
347 :
348 0 : v0path.trait_type = v0_type_prefix (ctx, trait_ty);
349 : }
350 : else
351 : // inherent impl: M <impl-path> <type>
352 0 : v0path.prefix = "M";
353 :
354 0 : return v0path;
355 : }
356 :
357 : static V0Path
358 1 : v0_closure (V0Path path, HirId closure)
359 : {
360 1 : V0Path v0path;
361 1 : v0path.prefix = "N";
362 1 : v0path.ns = "C";
363 1 : v0path.disambiguator = v0_disambiguator (closure);
364 1 : v0path.path = path.as_string ();
365 1 : v0path.ident = "0";
366 1 : return v0path;
367 : }
368 :
369 : static std::string
370 25 : v0_path (Rust::Compile::Context *ctx, const TyTy::BaseType *ty,
371 : const Resolver::CanonicalPath &cpath)
372 : {
373 25 : auto &mappings = Analysis::Mappings::get ();
374 :
375 25 : V0Path v0path = {};
376 :
377 25 : cpath.iterate_segs ([&] (const Resolver::CanonicalPath &seg) {
378 57 : tl::optional<HirId> hid = mappings.lookup_node_to_hir (seg.get_node_id ());
379 57 : if (!hid.has_value ())
380 : {
381 : // FIXME: generic arg in canonical path? (e.g. <i32> in crate::S<i32>)
382 0 : rust_unreachable ();
383 : }
384 :
385 57 : auto hir_id = hid.value ();
386 :
387 57 : if (auto impl_item = mappings.lookup_hir_implitem (hir_id))
388 : {
389 0 : switch (impl_item->first->get_impl_item_type ())
390 : {
391 0 : case HIR::ImplItem::FUNCTION:
392 0 : {
393 0 : HIR::Function *fn
394 0 : = static_cast<HIR::Function *> (impl_item->first);
395 0 : v0path
396 0 : = v0_function_path (v0path, ctx, ty, fn->get_generic_params (),
397 0 : v0_identifier (seg.get ()));
398 : }
399 0 : break;
400 0 : case HIR::ImplItem::CONSTANT:
401 0 : v0path = v0_scope_path (v0path, v0_identifier (seg.get ()), "v");
402 0 : break;
403 0 : default:
404 0 : rust_internal_error_at (UNDEF_LOCATION, "Attempt to mangle '%s'",
405 0 : cpath.get ().c_str ());
406 : break;
407 : }
408 : }
409 57 : else if (auto trait_item = mappings.lookup_hir_trait_item (hir_id))
410 : {
411 0 : switch (trait_item.value ()->get_item_kind ())
412 : {
413 0 : case HIR::TraitItem::FUNC:
414 0 : {
415 0 : auto fn = static_cast<HIR::TraitItemFunc *> (*trait_item);
416 0 : rust_unreachable ();
417 : v0path = v0_function_path (v0path, ctx, ty,
418 : fn->get_decl ().get_generic_params (),
419 : v0_identifier (seg.get ()));
420 : }
421 : break;
422 0 : case HIR::TraitItem::CONST:
423 0 : v0path = v0_scope_path (v0path, v0_identifier (seg.get ()), "v");
424 0 : break;
425 0 : default:
426 0 : rust_internal_error_at (UNDEF_LOCATION, "Attempt to mangle '%s'",
427 0 : cpath.get ().c_str ());
428 0 : break;
429 : }
430 : }
431 57 : else if (auto item = mappings.lookup_hir_item (hir_id))
432 31 : switch (item.value ()->get_item_kind ())
433 : {
434 23 : case HIR::Item::ItemKind::Function:
435 23 : {
436 23 : HIR::Function *fn = static_cast<HIR::Function *> (*item);
437 23 : v0path
438 46 : = v0_function_path (v0path, ctx, ty, fn->get_generic_params (),
439 69 : v0_identifier (seg.get ()));
440 : }
441 23 : break;
442 6 : case HIR::Item::ItemKind::Module:
443 6 : v0path = v0_scope_path (v0path, v0_identifier (seg.get ()), "t");
444 6 : break;
445 0 : case HIR::Item::ItemKind::Trait: // FIXME: correct?
446 0 : case HIR::Item::ItemKind::Static:
447 0 : case HIR::Item::ItemKind::Constant:
448 0 : v0path = v0_scope_path (v0path, v0_identifier (seg.get ()), "v");
449 0 : break;
450 2 : case HIR::Item::ItemKind::Struct:
451 2 : case HIR::Item::ItemKind::Enum:
452 2 : case HIR::Item::ItemKind::Union:
453 2 : v0path = v0_type_path (v0path, v0_identifier (seg.get ()));
454 2 : break;
455 0 : case HIR::Item::ItemKind::Impl:
456 : // Trait impl or inherent impl.
457 0 : {
458 0 : HIR::ImplBlock *impl_block = static_cast<HIR::ImplBlock *> (*item);
459 0 : v0path = v0_inherent_or_trait_impl_path (ctx, impl_block);
460 : }
461 0 : break;
462 0 : case HIR::Item::ItemKind::ExternBlock:
463 0 : case HIR::Item::ItemKind::ExternCrate:
464 0 : case HIR::Item::ItemKind::UseDeclaration:
465 0 : case HIR::Item::ItemKind::TypeAlias:
466 0 : case HIR::Item::ItemKind::EnumItem: // FIXME: correct?
467 0 : rust_internal_error_at (UNDEF_LOCATION, "Attempt to mangle '%s'",
468 0 : cpath.get ().c_str ());
469 : break;
470 : }
471 26 : else if (auto expr = mappings.lookup_hir_expr (hir_id))
472 : {
473 1 : rust_assert (expr.value ()->get_expression_type ()
474 : == HIR::Expr::ExprType::Closure);
475 : // Use HIR ID as disambiguator.
476 1 : v0path = v0_closure (v0path, hir_id);
477 : }
478 : else
479 : // Not HIR item, impl item, trait impl item, nor expr. Assume a crate.
480 25 : v0path
481 25 : = v0_crate_path (cpath.get_crate_num (), v0_identifier (seg.get ()));
482 :
483 57 : return true;
484 : });
485 :
486 25 : return v0path.as_string ();
487 25 : }
488 :
489 : std::string
490 23 : v0_mangle_item (Rust::Compile::Context *ctx, const TyTy::BaseType *ty,
491 : const Resolver::CanonicalPath &path)
492 : {
493 23 : rust_debug ("Start mangling: %s", path.get ().c_str ());
494 :
495 : // TODO: get Instanciating CrateNum
496 : // auto &mappings = Analysis::Mappings::get ();
497 : // std::string crate_name;
498 : // bool ok = mappings->get_crate_name (path.get_crate_num (), crate_name);
499 : // rust_assert (ok);
500 :
501 23 : std::stringstream mangled;
502 23 : mangled << "_R";
503 46 : mangled << v0_path (ctx, ty, path);
504 :
505 23 : rust_debug ("=> %s", mangled.str ().c_str ());
506 :
507 23 : return mangled.str ();
508 23 : }
509 :
510 : } // namespace Compile
511 : } // namespace Rust
|
