RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-12-02 00:16:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove Support/IncludeFile.h and its only user. This is actively harmful, since

Browse Source 
it breaks the modules builds (where CallGraph.h can be quite reasonably
transitively included by an unimported portion of a module, and CallGraph.cpp
not linked in), and appears to have been entirely redundant since PR780 was
fixed back in 2008.

If this breaks anything, please revert; I have only tested this with a single
configuration, and it's possible that this is still somehow fixing something
(though I doubt it, since no other similar file uses this mechanism any more).

llvm-svn: 215142
This commit is contained in:
Richard Smith 2014-08-07 20:41:17 +00:00
parent 8279279659
commit 930ab2538a
5 changed files with 0 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/Analysis/CallGraph.h
View File

@ -58,7 +58,6 @@
#include "llvm/IR/Function.h"
#include "llvm/IR/ValueHandle.h"
#include "llvm/Pass.h"
#include "llvm/Support/IncludeFile.h"
#include <map>
namespace llvm {
@ -461,7 +460,4 @@ struct GraphTraits<const CallGraph *> : public GraphTraits<
} // End llvm namespace
// Make sure that any clients of this file link in CallGraph.cpp
FORCE_DEFINING_FILE_TO_BE_LINKED(CallGraph)
#endif

79
include/llvm/Support/IncludeFile.h
View File

@ -1,79 +0,0 @@
//===- llvm/Support/IncludeFile.h - Ensure Linking Of Library ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the FORCE_DEFINING_FILE_TO_BE_LINKED and DEFINE_FILE_FOR
// macros.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SUPPORT_INCLUDEFILE_H
#define LLVM_SUPPORT_INCLUDEFILE_H
/// This macro is the public interface that IncludeFile.h exports. This gives
/// us the option to implement the "link the definition" capability in any
/// manner that we choose. All header files that depend on a specific .cpp
/// file being linked at run time should use this macro instead of the
/// IncludeFile class directly.
///
/// For example, foo.h would use:<br/>
/// <tt>FORCE_DEFINING_FILE_TO_BE_LINKED(foo)</tt><br/>
///
/// And, foo.cp would use:<br/>
/// <tt>DEFINING_FILE_FOR(foo)</tt><br/>
#ifdef __GNUC__
// If the `used' attribute is available, use it to create a variable
// with an initializer that will force the linking of the defining file.
#define FORCE_DEFINING_FILE_TO_BE_LINKED(name) \
namespace llvm { \
extern const char name ## LinkVar; \
__attribute__((used)) static const char *const name ## LinkObj = \
&name ## LinkVar; \
}
#else
// Otherwise use a constructor call.
#define FORCE_DEFINING_FILE_TO_BE_LINKED(name) \
namespace llvm { \
extern const char name ## LinkVar; \
static const IncludeFile name ## LinkObj ( &name ## LinkVar ); \
}
#endif
/// This macro is the counterpart to FORCE_DEFINING_FILE_TO_BE_LINKED. It should
/// be used in a .cpp file to define the name referenced in a header file that
/// will cause linkage of the .cpp file. It should only be used at extern level.
#define DEFINING_FILE_FOR(name) \
namespace llvm { const char name ## LinkVar = 0; }
namespace llvm {
/// This class is used in the implementation of FORCE_DEFINING_FILE_TO_BE_LINKED
/// macro to make sure that the implementation of a header file is included
/// into a tool that uses the header. This is solely
/// to overcome problems linking .a files and not getting the implementation
/// of compilation units we need. This is commonly an issue with the various
/// Passes but also occurs elsewhere in LLVM. We like to use .a files because
/// they link faster and provide the smallest executables. However, sometimes
/// those executables are too small, if the program doesn't reference something
/// that might be needed, especially by a loaded share object. This little class
/// helps to resolve that problem. The basic strategy is to use this class in
/// a header file and pass the address of a variable to the constructor. If the
/// variable is defined in the header file's corresponding .cpp file then all
/// tools/libraries that \#include the header file will require the .cpp as
/// well.
/// For example:<br/>
/// <tt>extern int LinkMyCodeStub;</tt><br/>
/// <tt>static IncludeFile LinkMyModule(&LinkMyCodeStub);</tt><br/>
/// @brief Class to ensure linking of corresponding object file.
struct IncludeFile {
explicit IncludeFile(const void *);
};
}
#endif

3
lib/Analysis/IPA/CallGraph.cpp
View File

@ -282,6 +282,3 @@ void CallGraphWrapperPass::print(raw_ostream &OS, const Module *) const {
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void CallGraphWrapperPass::dump() const { print(dbgs(), nullptr); }
#endif
// Enuse that users of CallGraph.h also link with this file
DEFINING_FILE_FOR(CallGraph)

1
lib/Support/CMakeLists.txt
View File

@ -76,7 +76,6 @@ add_llvm_library(LLVMSupport
DynamicLibrary.cpp
Errno.cpp
Host.cpp
IncludeFile.cpp
Memory.cpp
Mutex.cpp
Path.cpp

20
lib/Support/IncludeFile.cpp
View File

@ -1,20 +0,0 @@
//===- lib/Support/IncludeFile.cpp - Ensure Linking Of Implementation -----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the IncludeFile constructor.
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/IncludeFile.h"
using namespace llvm;
// This constructor is used to ensure linking of other modules. See the
// llvm/Support/IncludeFile.h header for details.
IncludeFile::IncludeFile(const void*) {}