[IRGen] Walk inlineable Clang functions and emit their dependencies.

This handles things like NSSwapHostLongLongToBig and MKMapRectMake that
are static inline functions that themselves call other static inline
functions.

<rdar://problem/17227237>

Swift SVN r21080

Author: jrose-apple

lib/ClangImporter/ClangImporter.cpp

@@ -214,7 +214,7 @@ ClangImporter::create(ASTContext &ctx,
   // target.
   std::vector<std::string> invocationArgStrs = {
     "-x", "objective-c", "-std=gnu11", "-fobjc-arc", "-fmodules", "-fblocks",
-    "-fsyntax-only", "-w",
+    "-fsyntax-only", "-w", "-femit-all-decls",
     "-triple", irGenOpts.Triple, "-target-cpu", irGenOpts.TargetCPU,
     "-target-abi", irGenOpts.TargetABI,
     SHIMS_INCLUDE_FLAG, searchPathOpts.RuntimeResourcePath,

lib/ClangImporter/ImportDecl.cpp

@@ -2021,17 +2021,7 @@ namespace {
       // Keep track of inline function bodies so that we can generate
       // IR from them using Clang's IR generator.
       if ((decl->isInlined() || decl->hasAttr<clang::AlwaysInlineAttr>())
-          && decl->getBody()) {
-        // FIXME: Total hack to force instantiation of inline
-        //        functions into the module rather than going through
-        //        Clang's CodeGenModule::Release(), which will emit
-        //        deferred decls that have been referenced, since
-        //        Release() does many things including emitting stuff
-        //        that along with what Swift emits results in broken
-        //        modules.
-        auto *attr = clang::UsedAttr::CreateImplicit(decl->getASTContext());
-        const_cast<clang::FunctionDecl *>(decl)->addAttr(attr);
-
+          && decl->hasBody()) {
         Impl.registerExternalDecl(result);
       }
 

lib/IRGen/CMakeLists.txt

@@ -1,6 +1,7 @@
 add_swift_library(swiftIRGen
   DebugTypeInfo.cpp
   GenCast.cpp
+  GenClangDecl.cpp
   GenClangType.cpp
   GenClass.cpp
   GenControl.cpp

lib/IRGen/GenClangDecl.cpp

@@ -0,0 +1,69 @@
+//===--- GenClangDecl.cpp - Swift IRGen for imported Clang declarations ---===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "IRGenModule.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclGroup.h"
+#include "clang/AST/DataRecursiveASTVisitor.h"
+#include "clang/CodeGen/ModuleBuilder.h"
+#include "llvm/ADT/SmallPtrSet.h"
+
+using namespace swift;
+using namespace irgen;
+
+namespace {
+class ClangDeclRefFinder
+    : public clang::DataRecursiveASTVisitor<ClangDeclRefFinder> {
+  std::function<void(const clang::DeclRefExpr *)> callback;
+public:
+  template <typename Fn>
+  explicit ClangDeclRefFinder(Fn fn) : callback(fn) {}
+
+  bool VisitDeclRefExpr(clang::DeclRefExpr *DRE) {
+    callback(DRE);
+    return true;
+  }
+};
+} // end anonymous namespace
+
+void IRGenModule::emitLocalDecls(clang::Decl *decl) {
+  auto valueDecl = dyn_cast<clang::ValueDecl>(decl);
+  if (!valueDecl || valueDecl->isExternallyVisible()) {
+    ClangCodeGen->HandleTopLevelDecl(clang::DeclGroupRef(decl));
+    return;
+  }
+
+  if (!GlobalClangDecls.insert(decl).second)
+    return;
+  SmallVector<const clang::Decl *, 8> stack;
+  stack.push_back(decl);
+
+  ClangDeclRefFinder refFinder([&](const clang::DeclRefExpr *DRE) {
+    const clang::ValueDecl *D = DRE->getDecl();
+    if (!D->hasLinkage() || D->isExternallyVisible())
+      return;
+    if (!GlobalClangDecls.insert(D->getCanonicalDecl()).second)
+      return;
+    stack.push_back(D);
+  });
+
+  while (!stack.empty()) {
+    auto *next = const_cast<clang::Decl *>(stack.pop_back_val());
+    if (auto fn = dyn_cast<clang::FunctionDecl>(next)) {
+      const clang::FunctionDecl *definition;
+      if (fn->hasBody(definition))
+        refFinder.TraverseDecl(const_cast<clang::FunctionDecl *>(definition));
+    }
+    ClangCodeGen->HandleTopLevelDecl(clang::DeclGroupRef(next));
+  }
+}
+

lib/IRGen/GenFunc.cpp

@@ -3112,9 +3112,3 @@ void IRGenModule::emitLocalDecls(DestructorDecl *dd) {
   if (dd->getBody())
     emitLocalDecls(dd->getBody());
 }
-
-// Emit IR for an imported inline Clang function body.
-void IRGenModule::emitLocalDecls(clang::Decl *decl) {
-  ClangCodeGen->HandleTopLevelDecl(clang::DeclGroupRef(decl));
-}
-

lib/IRGen/IRGenModule.h

@@ -22,6 +22,7 @@
 #include "swift/Basic/SuccessorMap.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
@@ -299,6 +300,7 @@ class IRGenModule {
 private:
   llvm::DenseMap<LinkEntity, llvm::Constant*> GlobalVars;
   llvm::DenseMap<LinkEntity, llvm::Function*> GlobalFuncs;
+  llvm::DenseSet<const clang::Decl *> GlobalClangDecls;
   llvm::StringMap<llvm::Constant*> GlobalStrings;
   llvm::StringMap<llvm::Constant*> GlobalUTF16Strings;
   llvm::StringMap<llvm::Constant*> ObjCSelectorRefs;

test/IRGen/Inputs/usr/include/Gizmo.h

@@ -42,6 +42,10 @@ typedef long NSInteger;
 
 static inline int innerZero(void) { return 0; }
 static inline int zero(void) { return innerZero(); }
+static inline int wrappedZero(void) { return zero(); }
+
+extern int getInt(void);
+static inline int wrappedGetInt(void) { return getInt(); }
 
 @interface NSView : NSObject
 - (struct NSRect) convertRectFromBase: (struct NSRect) r;

test/IRGen/clang_inline.swift

@@ -4,8 +4,21 @@ import gizmo
 
 // CHECK: define i64 @_TFC12clang_inline16CallStaticInline10ReturnZerofS0_FT_Si(%C12clang_inline16CallStaticInline*) {
 // CHECK: define internal i32 @zero() #0 {
-// FIXME: We should be generating the IR for the body of innerZero as well.
-// CHECK: declare i32 @innerZero() #2
 class CallStaticInline {
   func ReturnZero() -> Int { return Int(zero()) }
 }
+
+// CHECK: define i64 @_TFC12clang_inline17CallStaticInline210ReturnZerofS0_FT_Si(%C12clang_inline17CallStaticInline2*) {
+// CHECK: define internal i32 @wrappedZero() #0 {
+class CallStaticInline2 {
+  func ReturnZero() -> Int { return Int(wrappedZero()) }
+}
+
+// CHECK: define i32 @_TF12clang_inline10testExternFT_VSs5Int32() {
+// CHECK: define internal i32 @wrappedGetInt() #0 {
+func testExtern() -> CInt {
+  return wrappedGetInt()
+}
+
+// CHECK: define internal i32 @innerZero() #2 {
+// CHECK: declare i32 @getInt() #3

test/IRGen/clang_inline_reverse.swift

@@ -0,0 +1,19 @@
+// Same test as clang_inline.swift, but with the order swapped.
+
+// RUN: rm -rf %t/clang-module-cache
+// RUN: %swift -target x86_64-apple-macosx10.9 -module-cache-path %t/clang-module-cache -sdk %S/Inputs %s -emit-ir -module-name clang_inline | FileCheck %s
+import gizmo
+
+// CHECK: define i64 @_TFC12clang_inline16CallStaticInline10ReturnZerofS0_FT_Si(%C12clang_inline16CallStaticInline*) {
+// CHECK: define internal i32 @wrappedZero() #0 {
+class CallStaticInline {
+  func ReturnZero() -> Int { return Int(wrappedZero()) }
+}
+
+// CHECK: define i64 @_TFC12clang_inline17CallStaticInline210ReturnZerofS0_FT_Si(%C12clang_inline17CallStaticInline2*) {
+// CHECK: define internal i32 @zero() #0 {
+class CallStaticInline2 {
+  func ReturnZero() -> Int { return Int(zero()) }
+}
+
+// CHECK: define internal i32 @innerZero() #2 {

test/Interpreter/SDK/header_static.swift

@@ -0,0 +1,12 @@
+// RUN: %target-run-simple-swift | FileCheck %s
+
+import Foundation
+import MapKit
+
+let rect = MKMapRectMake(1.0, 2.0, 3.0, 4.0)
+// CHECK: {{^}}1.0 2.0 3.0 4.0{{$}}
+println("\(rect.origin.x) \(rect.origin.y) \(rect.size.width) \(rect.size.height)")
+
+let value: CUnsignedInt = 0xFF00FF00
+// CHECK: {{^}}ff00ff00 ff00ff{{$}}
+println("\(String(value, radix: 16)) \(String(NSSwapInt(value), radix: 16))")