Mangle.cpp | Explore in Territory

//===--- Mangle.cpp - Mangle C++ Names --------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Implements generic name mangling support for blocks and Objective-C.
//
//===----------------------------------------------------------------------===//
#include "clang/AST/Attr.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/Mangle.h"
#include "clang/AST/VTableBuilder.h"
#include "clang/Basic/ABI.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TargetInfo.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Mangler.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"

usingnamespaceclang;

// FIXME: For blocks we currently mimic GCC's mangling scheme, which leaves
// much to be desired. Come up with a better mangling scheme.

static void mangleFunctionBlock(MangleContext &Context,
                                StringRef Outer,
                                const BlockDecl *BD,
                                raw_ostream &Out) { … }

void MangleContext::anchor() { … }

enum CCMangling { … };

static bool isExternC(const NamedDecl *ND) { … }

static CCMangling getCallingConvMangling(const ASTContext &Context,
                                         const NamedDecl *ND) { … }

bool MangleContext::shouldMangleDeclName(const NamedDecl *D) { … }

void MangleContext::mangleName(GlobalDecl GD, raw_ostream &Out) { … }

void MangleContext::mangleMSGuidDecl(const MSGuidDecl *GD, raw_ostream &Out) { … }

void MangleContext::mangleGlobalBlock(const BlockDecl *BD,
                                      const NamedDecl *ID,
                                      raw_ostream &Out) { … }

void MangleContext::mangleCtorBlock(const CXXConstructorDecl *CD,
                                    CXXCtorType CT, const BlockDecl *BD,
                                    raw_ostream &ResStream) { … }

void MangleContext::mangleDtorBlock(const CXXDestructorDecl *DD,
                                    CXXDtorType DT, const BlockDecl *BD,
                                    raw_ostream &ResStream) { … }

void MangleContext::mangleBlock(const DeclContext *DC, const BlockDecl *BD,
                                raw_ostream &Out) { … }

void MangleContext::mangleObjCMethodName(const ObjCMethodDecl *MD,
                                         raw_ostream &OS,
                                         bool includePrefixByte,
                                         bool includeCategoryNamespace) { … }

void MangleContext::mangleObjCMethodNameAsSourceName(const ObjCMethodDecl *MD,
                                                     raw_ostream &Out) { … }

class ASTNameGenerator::Implementation { … };

ASTNameGenerator::ASTNameGenerator(ASTContext &Ctx)
    : … { … }

ASTNameGenerator::~ASTNameGenerator() { … }

bool ASTNameGenerator::writeName(const Decl *D, raw_ostream &OS) { … }

std::string ASTNameGenerator::getName(const Decl *D) { … }

std::vector<std::string> ASTNameGenerator::getAllManglings(const Decl *D) { … }
llvm/clang/lib/AST/Mangle.cpp
