diff options
Diffstat (limited to 'third_party/libwebrtc/tools/clang')
33 files changed, 1912 insertions, 0 deletions
diff --git a/third_party/libwebrtc/tools/clang/OWNERS b/third_party/libwebrtc/tools/clang/OWNERS new file mode 100644 index 0000000000..d86ef9424a --- /dev/null +++ b/third_party/libwebrtc/tools/clang/OWNERS @@ -0,0 +1,2 @@ +hans@chromium.org +thakis@chromium.org diff --git a/third_party/libwebrtc/tools/clang/plugins/ChromeClassTester.cpp b/third_party/libwebrtc/tools/clang/plugins/ChromeClassTester.cpp new file mode 100644 index 0000000000..055866c5c5 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/ChromeClassTester.cpp @@ -0,0 +1,294 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// A general interface for filtering and only acting on classes in Chromium C++ +// code. + +#include "ChromeClassTester.h" + +#include <sys/param.h> + +#include "clang/AST/AST.h" +#include "clang/Basic/FileManager.h" +#include "clang/Basic/SourceManager.h" + +using namespace clang; + +namespace { + +bool starts_with(const std::string& one, const std::string& two) { + return one.compare(0, two.size(), two) == 0; +} + +std::string lstrip(const std::string& one, const std::string& two) { + if (starts_with(one, two)) + return one.substr(two.size()); + return one; +} + +bool ends_with(const std::string& one, const std::string& two) { + if (two.size() > one.size()) + return false; + + return one.compare(one.size() - two.size(), two.size(), two) == 0; +} + +} // namespace + +ChromeClassTester::ChromeClassTester(CompilerInstance& instance) + : instance_(instance), + diagnostic_(instance.getDiagnostics()) { + BuildBannedLists(); +} + +ChromeClassTester::~ChromeClassTester() {} + +void ChromeClassTester::HandleTagDeclDefinition(TagDecl* tag) { + pending_class_decls_.push_back(tag); +} + +bool ChromeClassTester::HandleTopLevelDecl(DeclGroupRef group_ref) { + for (size_t i = 0; i < pending_class_decls_.size(); ++i) + CheckTag(pending_class_decls_[i]); + pending_class_decls_.clear(); + + return true; // true means continue parsing. +} + +void ChromeClassTester::CheckTag(TagDecl* tag) { + // We handle class types here where we have semantic information. We can only + // check structs/classes/enums here, but we get a bunch of nice semantic + // information instead of just parsing information. + + if (CXXRecordDecl* record = dyn_cast<CXXRecordDecl>(tag)) { + // If this is a POD or a class template or a type dependent on a + // templated class, assume there's no ctor/dtor/virtual method + // optimization that we can do. + if (record->isPOD() || + record->getDescribedClassTemplate() || + record->getTemplateSpecializationKind() || + record->isDependentType()) + return; + + if (InBannedNamespace(record)) + return; + + SourceLocation record_location = record->getInnerLocStart(); + if (InBannedDirectory(record_location)) + return; + + // We sadly need to maintain a blacklist of types that violate these + // rules, but do so for good reason or due to limitations of this + // checker (i.e., we don't handle extern templates very well). + std::string base_name = record->getNameAsString(); + if (IsIgnoredType(base_name)) + return; + + // We ignore all classes that end with "Matcher" because they're probably + // GMock artifacts. + if (ends_with(base_name, "Matcher")) + return; + + CheckChromeClass(record_location, record); + } +} + +void ChromeClassTester::emitWarning(SourceLocation loc, + const char* raw_error) { + FullSourceLoc full(loc, instance().getSourceManager()); + std::string err; + err = "[chromium-style] "; + err += raw_error; + DiagnosticsEngine::Level level = + diagnostic().getWarningsAsErrors() ? + DiagnosticsEngine::Error : + DiagnosticsEngine::Warning; + unsigned id = diagnostic().getCustomDiagID(level, err); + DiagnosticBuilder builder = diagnostic().Report(full, id); +} + +bool ChromeClassTester::InBannedNamespace(const Decl* record) { + std::string n = GetNamespace(record); + if (!n.empty()) { + return std::find(banned_namespaces_.begin(), banned_namespaces_.end(), n) + != banned_namespaces_.end(); + } + + return false; +} + +std::string ChromeClassTester::GetNamespace(const Decl* record) { + return GetNamespaceImpl(record->getDeclContext(), ""); +} + +bool ChromeClassTester::InImplementationFile(SourceLocation record_location) { + std::string filename; + if (!GetFilename(record_location, &filename)) + return false; + + if (ends_with(filename, ".cc") || ends_with(filename, ".cpp") || + ends_with(filename, ".mm")) { + return true; + } + + return false; +} + +void ChromeClassTester::BuildBannedLists() { + banned_namespaces_.push_back("std"); + banned_namespaces_.push_back("__gnu_cxx"); + banned_namespaces_.push_back("WebKit"); + + banned_directories_.push_back("third_party/"); + banned_directories_.push_back("native_client/"); + banned_directories_.push_back("breakpad/"); + banned_directories_.push_back("courgette/"); + banned_directories_.push_back("pdf/"); + banned_directories_.push_back("ppapi/"); + banned_directories_.push_back("usr/"); + banned_directories_.push_back("testing/"); + banned_directories_.push_back("googleurl/"); + banned_directories_.push_back("v8/"); + banned_directories_.push_back("dart/"); + banned_directories_.push_back("sdch/"); + banned_directories_.push_back("icu4c/"); + banned_directories_.push_back("frameworks/"); + + // Don't check autogenerated headers. + // Make puts them below $(builddir_name)/.../gen and geni. + // Ninja puts them below OUTPUT_DIR/.../gen + // Xcode has a fixed output directory for everything. + banned_directories_.push_back("gen/"); + banned_directories_.push_back("geni/"); + banned_directories_.push_back("xcodebuild/"); + + // You are standing in a mazy of twisty dependencies, all resolved by + // putting everything in the header. + banned_directories_.push_back("automation/"); + + // Don't check system headers. + banned_directories_.push_back("/Developer/"); + + // Used in really low level threading code that probably shouldn't be out of + // lined. + ignored_record_names_.insert("ThreadLocalBoolean"); + + // A complicated pickle derived struct that is all packed integers. + ignored_record_names_.insert("Header"); + + // Part of the GPU system that uses multiple included header + // weirdness. Never getting this right. + ignored_record_names_.insert("Validators"); + + // Has a UNIT_TEST only constructor. Isn't *terribly* complex... + ignored_record_names_.insert("AutocompleteController"); + ignored_record_names_.insert("HistoryURLProvider"); + + // Because of chrome frame + ignored_record_names_.insert("ReliabilityTestSuite"); + + // Used over in the net unittests. A large enough bundle of integers with 1 + // non-pod class member. Probably harmless. + ignored_record_names_.insert("MockTransaction"); + + // Used heavily in ui_unittests and once in views_unittests. Fixing this + // isn't worth the overhead of an additional library. + ignored_record_names_.insert("TestAnimationDelegate"); + + // Part of our public interface that nacl and friends use. (Arguably, this + // should mean that this is a higher priority but fixing this looks hard.) + ignored_record_names_.insert("PluginVersionInfo"); +} + +std::string ChromeClassTester::GetNamespaceImpl(const DeclContext* context, + const std::string& candidate) { + switch (context->getDeclKind()) { + case Decl::TranslationUnit: { + return candidate; + } + case Decl::Namespace: { + const NamespaceDecl* decl = dyn_cast<NamespaceDecl>(context); + std::string name_str; + llvm::raw_string_ostream OS(name_str); + if (decl->isAnonymousNamespace()) + OS << "<anonymous namespace>"; + else + OS << *decl; + return GetNamespaceImpl(context->getParent(), + OS.str()); + } + default: { + return GetNamespaceImpl(context->getParent(), candidate); + } + } +} + +bool ChromeClassTester::InBannedDirectory(SourceLocation loc) { + std::string filename; + if (!GetFilename(loc, &filename)) { + // If the filename cannot be determined, simply treat this as a banned + // location, instead of going through the full lookup process. + return true; + } + + // We need to special case scratch space; which is where clang does its + // macro expansion. We explicitly want to allow people to do otherwise bad + // things through macros that were defined due to third party libraries. + if (filename == "<scratch space>") + return true; + + // Don't complain about autogenerated protobuf files. + if (ends_with(filename, ".pb.h")) { + return true; + } + + // We need to munge the paths so that they are relative to the repository + // srcroot. We first resolve the symlinktastic relative path and then + // remove our known srcroot from it if needed. + char resolvedPath[MAXPATHLEN]; + if (realpath(filename.c_str(), resolvedPath)) { + filename = resolvedPath; + } + + // On linux, chrome is often checked out to /usr/local/google. Due to the + // "usr" rule in banned_directories_, all diagnostics would be suppressed + // in that case. As a workaround, strip that prefix. + filename = lstrip(filename, "/usr/local/google"); + + for (std::vector<std::string>::const_iterator it = + banned_directories_.begin(); + it != banned_directories_.end(); ++it) { + // If we can find any of the banned path components in this path, then + // this file is rejected. + size_t index = filename.find(*it); + if (index != std::string::npos) { + bool matches_full_dir_name = index == 0 || filename[index - 1] == '/'; + if ((*it)[0] == '/') + matches_full_dir_name = true; + if (matches_full_dir_name) + return true; + } + } + + return false; +} + +bool ChromeClassTester::IsIgnoredType(const std::string& base_name) { + return ignored_record_names_.find(base_name) != ignored_record_names_.end(); +} + +bool ChromeClassTester::GetFilename(SourceLocation loc, + std::string* filename) { + const SourceManager& source_manager = instance_.getSourceManager(); + SourceLocation spelling_location = source_manager.getSpellingLoc(loc); + PresumedLoc ploc = source_manager.getPresumedLoc(spelling_location); + if (ploc.isInvalid()) { + // If we're in an invalid location, we're looking at things that aren't + // actually stated in the source. + return false; + } + + *filename = ploc.getFilename(); + return true; +} diff --git a/third_party/libwebrtc/tools/clang/plugins/ChromeClassTester.h b/third_party/libwebrtc/tools/clang/plugins/ChromeClassTester.h new file mode 100644 index 0000000000..588ae9cae5 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/ChromeClassTester.h @@ -0,0 +1,84 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef TOOLS_CLANG_PLUGINS_CHROMECLASSTESTER_H_ +#define TOOLS_CLANG_PLUGINS_CHROMECLASSTESTER_H_ + +#include <set> +#include <vector> + +#include "clang/AST/ASTConsumer.h" +#include "clang/AST/TypeLoc.h" +#include "clang/Frontend/CompilerInstance.h" + +// A class on top of ASTConsumer that forwards classes defined in Chromium +// headers to subclasses which implement CheckChromeClass(). +class ChromeClassTester : public clang::ASTConsumer { + public: + explicit ChromeClassTester(clang::CompilerInstance& instance); + virtual ~ChromeClassTester(); + + // clang::ASTConsumer: + virtual void HandleTagDeclDefinition(clang::TagDecl* tag); + virtual bool HandleTopLevelDecl(clang::DeclGroupRef group_ref); + + protected: + clang::CompilerInstance& instance() { return instance_; } + clang::DiagnosticsEngine& diagnostic() { return diagnostic_; } + + // Emits a simple warning; this shouldn't be used if you require printf-style + // printing. + void emitWarning(clang::SourceLocation loc, const char* error); + + // Utility method for subclasses to check if this class is in a banned + // namespace. + bool InBannedNamespace(const clang::Decl* record); + + // Utility method for subclasses to determine the namespace of the + // specified record, if any. Unnamed namespaces will be identified as + // "<anonymous namespace>". + std::string GetNamespace(const clang::Decl* record); + + // Utility method for subclasses to check if this class is within an + // implementation (.cc, .cpp, .mm) file. + bool InImplementationFile(clang::SourceLocation location); + + private: + void BuildBannedLists(); + + void CheckTag(clang::TagDecl*); + + // Filtered versions of tags that are only called with things defined in + // chrome header files. + virtual void CheckChromeClass(clang::SourceLocation record_location, + clang::CXXRecordDecl* record) = 0; + + // Utility methods used for filtering out non-chrome classes (and ones we + // deliberately ignore) in HandleTagDeclDefinition(). + std::string GetNamespaceImpl(const clang::DeclContext* context, + const std::string& candidate); + bool InBannedDirectory(clang::SourceLocation loc); + bool IsIgnoredType(const std::string& base_name); + + // Attempts to determine the filename for the given SourceLocation. + // Returns false if the filename could not be determined. + bool GetFilename(clang::SourceLocation loc, std::string* filename); + + clang::CompilerInstance& instance_; + clang::DiagnosticsEngine& diagnostic_; + + // List of banned namespaces. + std::vector<std::string> banned_namespaces_; + + // List of banned directories. + std::vector<std::string> banned_directories_; + + // List of types that we don't check. + std::set<std::string> ignored_record_names_; + + // List of decls to check once the current top-level decl is parsed. + std::vector<clang::TagDecl*> pending_class_decls_; +}; + +#endif // TOOLS_CLANG_PLUGINS_CHROMECLASSTESTER_H_ diff --git a/third_party/libwebrtc/tools/clang/plugins/FindBadConstructs.cpp b/third_party/libwebrtc/tools/clang/plugins/FindBadConstructs.cpp new file mode 100644 index 0000000000..b79a64dbd1 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/FindBadConstructs.cpp @@ -0,0 +1,435 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// This file defines a bunch of recurring problems in the Chromium C++ code. +// +// Checks that are implemented: +// - Constructors/Destructors should not be inlined if they are of a complex +// class type. +// - Missing "virtual" keywords on methods that should be virtual. +// - Non-annotated overriding virtual methods. +// - Virtual methods with nonempty implementations in their headers. +// - Classes that derive from base::RefCounted / base::RefCountedThreadSafe +// should have protected or private destructors. + +#include "clang/Frontend/FrontendPluginRegistry.h" +#include "clang/AST/ASTConsumer.h" +#include "clang/AST/AST.h" +#include "clang/AST/CXXInheritance.h" +#include "clang/AST/TypeLoc.h" +#include "clang/Basic/SourceManager.h" +#include "clang/Frontend/CompilerInstance.h" +#include "llvm/Support/raw_ostream.h" + +#include "ChromeClassTester.h" + +using namespace clang; + +namespace { + +bool TypeHasNonTrivialDtor(const Type* type) { + if (const CXXRecordDecl* cxx_r = type->getCXXRecordDeclForPointerType()) + return cxx_r->hasTrivialDestructor(); + + return false; +} + +// Returns the underlying Type for |type| by expanding typedefs and removing +// any namespace qualifiers. +const Type* UnwrapType(const Type* type) { + if (const ElaboratedType* elaborated = dyn_cast<ElaboratedType>(type)) + return UnwrapType(elaborated->getNamedType().getTypePtr()); + if (const TypedefType* typedefed = dyn_cast<TypedefType>(type)) + return UnwrapType(typedefed->desugar().getTypePtr()); + return type; +} + +// Searches for constructs that we know we don't want in the Chromium code base. +class FindBadConstructsConsumer : public ChromeClassTester { + public: + FindBadConstructsConsumer(CompilerInstance& instance, + bool check_refcounted_dtors, + bool check_virtuals_in_implementations) + : ChromeClassTester(instance), + check_refcounted_dtors_(check_refcounted_dtors), + check_virtuals_in_implementations_(check_virtuals_in_implementations) { + } + + virtual void CheckChromeClass(SourceLocation record_location, + CXXRecordDecl* record) { + bool implementation_file = InImplementationFile(record_location); + + if (!implementation_file) { + // Only check for "heavy" constructors/destructors in header files; + // within implementation files, there is no performance cost. + CheckCtorDtorWeight(record_location, record); + } + + if (!implementation_file || check_virtuals_in_implementations_) { + bool warn_on_inline_bodies = !implementation_file; + + // Check that all virtual methods are marked accordingly with both + // virtual and OVERRIDE. + CheckVirtualMethods(record_location, record, warn_on_inline_bodies); + } + + if (check_refcounted_dtors_) + CheckRefCountedDtors(record_location, record); + } + + private: + bool check_refcounted_dtors_; + bool check_virtuals_in_implementations_; + + // Returns true if |base| specifies one of the Chromium reference counted + // classes (base::RefCounted / base::RefCountedThreadSafe). |user_data| is + // ignored. + static bool IsRefCountedCallback(const CXXBaseSpecifier* base, + CXXBasePath& path, + void* user_data) { + FindBadConstructsConsumer* self = + static_cast<FindBadConstructsConsumer*>(user_data); + + const TemplateSpecializationType* base_type = + dyn_cast<TemplateSpecializationType>( + UnwrapType(base->getType().getTypePtr())); + if (!base_type) { + // Base-most definition is not a template, so this cannot derive from + // base::RefCounted. However, it may still be possible to use with a + // scoped_refptr<> and support ref-counting, so this is not a perfect + // guarantee of safety. + return false; + } + + TemplateName name = base_type->getTemplateName(); + if (TemplateDecl* decl = name.getAsTemplateDecl()) { + std::string base_name = decl->getNameAsString(); + + // Check for both base::RefCounted and base::RefCountedThreadSafe. + if (base_name.compare(0, 10, "RefCounted") == 0 && + self->GetNamespace(decl) == "base") { + return true; + } + } + return false; + } + + // Prints errors if the destructor of a RefCounted class is public. + void CheckRefCountedDtors(SourceLocation record_location, + CXXRecordDecl* record) { + // Skip anonymous structs. + if (record->getIdentifier() == NULL) + return; + + CXXBasePaths paths; + if (!record->lookupInBases( + &FindBadConstructsConsumer::IsRefCountedCallback, this, paths)) { + return; // Class does not derive from a ref-counted base class. + } + + if (!record->hasUserDeclaredDestructor()) { + emitWarning( + record_location, + "Classes that are ref-counted should have explicit " + "destructors that are protected or private."); + } else if (CXXDestructorDecl* dtor = record->getDestructor()) { + if (dtor->getAccess() == AS_public) { + emitWarning( + dtor->getInnerLocStart(), + "Classes that are ref-counted should not have " + "public destructors."); + } + } + } + + // Prints errors if the constructor/destructor weight is too heavy. + void CheckCtorDtorWeight(SourceLocation record_location, + CXXRecordDecl* record) { + // We don't handle anonymous structs. If this record doesn't have a + // name, it's of the form: + // + // struct { + // ... + // } name_; + if (record->getIdentifier() == NULL) + return; + + // Count the number of templated base classes as a feature of whether the + // destructor can be inlined. + int templated_base_classes = 0; + for (CXXRecordDecl::base_class_const_iterator it = record->bases_begin(); + it != record->bases_end(); ++it) { + if (it->getTypeSourceInfo()->getTypeLoc().getTypeLocClass() == + TypeLoc::TemplateSpecialization) { + ++templated_base_classes; + } + } + + // Count the number of trivial and non-trivial member variables. + int trivial_member = 0; + int non_trivial_member = 0; + int templated_non_trivial_member = 0; + for (RecordDecl::field_iterator it = record->field_begin(); + it != record->field_end(); ++it) { + CountType(it->getType().getTypePtr(), + &trivial_member, + &non_trivial_member, + &templated_non_trivial_member); + } + + // Check to see if we need to ban inlined/synthesized constructors. Note + // that the cutoffs here are kind of arbitrary. Scores over 10 break. + int dtor_score = 0; + // Deriving from a templated base class shouldn't be enough to trigger + // the ctor warning, but if you do *anything* else, it should. + // + // TODO(erg): This is motivated by templated base classes that don't have + // any data members. Somehow detect when templated base classes have data + // members and treat them differently. + dtor_score += templated_base_classes * 9; + // Instantiating a template is an insta-hit. + dtor_score += templated_non_trivial_member * 10; + // The fourth normal class member should trigger the warning. + dtor_score += non_trivial_member * 3; + + int ctor_score = dtor_score; + // You should be able to have 9 ints before we warn you. + ctor_score += trivial_member; + + if (ctor_score >= 10) { + if (!record->hasUserDeclaredConstructor()) { + emitWarning(record_location, + "Complex class/struct needs an explicit out-of-line " + "constructor."); + } else { + // Iterate across all the constructors in this file and yell if we + // find one that tries to be inline. + for (CXXRecordDecl::ctor_iterator it = record->ctor_begin(); + it != record->ctor_end(); ++it) { + if (it->hasInlineBody()) { + if (it->isCopyConstructor() && + !record->hasUserDeclaredCopyConstructor()) { + emitWarning(record_location, + "Complex class/struct needs an explicit out-of-line " + "copy constructor."); + } else { + emitWarning(it->getInnerLocStart(), + "Complex constructor has an inlined body."); + } + } + } + } + } + + // The destructor side is equivalent except that we don't check for + // trivial members; 20 ints don't need a destructor. + if (dtor_score >= 10 && !record->hasTrivialDestructor()) { + if (!record->hasUserDeclaredDestructor()) { + emitWarning( + record_location, + "Complex class/struct needs an explicit out-of-line " + "destructor."); + } else if (CXXDestructorDecl* dtor = record->getDestructor()) { + if (dtor->hasInlineBody()) { + emitWarning(dtor->getInnerLocStart(), + "Complex destructor has an inline body."); + } + } + } + } + + void CheckVirtualMethod(const CXXMethodDecl* method, + bool warn_on_inline_bodies) { + if (!method->isVirtual()) + return; + + if (!method->isVirtualAsWritten()) { + SourceLocation loc = method->getTypeSpecStartLoc(); + if (isa<CXXDestructorDecl>(method)) + loc = method->getInnerLocStart(); + emitWarning(loc, "Overriding method must have \"virtual\" keyword."); + } + + // Virtual methods should not have inline definitions beyond "{}". This + // only matters for header files. + if (warn_on_inline_bodies && method->hasBody() && + method->hasInlineBody()) { + if (CompoundStmt* cs = dyn_cast<CompoundStmt>(method->getBody())) { + if (cs->size()) { + emitWarning( + cs->getLBracLoc(), + "virtual methods with non-empty bodies shouldn't be " + "declared inline."); + } + } + } + } + + bool InTestingNamespace(const Decl* record) { + return GetNamespace(record).find("testing") != std::string::npos; + } + + bool IsMethodInBannedNamespace(const CXXMethodDecl* method) { + if (InBannedNamespace(method)) + return true; + for (CXXMethodDecl::method_iterator i = method->begin_overridden_methods(); + i != method->end_overridden_methods(); + ++i) { + const CXXMethodDecl* overridden = *i; + if (IsMethodInBannedNamespace(overridden)) + return true; + } + + return false; + } + + void CheckOverriddenMethod(const CXXMethodDecl* method) { + if (!method->size_overridden_methods() || method->getAttr<OverrideAttr>()) + return; + + if (isa<CXXDestructorDecl>(method) || method->isPure()) + return; + + if (IsMethodInBannedNamespace(method)) + return; + + SourceLocation loc = method->getTypeSpecStartLoc(); + emitWarning(loc, "Overriding method must be marked with OVERRIDE."); + } + + // Makes sure there is a "virtual" keyword on virtual methods. + // + // Gmock objects trigger these for each MOCK_BLAH() macro used. So we have a + // trick to get around that. If a class has member variables whose types are + // in the "testing" namespace (which is how gmock works behind the scenes), + // there's a really high chance we won't care about these errors + void CheckVirtualMethods(SourceLocation record_location, + CXXRecordDecl* record, + bool warn_on_inline_bodies) { + for (CXXRecordDecl::field_iterator it = record->field_begin(); + it != record->field_end(); ++it) { + CXXRecordDecl* record_type = + it->getTypeSourceInfo()->getTypeLoc().getTypePtr()-> + getAsCXXRecordDecl(); + if (record_type) { + if (InTestingNamespace(record_type)) { + return; + } + } + } + + for (CXXRecordDecl::method_iterator it = record->method_begin(); + it != record->method_end(); ++it) { + if (it->isCopyAssignmentOperator() || isa<CXXConstructorDecl>(*it)) { + // Ignore constructors and assignment operators. + } else if (isa<CXXDestructorDecl>(*it) && + !record->hasUserDeclaredDestructor()) { + // Ignore non-user-declared destructors. + } else { + CheckVirtualMethod(*it, warn_on_inline_bodies); + CheckOverriddenMethod(*it); + } + } + } + + void CountType(const Type* type, + int* trivial_member, + int* non_trivial_member, + int* templated_non_trivial_member) { + switch (type->getTypeClass()) { + case Type::Record: { + // Simplifying; the whole class isn't trivial if the dtor is, but + // we use this as a signal about complexity. + if (TypeHasNonTrivialDtor(type)) + (*trivial_member)++; + else + (*non_trivial_member)++; + break; + } + case Type::TemplateSpecialization: { + TemplateName name = + dyn_cast<TemplateSpecializationType>(type)->getTemplateName(); + bool whitelisted_template = false; + + // HACK: I'm at a loss about how to get the syntax checker to get + // whether a template is exterened or not. For the first pass here, + // just do retarded string comparisons. + if (TemplateDecl* decl = name.getAsTemplateDecl()) { + std::string base_name = decl->getNameAsString(); + if (base_name == "basic_string") + whitelisted_template = true; + } + + if (whitelisted_template) + (*non_trivial_member)++; + else + (*templated_non_trivial_member)++; + break; + } + case Type::Elaborated: { + CountType( + dyn_cast<ElaboratedType>(type)->getNamedType().getTypePtr(), + trivial_member, non_trivial_member, templated_non_trivial_member); + break; + } + case Type::Typedef: { + while (const TypedefType* TT = dyn_cast<TypedefType>(type)) { + type = TT->getDecl()->getUnderlyingType().getTypePtr(); + } + CountType(type, trivial_member, non_trivial_member, + templated_non_trivial_member); + break; + } + default: { + // Stupid assumption: anything we see that isn't the above is one of + // the 20 integer types. + (*trivial_member)++; + break; + } + } + } +}; + +class FindBadConstructsAction : public PluginASTAction { + public: + FindBadConstructsAction() + : check_refcounted_dtors_(true), + check_virtuals_in_implementations_(true) { + } + + protected: + // Overridden from PluginASTAction: + virtual ASTConsumer* CreateASTConsumer(CompilerInstance& instance, + llvm::StringRef ref) { + return new FindBadConstructsConsumer( + instance, check_refcounted_dtors_, check_virtuals_in_implementations_); + } + + virtual bool ParseArgs(const CompilerInstance& instance, + const std::vector<std::string>& args) { + bool parsed = true; + + for (size_t i = 0; i < args.size() && parsed; ++i) { + if (args[i] == "skip-refcounted-dtors") { + check_refcounted_dtors_ = false; + } else if (args[i] == "skip-virtuals-in-implementations") { + check_virtuals_in_implementations_ = false; + } else { + parsed = false; + llvm::errs() << "Unknown argument: " << args[i] << "\n"; + } + } + + return parsed; + } + + private: + bool check_refcounted_dtors_; + bool check_virtuals_in_implementations_; +}; + +} // namespace + +static FrontendPluginRegistry::Add<FindBadConstructsAction> +X("find-bad-constructs", "Finds bad C++ constructs"); diff --git a/third_party/libwebrtc/tools/clang/plugins/Makefile b/third_party/libwebrtc/tools/clang/plugins/Makefile new file mode 100644 index 0000000000..0cfec71159 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/Makefile @@ -0,0 +1,19 @@ +# This file requires the clang build system, at least for now. So to use this +# Makefile, you should execute the following commands to copy this directory +# into a clang checkout: +# +# cp -R <this directory> third_party/llvm/tools/clang/tools/chrome-plugin +# cd third_party/llvm/tools/clang/tools/chrome-plugin +# make + +CLANG_LEVEL := ../.. +LIBRARYNAME = FindBadConstructs + +LINK_LIBS_IN_SHARED = 0 +SHARED_LIBRARY = 1 + +include $(CLANG_LEVEL)/Makefile + +ifeq ($(OS),Darwin) + LDFLAGS=-Wl,-undefined,dynamic_lookup +endif diff --git a/third_party/libwebrtc/tools/clang/plugins/OWNERS b/third_party/libwebrtc/tools/clang/plugins/OWNERS new file mode 100644 index 0000000000..4733a4f06b --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/OWNERS @@ -0,0 +1 @@ +erg@chromium.org diff --git a/third_party/libwebrtc/tools/clang/plugins/README.chromium b/third_party/libwebrtc/tools/clang/plugins/README.chromium new file mode 100644 index 0000000000..a2ce0ff557 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/README.chromium @@ -0,0 +1,4 @@ +Documentation for this code is: + +- http://code.google.com/p/chromium/wiki/Clang +- http://code.google.com/p/chromium/wiki/WritingClangPlugins diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/base_refcounted.cpp b/third_party/libwebrtc/tools/clang/plugins/tests/base_refcounted.cpp new file mode 100644 index 0000000000..364a3e888c --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/base_refcounted.cpp @@ -0,0 +1,72 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "base_refcounted.h" + +#include <cstddef> + +namespace { + +// Unsafe; should error. +class AnonymousDerivedProtectedToPublicInImpl + : public ProtectedRefCountedDtorInHeader { + public: + AnonymousDerivedProtectedToPublicInImpl() {} + ~AnonymousDerivedProtectedToPublicInImpl() {} +}; + +} // namespace + +// Unsafe; should error. +class PublicRefCountedDtorInImpl + : public base::RefCounted<PublicRefCountedDtorInImpl> { + public: + PublicRefCountedDtorInImpl() {} + ~PublicRefCountedDtorInImpl() {} + + private: + friend class base::RefCounted<PublicRefCountedDtorInImpl>; +}; + +class Foo { + public: + class BarInterface { + protected: + virtual ~BarInterface() {} + }; + + typedef base::RefCounted<BarInterface> RefCountedBar; + typedef RefCountedBar AnotherTypedef; +}; + +class Baz { + public: + typedef typename Foo::AnotherTypedef MyLocalTypedef; +}; + +// Unsafe; should error. +class UnsafeTypedefChainInImpl : public Baz::MyLocalTypedef { + public: + UnsafeTypedefChainInImpl() {} + ~UnsafeTypedefChainInImpl() {} +}; + +int main() { + PublicRefCountedDtorInHeader bad; + PublicRefCountedDtorInImpl also_bad; + + ProtectedRefCountedDtorInHeader* protected_ok = NULL; + PrivateRefCountedDtorInHeader* private_ok = NULL; + + DerivedProtectedToPublicInHeader still_bad; + PublicRefCountedThreadSafeDtorInHeader another_bad_variation; + AnonymousDerivedProtectedToPublicInImpl and_this_is_bad_too; + ImplicitDerivedProtectedToPublicInHeader bad_yet_again; + UnsafeTypedefChainInImpl and_again_this_is_bad; + + WebKitPublicDtorInHeader ignored; + WebKitDerivedPublicDtorInHeader still_ignored; + + return 0; +} diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/base_refcounted.h b/third_party/libwebrtc/tools/clang/plugins/tests/base_refcounted.h new file mode 100644 index 0000000000..1e53215997 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/base_refcounted.h @@ -0,0 +1,121 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef BASE_REFCOUNTED_H_ +#define BASE_REFCOUNTED_H_ + +namespace base { + +template <typename T> +class RefCounted { + public: + RefCounted() {} + ~RefCounted() {} +}; + +template <typename T> +class RefCountedThreadSafe { + public: + RefCountedThreadSafe() {} + ~RefCountedThreadSafe() {} +}; + +} // namespace base + +// Ignore classes whose inheritance tree ends in WebKit's RefCounted base +// class. Though prone to error, this pattern is very prevalent in WebKit +// code, so do not issue any warnings. +namespace WebKit { + +template <typename T> +class RefCounted { + public: + RefCounted() {} + ~RefCounted() {} +}; + +} // namespace WebKit + +// Unsafe; should error. +class PublicRefCountedDtorInHeader + : public base::RefCounted<PublicRefCountedDtorInHeader> { + public: + PublicRefCountedDtorInHeader() {} + ~PublicRefCountedDtorInHeader() {} + + private: + friend class base::RefCounted<PublicRefCountedDtorInHeader>; +}; + +// Unsafe; should error. +class PublicRefCountedThreadSafeDtorInHeader + : public base::RefCountedThreadSafe< + PublicRefCountedThreadSafeDtorInHeader> { + public: + PublicRefCountedThreadSafeDtorInHeader() {} + ~PublicRefCountedThreadSafeDtorInHeader() {} + + private: + friend class base::RefCountedThreadSafe< + PublicRefCountedThreadSafeDtorInHeader>; +}; + +// Safe; should not have errors. +class ProtectedRefCountedDtorInHeader + : public base::RefCounted<ProtectedRefCountedDtorInHeader> { + public: + ProtectedRefCountedDtorInHeader() {} + + protected: + ~ProtectedRefCountedDtorInHeader() {} + + private: + friend class base::RefCounted<ProtectedRefCountedDtorInHeader>; +}; + +// Safe; should not have errors. +class PrivateRefCountedDtorInHeader + : public base::RefCounted<PrivateRefCountedDtorInHeader> { + public: + PrivateRefCountedDtorInHeader() {} + + private: + ~PrivateRefCountedDtorInHeader() {} + friend class base::RefCounted<PrivateRefCountedDtorInHeader>; +}; + +// Unsafe; A grandchild class ends up exposing their parent and grandparent's +// destructors. +class DerivedProtectedToPublicInHeader + : public ProtectedRefCountedDtorInHeader { + public: + DerivedProtectedToPublicInHeader() {} + ~DerivedProtectedToPublicInHeader() {} +}; + +// Unsafe; A grandchild ends up implicitly exposing their parent and +// grantparent's destructors. +class ImplicitDerivedProtectedToPublicInHeader + : public ProtectedRefCountedDtorInHeader { + public: + ImplicitDerivedProtectedToPublicInHeader() {} +}; + +// Unsafe-but-ignored; should not have errors. +class WebKitPublicDtorInHeader + : public WebKit::RefCounted<WebKitPublicDtorInHeader> { + public: + WebKitPublicDtorInHeader() {} + ~WebKitPublicDtorInHeader() {} +}; + +// Unsafe-but-ignored; should not have errors. +class WebKitDerivedPublicDtorInHeader + : public WebKitPublicDtorInHeader { + public: + WebKitDerivedPublicDtorInHeader() {} + ~WebKitDerivedPublicDtorInHeader() {} +}; + +#endif // BASE_REFCOUNTED_H_ diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/base_refcounted.txt b/third_party/libwebrtc/tools/clang/plugins/tests/base_refcounted.txt new file mode 100644 index 0000000000..4626424177 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/base_refcounted.txt @@ -0,0 +1,23 @@ +In file included from base_refcounted.cpp:5: +./base_refcounted.h:45:3: warning: [chromium-style] Classes that are ref-counted should not have public destructors. + ~PublicRefCountedDtorInHeader() {} + ^ +./base_refcounted.h:57:3: warning: [chromium-style] Classes that are ref-counted should not have public destructors. + ~PublicRefCountedThreadSafeDtorInHeader() {} + ^ +./base_refcounted.h:94:3: warning: [chromium-style] Classes that are ref-counted should not have public destructors. + ~DerivedProtectedToPublicInHeader() {} + ^ +./base_refcounted.h:99:1: warning: [chromium-style] Classes that are ref-counted should have explicit destructors that are protected or private. +class ImplicitDerivedProtectedToPublicInHeader +^ +base_refcounted.cpp:16:3: warning: [chromium-style] Classes that are ref-counted should not have public destructors. + ~AnonymousDerivedProtectedToPublicInImpl() {} + ^ +base_refcounted.cpp:26:3: warning: [chromium-style] Classes that are ref-counted should not have public destructors. + ~PublicRefCountedDtorInImpl() {} + ^ +base_refcounted.cpp:52:3: warning: [chromium-style] Classes that are ref-counted should not have public destructors. + ~UnsafeTypedefChainInImpl() {} + ^ +7 warnings generated. diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/inline_copy_ctor.cpp b/third_party/libwebrtc/tools/clang/plugins/tests/inline_copy_ctor.cpp new file mode 100644 index 0000000000..dcd90020c5 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/inline_copy_ctor.cpp @@ -0,0 +1,5 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "inline_copy_ctor.h" diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/inline_copy_ctor.h b/third_party/libwebrtc/tools/clang/plugins/tests/inline_copy_ctor.h new file mode 100644 index 0000000000..619a18392b --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/inline_copy_ctor.h @@ -0,0 +1,12 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +struct C { + C(); + ~C(); + + static C foo() { return C(); } + + int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p , q, r, s, t, u, v, w, x; +}; diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/inline_copy_ctor.txt b/third_party/libwebrtc/tools/clang/plugins/tests/inline_copy_ctor.txt new file mode 100644 index 0000000000..bc4bd8911e --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/inline_copy_ctor.txt @@ -0,0 +1,5 @@ +In file included from inline_copy_ctor.cpp:5: +./inline_copy_ctor.h:5:1: warning: [chromium-style] Complex class/struct needs an explicit out-of-line copy constructor. +struct C { +^ +1 warning generated. diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/inline_ctor.cpp b/third_party/libwebrtc/tools/clang/plugins/tests/inline_ctor.cpp new file mode 100644 index 0000000000..6a751fb405 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/inline_ctor.cpp @@ -0,0 +1,25 @@ +// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "inline_ctor.h" + +#include <string> +#include <vector> + +// We don't warn on classes that are in CPP files. +class InlineInCPPOK { + public: + InlineInCPPOK() {} + ~InlineInCPPOK() {} + + private: + std::vector<int> one_; + std::vector<std::string> two_; +}; + +int main() { + InlineInCPPOK one; + InlineCtorsArentOKInHeader two; + return 0; +} diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/inline_ctor.h b/third_party/libwebrtc/tools/clang/plugins/tests/inline_ctor.h new file mode 100644 index 0000000000..d053b2f57d --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/inline_ctor.h @@ -0,0 +1,21 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef INLINE_CTOR_H_ +#define INLINE_CTOR_H_ + +#include <string> +#include <vector> + +class InlineCtorsArentOKInHeader { + public: + InlineCtorsArentOKInHeader() {} + ~InlineCtorsArentOKInHeader() {} + + private: + std::vector<int> one_; + std::vector<std::string> two_; +}; + +#endif // INLINE_CTOR_H_ diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/inline_ctor.txt b/third_party/libwebrtc/tools/clang/plugins/tests/inline_ctor.txt new file mode 100644 index 0000000000..caa0cb4e3b --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/inline_ctor.txt @@ -0,0 +1,8 @@ +In file included from inline_ctor.cpp:5: +./inline_ctor.h:13:3: warning: [chromium-style] Complex constructor has an inlined body. + InlineCtorsArentOKInHeader() {} + ^ +./inline_ctor.h:14:3: warning: [chromium-style] Complex destructor has an inline body. + ~InlineCtorsArentOKInHeader() {} + ^ +2 warnings generated. diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/missing_ctor.cpp b/third_party/libwebrtc/tools/clang/plugins/tests/missing_ctor.cpp new file mode 100644 index 0000000000..8ee2fb2ac8 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/missing_ctor.cpp @@ -0,0 +1,23 @@ +// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "missing_ctor.h" + +#include <string> +#include <vector> + +// We don't warn on classes that use default ctors in cpp files. +class MissingInCPPOK { + public: + + private: + std::vector<int> one_; + std::vector<std::string> two_; +}; + +int main() { + MissingInCPPOK one; + MissingCtorsArentOKInHeader two; + return 0; +} diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/missing_ctor.h b/third_party/libwebrtc/tools/clang/plugins/tests/missing_ctor.h new file mode 100644 index 0000000000..1050457a1a --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/missing_ctor.h @@ -0,0 +1,19 @@ +// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef MISSING_CTOR_H_ +#define MISSING_CTOR_H_ + +#include <string> +#include <vector> + +class MissingCtorsArentOKInHeader { + public: + + private: + std::vector<int> one_; + std::vector<std::string> two_; +}; + +#endif // MISSING_CTOR_H_ diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/missing_ctor.txt b/third_party/libwebrtc/tools/clang/plugins/tests/missing_ctor.txt new file mode 100644 index 0000000000..301449c4ac --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/missing_ctor.txt @@ -0,0 +1,6 @@ +In file included from missing_ctor.cpp:5: +./missing_ctor.h:11:1: warning: [chromium-style] Complex class/struct needs an explicit out-of-line constructor. +class MissingCtorsArentOKInHeader { +^ +./missing_ctor.h:11:1: warning: [chromium-style] Complex class/struct needs an explicit out-of-line destructor. +2 warnings generated. diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/nested_class_inline_ctor.cpp b/third_party/libwebrtc/tools/clang/plugins/tests/nested_class_inline_ctor.cpp new file mode 100644 index 0000000000..aa90a95eb3 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/nested_class_inline_ctor.cpp @@ -0,0 +1,5 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "nested_class_inline_ctor.h" diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/nested_class_inline_ctor.h b/third_party/libwebrtc/tools/clang/plugins/tests/nested_class_inline_ctor.h new file mode 100644 index 0000000000..01cfea9232 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/nested_class_inline_ctor.h @@ -0,0 +1,22 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef NESTED_CLASS_INLINE_CTOR_H_ +#define NESTED_CLASS_INLINE_CTOR_H_ + +#include <string> +#include <vector> + +// See crbug.com/136863. + +class Foo { + class Bar { + Bar() {} + ~Bar() {} + + std::vector<std::string> a; + }; +}; + +#endif // NESTED_CLASS_INLINE_CTOR_H_ diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/nested_class_inline_ctor.txt b/third_party/libwebrtc/tools/clang/plugins/tests/nested_class_inline_ctor.txt new file mode 100644 index 0000000000..39bd6e1dce --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/nested_class_inline_ctor.txt @@ -0,0 +1,8 @@ +In file included from nested_class_inline_ctor.cpp:5: +./nested_class_inline_ctor.h:15:5: warning: [chromium-style] Complex constructor has an inlined body. + Bar() {} + ^ +./nested_class_inline_ctor.h:16:5: warning: [chromium-style] Complex destructor has an inline body. + ~Bar() {} + ^ +2 warnings generated. diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/overridden_methods.cpp b/third_party/libwebrtc/tools/clang/plugins/tests/overridden_methods.cpp new file mode 100644 index 0000000000..f572a41733 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/overridden_methods.cpp @@ -0,0 +1,38 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "overridden_methods.h" + +// Fill in the implementations +void DerivedClass::SomeMethod() {} +void DerivedClass::SomeOtherMethod() {} +void DerivedClass::WebKitModifiedSomething() {} + +class ImplementationInterimClass : public BaseClass { + public: + // Should not warn about pure virtual methods. + virtual void SomeMethod() = 0; +}; + +class ImplementationDerivedClass : public ImplementationInterimClass, + public webkit_glue::WebKitObserverImpl { + public: + // Should not warn about destructors. + virtual ~ImplementationDerivedClass() {} + // Should warn. + virtual void SomeMethod(); + // Should not warn if marked as override. + virtual void SomeOtherMethod() override; + // Should not warn for inline implementations in implementation files. + virtual void SomeInlineMethod() {} + // Should not warn if overriding a method whose origin is WebKit. + virtual void WebKitModifiedSomething(); + // Should warn if overridden method isn't pure. + virtual void SomeNonPureBaseMethod() {} +}; + +int main() { + DerivedClass something; + ImplementationDerivedClass something_else; +} diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/overridden_methods.h b/third_party/libwebrtc/tools/clang/plugins/tests/overridden_methods.h new file mode 100644 index 0000000000..150c79913f --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/overridden_methods.h @@ -0,0 +1,54 @@ +// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef OVERRIDDEN_METHODS_H_ +#define OVERRIDDEN_METHODS_H_ + +// Should warn about overriding of methods. +class BaseClass { + public: + virtual ~BaseClass() {} + virtual void SomeMethod() = 0; + virtual void SomeOtherMethod() = 0; + virtual void SomeInlineMethod() = 0; + virtual void SomeNonPureBaseMethod() {} +}; + +class InterimClass : public BaseClass { + // Should not warn about pure virtual methods. + virtual void SomeMethod() = 0; +}; + +namespace WebKit { +class WebKitObserver { + public: + virtual void WebKitModifiedSomething() {}; +}; +} // namespace WebKit + +namespace webkit_glue { +class WebKitObserverImpl : WebKit::WebKitObserver { + public: + virtual void WebKitModifiedSomething() {}; +}; +} // namespace webkit_glue + +class DerivedClass : public InterimClass, + public webkit_glue::WebKitObserverImpl { + public: + // Should not warn about destructors. + virtual ~DerivedClass() {} + // Should warn. + virtual void SomeMethod(); + // Should not warn if marked as override. + virtual void SomeOtherMethod() override; + // Should warn for inline implementations. + virtual void SomeInlineMethod() {} + // Should not warn if overriding a method whose origin is WebKit. + virtual void WebKitModifiedSomething(); + // Should warn if overridden method isn't pure. + virtual void SomeNonPureBaseMethod() {} +}; + +#endif // OVERRIDDEN_METHODS_H_ diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/overridden_methods.txt b/third_party/libwebrtc/tools/clang/plugins/tests/overridden_methods.txt new file mode 100644 index 0000000000..7553ade70e --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/overridden_methods.txt @@ -0,0 +1,20 @@ +In file included from overridden_methods.cpp:5: +./overridden_methods.h:43:11: warning: [chromium-style] Overriding method must be marked with OVERRIDE. + virtual void SomeMethod(); + ^ +./overridden_methods.h:47:11: warning: [chromium-style] Overriding method must be marked with OVERRIDE. + virtual void SomeInlineMethod() {} + ^ +./overridden_methods.h:51:11: warning: [chromium-style] Overriding method must be marked with OVERRIDE. + virtual void SomeNonPureBaseMethod() {} + ^ +overridden_methods.cpp:24:11: warning: [chromium-style] Overriding method must be marked with OVERRIDE. + virtual void SomeMethod(); + ^ +overridden_methods.cpp:28:11: warning: [chromium-style] Overriding method must be marked with OVERRIDE. + virtual void SomeInlineMethod() {} + ^ +overridden_methods.cpp:32:11: warning: [chromium-style] Overriding method must be marked with OVERRIDE. + virtual void SomeNonPureBaseMethod() {} + ^ +6 warnings generated. diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/test.sh b/third_party/libwebrtc/tools/clang/plugins/tests/test.sh new file mode 100755 index 0000000000..262ebbba29 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/test.sh @@ -0,0 +1,72 @@ +#!/bin/bash +# +# Copyright (c) 2011 The Chromium Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. +# +# Hacky, primitive testing: This runs the style plugin for a set of input files +# and compares the output with golden result files. + +E_BADARGS=65 +E_FAILEDTEST=1 + +failed_any_test= + +# Prints usage information. +usage() { + echo "Usage: $(basename "${0}")" \ + "<Path to the llvm build dir, usually Release+Asserts>" + echo "" + echo " Runs all the libFindBadConstructs unit tests" + echo "" +} + +# Runs a single test case. +do_testcase() { + local output="$("${CLANG_DIR}"/bin/clang -c -Wno-c++11-extensions \ + -Xclang -load -Xclang "${CLANG_DIR}"/lib/libFindBadConstructs.${LIB} \ + -Xclang -plugin -Xclang find-bad-constructs ${1} 2>&1)" + local diffout="$(echo "${output}" | diff - "${2}")" + if [ "${diffout}" = "" ]; then + echo "PASS: ${1}" + else + failed_any_test=yes + echo "FAIL: ${1}" + echo "Output of compiler:" + echo "${output}" + echo "Expected output:" + cat "${2}" + echo + fi +} + +# Validate input to the script. +if [[ -z "${1}" ]]; then + usage + exit ${E_BADARGS} +elif [[ ! -d "${1}" ]]; then + echo "${1} is not a directory." + usage + exit ${E_BADARGS} +else + export CLANG_DIR="${PWD}/${1}" + echo "Using clang directory ${CLANG_DIR}..." + + # The golden files assume that the cwd is this directory. To make the script + # work no matter what the cwd is, explicitly cd to there. + cd "$(dirname "${0}")" + + if [ "$(uname -s)" = "Linux" ]; then + export LIB=so + elif [ "$(uname -s)" = "Darwin" ]; then + export LIB=dylib + fi +fi + +for input in *.cpp; do + do_testcase "${input}" "${input%cpp}txt" +done + +if [[ "${failed_any_test}" ]]; then + exit ${E_FAILEDTEST} +fi diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/virtual_methods.cpp b/third_party/libwebrtc/tools/clang/plugins/tests/virtual_methods.cpp new file mode 100644 index 0000000000..a07cbe4875 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/virtual_methods.cpp @@ -0,0 +1,36 @@ +// Copyright (c) 2012 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "virtual_methods.h" + +// Shouldn't warn about method usage in the implementation file. +class VirtualMethodsInImplementation { + public: + virtual void MethodIsAbstract() = 0; + virtual void MethodHasNoArguments(); + virtual void MethodHasEmptyDefaultImpl() {} + virtual bool ComplainAboutThis() { return true; } +}; + +// Stubs to fill in the abstract method +class ConcreteVirtualMethodsInHeaders : public VirtualMethodsInHeaders { + public: + virtual void MethodIsAbstract() override {} +}; + +class ConcreteVirtualMethodsInImplementation + : public VirtualMethodsInImplementation { + public: + virtual void MethodIsAbstract() override {} +}; + +// Fill in the implementations +void VirtualMethodsInHeaders::MethodHasNoArguments() {} +void WarnOnMissingVirtual::MethodHasNoArguments() {} +void VirtualMethodsInImplementation::MethodHasNoArguments() {} + +int main() { + ConcreteVirtualMethodsInHeaders one; + ConcreteVirtualMethodsInImplementation two; +} diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/virtual_methods.h b/third_party/libwebrtc/tools/clang/plugins/tests/virtual_methods.h new file mode 100644 index 0000000000..d9fbf96ed3 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/virtual_methods.h @@ -0,0 +1,39 @@ +// Copyright (c) 2011 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef VIRTUAL_METHODS_H_ +#define VIRTUAL_METHODS_H_ + +// Should warn about virtual method usage. +class VirtualMethodsInHeaders { + public: + // Don't complain about these. + virtual void MethodIsAbstract() = 0; + virtual void MethodHasNoArguments(); + virtual void MethodHasEmptyDefaultImpl() {} + + // But complain about this: + virtual bool ComplainAboutThis() { return true; } +}; + +// Complain on missing 'virtual' keyword in overrides. +class WarnOnMissingVirtual : public VirtualMethodsInHeaders { + public: + void MethodHasNoArguments() override; +}; + +// Don't complain about things in a 'testing' namespace. +namespace testing { +struct TestStruct {}; +} // namespace testing + +class VirtualMethodsInHeadersTesting : public VirtualMethodsInHeaders { + public: + // Don't complain about no virtual testing methods. + void MethodHasNoArguments(); + private: + testing::TestStruct tester_; +}; + +#endif // VIRTUAL_METHODS_H_ diff --git a/third_party/libwebrtc/tools/clang/plugins/tests/virtual_methods.txt b/third_party/libwebrtc/tools/clang/plugins/tests/virtual_methods.txt new file mode 100644 index 0000000000..571d6d667d --- /dev/null +++ b/third_party/libwebrtc/tools/clang/plugins/tests/virtual_methods.txt @@ -0,0 +1,8 @@ +In file included from virtual_methods.cpp:5: +./virtual_methods.h:17:36: warning: [chromium-style] virtual methods with non-empty bodies shouldn't be declared inline. + virtual bool ComplainAboutThis() { return true; } + ^ +./virtual_methods.h:23:3: warning: [chromium-style] Overriding method must have "virtual" keyword. + void MethodHasNoArguments() override; + ^ +2 warnings generated. diff --git a/third_party/libwebrtc/tools/clang/scripts/package.sh b/third_party/libwebrtc/tools/clang/scripts/package.sh new file mode 100755 index 0000000000..eb345810b9 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/scripts/package.sh @@ -0,0 +1,87 @@ +#!/bin/bash +# Copyright (c) 2012 The Chromium Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +# This script will check out llvm and clang, and then package the results up +# to a tgz file. + +THIS_DIR="$(dirname "${0}")" +LLVM_DIR="${THIS_DIR}/../../../third_party/llvm" +LLVM_BOOTSTRAP_DIR="${THIS_DIR}/../../../third_party/llvm-bootstrap" +LLVM_BUILD_DIR="${THIS_DIR}/../../../third_party/llvm-build" +LLVM_BIN_DIR="${LLVM_BUILD_DIR}/Release+Asserts/bin" +LLVM_LIB_DIR="${LLVM_BUILD_DIR}/Release+Asserts/lib" + +echo "Diff in llvm:" | tee buildlog.txt +svn stat "${LLVM_DIR}" 2>&1 | tee -a buildlog.txt +svn diff "${LLVM_DIR}" 2>&1 | tee -a buildlog.txt +echo "Diff in llvm/tools/clang:" | tee -a buildlog.txt +svn stat "${LLVM_DIR}/tools/clang" 2>&1 | tee -a buildlog.txt +svn diff "${LLVM_DIR}/tools/clang" 2>&1 | tee -a buildlog.txt +echo "Diff in llvm/projects/compiler-rt:" | tee -a buildlog.txt +svn stat "${LLVM_DIR}/projects/compiler-rt" 2>&1 | tee -a buildlog.txt +svn diff "${LLVM_DIR}/projects/compiler-rt" 2>&1 | tee -a buildlog.txt + +echo "Starting build" | tee -a buildlog.txt + +set -ex + +# Do a clobber build. +rm -rf "${LLVM_BOOTSTRAP_DIR}" +rm -rf "${LLVM_BUILD_DIR}" +"${THIS_DIR}"/update.sh --run-tests --bootstrap --force-local-build 2>&1 | \ + tee -a buildlog.txt + +R=$("${LLVM_BIN_DIR}/clang" --version | \ + sed -ne 's/clang version .*(trunk \([0-9]*\))/\1/p') + +PDIR=clang-$R +rm -rf $PDIR +mkdir $PDIR +mkdir $PDIR/bin +mkdir $PDIR/lib + +# Copy buildlog over. +cp buildlog.txt $PDIR/ + +# Copy clang into pdir, symlink clang++ to it. +cp "${LLVM_BIN_DIR}/clang" $PDIR/bin/ +(cd $PDIR/bin && ln -sf clang clang++ && cd -) + +# Copy plugins. Some of the dylibs are pretty big, so copy only the ones we +# care about. +if [ "$(uname -s)" = "Darwin" ]; then + cp "${LLVM_LIB_DIR}/libFindBadConstructs.dylib" $PDIR/lib +else + cp "${LLVM_LIB_DIR}/libFindBadConstructs.so" $PDIR/lib +fi + +# Copy built-in headers (lib/clang/3.2/include). +# libcompiler-rt puts all kinds of libraries there too, but we want only ASan. +if [ "$(uname -s)" = "Darwin" ]; then + # Keep only Release+Asserts/lib/clang/3.2/lib/darwin/libclang_rt.asan_osx.a + find "${LLVM_LIB_DIR}/clang" -type f -path '*lib/darwin*' | grep -v asan | \ + xargs rm +else + # Keep only + # Release+Asserts/lib/clang/3.2/lib/linux/libclang_rt.{asan,tsan}-x86_64.a + # TODO(thakis): Make sure the 32bit version of ASan runtime is kept too once + # that's built. TSan runtime exists only for 64 bits. + find "${LLVM_LIB_DIR}/clang" -type f -path '*lib/linux*' | \ + grep -v "asan\|tsan" | xargs rm +fi + +cp -R "${LLVM_LIB_DIR}/clang" $PDIR/lib + +tar zcf $PDIR.tgz -C $PDIR bin lib buildlog.txt + +if [ "$(uname -s)" = "Darwin" ]; then + PLATFORM=Mac +else + PLATFORM=Linux_x64 +fi + +echo To upload, run: +echo gsutil cp -a public-read $PDIR.tgz \ + gs://chromium-browser-clang/$PLATFORM/$PDIR.tgz diff --git a/third_party/libwebrtc/tools/clang/scripts/plugin_flags.sh b/third_party/libwebrtc/tools/clang/scripts/plugin_flags.sh new file mode 100755 index 0000000000..217c5c3bd6 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/scripts/plugin_flags.sh @@ -0,0 +1,24 @@ +#!/bin/bash +# Copyright (c) 2012 The Chromium Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +# This script returns the flags that should be used when GYP_DEFINES contains +# clang_use_chrome_plugins. The flags are stored in a script so that they can +# be changed on the bots without requiring a master restart. + +THIS_ABS_DIR=$(cd $(dirname $0) && echo $PWD) +CLANG_LIB_PATH=$THIS_ABS_DIR/../../../third_party/llvm-build/Release+Asserts/lib + +if uname -s | grep -q Darwin; then + LIBSUFFIX=dylib +else + LIBSUFFIX=so +fi + +echo -Xclang -load -Xclang $CLANG_LIB_PATH/libFindBadConstructs.$LIBSUFFIX \ + -Xclang -add-plugin -Xclang find-bad-constructs \ + -Xclang -plugin-arg-find-bad-constructs \ + -Xclang skip-virtuals-in-implementations \ + -Xclang -plugin-arg-find-bad-constructs \ + -Xclang check-cc-directory diff --git a/third_party/libwebrtc/tools/clang/scripts/update.py b/third_party/libwebrtc/tools/clang/scripts/update.py new file mode 100755 index 0000000000..bdc781f715 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/scripts/update.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python +# Copyright (c) 2012 The Chromium Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +"""Windows can't run .sh files, so this is a small python wrapper around +update.sh. +""" + +import os +import subprocess +import sys + + +def main(): + if sys.platform in ['win32', 'cygwin']: + return 0 + + # This script is called by gclient. gclient opens its hooks subprocesses with + # (stdout=subprocess.PIPE, stderr=subprocess.STDOUT) and then does custom + # output processing that breaks printing '\r' characters for single-line + # updating status messages as printed by curl and wget. + # Work around this by setting stderr of the update.sh process to stdin (!): + # gclient doesn't redirect stdin, and while stdin itself is read-only, a + # dup()ed sys.stdin is writable, try + # fd2 = os.dup(sys.stdin.fileno()); os.write(fd2, 'hi') + # TODO: Fix gclient instead, http://crbug.com/95350 + return subprocess.call( + [os.path.join(os.path.dirname(__file__), 'update.sh')] + sys.argv[1:], + stderr=os.fdopen(os.dup(sys.stdin.fileno()))) + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/third_party/libwebrtc/tools/clang/scripts/update.sh b/third_party/libwebrtc/tools/clang/scripts/update.sh new file mode 100755 index 0000000000..e9448236c8 --- /dev/null +++ b/third_party/libwebrtc/tools/clang/scripts/update.sh @@ -0,0 +1,286 @@ +#!/usr/bin/env bash +# Copyright (c) 2012 The Chromium Authors. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +# This script will check out llvm and clang into third_party/llvm and build it. + +# Do NOT CHANGE this if you don't know what you're doing -- see +# https://code.google.com/p/chromium/wiki/UpdatingClang +# Reverting problematic clang rolls is safe, though. +CLANG_REVISION=163674 + +THIS_DIR="$(dirname "${0}")" +LLVM_DIR="${THIS_DIR}/../../../third_party/llvm" +LLVM_BUILD_DIR="${LLVM_DIR}/../llvm-build" +LLVM_BOOTSTRAP_DIR="${LLVM_DIR}/../llvm-bootstrap" +CLANG_DIR="${LLVM_DIR}/tools/clang" +COMPILER_RT_DIR="${LLVM_DIR}/projects/compiler-rt" +STAMP_FILE="${LLVM_BUILD_DIR}/cr_build_revision" + +# ${A:-a} returns $A if it's set, a else. +LLVM_REPO_URL=${LLVM_URL:-https://llvm.org/svn/llvm-project} + +# Die if any command dies. +set -e + +OS="$(uname -s)" + +# Parse command line options. +force_local_build= +mac_only= +run_tests= +bootstrap= +while [[ $# > 0 ]]; do + case $1 in + --bootstrap) + bootstrap=yes + ;; + --force-local-build) + force_local_build=yes + ;; + --mac-only) + mac_only=yes + ;; + --run-tests) + run_tests=yes + ;; + --help) + echo "usage: $0 [--force-local-build] [--mac-only] [--run-tests] " + echo "--bootstrap: First build clang with CC, then with itself." + echo "--force-local-build: Don't try to download prebuilt binaries." + echo "--mac-only: Do initial download only on Mac systems." + echo "--run-tests: Run tests after building. Only for local builds." + exit 1 + ;; + esac + shift +done + +# --mac-only prevents the initial download on non-mac systems, but if clang has +# already been downloaded in the past, this script keeps it up to date even if +# --mac-only is passed in and the system isn't a mac. People who don't like this +# can just delete their third_party/llvm-build directory. +if [[ -n "$mac_only" ]] && [[ "${OS}" != "Darwin" ]] && + [[ "$GYP_DEFINES" != *clang=1* ]] && ! [[ -d "${LLVM_BUILD_DIR}" ]]; then + exit 0 +fi + +# Xcode and clang don't get along when predictive compilation is enabled. +# http://crbug.com/96315 +if [[ "${OS}" = "Darwin" ]] && xcodebuild -version | grep -q 'Xcode 3.2' ; then + XCONF=com.apple.Xcode + if [[ "${GYP_GENERATORS}" != "make" ]] && \ + [ "$(defaults read "${XCONF}" EnablePredictiveCompilation)" != "0" ]; then + echo + echo " HEARKEN!" + echo "You're using Xcode3 and you have 'Predictive Compilation' enabled." + echo "This does not work well with clang (http://crbug.com/96315)." + echo "Disable it in Preferences->Building (lower right), or run" + echo " defaults write ${XCONF} EnablePredictiveCompilation -boolean NO" + echo "while Xcode is not running." + echo + fi + + SUB_VERSION=$(xcodebuild -version | sed -Ene 's/Xcode 3\.2\.([0-9]+)/\1/p') + if [[ "${SUB_VERSION}" < 6 ]]; then + echo + echo " YOUR LD IS BUGGY!" + echo "Please upgrade Xcode to at least 3.2.6." + echo + fi +fi + + +# Check if there's anything to be done, exit early if not. +if [[ -f "${STAMP_FILE}" ]]; then + PREVIOUSLY_BUILT_REVISON=$(cat "${STAMP_FILE}") + if [[ -z "$force_local_build" ]] && \ + [[ "${PREVIOUSLY_BUILT_REVISON}" = "${CLANG_REVISION}" ]]; then + echo "Clang already at ${CLANG_REVISION}" + exit 0 + fi +fi +# To always force a new build if someone interrupts their build half way. +rm -f "${STAMP_FILE}" + +# Clobber pch files, since they only work with the compiler version that +# created them. Also clobber .o files, to make sure everything will be built +# with the new compiler. +if [[ "${OS}" = "Darwin" ]]; then + XCODEBUILD_DIR="${THIS_DIR}/../../../xcodebuild" + + # Xcode groups .o files by project first, configuration second. + if [[ -d "${XCODEBUILD_DIR}" ]]; then + echo "Clobbering .o files for Xcode build" + find "${XCODEBUILD_DIR}" -name '*.o' -exec rm {} + + fi +fi + +if [ -f "${THIS_DIR}/../../../WebKit.gyp" ]; then + # We're inside a WebKit checkout. + # TODO(thakis): try to unify the directory layout of the xcode- and + # make-based builds. http://crbug.com/110455 + MAKE_DIR="${THIS_DIR}/../../../../../../out" +else + # We're inside a Chromium checkout. + MAKE_DIR="${THIS_DIR}/../../../out" +fi + +for CONFIG in Debug Release; do + if [[ -d "${MAKE_DIR}/${CONFIG}/obj.target" || + -d "${MAKE_DIR}/${CONFIG}/obj.host" ]]; then + echo "Clobbering ${CONFIG} PCH and .o files for make build" + if [[ -d "${MAKE_DIR}/${CONFIG}/obj.target" ]]; then + find "${MAKE_DIR}/${CONFIG}/obj.target" -name '*.gch' -exec rm {} + + find "${MAKE_DIR}/${CONFIG}/obj.target" -name '*.o' -exec rm {} + + fi + if [[ -d "${MAKE_DIR}/${CONFIG}/obj.host" ]]; then + find "${MAKE_DIR}/${CONFIG}/obj.host" -name '*.o' -exec rm {} + + fi + fi + + # ninja puts its output below ${MAKE_DIR} as well. + if [[ -d "${MAKE_DIR}/${CONFIG}/obj" ]]; then + echo "Clobbering ${CONFIG} PCH and .o files for ninja build" + find "${MAKE_DIR}/${CONFIG}/obj" -name '*.gch' -exec rm {} + + find "${MAKE_DIR}/${CONFIG}/obj" -name '*.o' -exec rm {} + + find "${MAKE_DIR}/${CONFIG}/obj" -name '*.o.d' -exec rm {} + + fi + + if [[ "${OS}" = "Darwin" ]]; then + if [[ -d "${XCODEBUILD_DIR}/${CONFIG}/SharedPrecompiledHeaders" ]]; then + echo "Clobbering ${CONFIG} PCH files for Xcode build" + rm -rf "${XCODEBUILD_DIR}/${CONFIG}/SharedPrecompiledHeaders" + fi + fi +done + +if [[ -z "$force_local_build" ]]; then + # Check if there's a prebuilt binary and if so just fetch that. That's faster, + # and goma relies on having matching binary hashes on client and server too. + CDS_URL=https://commondatastorage.googleapis.com/chromium-browser-clang + CDS_FILE="clang-${CLANG_REVISION}.tgz" + CDS_OUT_DIR=$(mktemp -d -t clang_download.XXXXXX) + CDS_OUTPUT="${CDS_OUT_DIR}/${CDS_FILE}" + if [ "${OS}" = "Linux" ]; then + CDS_FULL_URL="${CDS_URL}/Linux_x64/${CDS_FILE}" + elif [ "${OS}" = "Darwin" ]; then + CDS_FULL_URL="${CDS_URL}/Mac/${CDS_FILE}" + fi + echo Trying to download prebuilt clang + if which curl > /dev/null; then + curl -L --fail "${CDS_FULL_URL}" -o "${CDS_OUTPUT}" || \ + rm -rf "${CDS_OUT_DIR}" + elif which wget > /dev/null; then + wget "${CDS_FULL_URL}" -O "${CDS_OUTPUT}" || rm -rf "${CDS_OUT_DIR}" + else + echo "Neither curl nor wget found. Please install one of these." + exit 1 + fi + if [ -f "${CDS_OUTPUT}" ]; then + rm -rf "${LLVM_BUILD_DIR}/Release+Asserts" + mkdir -p "${LLVM_BUILD_DIR}/Release+Asserts" + tar -xzf "${CDS_OUTPUT}" -C "${LLVM_BUILD_DIR}/Release+Asserts" + echo clang "${CLANG_REVISION}" unpacked + echo "${CLANG_REVISION}" > "${STAMP_FILE}" + rm -rf "${CDS_OUT_DIR}" + exit 0 + else + echo Did not find prebuilt clang at r"${CLANG_REVISION}", building + fi +fi + +echo Getting LLVM r"${CLANG_REVISION}" in "${LLVM_DIR}" +if ! svn co --force "${LLVM_REPO_URL}/llvm/trunk@${CLANG_REVISION}" \ + "${LLVM_DIR}"; then + echo Checkout failed, retrying + rm -rf "${LLVM_DIR}" + svn co --force "${LLVM_REPO_URL}/llvm/trunk@${CLANG_REVISION}" "${LLVM_DIR}" +fi + +echo Getting clang r"${CLANG_REVISION}" in "${CLANG_DIR}" +svn co --force "${LLVM_REPO_URL}/cfe/trunk@${CLANG_REVISION}" "${CLANG_DIR}" + +echo Getting compiler-rt r"${CLANG_REVISION}" in "${COMPILER_RT_DIR}" +svn co --force "${LLVM_REPO_URL}/compiler-rt/trunk@${CLANG_REVISION}" \ + "${COMPILER_RT_DIR}" + +# Echo all commands. +set -x + +NUM_JOBS=3 +if [[ "${OS}" = "Linux" ]]; then + NUM_JOBS="$(grep -c "^processor" /proc/cpuinfo)" +elif [ "${OS}" = "Darwin" ]; then + NUM_JOBS="$(sysctl -n hw.ncpu)" +fi + +# Build bootstrap clang if requested. +if [[ -n "${bootstrap}" ]]; then + echo "Building bootstrap compiler" + mkdir -p "${LLVM_BOOTSTRAP_DIR}" + cd "${LLVM_BOOTSTRAP_DIR}" + if [[ ! -f ./config.status ]]; then + # The bootstrap compiler only needs to be able to build the real compiler, + # so it needs no cross-compiler output support. In general, the host + # compiler should be as similar to the final compiler as possible, so do + # keep --disable-threads & co. + ../llvm/configure \ + --enable-optimized \ + --enable-targets=host-only \ + --disable-threads \ + --disable-pthreads \ + --without-llvmgcc \ + --without-llvmgxx + MACOSX_DEPLOYMENT_TARGET=10.5 make -j"${NUM_JOBS}" + fi + if [[ -n "${run_tests}" ]]; then + make check-all + fi + cd - + export CC="${PWD}/${LLVM_BOOTSTRAP_DIR}/Release+Asserts/bin/clang" + export CXX="${PWD}/${LLVM_BOOTSTRAP_DIR}/Release+Asserts/bin/clang++" + echo "Building final compiler" +fi + +# Build clang (in a separate directory). +# The clang bots have this path hardcoded in built/scripts/slave/compile.py, +# so if you change it you also need to change these links. +mkdir -p "${LLVM_BUILD_DIR}" +cd "${LLVM_BUILD_DIR}" +if [[ ! -f ./config.status ]]; then + ../llvm/configure \ + --enable-optimized \ + --disable-threads \ + --disable-pthreads \ + --without-llvmgcc \ + --without-llvmgxx +fi + +MACOSX_DEPLOYMENT_TARGET=10.5 make -j"${NUM_JOBS}" +cd - + +# Build plugin. +# Copy it into the clang tree and use clang's build system to compile the +# plugin. +PLUGIN_SRC_DIR="${THIS_DIR}/../plugins" +PLUGIN_DST_DIR="${LLVM_DIR}/tools/clang/tools/chrome-plugin" +PLUGIN_BUILD_DIR="${LLVM_BUILD_DIR}/tools/clang/tools/chrome-plugin" +rm -rf "${PLUGIN_DST_DIR}" +cp -R "${PLUGIN_SRC_DIR}" "${PLUGIN_DST_DIR}" +rm -rf "${PLUGIN_BUILD_DIR}" +mkdir -p "${PLUGIN_BUILD_DIR}" +cp "${PLUGIN_SRC_DIR}/Makefile" "${PLUGIN_BUILD_DIR}" +MACOSX_DEPLOYMENT_TARGET=10.5 make -j"${NUM_JOBS}" -C "${PLUGIN_BUILD_DIR}" + +if [[ -n "$run_tests" ]]; then + # Run a few tests. + "${PLUGIN_SRC_DIR}/tests/test.sh" "${LLVM_BUILD_DIR}/Release+Asserts" + cd "${LLVM_BUILD_DIR}" + make check-all + cd - +fi + +# After everything is done, log success for this revision. +echo "${CLANG_REVISION}" > "${STAMP_FILE}" |