tor-browser

BindingOperations.cpp (23088B)

---

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "BindingOperations.h"

#include <clang/AST/Attr.h>
#include <clang/AST/Expr.h>
#include <clang/AST/RecursiveASTVisitor.h>
#include <clang/Basic/Version.h>

#include <algorithm>
#include <array>
#include <cuchar>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>

#ifdef __cpp_lib_optional
#include <optional>
template <typename T> using optional = std::optional<T>;
#else
#include <llvm/ADT/Optional.h>
template <typename T> using optional = clang::Optional<T>;
#endif

using namespace clang;

namespace {

template <typename InputIt>
bool hasReverseQualifiedName(InputIt first, InputIt last,
                            const NamedDecl &tag) {
 const NamedDecl *currentDecl = &tag;
 InputIt currentName;
 for (currentName = first; currentName != last; currentName++) {
   if (!currentDecl || !currentDecl->getIdentifier() ||
       currentDecl->getName() != *currentName)
     return false;

   currentDecl = dyn_cast<NamedDecl>(currentDecl->getDeclContext());
 }
 if (currentName != last)
   return false;

 if (currentDecl != nullptr)
   return false;

 return true;
}

bool isMozillaJniObjectBase(const CXXRecordDecl &klass) {
 const auto qualifiedName =
     std::array<StringRef, 3>{"mozilla", "jni", "ObjectBase"};
 return hasReverseQualifiedName(qualifiedName.crbegin(), qualifiedName.crend(),
                                klass);
}

bool isMozillaJniNativeImpl(const CXXRecordDecl &klass) {
 const auto qualifiedName =
     std::array<StringRef, 3>{"mozilla", "jni", "NativeImpl"};
 return hasReverseQualifiedName(qualifiedName.crbegin(), qualifiedName.crend(),
                                klass);
}

const NamedDecl *fieldNamed(StringRef name, const RecordDecl &strukt) {
 for (const auto *decl : strukt.decls()) {
   const auto *namedDecl = dyn_cast<VarDecl>(decl);
   if (!namedDecl)
     continue;

   if (!namedDecl->getIdentifier() || namedDecl->getName() != name)
     continue;

   return namedDecl;
 }

 return {};
}

optional<StringRef> nameFieldValue(const RecordDecl &strukt) {
 const auto *nameField = dyn_cast_or_null<VarDecl>(fieldNamed("name", strukt));
 if (!nameField)
   return {};

 const auto *def = nameField->getDefinition();
 if (!def)
   return {};

 const auto *name = dyn_cast_or_null<StringLiteral>(def->getInit());
 if (!name)
   return {};

 return name->getString();
}

struct AbstractBinding {
 // Subset of tools/analysis/BindingSlotLang
 enum class Lang {
   Cpp,
   Jvm,
 };
 static constexpr size_t LangLength = 2;
 static constexpr std::array<StringRef, LangLength> langNames = {
     "cpp",
     "jvm",
 };

 static optional<Lang> langFromString(StringRef langName) {
   const auto it = std::find(langNames.begin(), langNames.end(), langName);
   if (it == langNames.end())
     return {};

   return Lang(it - langNames.begin());
 }
 static StringRef stringFromLang(Lang lang) { return langNames[size_t(lang)]; }

 // Subset of tools/analysis/BindingSlotKind
 enum class Kind {
   Class,
   Method,
   Getter,
   Setter,
   Const,
 };
 static constexpr size_t KindLength = 5;
 static constexpr std::array<StringRef, KindLength> kindNames = {
     "class", "method", "getter", "setter", "const",
 };

 static optional<Kind> kindFromString(StringRef kindName) {
   const auto it = std::find(kindNames.begin(), kindNames.end(), kindName);
   if (it == kindNames.end())
     return {};

   return Kind(it - kindNames.begin());
 }
 static StringRef stringFromKind(Kind kind) { return kindNames[size_t(kind)]; }

 Lang lang;
 Kind kind;
 StringRef symbol;
};
constexpr size_t AbstractBinding::KindLength;
constexpr std::array<StringRef, AbstractBinding::KindLength>
   AbstractBinding::kindNames;
constexpr size_t AbstractBinding::LangLength;
constexpr std::array<StringRef, AbstractBinding::LangLength>
   AbstractBinding::langNames;

struct BindingTo : public AbstractBinding {
 BindingTo(AbstractBinding b) : AbstractBinding(std::move(b)) {}
 static constexpr StringRef ANNOTATION = "binding_to";
};
constexpr StringRef BindingTo::ANNOTATION;

struct BoundAs : public AbstractBinding {
 BoundAs(AbstractBinding b) : AbstractBinding(std::move(b)) {}
 static constexpr StringRef ANNOTATION = "bound_as";
};
constexpr StringRef BoundAs::ANNOTATION;

template <typename B>
void setBindingAttr(ASTContext &C, Decl &decl, B binding) {
#if CLANG_VERSION_MAJOR >= 18
 auto utf8 = StringLiteralKind::UTF8;
#else
 auto utf8 = StringLiteral::UTF8;
#endif
 // recent LLVM: CreateImplicit then setDelayedArgs
 Expr *langExpr = StringLiteral::Create(
     C, AbstractBinding::stringFromLang(binding.lang), utf8, false, {}, {});
 Expr *kindExpr = StringLiteral::Create(
     C, AbstractBinding::stringFromKind(binding.kind), utf8, false, {}, {});
 Expr *symbolExpr =
     StringLiteral::Create(C, binding.symbol, utf8, false, {}, {});
 auto **args = new (C, 16) Expr *[3]{langExpr, kindExpr, symbolExpr};
 auto *attr = AnnotateAttr::CreateImplicit(C, B::ANNOTATION, args, 3);
 decl.addAttr(attr);
}

optional<AbstractBinding> readBinding(const AnnotateAttr &attr) {
 if (attr.args_size() != 3)
   return {};

 const auto *langExpr = attr.args().begin()[0];
 const auto *kindExpr = attr.args().begin()[1];
 const auto *symbolExpr = attr.args().begin()[2];
 if (!langExpr || !kindExpr || !symbolExpr)
   return {};

 const auto *langName =
     dyn_cast<StringLiteral>(langExpr->IgnoreUnlessSpelledInSource());
 const auto *kindName =
     dyn_cast<StringLiteral>(kindExpr->IgnoreUnlessSpelledInSource());
 const auto *symbol =
     dyn_cast<StringLiteral>(symbolExpr->IgnoreUnlessSpelledInSource());
 if (!langName || !kindName || !symbol)
   return {};

 const auto lang = AbstractBinding::langFromString(langName->getString());
 const auto kind = AbstractBinding::kindFromString(kindName->getString());

 if (!lang || !kind)
   return {};

 return AbstractBinding{
     .lang = *lang,
     .kind = *kind,
     .symbol = symbol->getString(),
 };
}

optional<BindingTo> getBindingTo(const Decl &decl) {
 for (const auto *attr : decl.specific_attrs<AnnotateAttr>()) {
   if (attr->getAnnotation() != BindingTo::ANNOTATION)
     continue;

   const auto binding = readBinding(*attr);
   if (!binding)
     continue;

   return BindingTo{*binding};
 }
 return {};
}

// C++23: turn into generator
std::vector<BoundAs> getBoundAs(const Decl &decl) {
 std::vector<BoundAs> found;

 for (const auto *attr : decl.specific_attrs<AnnotateAttr>()) {
   if (attr->getAnnotation() != BoundAs::ANNOTATION)
     continue;

   const auto binding = readBinding(*attr);
   if (!binding)
     continue;

   found.push_back(BoundAs{*binding});
 }

 return found;
}

class FindCallCall : private RecursiveASTVisitor<FindCallCall> {
public:
 struct Result {
   using Kind = AbstractBinding::Kind;

   Kind kind;
   StringRef name;
 };

 static optional<Result> search(Stmt *statement) {
   FindCallCall finder;
   finder.TraverseStmt(statement);
   return finder.result;
 }

private:
 optional<Result> result;

 friend RecursiveASTVisitor<FindCallCall>;

 optional<Result> tryParseCallCall(CallExpr *callExpr) {
   const auto *callee =
       dyn_cast_or_null<CXXMethodDecl>(callExpr->getDirectCallee());
   if (!callee)
     return {};

   if (!callee->getIdentifier())
     return {};

   const auto action = callee->getIdentifier()->getName();

   if (action != "Call" && action != "Get" && action != "Set")
     return {};

   const auto *parentClass =
       dyn_cast_or_null<ClassTemplateSpecializationDecl>(callee->getParent());

   if (!parentClass)
     return {};

   const auto *parentTemplate = parentClass->getTemplateInstantiationPattern();

   if (!parentTemplate || !parentTemplate->getIdentifier())
     return {};

   const auto parentName = parentTemplate->getIdentifier()->getName();

   AbstractBinding::Kind kind;
   if (action == "Call") {
     if (parentName == "Constructor" || parentName == "Method") {
       kind = AbstractBinding::Kind::Method;
     } else {
       return {};
     }
   } else if (parentName == "Field") {
     if (action == "Get") {
       kind = AbstractBinding::Kind::Getter;
     } else if (action == "Set") {
       kind = AbstractBinding::Kind::Setter;
     } else {
       return {};
     }
   } else {
     return {};
   }

   const auto *templateArg =
       parentClass->getTemplateArgs().get(0).getAsType()->getAsRecordDecl();

   if (!templateArg)
     return {};

   const auto name = nameFieldValue(*templateArg);
   if (!name)
     return {};

   return Result{
       .kind = kind,
       .name = *name,
   };

   return {};
 }
 bool VisitCallExpr(CallExpr *callExpr) {
   return !(result = tryParseCallCall(callExpr));
 }
};

constexpr StringRef JVM_SCIP_SYMBOL_PREFIX = "S_jvm_";

std::string javaScipSymbol(StringRef prefix, StringRef name,
                          AbstractBinding::Kind kind) {
 auto symbol = (prefix + name).str();

 switch (kind) {
 case AbstractBinding::Kind::Class:
   std::replace(symbol.begin(), symbol.end(), '$', '#');
   symbol += "#";
   break;
 case AbstractBinding::Kind::Method:
   symbol += "().";
   break;
 case AbstractBinding::Kind::Const:
 case AbstractBinding::Kind::Getter:
 case AbstractBinding::Kind::Setter:
   symbol += ".";
   break;
 }

 return symbol;
}

void addSlotOwnerAttribute(llvm::json::OStream &J, const Decl &decl) {
 if (const auto bindingTo = getBindingTo(decl)) {
   J.attributeBegin("slotOwner");
   J.objectBegin();
   J.attribute("slotKind", AbstractBinding::stringFromKind(bindingTo->kind));
   J.attribute("slotLang", "cpp");
   J.attribute("ownerLang", AbstractBinding::stringFromLang(bindingTo->lang));
   J.attribute("sym", bindingTo->symbol);
   J.objectEnd();
   J.attributeEnd();
 }
}
void addBindingSlotsAttribute(llvm::json::OStream &J, const Decl &decl) {
 const auto allBoundAs = getBoundAs(decl);
 if (!allBoundAs.empty()) {
   J.attributeBegin("bindingSlots");
   J.arrayBegin();
   for (const auto boundAs : allBoundAs) {
     J.objectBegin();
     J.attribute("slotKind", AbstractBinding::stringFromKind(boundAs.kind));
     J.attribute("slotLang", AbstractBinding::stringFromLang(boundAs.lang));
     J.attribute("ownerLang", "cpp");
     J.attribute("sym", boundAs.symbol);
     J.objectEnd();
   }
   J.arrayEnd();
   J.attributeEnd();
 }
}

// The mangling scheme is documented at
// https://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/design.html
// The main takeaways are:
// - _0xxxx is the utf16 code unit xxxx
// - _1 is _
// - _2 is ;
// - _3 is [
// - __ is the separator between function name and overload specification
// - _ is otherwise the separator between packages/classes/methods
//
// This method takes a StringRef & and mutates it and can be called twice on a
// Jnicall function name to get
//  first the demangled name
//  second the demangled overload specification
// But we don't use the later for now because we have no way to map that to how
// SCIP resolves overloads.
optional<std::string> demangleJnicallPart(StringRef &remainder) {
 std::string demangled;

 std::mbstate_t ps = {};

 while (!remainder.empty()) {
   switch (remainder[0]) {
   case '0': {
     remainder = remainder.drop_front(1);

     uint16_t codeUnit;
     const auto ok = remainder.substr(1, 4).getAsInteger(16, codeUnit);
     remainder = remainder.drop_front(4);

     if (!ok) // failed reading xxxx as hexadecimal from _0xxxx
       return {};

     std::array<char, MB_LEN_MAX> codePoint;
     const auto mbLen = std::c16rtomb(codePoint.data(), codeUnit, &ps);

     if (mbLen == -1) // failed converting utf16 to utf8
       return {};

     demangled += StringRef(codePoint.begin(), mbLen);
     break;
   }
   case '1':
     remainder = remainder.drop_front(1);
     ps = {};
     demangled += '_';
     break;
   case '2':
     remainder = remainder.drop_front(1);
     ps = {};
     demangled += ';';
     break;
   case '3':
     remainder = remainder.drop_front(1);
     ps = {};
     demangled += '[';
     break;
   case '_':
     remainder = remainder.drop_front(1);
     ps = {};
     if (remainder.empty()) // the string ends with _
       return {};

     switch (remainder[0]) {
     case '0':
     case '1':
     case '2':
     case '3':
       demangled += '.';
       break;
     default:
       // either:
       // * the string began with _[^0-3], which is not supposed to happen; or
       // * we reached __[^0-3] meaning we finished the first part of the name
       // and remainder holds the overload specification
       return demangled;
     }
   default:
     ps = {};
     demangled += '.';
     break;
   }
   StringRef token;
   std::tie(token, remainder) = remainder.split('_');
   demangled += token;
 }

 return demangled;
}

optional<std::string>
scipSymbolFromJnicallFunctionName(StringRef functionName) {
 if (!functionName.consume_front("Java_"))
   return {};

 const auto demangledName = demangleJnicallPart(functionName);

 if (!demangledName || demangledName->empty())
   return {};

 // demangleJavaName returns something like
 // .some.package.Class$InnerClass.method
 // - prepend S_jvm_
 // - remove the leading dot
 // - replace the last dot with a #
 // - replace the other dots with /
 // - replace $ with #
 // - add the ([+overloadNumber]). suffix
 auto symbol = JVM_SCIP_SYMBOL_PREFIX.str();
 symbol += demangledName->substr(1);
 const auto lastDot = symbol.rfind('.');
 if (lastDot != std::string::npos)
   symbol[lastDot] = '#';
 std::replace(symbol.begin(), symbol.end(), '.', '/');
 std::replace(symbol.begin(), symbol.end(), '$', '#');

 // Keep track of how many times we have seen this method, to build the
 // ([+overloadNumber]). suffix. This assumes this function is called on C
 // function definitions in the same order the matching overloads are declared
 // in Java.
 static std::unordered_map<std::string, uint> jnicallFunctions;
 auto &overloadNumber = jnicallFunctions[symbol];

 symbol += '(';
 if (overloadNumber) {
   symbol += '+';
   symbol += overloadNumber;
   overloadNumber++;
 }
 symbol += ").";

 return symbol;
};

} // anonymous namespace

// class [wrapper] : public mozilla::jni::ObjectBase<[wrapper]>
// {
//   static constexpr char name[] = "[nameFieldValue]";
// }
void findBindingToJavaClass(ASTContext &C, CXXRecordDecl &klass) {
 for (const auto &baseSpecifier : klass.bases()) {
   const auto *base = baseSpecifier.getType()->getAsCXXRecordDecl();
   if (!base)
     continue;

   if (!isMozillaJniObjectBase(*base))
     continue;

   const auto name = nameFieldValue(klass);
   if (!name)
     continue;

   const auto symbol =
       javaScipSymbol(JVM_SCIP_SYMBOL_PREFIX, *name, BindingTo::Kind::Class);
   const auto binding = BindingTo{{
       .lang = BindingTo::Lang::Jvm,
       .kind = BindingTo::Kind::Class,
       .symbol = symbol,
   }};

   setBindingAttr(C, klass, binding);
   return;
 }
}

// When a Java method is marked as native, the JRE looks by default for a
// function named Java_<mangled method name>[__<mangled overload
// specification>].
void findBindingToJavaFunction(ASTContext &C, FunctionDecl &function) {
 const auto *identifier = function.getIdentifier();
 if (!identifier)
   return;

 const auto name = identifier->getName();
 const auto symbol = scipSymbolFromJnicallFunctionName(name);
 if (!symbol)
   return;

 const auto binding = BoundAs{{
     .lang = BindingTo::Lang::Jvm,
     .kind = BindingTo::Kind::Method,
     .symbol = *symbol,
 }};

 setBindingAttr(C, function, binding);
}

// class [parent]
// {
//   struct [methodStruct] {
//     static constexpr char name[] = "[methodNameFieldValue]";
//   }
//   [method]
//   {
//     ...
//     mozilla::jni::{Method,Constructor,Field}<[methodStruct]>::{Call,Get,Set}(...)
//     ...
//   }
// }
void findBindingToJavaMember(ASTContext &C, CXXMethodDecl &method) {
 const auto *parent = method.getParent();
 if (!parent)
   return;
 const auto classBinding = getBindingTo(*parent);
 if (!classBinding)
   return;

 auto *body = method.getBody();
 if (!body)
   return;

 const auto found = FindCallCall::search(body);
 if (!found)
   return;

 const auto symbol =
     javaScipSymbol(classBinding->symbol, found->name, found->kind);
 const auto binding = BindingTo{{
     .lang = BindingTo::Lang::Jvm,
     .kind = found->kind,
     .symbol = symbol,
 }};

 setBindingAttr(C, method, binding);
}

// class [parent]
// {
//   struct [methodStruct] {
//     static constexpr char name[] = "[methodNameFieldValue]";
//   }
//   [method]
//   {
//     ...
//     mozilla::jni::{Method,Constructor,Field}<[methodStruct]>::{Call,Get,Set}(...)
//     ...
//   }
// }
void findBindingToJavaConstant(ASTContext &C, VarDecl &field) {
 const auto *parent = dyn_cast_or_null<CXXRecordDecl>(field.getDeclContext());
 if (!parent)
   return;

 const auto classBinding = getBindingTo(*parent);
 if (!classBinding)
   return;

 const auto symbol = javaScipSymbol(classBinding->symbol, field.getName(),
                                    BindingTo::Kind::Const);
 const auto binding = BindingTo{{
     .lang = BindingTo::Lang::Jvm,
     .kind = BindingTo::Kind::Const,
     .symbol = symbol,
 }};

 setBindingAttr(C, field, binding);
}

// class [klass] : public [wrapper]::Natives<[klass]> {...}
// class [wrapper] : public mozilla::jni::ObjectBase<[wrapper]>
// {
//   static constexpr char name[] = "[nameFieldValue]";
//
//   struct [methodStruct] {
//     static constexpr char name[] = "[methodNameFieldValue]";
//   }
//
//   template<typename T>
//   class [wrapper]::Natives : public mozilla::jni::NativeImpl<[wrapper], T> {
//     static const JNINativeMethod methods[] = {
//       mozilla::jni::MakeNativeMethod<[wrapper]::[methodStruct]>(
//               mozilla::jni::NativeStub<[wrapper]::[methodStruct], Impl>
//               ::template Wrap<&Impl::[method]>),
//     }
//   }
// }
void findBoundAsJavaClasses(ASTContext &C, CXXRecordDecl &klass) {
 for (const auto &baseSpecifier : klass.bases()) {
   const auto *base = baseSpecifier.getType()->getAsCXXRecordDecl();
   if (!base)
     continue;

   for (const auto &baseBaseSpecifier : base->bases()) {
     const auto *baseBase = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
         baseBaseSpecifier.getType()->getAsCXXRecordDecl());
     if (!baseBase)
       continue;

     if (!isMozillaJniNativeImpl(*baseBase))
       continue;

     const auto *wrapper =
         baseBase->getTemplateArgs().get(0).getAsType()->getAsCXXRecordDecl();

     if (!wrapper)
       continue;

     const auto name = nameFieldValue(*wrapper);
     if (!name)
       continue;

     const auto javaClassSymbol =
         javaScipSymbol(JVM_SCIP_SYMBOL_PREFIX, *name, BoundAs::Kind::Class);
     const auto classBinding = BoundAs{{
         .lang = BoundAs::Lang::Jvm,
         .kind = BoundAs::Kind::Class,
         .symbol = javaClassSymbol,
     }};
     setBindingAttr(C, klass, classBinding);

     const auto *methodsDecl =
         dyn_cast_or_null<VarDecl>(fieldNamed("methods", *base));
     if (!methodsDecl)
       continue;

     const auto *methodsDef = methodsDecl->getDefinition();
     if (!methodsDef)
       continue;

     const auto *inits = dyn_cast_or_null<InitListExpr>(methodsDef->getInit());
     if (!inits)
       continue;

     std::set<const CXXMethodDecl *> alreadyBound;

     for (const auto *init : inits->inits()) {
       const auto *call =
           dyn_cast<CallExpr>(init->IgnoreUnlessSpelledInSource());
       if (!call)
         continue;

       const auto *funcDecl = call->getDirectCallee();
       if (!funcDecl)
         continue;

       const auto *templateArgs = funcDecl->getTemplateSpecializationArgs();
       if (!templateArgs)
         continue;

       const auto *strukt = dyn_cast_or_null<RecordDecl>(
           templateArgs->get(0).getAsType()->getAsRecordDecl());
       if (!strukt)
         continue;

       const auto *wrapperRef = dyn_cast_or_null<DeclRefExpr>(
           call->getArg(0)->IgnoreUnlessSpelledInSource());
       if (!wrapperRef)
         continue;

       const auto *boundRef = dyn_cast_or_null<UnaryOperator>(
           wrapperRef->template_arguments().front().getArgument().getAsExpr());
       if (!boundRef)
         continue;

       auto addToBound = [&](CXXMethodDecl &boundDecl, uint overloadNum) {
         const auto methodName = nameFieldValue(*strukt);
         if (!methodName)
           return;

         auto javaMethodSymbol = javaClassSymbol;
         javaMethodSymbol += *methodName;
         javaMethodSymbol += '(';
         if (overloadNum > 0) {
           javaMethodSymbol += '+';
           javaMethodSymbol += std::to_string(overloadNum);
         }
         javaMethodSymbol += ").";

         const auto binding = BoundAs{{
             .lang = BoundAs::Lang::Jvm,
             .kind = BoundAs::Kind::Method,
             .symbol = javaMethodSymbol,
         }};
         setBindingAttr(C, boundDecl, binding);
       };

       if (auto *bound =
               dyn_cast_or_null<DeclRefExpr>(boundRef->getSubExpr())) {
         auto *method = dyn_cast_or_null<CXXMethodDecl>(bound->getDecl());
         if (!method)
           continue;
         addToBound(*method, 0);
       } else if (const auto *bound = dyn_cast_or_null<UnresolvedLookupExpr>(
                      boundRef->getSubExpr())) {
         // XXX This is hackish
         // In case of overloads it's not obvious which one we should use
         // this expects the declaration order between C++ and Java to match
         auto declarations =
             std::vector<Decl *>(bound->decls_begin(), bound->decls_end());
         auto byLocation = [](Decl *a, Decl *b) {
           return a->getLocation() < b->getLocation();
         };
         std::sort(declarations.begin(), declarations.end(), byLocation);

         uint i = 0;
         for (auto *decl : declarations) {
           auto *method = dyn_cast<CXXMethodDecl>(decl);
           if (!method)
             continue;
           if (alreadyBound.find(method) == alreadyBound.end()) {
             addToBound(*method, i);
             alreadyBound.insert(method);
             break;
           }
           i++;
         }
       }
     }
   }
 }
}

void emitBindingAttributes(llvm::json::OStream &J, const Decl &decl) {
 addSlotOwnerAttribute(J, decl);
 addBindingSlotsAttribute(J, decl);
}