Fix bitcode parser to check type signatures of functions.

src/IceGlobalInits.h

 //===- subzero/src/IceGlobalInits.h - Global declarations -------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Declares the representation of function declarations, global variable
 /// declarations, and the corresponding variable initializers in Subzero.
 ///
 /// Global variable initializers are represented as a sequence of simple
 /// initializers.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEGLOBALINITS_H
 #define SUBZERO_SRC_ICEGLOBALINITS_H
 
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
+#include "IceIntrinsics.h"
 #include "IceTypes.h"
 
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
 #pragma clang diagnostic ignored "-Wredundant-move"
 #endif // __clang__
 
 #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h" // for NaClBitcodeRecord.
 #include "llvm/IR/CallingConv.h"
@@ skipping 115 matching lines @@
   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);
   }
 
+  /// Validates that type signature of function is correct. Returns true if

[Jim Stichnoth, 2016/01/14 22:59:08]

How about "the type signature" and "the function"?

[Karl, 2016/01/15 15:33:34]

Done.

+  /// valid,

[Jim Stichnoth, 2016/01/14 22:59:08]

End sentence with a period, or fill in the missing remainder. :)

[Karl, 2016/01/15 15:33:34]

Done.

+  bool validateTypeSignature(const GlobalContext *Ctx) {
+    bool IsIntrinsic;
+    if (const Intrinsics::FullIntrinsicInfo *Info =
+            getIntrinsicInfo(Ctx, IsIntrinsic))
+      return validateIntrinsicTypeSignature(Info);
+    return !IsIntrinsic && validateRegularTypeSignature();
+  }
+
+  /// Generates error message describing why validateTypeSignature returns

[Jim Stichnoth, 2016/01/14 22:59:08]

an error message

[Karl, 2016/01/15 15:33:34]

Done.

+  /// false.
+  IceString getTypeSignatureError(const GlobalContext *Ctx);
+
+  /// Returns corresponding PNaCl intrisic information.
+  const Intrinsics::FullIntrinsicInfo *
+  getIntrinsicInfo(const GlobalContext *Ctx) const {
+    bool BadIntrinsic;
+    return getIntrinsicInfo(Ctx, BadIntrinsic);
+  }
+
+  /// Same as above, except IsIntrinsic is true if the function is intrinsic
+  /// (even if not a PNaCl intrinsic).
+  const Intrinsics::FullIntrinsicInfo *
+  getIntrinsicInfo(const GlobalContext *Ctx, bool &IsIntrinsic) const;

[Jim Stichnoth, 2016/01/14 22:59:08]

I'm guessing John is going to ask for bool* here.

[Karl, 2016/01/15 15:33:34]

Changed to use bool *.

+
 private:
   const Ice::FuncSigType Signature;
   llvm::CallingConv::ID CallingConv;
   bool IsProto;
 
   FunctionDeclaration(const FuncSigType &Signature,
                       llvm::CallingConv::ID CallingConv,
                       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;
+    bool IsIntrinsic;
+    getIntrinsicInfo(Ctx, IsIntrinsic);
+    return IsIntrinsic;
   }
+
+  bool validateRegularTypeSignature() const;
+
+  bool validateIntrinsicTypeSignature(
+      const Intrinsics::FullIntrinsicInfo *Info) const;
 };
 
 /// Models a global variable declaration, and its initializers.
 class VariableDeclaration : public GlobalDeclaration {
   VariableDeclaration(const VariableDeclaration &) = delete;
   VariableDeclaration &operator=(const VariableDeclaration &) = delete;
 
 public:
   /// Base class for a global variable initializer.
   class Initializer {
@@ skipping 209 matching lines @@
 template <class StreamType>
 inline StreamType &operator<<(StreamType &Stream,
                               const GlobalDeclaration &Addr) {
   Addr.dump(Stream);
   return Stream;
 }
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALINITS_H