/*
|
* Copyright (C) 2016 The Android Open Source Project
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#include "DeclarationDatabase.h"
|
|
#include <err.h>
|
|
#include <iostream>
|
#include <map>
|
#include <mutex>
|
#include <set>
|
#include <sstream>
|
#include <string>
|
#include <utility>
|
|
#include <clang/AST/AST.h>
|
#include <clang/AST/Attr.h>
|
#include <clang/AST/Mangle.h>
|
#include <clang/AST/RecursiveASTVisitor.h>
|
#include <clang/Frontend/ASTUnit.h>
|
#include <llvm/Support/raw_ostream.h>
|
|
using namespace clang;
|
|
static bool shouldMangle(MangleContext* mangler, NamedDecl* decl) {
|
// Passing a decl with static linkage to the mangler gives incorrect results.
|
// Check some things ourselves before handing it off to the mangler.
|
if (auto FD = dyn_cast<FunctionDecl>(decl)) {
|
if (FD->isExternC()) {
|
return false;
|
}
|
|
if (FD->isInExternCContext()) {
|
return false;
|
}
|
}
|
|
return mangler->shouldMangleDeclName(decl);
|
}
|
|
class Visitor : public RecursiveASTVisitor<Visitor> {
|
HeaderDatabase& database;
|
CompilationType type;
|
SourceManager& src_manager;
|
std::unique_ptr<MangleContext> mangler;
|
|
public:
|
Visitor(HeaderDatabase& database, CompilationType type, ASTContext& ctx)
|
: database(database), type(type), src_manager(ctx.getSourceManager()) {
|
mangler.reset(ItaniumMangleContext::create(ctx, ctx.getDiagnostics()));
|
}
|
|
std::string getDeclName(NamedDecl* decl) {
|
if (auto var_decl = dyn_cast<VarDecl>(decl)) {
|
if (!var_decl->isFileVarDecl()) {
|
return "<local var>";
|
}
|
}
|
|
// <math.h> maps fool onto foo on 32-bit, since long double is the same as double.
|
if (auto asm_attr = decl->getAttr<AsmLabelAttr>()) {
|
return asm_attr->getLabel();
|
}
|
|
// The decl might not have a name (e.g. bitfields).
|
if (auto identifier = decl->getIdentifier()) {
|
if (shouldMangle(mangler.get(), decl)) {
|
std::string mangled;
|
llvm::raw_string_ostream ss(mangled);
|
mangler->mangleName(decl, ss);
|
return mangled;
|
}
|
|
return identifier->getName();
|
}
|
|
return "<unnamed>";
|
}
|
|
bool VisitDeclaratorDecl(DeclaratorDecl* decl, SourceRange range) {
|
// Skip declarations inside of functions (function arguments, variable declarations inside of
|
// inline functions, etc).
|
if (decl->getParentFunctionOrMethod()) {
|
return true;
|
}
|
|
auto named_decl = dyn_cast<NamedDecl>(decl);
|
if (!named_decl) {
|
return true;
|
}
|
|
std::string declaration_name = getDeclName(named_decl);
|
bool is_extern = named_decl->getFormalLinkage() == ExternalLinkage;
|
bool is_definition = false;
|
bool no_guard = false;
|
|
if (auto function_decl = dyn_cast<FunctionDecl>(decl)) {
|
is_definition = function_decl->isThisDeclarationADefinition();
|
} else if (auto var_decl = dyn_cast<VarDecl>(decl)) {
|
if (!var_decl->isFileVarDecl()) {
|
return true;
|
}
|
|
switch (var_decl->isThisDeclarationADefinition()) {
|
case VarDecl::DeclarationOnly:
|
is_definition = false;
|
break;
|
|
case VarDecl::Definition:
|
is_definition = true;
|
break;
|
|
case VarDecl::TentativeDefinition:
|
// Forbid tentative definitions in headers.
|
fprintf(stderr, "ERROR: declaration '%s' is a tentative definition\n",
|
declaration_name.c_str());
|
decl->dump();
|
abort();
|
}
|
} else {
|
// We only care about function and variable declarations.
|
return true;
|
}
|
|
if (decl->hasAttr<UnavailableAttr>()) {
|
// Skip declarations that exist only for compile-time diagnostics.
|
return true;
|
}
|
|
DeclarationAvailability availability;
|
|
// Find and parse __ANDROID_AVAILABILITY_DUMP__ annotations.
|
for (const AnnotateAttr* attr : decl->specific_attrs<AnnotateAttr>()) {
|
llvm::StringRef annotation = attr->getAnnotation();
|
if (annotation == "versioner_no_guard") {
|
no_guard = true;
|
} else {
|
llvm::SmallVector<llvm::StringRef, 2> fragments;
|
annotation.split(fragments, "=");
|
if (fragments.size() != 2) {
|
continue;
|
}
|
|
auto& global_availability = availability.global_availability;
|
auto& arch_availability = availability.arch_availability;
|
std::map<std::string, std::vector<int*>> prefix_map = {
|
{ "introduced_in", { &global_availability.introduced } },
|
{ "deprecated_in", { &global_availability.deprecated } },
|
{ "obsoleted_in", { &global_availability.obsoleted } },
|
{ "introduced_in_arm", { &arch_availability[Arch::arm].introduced } },
|
{ "introduced_in_mips", { &arch_availability[Arch::mips].introduced } },
|
{ "introduced_in_x86", { &arch_availability[Arch::x86].introduced } },
|
{ "introduced_in_32",
|
{ &arch_availability[Arch::arm].introduced,
|
&arch_availability[Arch::mips].introduced,
|
&arch_availability[Arch::x86].introduced } },
|
{ "introduced_in_64",
|
{ &arch_availability[Arch::arm64].introduced,
|
&arch_availability[Arch::mips64].introduced,
|
&arch_availability[Arch::x86_64].introduced } },
|
};
|
|
if (auto it = prefix_map.find(fragments[0]); it != prefix_map.end()) {
|
int value;
|
if (fragments[1].getAsInteger(10, value)) {
|
errx(1, "invalid __ANDROID_AVAILABILITY_DUMP__ annotation: '%s'",
|
annotation.str().c_str());
|
}
|
|
for (int* ptr : it->second) {
|
*ptr = value;
|
}
|
}
|
}
|
}
|
|
auto symbol_it = database.symbols.find(declaration_name);
|
if (symbol_it == database.symbols.end()) {
|
Symbol symbol = {.name = declaration_name };
|
bool dummy;
|
std::tie(symbol_it, dummy) = database.symbols.insert({ declaration_name, symbol });
|
}
|
|
auto expansion_range = src_manager.getExpansionRange(range);
|
auto filename = src_manager.getFilename(expansion_range.getBegin());
|
if (filename != src_manager.getFilename(expansion_range.getEnd())) {
|
errx(1, "expansion range filenames don't match");
|
}
|
|
Location location = {
|
.filename = filename,
|
.start = {
|
.line = src_manager.getExpansionLineNumber(expansion_range.getBegin()),
|
.column = src_manager.getExpansionColumnNumber(expansion_range.getBegin()),
|
},
|
.end = {
|
.line = src_manager.getExpansionLineNumber(expansion_range.getEnd()),
|
.column = src_manager.getExpansionColumnNumber(expansion_range.getEnd()),
|
}
|
};
|
|
// Find or insert an entry for the declaration.
|
if (auto declaration_it = symbol_it->second.declarations.find(location);
|
declaration_it != symbol_it->second.declarations.end()) {
|
if (declaration_it->second.is_extern != is_extern ||
|
declaration_it->second.is_definition != is_definition ||
|
declaration_it->second.no_guard != no_guard) {
|
errx(1, "varying declaration of '%s' at %s:%u:%u", declaration_name.c_str(),
|
location.filename.c_str(), location.start.line, location.start.column);
|
}
|
declaration_it->second.availability.insert(std::make_pair(type, availability));
|
} else {
|
Declaration declaration;
|
declaration.name = declaration_name;
|
declaration.location = location;
|
declaration.is_extern = is_extern;
|
declaration.is_definition = is_definition;
|
declaration.no_guard = no_guard;
|
declaration.availability.insert(std::make_pair(type, availability));
|
symbol_it->second.declarations.insert(std::make_pair(location, declaration));
|
}
|
|
return true;
|
}
|
|
bool VisitDeclaratorDecl(DeclaratorDecl* decl) {
|
return VisitDeclaratorDecl(decl, decl->getSourceRange());
|
}
|
|
bool TraverseLinkageSpecDecl(LinkageSpecDecl* decl) {
|
// Make sure that we correctly calculate the SourceRange of a declaration that has a non-braced
|
// extern "C"/"C++".
|
if (!decl->hasBraces()) {
|
DeclaratorDecl* child = nullptr;
|
for (auto child_decl : decl->decls()) {
|
if (child != nullptr) {
|
errx(1, "LinkageSpecDecl has multiple children");
|
}
|
|
if (DeclaratorDecl* declarator_decl = dyn_cast<DeclaratorDecl>(child_decl)) {
|
child = declarator_decl;
|
} else {
|
errx(1, "child of LinkageSpecDecl is not a DeclaratorDecl");
|
}
|
}
|
|
return VisitDeclaratorDecl(child, decl->getSourceRange());
|
}
|
|
for (auto child : decl->decls()) {
|
if (!TraverseDecl(child)) {
|
return false;
|
}
|
}
|
return true;
|
}
|
};
|
|
bool DeclarationAvailability::merge(const DeclarationAvailability& other) {
|
#define check_avail(expr) error |= (!this->expr.empty() && this->expr != other.expr);
|
bool error = false;
|
|
if (!other.global_availability.empty()) {
|
check_avail(global_availability);
|
this->global_availability = other.global_availability;
|
}
|
|
for (Arch arch : supported_archs) {
|
if (!other.arch_availability[arch].empty()) {
|
check_avail(arch_availability[arch]);
|
this->arch_availability[arch] = other.arch_availability[arch];
|
}
|
}
|
#undef check_avail
|
|
return !error;
|
}
|
|
bool Declaration::calculateAvailability(DeclarationAvailability* output) const {
|
DeclarationAvailability avail;
|
for (const auto& it : this->availability) {
|
if (!avail.merge(it.second)) {
|
return false;
|
}
|
}
|
*output = avail;
|
return true;
|
}
|
|
bool Symbol::calculateAvailability(DeclarationAvailability* output) const {
|
DeclarationAvailability avail;
|
for (const auto& it : this->declarations) {
|
// Don't merge availability for inline functions (because they shouldn't have any).
|
if (it.second.is_definition) {
|
continue;
|
}
|
|
DeclarationAvailability decl_availability;
|
if (!it.second.calculateAvailability(&decl_availability)) {
|
return false;
|
abort();
|
}
|
|
if (!avail.merge(decl_availability)) {
|
return false;
|
}
|
}
|
*output = avail;
|
return true;
|
}
|
|
bool Symbol::hasDeclaration(const CompilationType& type) const {
|
for (const auto& decl_it : this->declarations) {
|
for (const auto& compilation_it : decl_it.second.availability) {
|
if (compilation_it.first == type) {
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
void HeaderDatabase::parseAST(CompilationType type, ASTContext& ctx) {
|
std::unique_lock<std::mutex> lock(this->mutex);
|
Visitor visitor(*this, type, ctx);
|
visitor.TraverseDecl(ctx.getTranslationUnitDecl());
|
}
|
|
std::string to_string(const AvailabilityValues& av) {
|
std::stringstream ss;
|
|
if (av.introduced != 0) {
|
ss << "introduced = " << av.introduced << ", ";
|
}
|
|
if (av.deprecated != 0) {
|
ss << "deprecated = " << av.deprecated << ", ";
|
}
|
|
if (av.obsoleted != 0) {
|
ss << "obsoleted = " << av.obsoleted << ", ";
|
}
|
|
std::string result = ss.str();
|
if (!result.empty()) {
|
result = result.substr(0, result.length() - 2);
|
}
|
return result;
|
}
|
|
std::string to_string(const DeclarationType& type) {
|
switch (type) {
|
case DeclarationType::function:
|
return "function";
|
case DeclarationType::variable:
|
return "variable";
|
case DeclarationType::inconsistent:
|
return "inconsistent";
|
}
|
abort();
|
}
|
|
std::string to_string(const DeclarationAvailability& decl_av) {
|
std::stringstream ss;
|
if (!decl_av.global_availability.empty()) {
|
ss << to_string(decl_av.global_availability) << ", ";
|
}
|
|
for (const auto& it : decl_av.arch_availability) {
|
if (!it.second.empty()) {
|
ss << to_string(it.first) << ": " << to_string(it.second) << ", ";
|
}
|
}
|
|
std::string result = ss.str();
|
if (result.size() == 0) {
|
return "no availability";
|
}
|
|
return result.substr(0, result.length() - 2);
|
}
|
|
std::string to_string(const Location& loc) {
|
std::stringstream ss;
|
ss << loc.filename << ":" << loc.start.line << ":" << loc.start.column;
|
return ss.str();
|
}
|
