Make sure that all globals are internal, except for "start" functions.
The existing code, when run on a fuzzed example, generates a runtime
assertion. The reason for this is that the input defines "memmove" as
an external global. However, the code generator can generate calls to
"memmove" which assumes it is internal (see PNaCl ABI). As a result,
the assertion that checks that global names are unique (for memmove)
fails.
This code fixes the problem by checking that global names are
internal, unless they are one of the "start" functions,
or the function is an intrinsic. To allow for
non-PNaCl ABI input, a flag was added to allow functions to be
external. However, in such cases the external can't be one of
Subzero's runtime helper functions.
BUG= https://code.google.com/p/nativeclient/issues/detail?id=4330
R=jpp@chromium.org, stichnot@chromium.org
Review URL: https://codereview.chromium.org/1387963002 .
diff --git a/src/IceGlobalInits.h b/src/IceGlobalInits.h
index 8f51db2..82e5cde 100644
--- a/src/IceGlobalInits.h
+++ b/src/IceGlobalInits.h
@@ -87,11 +87,29 @@
return getSuppressMangling() ? Name : Ctx->mangleName(Name);
}
+ /// Returns textual name of linkage.
+ const char *getLinkageName() const {
+ return isInternal() ? "internal" : "external";
+ }
+
protected:
GlobalDeclaration(GlobalDeclarationKind Kind,
llvm::GlobalValue::LinkageTypes Linkage)
: Kind(Kind), Linkage(Linkage) {}
+ /// Returns true if linkage is defined correctly for the global declaration,
+ /// based on default rules.
+ bool verifyLinkageDefault(const GlobalContext *Ctx) const {
+ switch (Linkage) {
+ default:
+ return false;
+ case llvm::GlobalValue::InternalLinkage:
+ return true;
+ case llvm::GlobalValue::ExternalLinkage:
+ return Ctx->getFlags().getAllowExternDefinedSymbols();
+ }
+ }
+
const GlobalDeclarationKind Kind;
IceString Name;
llvm::GlobalValue::LinkageTypes Linkage;
@@ -124,6 +142,13 @@
void dump(GlobalContext *Ctx, Ostream &Stream) const final;
bool getSuppressMangling() const final { return isExternal() && IsProto; }
+ /// Returns true if linkage is correct for the function declaration.
+ bool verifyLinkageCorrect(const GlobalContext *Ctx) const {
+ if (isPNaClABIExternalName() || isIntrinsicName(Ctx))
+ return Linkage == llvm::GlobalValue::ExternalLinkage;
+ return verifyLinkageDefault(Ctx);
+ }
+
private:
const Ice::FuncSigType Signature;
llvm::CallingConv::ID CallingConv;
@@ -134,6 +159,19 @@
llvm::GlobalValue::LinkageTypes Linkage, bool IsProto)
: GlobalDeclaration(FunctionDeclarationKind, Linkage),
Signature(Signature), CallingConv(CallingConv), IsProto(IsProto) {}
+
+ bool isPNaClABIExternalName() const {
+ const char *Name = getName().c_str();
+ return strcmp(Name, "_start") == 0 || strcmp(Name, "__pnacl_pso_root") == 0;
+ }
+
+ bool isIntrinsicName(const GlobalContext *Ctx) const {
+ if (!hasName())
+ return false;
+ bool BadIntrinsic;
+ return Ctx->getIntrinsicsInfo().find(getName(), BadIntrinsic) &&
+ !BadIntrinsic;
+ }
};
/// Models a global variable declaration, and its initializers.
@@ -309,6 +347,11 @@
/// initialization).
void dump(GlobalContext *Ctx, Ostream &Stream) const final;
+ /// Returns true if linkage is correct for the variable declaration.
+ bool verifyLinkageCorrect(const GlobalContext *Ctx) const {
+ return verifyLinkageDefault(Ctx);
+ }
+
static bool classof(const GlobalDeclaration *Addr) {
return Addr->getKind() == VariableDeclarationKind;
}
