/**
* Implements all abstract methods in {@code proxyClass}. This should be called after
* {@link #addProxyMethods()} which will override all methods defined by the proxy's
* ancestor classes (abstract or concrete).
*/
static jboolean implementAbstractInterfaceMethods(Env* env, Class* proxyClass, Interface* interface, ProxyClassData* proxyClassData) {
if (!interface) return TRUE;
Method* method = rvmGetMethods(env, interface->interface);
if (rvmExceptionOccurred(env)) return FALSE;
for (; method != NULL; method = method->next) {
if (!METHOD_IS_CLASS_INITIALIZER(method)) {
ProxyMethod* proxyMethod = hasMethod(env, proxyClass, method->name, method->desc);
if (rvmExceptionOccurred(env)) return FALSE;
if (!proxyMethod) {
jint access = (method->access & (~ACC_ABSTRACT)) | ACC_FINAL;
proxyMethod = addProxyMethod(env, proxyClass, method, access, _proxy0);
if (!proxyMethod) return FALSE;
}
// Record the lookup function in proxyClassData
LookupEntry* entry = rvmAllocateMemory(env, sizeof(LookupEntry));
if (!entry) return FALSE;
entry->key.name = method->name;
entry->key.desc = method->desc;
entry->method = proxyMethod;
HASH_ADD(hh, proxyClassData->lookupsHash, key, sizeof(LookupKey), entry);
}
}
if (!implementAbstractInterfaceMethods(env, proxyClass, interface->next, proxyClassData)) return FALSE;
Interface* interfaceInterfaces = rvmGetInterfaces(env, interface->interface);
if (rvmExceptionCheck(env)) return FALSE;
if (!implementAbstractInterfaceMethods(env, proxyClass, interfaceInterfaces, proxyClassData)) return FALSE;
return TRUE;
}
void UseEqualsDeleteCheck::registerMatchers(MatchFinder *Finder) {
auto PrivateSpecialFn = cxxMethodDecl(
isPrivate(),
anyOf(cxxConstructorDecl(anyOf(isDefaultConstructor(),
isCopyConstructor(), isMoveConstructor())),
cxxMethodDecl(
anyOf(isCopyAssignmentOperator(), isMoveAssignmentOperator())),
cxxDestructorDecl()));
Finder->addMatcher(
cxxMethodDecl(
PrivateSpecialFn,
unless(anyOf(hasBody(stmt()), isDefaulted(), isDeleted(),
ast_matchers::isTemplateInstantiation(),
// Ensure that all methods except private special member
// functions are defined.
hasParent(cxxRecordDecl(hasMethod(unless(
anyOf(PrivateSpecialFn, hasBody(stmt()), isPure(),
isDefaulted(), isDeleted()))))))))
.bind(SpecialFunction),
this);
Finder->addMatcher(
cxxMethodDecl(isDeleted(), unless(isPublic())).bind(DeletedNotPublic),
this);
}
void SizeofContainerCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
expr(unless(isInTemplateInstantiation()),
expr(sizeOfExpr(has(ignoringParenImpCasts(
expr(hasType(hasCanonicalType(hasDeclaration(cxxRecordDecl(
matchesName("^(::std::|::string)"),
unless(matchesName("^::std::(bitset|array)$")),
hasMethod(cxxMethodDecl(hasName("size"), isPublic(),
isConst())))))))))))
.bind("sizeof"),
// Ignore ARRAYSIZE(<array of containers>) pattern.
unless(hasAncestor(binaryOperator(
anyOf(hasOperatorName("/"), hasOperatorName("%")),
hasLHS(ignoringParenCasts(sizeOfExpr(expr()))),
hasRHS(ignoringParenCasts(equalsBoundNode("sizeof"))))))),
this);
}
void MoveConstructorInitCheck::registerMatchers(MatchFinder *Finder) {
// Only register the matchers for C++11; the functionality currently does not
// provide any benefit to other languages, despite being benign.
if (!getLangOpts().CPlusPlus11)
return;
Finder->addMatcher(
cxxConstructorDecl(
unless(isImplicit()),
allOf(isMoveConstructor(),
hasAnyConstructorInitializer(
cxxCtorInitializer(
withInitializer(cxxConstructExpr(hasDeclaration(
cxxConstructorDecl(isCopyConstructor())
.bind("ctor")))))
.bind("move-init")))),
this);
auto NonConstValueMovableAndExpensiveToCopy =
qualType(allOf(unless(pointerType()), unless(isConstQualified()),
hasDeclaration(cxxRecordDecl(hasMethod(cxxConstructorDecl(
isMoveConstructor(), unless(isDeleted()))))),
matchers::isExpensiveToCopy()));
// This checker is also used to implement cert-oop11-cpp, but when using that
// form of the checker, we do not want to diagnose movable parameters.
if (!UseCERTSemantics) {
Finder->addMatcher(
cxxConstructorDecl(
allOf(
unless(isMoveConstructor()),
hasAnyConstructorInitializer(withInitializer(cxxConstructExpr(
hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
hasArgument(
0,
declRefExpr(
to(parmVarDecl(
hasType(
NonConstValueMovableAndExpensiveToCopy))
.bind("movable-param")))
.bind("init-arg")))))))
.bind("ctor-decl"),
this);
}
}
static jboolean addProxyMethods(Env* env, Class* proxyClass, Class* clazz, ProxyClassData* proxyClassData) {
// Add constructors from the super class and override all overridable methods. Constructors will use
// the same impl as the superclass. Overridden methods will have _rvmProxy0 as its impl.
if (clazz->superclass) {
if (!addProxyMethods(env, proxyClass, clazz->superclass, proxyClassData)) return FALSE;
}
Method* method = rvmGetMethods(env, clazz);
if (rvmExceptionOccurred(env)) return FALSE;
for (; method != NULL; method = method->next) {
if (!METHOD_IS_STATIC(method) && !METHOD_IS_PRIVATE(method) && !METHOD_IS_FINAL(method)
&& (!METHOD_IS_CONSTRUCTOR(method) || clazz == proxyClass->superclass)) {
void* impl = NULL;
jint access = (method->access & (~ACC_ABSTRACT & ~ACC_NATIVE)) | ACC_FINAL;
if (METHOD_IS_CONSTRUCTOR(method)) {
impl = method->impl;
// TODO: For now we make all constructors public to satisfy java.lang.reflect.Proxy.
access = ACC_PUBLIC;
if (!addProxyMethod(env, proxyClass, method, access, impl)) return FALSE;
} else {
impl = _proxy0;
if (METHOD_IS_PUBLIC(method)) {
ProxyMethod* proxyMethod = hasMethod(env, proxyClass, method->name, method->desc);
if (rvmExceptionOccurred(env)) return FALSE;
if (!proxyMethod) {
proxyMethod = addProxyMethod(env, proxyClass, method, access, impl);
if (!proxyMethod) return FALSE;
}
// Record the lookup function in proxyClassData
LookupEntry* entry = rvmAllocateMemory(env, sizeof(LookupEntry));
if (!entry) return FALSE;
entry->key.name = method->name;
entry->key.desc = method->desc;
entry->method = proxyMethod;
HASH_ADD(hh, proxyClassData->lookupsHash, key, sizeof(LookupKey), entry);
}
}
}
}
return TRUE;
}
