diff --git a/src/main/java/com/google/devtools/build/lib/analysis/PlatformOptions.java b/src/main/java/com/google/devtools/build/lib/analysis/PlatformOptions.java
index 788dc3a..391aae3 100644
--- a/src/main/java/com/google/devtools/build/lib/analysis/PlatformOptions.java
+++ b/src/main/java/com/google/devtools/build/lib/analysis/PlatformOptions.java
@@ -20,6 +20,8 @@
 import com.google.devtools.build.lib.analysis.config.BuildConfiguration.LabelListConverter;
 import com.google.devtools.build.lib.analysis.config.FragmentOptions;
 import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.build.lib.util.OptionsUtils;
+import com.google.devtools.build.lib.vfs.PathFragment;
 import com.google.devtools.common.options.Converters.CommaSeparatedOptionListConverter;
 import com.google.devtools.common.options.Option;
 import com.google.devtools.common.options.OptionDocumentationCategory;
@@ -39,6 +41,13 @@
   public static final Label LEGACY_DEFAULT_TARGET_PLATFORM =
       Label.parseAbsoluteUnchecked("@bazel_tools//platforms:target_platform");
 
+  /**
+   * Main workspace-relative location to use when the user does not explicitly set {@code
+   * --platform_mappings}.
+   */
+  public static final PathFragment DEFAULT_PLATFORM_MAPPINGS =
+      PathFragment.create("platform_mappings");
+
   @Option(
       name = "host_platform",
       oldName = "experimental_host_platform",
@@ -169,6 +178,23 @@
               + " java_runtime.")
   public boolean useToolchainResolutionForJavaRules;
 
+  @Option(
+      name = "platform_mappings",
+      converter = OptionsUtils.EmptyToNullRelativePathFragmentConverter.class,
+      defaultValue = "",
+      documentationCategory = OptionDocumentationCategory.TOOLCHAIN,
+      effectTags = {
+        OptionEffectTag.AFFECTS_OUTPUTS,
+        OptionEffectTag.CHANGES_INPUTS,
+        OptionEffectTag.LOADING_AND_ANALYSIS
+      },
+      help =
+          "The location of a mapping file that describes which platform to use if none is set or "
+              + "which flags to set when a platform already exists. Must be relative to the main "
+              + "workspace root. Defaults to 'platform_mappings' (a file directly under the "
+              + "workspace root).")
+  public PathFragment platformMappings;
+
   @Override
   public PlatformOptions getHost() {
     PlatformOptions host = (PlatformOptions) getDefault();
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/PlatformMappingFunction.java b/src/main/java/com/google/devtools/build/lib/skyframe/PlatformMappingFunction.java
new file mode 100644
index 0000000..33694f4
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/PlatformMappingFunction.java
@@ -0,0 +1,309 @@
+// Copyright 2019 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.devtools.build.lib.skyframe;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.devtools.build.lib.actions.FileValue;
+import com.google.devtools.build.lib.actions.MissingInputFileException;
+import com.google.devtools.build.lib.analysis.BlazeDirectories;
+import com.google.devtools.build.lib.analysis.config.BuildOptions;
+import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.build.lib.cmdline.LabelSyntaxException;
+import com.google.devtools.build.lib.cmdline.RepositoryName;
+import com.google.devtools.build.lib.events.Location;
+import com.google.devtools.build.lib.vfs.FileSystemUtils;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.Root;
+import com.google.devtools.build.lib.vfs.RootedPath;
+import com.google.devtools.build.skyframe.SkyFunction;
+import com.google.devtools.build.skyframe.SkyFunctionException;
+import com.google.devtools.build.skyframe.SkyKey;
+import com.google.devtools.build.skyframe.SkyValue;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Optional;
+import javax.annotation.Nullable;
+
+/**
+ * Function that reads the contents of a mapping file specified in {@code --platform_mappings} and
+ * parses them for use in a {@link PlatformMappingValue}.
+ *
+ * <p>Note that this class only parses the mapping-file specific format, parsing (and validation) of
+ * flags contained therein is left to the invocation of {@link
+ * PlatformMappingValue#map(BuildConfigurationValue.Key, BuildOptions)}.
+ */
+public class PlatformMappingFunction implements SkyFunction {
+
+  private final BlazeDirectories blazeDirectories;
+
+  public PlatformMappingFunction(BlazeDirectories blazeDirectories) {
+    this.blazeDirectories = blazeDirectories;
+  }
+
+  @Nullable
+  @Override
+  public SkyValue compute(SkyKey skyKey, Environment env)
+      throws PlatformMappingException, InterruptedException {
+    PlatformMappingValue.Key platformMappingKey = (PlatformMappingValue.Key) skyKey.argument();
+    PathFragment workspaceRelativeMappingPath =
+        platformMappingKey.getWorkspaceRelativeMappingPath();
+
+    Root workspaceRoot = Root.fromPath(blazeDirectories.getWorkspace());
+    RootedPath rootedMappingPath =
+        RootedPath.toRootedPath(workspaceRoot, workspaceRelativeMappingPath);
+    FileValue fileValue = (FileValue) env.getValue(FileValue.key(rootedMappingPath));
+    if (fileValue == null) {
+      return null;
+    }
+
+    if (!fileValue.exists()) {
+      if (!platformMappingKey.wasExplicitlySetByUser()) {
+        // If no flag was passed and the default mapping file does not exist treat this as if the
+        // mapping file was empty rather than an error.
+        return PlatformMappingValue.EMPTY;
+      }
+      throw new PlatformMappingException(
+          new MissingInputFileException(
+              String.format(
+                  "--platform_mappings was set to '%s' but no such file exists relative to the "
+                      + "top-level workspace, '%s'",
+                  workspaceRelativeMappingPath, workspaceRoot),
+              Location.BUILTIN),
+          SkyFunctionException.Transience.PERSISTENT);
+    }
+    if (fileValue.isDirectory()) {
+      throw new PlatformMappingException(
+          new MissingInputFileException(
+              String.format(
+                  "--platform_mappings was set to '%s' relative to the top-level workspace '%s' but"
+                      + "that path refers to a directory, not a file",
+                  workspaceRelativeMappingPath, workspaceRoot),
+              Location.BUILTIN),
+          SkyFunctionException.Transience.PERSISTENT);
+    }
+
+    Iterable<String> lines;
+    try {
+      lines =
+          FileSystemUtils.readLines(fileValue.realRootedPath().asPath(), StandardCharsets.UTF_8);
+    } catch (IOException e) {
+      throw new PlatformMappingException(e, SkyFunctionException.Transience.PERSISTENT);
+    }
+
+    return new Parser(lines.iterator()).parse().toPlatformMappingValue();
+  }
+
+  @Nullable
+  @Override
+  public String extractTag(SkyKey skyKey) {
+    return null;
+  }
+
+  @VisibleForTesting
+  static class PlatformMappingException extends SkyFunctionException {
+
+    public PlatformMappingException(Exception cause, Transience transience) {
+      super(cause, transience);
+    }
+  }
+
+  @VisibleForTesting
+  static class Parser {
+
+    private final Iterator<String> lines;
+
+    /**
+     * Using an optional to represent the next line with contents, {@link Optional#empty()} if we
+     * reached end of file.
+     *
+     * <p>Stores the current non-comment, non-empty, non-whitespace line. Don't access the field
+     * directly, it can either be "used up" by calling {@link #consume()} or retrieved without
+     * moving on by calling {@link #peek()}.
+     */
+    private Optional<String> line;
+
+    Parser(Iterator<String> lines) {
+      this.lines = lines;
+    }
+
+    Mappings parse() throws PlatformMappingException {
+      goToNextContentLine();
+
+      if (!line.isPresent()) {
+        return new Mappings(ImmutableMap.of(), ImmutableMap.of());
+      }
+
+      Map<Label, Collection<String>> platformsToFlags = ImmutableMap.of();
+      Map<Collection<String>, Label> flagsToPlatforms = ImmutableMap.of();
+
+      if (!peek().equalsIgnoreCase("platforms:") && !peek().equalsIgnoreCase("flags:")) {
+        throwParsingException("Expected 'platforms:' or 'flags:' but got " + peek());
+      }
+
+      if (peek().equalsIgnoreCase("platforms:")) {
+        consume();
+        platformsToFlags = platformsToFlags();
+      }
+
+      if (line.isPresent()) {
+        if (!peek().equalsIgnoreCase("flags:")) {
+          throwParsingException("Expected 'flags:' but got " + peek());
+        }
+        consume();
+        flagsToPlatforms = flagsToPlatforms();
+      }
+
+      if (line.isPresent()) {
+        throwParsingException("Expected end of file but got " + peek());
+      }
+      return new Mappings(platformsToFlags, flagsToPlatforms);
+    }
+
+    private Map<Label, Collection<String>> platformsToFlags() throws PlatformMappingException {
+      ImmutableMap.Builder<Label, Collection<String>> platformsToFlags = ImmutableMap.builder();
+      while (line.isPresent() && !peek().equalsIgnoreCase("flags:")) {
+        Label platform = platform();
+        Collection<String> flags = flags();
+        platformsToFlags.put(platform, flags);
+      }
+
+      return platformsToFlags.build();
+    }
+
+    private Label platform() throws PlatformMappingException {
+      if (!line.isPresent()) {
+        throwParsingException("Expected platform label but got end of file");
+      }
+      String label = consume();
+
+      Label platform;
+      try {
+        ImmutableMap<RepositoryName, RepositoryName> emptyRepositoryMapping = ImmutableMap.of();
+        // It is ok for us to use an empty repository mapping in this instance because all platform
+        // labels used in the mapping file should be relative to the root repository. Repository
+        // mappings however only apply within a repository imported by the root repository.
+        platform = Label.parseAbsolute(label, emptyRepositoryMapping);
+      } catch (LabelSyntaxException e) {
+        throw new PlatformMappingException(
+            new PlatformMappingParsingException("Expected platform label but got " + label, e),
+            SkyFunctionException.Transience.PERSISTENT);
+      }
+      return platform;
+    }
+
+    private Collection<String> flags() throws PlatformMappingException {
+      ImmutableSet.Builder<String> flags = ImmutableSet.builder();
+      // Note: Short form flags are not supported.
+      while (lineIsFlag()) {
+        flags.add(consume());
+      }
+      ImmutableSet<String> parsedFlags = flags.build();
+      if (parsedFlags.isEmpty()) {
+        if (!line.isPresent()) {
+          throwParsingException("Expected a flag but got end of file");
+        }
+        throwParsingException(
+            "Expected a standard format flag (starting with --) but got " + peek());
+      }
+
+      return parsedFlags;
+    }
+
+    private Map<Collection<String>, Label> flagsToPlatforms() throws PlatformMappingException {
+      ImmutableMap.Builder<Collection<String>, Label> flagsToPlatforms = ImmutableMap.builder();
+      while (lineIsFlag()) {
+        Collection<String> flags = flags();
+        Label platform = platform();
+        flagsToPlatforms.put(flags, platform);
+      }
+      return flagsToPlatforms.build();
+    }
+
+    private String consume() {
+      Preconditions.checkState(
+          line.isPresent(), "Must make sure that a line exists before consuming.");
+      String value = line.get();
+      goToNextContentLine();
+      return value;
+    }
+
+    private String peek() {
+      Preconditions.checkState(
+          line.isPresent(), "Must make sure that a line exists before peeking.");
+      return line.get();
+    }
+
+    private void throwParsingException(String message) throws PlatformMappingException {
+      throw new PlatformMappingException(
+          new PlatformMappingParsingException(message), SkyFunctionException.Transience.PERSISTENT);
+    }
+
+    private boolean lineIsFlag() {
+      return line.isPresent() && peek().startsWith("--");
+    }
+
+    private void goToNextContentLine() {
+      while (lines.hasNext()) {
+        String line = lines.next().trim();
+        if (line.isEmpty() || line.startsWith("#")) {
+          continue;
+        }
+        this.line = Optional.of(line);
+        return;
+      }
+      line = Optional.empty();
+    }
+  }
+
+  /**
+   * Simple data holder to make testing easier. Only for use internal to this file/tests thereof.
+   */
+  @VisibleForTesting
+  static class Mappings {
+    final Map<Label, Collection<String>> platformsToFlags;
+    final Map<Collection<String>, Label> flagsToPlatforms;
+
+    Mappings(
+        Map<Label, Collection<String>> platformsToFlags,
+        Map<Collection<String>, Label> flagsToPlatforms) {
+      this.platformsToFlags = platformsToFlags;
+      this.flagsToPlatforms = flagsToPlatforms;
+    }
+
+    PlatformMappingValue toPlatformMappingValue() {
+      return new PlatformMappingValue(platformsToFlags, flagsToPlatforms);
+    }
+  }
+
+  /**
+   * Inner wrapper exception to work around the fact that {@link SkyFunctionException} cannot carry
+   * a message of its own.
+   */
+  private static class PlatformMappingParsingException extends Exception {
+    public PlatformMappingParsingException(String message) {
+      super(message);
+    }
+
+    public PlatformMappingParsingException(String message, Throwable cause) {
+      super(message, cause);
+    }
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/PlatformMappingValue.java b/src/main/java/com/google/devtools/build/lib/skyframe/PlatformMappingValue.java
index 4ad16cb..1c90fa6 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/PlatformMappingValue.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/PlatformMappingValue.java
@@ -16,6 +16,7 @@
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Interner;
 import com.google.common.collect.Iterables;
 import com.google.devtools.build.lib.analysis.PlatformOptions;
@@ -24,7 +25,7 @@
 import com.google.devtools.build.lib.concurrent.BlazeInterners;
 import com.google.devtools.build.lib.concurrent.ThreadSafety;
 import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec;
-import com.google.devtools.build.lib.vfs.RootedPath;
+import com.google.devtools.build.lib.vfs.PathFragment;
 import com.google.devtools.build.skyframe.SkyFunctionName;
 import com.google.devtools.build.skyframe.SkyKey;
 import com.google.devtools.build.skyframe.SkyValue;
@@ -35,6 +36,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import javax.annotation.Nullable;
 
 /**
  * Stores contents of a platforms/flags mapping file for transforming one {@link
@@ -46,22 +48,54 @@
  */
 public final class PlatformMappingValue implements SkyValue {
 
+  public static final PlatformMappingValue EMPTY =
+      new PlatformMappingValue(ImmutableMap.of(), ImmutableMap.of());
+
   /** Key for {@link PlatformMappingValue} based on the location of the mapping file. */
   @ThreadSafety.Immutable
   @AutoCodec
   public static final class Key implements SkyKey {
     private static final Interner<Key> interner = BlazeInterners.newWeakInterner();
 
-    private final RootedPath path;
-
-    private Key(RootedPath path) {
-      this.path = path;
+    /**
+     * Creates a new platform mappings key with the given, main workspace-relative path to the
+     * mappings file, typically derived from the {@code --platform_mappings} flag.
+     *
+     * <p>If the path is {@code null} the {@link PlatformOptions#DEFAULT_PLATFORM_MAPPINGS default
+     * path} will be used and the key marked as not having been set by a user.
+     *
+     * @param workspaceRelativeMappingPath main workspace relative path to the mappings file or
+     *     {@code null} if the default location should be used
+     */
+    public static Key create(@Nullable PathFragment workspaceRelativeMappingPath) {
+      if (workspaceRelativeMappingPath == null) {
+        return create(PlatformOptions.DEFAULT_PLATFORM_MAPPINGS, false);
+      } else {
+        return create(workspaceRelativeMappingPath, true);
+      }
     }
 
-    @AutoCodec.VisibleForSerialization
     @AutoCodec.Instantiator
-    static Key create(RootedPath path) {
-      return interner.intern(new Key(path));
+    @AutoCodec.VisibleForSerialization
+    static Key create(PathFragment workspaceRelativeMappingPath, boolean wasExplicitlySetByUser) {
+      return interner.intern(new Key(workspaceRelativeMappingPath, wasExplicitlySetByUser));
+    }
+
+    private final PathFragment path;
+    private final boolean wasExplicitlySetByUser;
+
+    private Key(PathFragment path, boolean wasExplicitlySetByUser) {
+      this.path = path;
+      this.wasExplicitlySetByUser = wasExplicitlySetByUser;
+    }
+
+    /** Returns the main-workspace relative path this mapping's mapping file can be found at. */
+    public PathFragment getWorkspaceRelativeMappingPath() {
+      return path;
+    }
+
+    public boolean wasExplicitlySetByUser() {
+      return wasExplicitlySetByUser;
     }
 
     @Override
@@ -78,17 +112,21 @@
         return false;
       }
       Key key = (Key) o;
-      return Objects.equals(path, key.path);
+      return Objects.equals(path, key.path) && wasExplicitlySetByUser == key.wasExplicitlySetByUser;
     }
 
     @Override
     public int hashCode() {
-      return Objects.hash(path);
+      return Objects.hash(path, wasExplicitlySetByUser);
     }
 
     @Override
     public String toString() {
-      return "PlatformMappingValue.Key{" + "path=" + path + '}';
+      return "PlatformMappingValue.Key{path="
+          + path
+          + ", wasExplicitlySetByUser="
+          + wasExplicitlySetByUser
+          + "}";
     }
   }
 
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java b/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java
index 8bfa5df..21f5ad1 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/SkyFunctions.java
@@ -118,7 +118,7 @@
   public static final SkyFunctionName BUILD_INFO = SkyFunctionName.createHermetic("BUILD_INFO");
   public static final SkyFunctionName WORKSPACE_NAME =
       SkyFunctionName.createHermetic("WORKSPACE_NAME");
-  static final SkyFunctionName PLATFORM_MAPPING =
+  public static final SkyFunctionName PLATFORM_MAPPING =
       SkyFunctionName.createHermetic("PLATFORM_MAPPING");
   static final SkyFunctionName COVERAGE_REPORT = SkyFunctionName.createHermetic("COVERAGE_REPORT");
   public static final SkyFunctionName REPOSITORY = SkyFunctionName.createHermetic("REPOSITORY");
diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/SkyframeExecutor.java b/src/main/java/com/google/devtools/build/lib/skyframe/SkyframeExecutor.java
index 2e84d5e..eb44df0 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/SkyframeExecutor.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/SkyframeExecutor.java
@@ -587,6 +587,7 @@
     map.put(SkyFunctions.REPOSITORY_MAPPING, new RepositoryMappingFunction());
     map.put(SkyFunctions.RESOLVED_HASH_VALUES, new ResolvedHashesFunction());
     map.put(SkyFunctions.RESOLVED_FILE, new ResolvedFileFunction());
+    map.put(SkyFunctions.PLATFORM_MAPPING, new PlatformMappingFunction(directories));
     map.putAll(extraSkyFunctions);
     return map.build();
   }