| // Copyright (c) 2013 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 "tools/gn/toolchain_manager.h" | |
| #include <set> | |
| #include "base/bind.h" | |
| #include "tools/gn/err.h" | |
| #include "tools/gn/item.h" | |
| #include "tools/gn/item_node.h" | |
| #include "tools/gn/item_tree.h" | |
| #include "tools/gn/parse_tree.h" | |
| #include "tools/gn/scheduler.h" | |
| #include "tools/gn/scope.h" | |
| #include "tools/gn/scope_per_file_provider.h" | |
| namespace { | |
| SourceFile DirToBuildFile(const SourceDir& dir) { | |
| return SourceFile(dir.value() + "BUILD.gn"); | |
| } | |
| void SetSystemVars(const Settings& settings, Scope* scope) { | |
| // FIXME(brettw) port. | |
| scope->SetValue("is_win", Value(NULL, 1), NULL); | |
| scope->SetValue("is_linux", Value(NULL, 0), NULL); | |
| scope->SetValue("is_posix", Value(NULL, 0), NULL); | |
| scope->SetValue("is_mac", Value(NULL, 0), NULL); | |
| scope->SetValue("is_android", Value(NULL, 0), NULL); | |
| scope->SetValue("is_ios", Value(NULL, 0), NULL); | |
| // Set this value without the terminating slash because the code expects | |
| // $root_output_dir/foo to work. | |
| scope->SetValue(ScopePerFileProvider::kRootOutputDirName, | |
| ScopePerFileProvider::GetRootOutputDir(&settings), | |
| NULL); | |
| scope->SetValue(ScopePerFileProvider::kRootGenDirName, | |
| ScopePerFileProvider::GetRootGenDir(&settings), | |
| NULL); | |
| } | |
| } // namespace | |
| struct ToolchainManager::Info { | |
| Info(const BuildSettings* build_settings, | |
| const Label& toolchain_name, | |
| const std::string& output_subdir_name) | |
| : state(TOOLCHAIN_SETTINGS_NOT_LOADED), | |
| toolchain(toolchain_name), | |
| toolchain_set(false), | |
| settings(build_settings, &toolchain, output_subdir_name), | |
| item_node(NULL) { | |
| } | |
| // MAkes sure that an ItemNode is created for the toolchain, which lets | |
| // targets depend on the (potentially future) loading of the toolchain. | |
| // | |
| // We can't always do this at the beginning since when doing the default | |
| // build config, we don't know the toolchain name yet. We also need to go | |
| // through some effort to avoid doing this inside the toolchain manager's | |
| // lock (to avoid holding two locks at once). | |
| void EnsureItemNode() { | |
| if (!item_node) { | |
| ItemTree& tree = settings.build_settings()->item_tree(); | |
| item_node = new ItemNode(&toolchain); | |
| tree.AddNodeLocked(item_node); | |
| } | |
| } | |
| SettingsState state; | |
| Toolchain toolchain; | |
| bool toolchain_set; | |
| LocationRange toolchain_definition_location; | |
| // When the state is TOOLCHAIN_SETTINGS_LOADED, the settings should be | |
| // considered read-only and can be read without locking. Otherwise, they | |
| // should not be accessed at all except to load them (which can therefore | |
| // also be done outside of the lock). This works as long as the state flag | |
| // is only ever read or written inside the lock. | |
| Settings settings; | |
| // While state == TOOLCHAIN_SETTINGS_LOADING, this will collect all | |
| // scheduled invocations using this toolchain. They'll be issued once the | |
| // settings file has been interpreted. | |
| // | |
| // The map maps the source file to "some" location it was invoked from (so | |
| // we can give good error messages. It does NOT map to the root of the | |
| // file to be invoked (the file still needs loading). This will be NULL | |
| // for internally invoked files. | |
| typedef std::map<SourceFile, LocationRange> ScheduledInvocationMap; | |
| ScheduledInvocationMap scheduled_invocations; | |
| // Tracks all scheduled and executed invocations for this toolchain. This | |
| // is used to avoid invoking a file more than once for a toolchain. | |
| std::set<SourceFile> all_invocations; | |
| // Filled in by EnsureItemNode, see that for more. | |
| ItemNode* item_node; | |
| }; | |
| ToolchainManager::ToolchainManager(const BuildSettings* build_settings) | |
| : build_settings_(build_settings) { | |
| } | |
| ToolchainManager::~ToolchainManager() { | |
| for (ToolchainMap::iterator i = toolchains_.begin(); | |
| i != toolchains_.end(); ++i) | |
| delete i->second; | |
| toolchains_.clear(); | |
| } | |
| void ToolchainManager::StartLoadingUnlocked(const SourceFile& build_file_name) { | |
| // How the default build config works: Initially we don't have a toolchain | |
| // name to call the settings for the default build config. So we create one | |
| // with an empty toolchain name and execute the default build config file. | |
| // When that's done, we'll go and fix up the name to the default build config | |
| // that the script set. | |
| base::AutoLock lock(GetLock()); | |
| Err err; | |
| Info* info = LoadNewToolchainLocked(LocationRange(), Label(), &err); | |
| if (err.has_error()) | |
| g_scheduler->FailWithError(err); | |
| CHECK(info); | |
| info->scheduled_invocations[build_file_name] = LocationRange(); | |
| info->all_invocations.insert(build_file_name); | |
| g_scheduler->IncrementWorkCount(); | |
| if (!g_scheduler->input_file_manager()->AsyncLoadFile( | |
| LocationRange(), build_settings_, | |
| build_settings_->build_config_file(), | |
| base::Bind(&ToolchainManager::BackgroundLoadBuildConfig, | |
| base::Unretained(this), info, true), | |
| &err)) { | |
| g_scheduler->FailWithError(err); | |
| g_scheduler->DecrementWorkCount(); | |
| } | |
| } | |
| const Settings* ToolchainManager::GetSettingsForToolchainLocked( | |
| const LocationRange& from_here, | |
| const Label& toolchain_name, | |
| Err* err) { | |
| GetLock().AssertAcquired(); | |
| ToolchainMap::iterator found = toolchains_.find(toolchain_name); | |
| Info* info = NULL; | |
| if (found == toolchains_.end()) { | |
| info = LoadNewToolchainLocked(from_here, toolchain_name, err); | |
| if (!info) | |
| return NULL; | |
| } else { | |
| info = found->second; | |
| } | |
| info->EnsureItemNode(); | |
| return &info->settings; | |
| } | |
| const Toolchain* ToolchainManager::GetToolchainDefinitionUnlocked( | |
| const Label& toolchain_name) { | |
| base::AutoLock lock(GetLock()); | |
| ToolchainMap::iterator found = toolchains_.find(toolchain_name); | |
| if (found == toolchains_.end() || !found->second->toolchain_set) | |
| return NULL; | |
| // Since we don't allow defining a toolchain more than once, we know that | |
| // once it's set it won't be mutated, so we can safely return this pointer | |
| // for reading outside the lock. | |
| return &found->second->toolchain; | |
| } | |
| bool ToolchainManager::SetDefaultToolchainUnlocked( | |
| const Label& default_toolchain, | |
| const LocationRange& defined_here, | |
| Err* err) { | |
| base::AutoLock lock(GetLock()); | |
| if (!default_toolchain_.is_null()) { | |
| *err = Err(defined_here, "Default toolchain already set."); | |
| err->AppendSubErr(Err(default_toolchain_defined_here_, | |
| "Previously defined here.", | |
| "You can only set this once.")); | |
| return false; | |
| } | |
| if (default_toolchain.is_null()) { | |
| *err = Err(defined_here, "Bad default toolchain name.", | |
| "You can't set the default toolchain name to nothing."); | |
| return false; | |
| } | |
| if (!default_toolchain.toolchain_dir().is_null() || | |
| !default_toolchain.toolchain_name().empty()) { | |
| *err = Err(defined_here, "Toolchain name has toolchain.", | |
| "You can't specify a toolchain (inside the parens) for a toolchain " | |
| "name. I got:\n" + default_toolchain.GetUserVisibleName(true)); | |
| return false; | |
| } | |
| default_toolchain_ = default_toolchain; | |
| default_toolchain_defined_here_ = defined_here; | |
| return true; | |
| } | |
| Label ToolchainManager::GetDefaultToolchainUnlocked() const { | |
| base::AutoLock lock(GetLock()); | |
| return default_toolchain_; | |
| } | |
| bool ToolchainManager::SetToolchainDefinitionLocked( | |
| const Toolchain& tc, | |
| const LocationRange& defined_from, | |
| Err* err) { | |
| GetLock().AssertAcquired(); | |
| ToolchainMap::iterator found = toolchains_.find(tc.label()); | |
| Info* info = NULL; | |
| if (found == toolchains_.end()) { | |
| // New toolchain. | |
| info = LoadNewToolchainLocked(defined_from, tc.label(), err); | |
| if (!info) | |
| return false; | |
| } else { | |
| // It's important to preserve the exact Toolchain object in our tree since | |
| // it will be in the ItemTree and targets may have dependencies on it. | |
| info = found->second; | |
| } | |
| // The labels should match or else we're setting the wrong one! | |
| CHECK(info->toolchain.label() == tc.label()); | |
| info->toolchain = tc; | |
| if (info->toolchain_set) { | |
| *err = Err(defined_from, "Duplicate toolchain definition."); | |
| err->AppendSubErr(Err( | |
| info->toolchain_definition_location, | |
| "Previously defined here.", | |
| "A toolchain can only be defined once. One tricky way that this could\n" | |
| "happen is if your definition is itself in a file that's interpreted\n" | |
| "under different toolchains, which would result in multiple\n" | |
| "definitions as the file is loaded multiple times. So be sure your\n" | |
| "toolchain definitions are in files that either don't define any\n" | |
| "targets (probably best) or at least don't contain targets executed\n" | |
| "with more than one toolchain.")); | |
| return false; | |
| } | |
| info->EnsureItemNode(); | |
| info->toolchain_set = true; | |
| info->toolchain_definition_location = defined_from; | |
| return true; | |
| } | |
| bool ToolchainManager::ScheduleInvocationLocked( | |
| const LocationRange& specified_from, | |
| const Label& toolchain_name, | |
| const SourceDir& dir, | |
| Err* err) { | |
| GetLock().AssertAcquired(); | |
| SourceFile build_file(DirToBuildFile(dir)); | |
| ToolchainMap::iterator found = toolchains_.find(toolchain_name); | |
| Info* info = NULL; | |
| if (found == toolchains_.end()) { | |
| // New toolchain. | |
| info = LoadNewToolchainLocked(specified_from, toolchain_name, err); | |
| if (!info) | |
| return false; | |
| } else { | |
| // Use existing one. | |
| info = found->second; | |
| if (info->all_invocations.find(build_file) != | |
| info->all_invocations.end()) { | |
| // We've already seen this source file for this toolchain, don't need | |
| // to do anything. | |
| return true; | |
| } | |
| } | |
| info->all_invocations.insert(build_file); | |
| // True if the settings load needs to be scheduled. | |
| bool info_needs_settings_load = false; | |
| // True if the settings load has completed. | |
| bool info_settings_loaded = false; | |
| switch (info->state) { | |
| case TOOLCHAIN_SETTINGS_NOT_LOADED: | |
| info_needs_settings_load = true; | |
| info->scheduled_invocations[build_file] = specified_from; | |
| break; | |
| case TOOLCHAIN_SETTINGS_LOADING: | |
| info->scheduled_invocations[build_file] = specified_from; | |
| break; | |
| case TOOLCHAIN_SETTINGS_LOADED: | |
| info_settings_loaded = true; | |
| break; | |
| } | |
| if (info_needs_settings_load) { | |
| // Load the settings file. | |
| g_scheduler->IncrementWorkCount(); | |
| if (!g_scheduler->input_file_manager()->AsyncLoadFile( | |
| specified_from, build_settings_, | |
| build_settings_->build_config_file(), | |
| base::Bind(&ToolchainManager::BackgroundLoadBuildConfig, | |
| base::Unretained(this), info, false), | |
| err)) { | |
| g_scheduler->DecrementWorkCount(); | |
| return false; | |
| } | |
| } else if (info_settings_loaded) { | |
| // Settings are ready to go, load the target file. | |
| g_scheduler->IncrementWorkCount(); | |
| if (!g_scheduler->input_file_manager()->AsyncLoadFile( | |
| specified_from, build_settings_, build_file, | |
| base::Bind(&ToolchainManager::BackgroundInvoke, | |
| base::Unretained(this), info, build_file), | |
| err)) { | |
| g_scheduler->DecrementWorkCount(); | |
| return false; | |
| } | |
| } | |
| // Else we should have added the infocations to the scheduled_invocations | |
| // from within the lock above. | |
| return true; | |
| } | |
| // static | |
| std::string ToolchainManager::ToolchainToOutputSubdir( | |
| const Label& toolchain_name) { | |
| // For now just assume the toolchain name is always a valid dir name. We may | |
| // want to clean up the in the future. | |
| return toolchain_name.name(); | |
| } | |
| ToolchainManager::Info* ToolchainManager::LoadNewToolchainLocked( | |
| const LocationRange& specified_from, | |
| const Label& toolchain_name, | |
| Err* err) { | |
| GetLock().AssertAcquired(); | |
| Info* info = new Info(build_settings_, | |
| toolchain_name, | |
| ToolchainToOutputSubdir(toolchain_name)); | |
| toolchains_[toolchain_name] = info; | |
| // Invoke the file containing the toolchain definition so that it gets | |
| // defined. The default one (label is empty) will be done spearately. | |
| if (!toolchain_name.is_null()) { | |
| // The default toolchain should be specified whenever we're requesting | |
| // another one. This is how we know under what context we should execute | |
| // the invoke for the toolchain file. | |
| CHECK(!default_toolchain_.is_null()); | |
| ScheduleInvocationLocked(specified_from, default_toolchain_, | |
| toolchain_name.dir(), err); | |
| } | |
| return info; | |
| } | |
| void ToolchainManager::FixupDefaultToolchainLocked() { | |
| // Now that we've run the default build config, we should know the | |
| // default toolchain name. Fix up our reference. | |
| // See Start() for more. | |
| GetLock().AssertAcquired(); | |
| if (default_toolchain_.is_null()) { | |
| g_scheduler->FailWithError(Err(Location(), | |
| "Default toolchain not set.", | |
| "Your build config file \"" + | |
| build_settings_->build_config_file().value() + | |
| "\"\ndid not call set_default_toolchain(). This is needed so " | |
| "I know how to actually\ncompile your code.")); | |
| return; | |
| } | |
| ToolchainMap::iterator old_default = toolchains_.find(Label()); | |
| CHECK(old_default != toolchains_.end()); | |
| Info* info = old_default->second; | |
| toolchains_[default_toolchain_] = info; | |
| toolchains_.erase(old_default); | |
| // Toolchain should not have been loaded in the build config file. | |
| CHECK(!info->toolchain_set); | |
| // We need to set the toolchain label now that we know it. There's no way | |
| // to set the label, but we can assign the toolchain to a new one. Loading | |
| // the build config can not change the toolchain, so we won't be overwriting | |
| // anything useful. | |
| info->toolchain = Toolchain(default_toolchain_); | |
| info->EnsureItemNode(); | |
| // Schedule a load of the toolchain build file. | |
| Err err; | |
| ScheduleInvocationLocked(LocationRange(), default_toolchain_, | |
| default_toolchain_.dir(), &err); | |
| if (err.has_error()) | |
| g_scheduler->FailWithError(err); | |
| } | |
| void ToolchainManager::BackgroundLoadBuildConfig(Info* info, | |
| bool is_default, | |
| const ParseNode* root) { | |
| // Danger: No early returns without decrementing the work count. | |
| if (root && !g_scheduler->is_failed()) { | |
| // Nobody should be accessing settings at this point other than us since we | |
| // haven't marked it loaded, so we can do it outside the lock. | |
| Scope* base_config = info->settings.base_config(); | |
| SetSystemVars(info->settings, base_config); | |
| base_config->SetProcessingBuildConfig(); | |
| if (is_default) | |
| base_config->SetProcessingDefaultBuildConfig(); | |
| const BlockNode* root_block = root->AsBlock(); | |
| Err err; | |
| root_block->ExecuteBlockInScope(base_config, &err); | |
| base_config->ClearProcessingBuildConfig(); | |
| if (is_default) | |
| base_config->ClearProcessingDefaultBuildConfig(); | |
| if (err.has_error()) { | |
| g_scheduler->FailWithError(err); | |
| } else { | |
| // Base config processing succeeded. | |
| Info::ScheduledInvocationMap schedule_these; | |
| { | |
| base::AutoLock lock(GetLock()); | |
| schedule_these.swap(info->scheduled_invocations); | |
| info->state = TOOLCHAIN_SETTINGS_LOADED; | |
| if (is_default) | |
| FixupDefaultToolchainLocked(); | |
| } | |
| // Schedule build files waiting on this settings. There can be many so we | |
| // want to load them in parallel on the pool. | |
| for (Info::ScheduledInvocationMap::iterator i = schedule_these.begin(); | |
| i != schedule_these.end() && !g_scheduler->is_failed(); ++i) { | |
| // Note i->second may be NULL, so don't dereference. | |
| g_scheduler->IncrementWorkCount(); | |
| if (!g_scheduler->input_file_manager()->AsyncLoadFile( | |
| i->second, build_settings_, i->first, | |
| base::Bind(&ToolchainManager::BackgroundInvoke, | |
| base::Unretained(this), info, i->first), | |
| &err)) { | |
| g_scheduler->FailWithError(err); | |
| g_scheduler->DecrementWorkCount(); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| g_scheduler->DecrementWorkCount(); | |
| } | |
| void ToolchainManager::BackgroundInvoke(const Info* info, | |
| const SourceFile& file_name, | |
| const ParseNode* root) { | |
| if (root && !g_scheduler->is_failed()) { | |
| if (g_scheduler->verbose_logging()) | |
| g_scheduler->Log("Running", file_name.value()); | |
| Scope our_scope(info->settings.base_config()); | |
| ScopePerFileProvider per_file_provider(&our_scope, file_name); | |
| Err err; | |
| root->Execute(&our_scope, &err); | |
| if (err.has_error()) | |
| g_scheduler->FailWithError(err); | |
| } | |
| g_scheduler->DecrementWorkCount(); | |
| } | |
| base::Lock& ToolchainManager::GetLock() const { | |
| return build_settings_->item_tree().lock(); | |
| } |