diff --git a/Android.bp b/Android.bp
index 8cb298d..0deee8d 100644
--- a/Android.bp
+++ b/Android.bp
@@ -57,6 +57,7 @@
         "generate_ndk.cpp",
         "generate_java.cpp",
         "generate_java_binder.cpp",
+        "generate_aidl_mappings.cpp",
         "import_resolver.cpp",
         "line_reader.cpp",
         "io_delegate.cpp",
diff --git a/aidl.cpp b/aidl.cpp
index 227ba16..6fc4aa3 100644
--- a/aidl.cpp
+++ b/aidl.cpp
@@ -38,6 +38,7 @@
 
 #include "aidl_language.h"
 #include "aidl_typenames.h"
+#include "generate_aidl_mappings.h"
 #include "generate_cpp.h"
 #include "generate_java.h"
 #include "generate_ndk.h"
@@ -773,6 +774,34 @@
   return 0;
 }
 
+bool dump_mappings(const Options& options, const IoDelegate& io_delegate) {
+  android::aidl::mappings::SignatureMap all_mappings;
+  for (const string& input_file : options.InputFiles()) {
+    java::JavaTypeNamespace java_types;
+    java_types.Init();
+    vector<AidlDefinedType*> defined_types;
+    vector<string> imported_files;
+
+    AidlError aidl_err = internals::load_and_validate_aidl(
+        input_file, options, io_delegate, &java_types, &defined_types, &imported_files);
+    if (aidl_err != AidlError::OK) {
+      LOG(WARNING) << "AIDL file is invalid.\n";
+      continue;
+    }
+    for (const auto defined_type : defined_types) {
+      auto mappings = mappings::generate_mappings(defined_type);
+      all_mappings.insert(mappings.begin(), mappings.end());
+    }
+  }
+  std::stringstream mappings_str;
+  for (const auto& mapping : all_mappings) {
+    mappings_str << mapping.first << "\n" << mapping.second << "\n";
+  }
+  auto code_writer = io_delegate.GetCodeWriter(options.OutputFile());
+  code_writer->Write("%s", mappings_str.str().c_str());
+  return true;
+}
+
 bool preprocess_aidl(const Options& options, const IoDelegate& io_delegate) {
   unique_ptr<CodeWriter> writer = io_delegate.GetCodeWriter(options.OutputFile());
 
diff --git a/aidl.h b/aidl.h
index 965aa71..7b5628f 100644
--- a/aidl.h
+++ b/aidl.h
@@ -49,6 +49,7 @@
 int compile_aidl(const Options& options, const IoDelegate& io_delegate);
 bool preprocess_aidl(const Options& options, const IoDelegate& io_delegate);
 bool dump_api(const Options& options, const IoDelegate& io_delegate);
+bool dump_mappings(const Options& options, const IoDelegate& io_delegate);
 
 const string kGetInterfaceVersion("getInterfaceVersion");
 
diff --git a/aidl_language.cpp b/aidl_language.cpp
index 9ee3d05..547816a 100644
--- a/aidl_language.cpp
+++ b/aidl_language.cpp
@@ -64,6 +64,12 @@
 
 AidlNode::AidlNode(const AidlLocation& location) : location_(location) {}
 
+std::string AidlNode::PrintLocation() const {
+  std::stringstream ss;
+  ss << location_.file_ << ":" << location_.begin_.line;
+  return ss.str();
+}
+
 AidlError::AidlError(bool fatal) : os_(std::cerr), fatal_(fatal) {
   os_ << "ERROR: ";
 }
diff --git a/aidl_language.h b/aidl_language.h
index 1793f65..49a4606 100644
--- a/aidl_language.h
+++ b/aidl_language.h
@@ -22,6 +22,16 @@
 using std::unique_ptr;
 using std::vector;
 
+class AidlNode;
+
+namespace android {
+namespace aidl {
+namespace mappings {
+std::string dump_location(const AidlNode& method);
+}  // namespace mappings
+}  // namespace aidl
+}  // namespace android
+
 class AidlToken {
  public:
   AidlToken(const std::string& text, const std::string& comments);
@@ -46,6 +56,7 @@
   AidlLocation(const std::string& file, Point begin, Point end);
 
   friend std::ostream& operator<<(std::ostream& os, const AidlLocation& l);
+  friend class AidlNode;
 
  private:
   const std::string file_;
@@ -75,8 +86,10 @@
 
   // To be able to print AidlLocation (nothing else should use this information)
   friend class AidlError;
+  friend std::string android::aidl::mappings::dump_location(const AidlNode&);
 
  private:
+  std::string PrintLocation() const;
   const AidlLocation location_;
 };
 
diff --git a/build/aidl_interface.go b/build/aidl_interface.go
index 4014ac5..5ba98c1 100644
--- a/build/aidl_interface.go
+++ b/build/aidl_interface.go
@@ -70,6 +70,13 @@
 		CommandDeps: []string{"${aidlCmd}"},
 	}, "imports")
 
+	aidlDumpMappingsRule = pctx.StaticRule("aidlDumpMappingsRule", blueprint.RuleParams{
+		Command: `rm -rf "${outDir}" && mkdir -p "${outDir}" && ` +
+			`${aidlCmd} --apimapping ${outDir}/intermediate.txt ${in} ${imports} && ` +
+			`${aidlToJniCmd} ${outDir}/intermediate.txt ${out}`,
+		CommandDeps: []string{"${aidlCmd}"},
+	}, "imports", "outDir")
+
 	aidlFreezeApiRule = pctx.AndroidStaticRule("aidlFreezeApiRule",
 		blueprint.RuleParams{
 			Command: `mkdir -p ${to} && rm -rf ${to}/* && ` +
@@ -88,7 +95,9 @@
 func init() {
 	pctx.HostBinToolVariable("aidlCmd", "aidl")
 	pctx.HostBinToolVariable("bpmodifyCmd", "bpmodify")
+	pctx.SourcePathVariable("aidlToJniCmd", "system/tools/aidl/build/aidl_to_jni.py")
 	android.RegisterModuleType("aidl_interface", aidlInterfaceFactory)
+	android.RegisterModuleType("aidl_mapping", aidlMappingFactory)
 }
 
 // wrap(p, a, s) = [p + v + s for v in a]
@@ -832,3 +841,101 @@
 	}
 	return nil
 }
+
+type aidlMappingProperties struct {
+	// Source file of this prebuilt.
+	Srcs   []string `android:"arch_variant"`
+	Output string
+}
+
+type aidlMapping struct {
+	android.ModuleBase
+	properties     aidlMappingProperties
+	outputFilePath android.WritablePath
+}
+
+func (s *aidlMapping) DepsMutator(ctx android.BottomUpMutatorContext) {
+	android.ExtractSourcesDeps(ctx, s.properties.Srcs)
+}
+
+func addItemsToMap(dest map[string]bool, src []string) {
+	for _, item := range src {
+		dest[item] = true
+	}
+}
+
+func (s *aidlMapping) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+	var srcs android.Paths
+	var all_import_dirs map[string]bool = make(map[string]bool)
+
+	ctx.VisitDirectDeps(func(module android.Module) {
+		for _, property := range module.GetProperties() {
+			if jproperty, ok := property.(*java.CompilerProperties); ok {
+				for _, src := range jproperty.Srcs {
+					if strings.HasSuffix(src, ".aidl") {
+						full_path := android.PathForModuleSrc(ctx, src)
+						srcs = append(srcs, full_path)
+						all_import_dirs[filepath.Dir(full_path.String())] = true
+					} else if pathtools.IsGlob(src) {
+						globbedSrcFiles, err := ctx.GlobWithDeps(src, nil)
+						if err == nil {
+							for _, globbedSrc := range globbedSrcFiles {
+								full_path := android.PathForModuleSrc(ctx, globbedSrc)
+								all_import_dirs[full_path.String()] = true
+							}
+						}
+					}
+				}
+			} else if jproperty, ok := property.(*java.CompilerDeviceProperties); ok {
+				addItemsToMap(all_import_dirs, jproperty.Aidl.Include_dirs)
+				for _, include_dir := range jproperty.Aidl.Export_include_dirs {
+					var full_path = filepath.Join(ctx.ModuleDir(), include_dir)
+					all_import_dirs[full_path] = true
+				}
+				for _, include_dir := range jproperty.Aidl.Local_include_dirs {
+					var full_path = filepath.Join(ctx.ModuleSubDir(), include_dir)
+					all_import_dirs[full_path] = true
+				}
+			}
+		}
+	})
+
+	var import_dirs []string
+	for dir := range all_import_dirs {
+		import_dirs = append(import_dirs, dir)
+	}
+	imports := strings.Join(wrap("-I", import_dirs, ""), " ")
+	s.outputFilePath = android.PathForModuleOut(ctx, s.properties.Output)
+	outDir := android.PathForModuleGen(ctx)
+	ctx.Build(pctx, android.BuildParams{
+		Rule:   aidlDumpMappingsRule,
+		Inputs: srcs,
+		Output: s.outputFilePath,
+		Args: map[string]string{
+			"imports": imports,
+			"outDir":  outDir.String(),
+		},
+	})
+}
+
+func InitAidlMappingModule(s *aidlMapping) {
+	s.AddProperties(&s.properties)
+}
+
+func aidlMappingFactory() android.Module {
+	module := &aidlMapping{}
+	InitAidlMappingModule(module)
+	android.InitAndroidModule(module)
+	return module
+}
+
+func (m *aidlMapping) AndroidMk() android.AndroidMkData {
+	return android.AndroidMkData{
+		Custom: func(w io.Writer, name, prefix, moduleDir string, data android.AndroidMkData) {
+			android.WriteAndroidMkData(w, data)
+			targetName := m.Name()
+			fmt.Fprintln(w, ".PHONY:", targetName)
+			fmt.Fprintln(w, targetName+":", m.outputFilePath.String())
+		},
+	}
+}
diff --git a/build/aidl_to_jni.py b/build/aidl_to_jni.py
new file mode 100755
index 0000000..55b1d52
--- /dev/null
+++ b/build/aidl_to_jni.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+
+#
+# Copyright (C) 2019 The Android Open Source Project
+#
+# 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.
+#
+
+import sys
+
+DEFAULT_TYPES_TO_JNI = {
+  "boolean": "Z",
+  "byte": "B",
+  "char": "C",
+  "short": "S",
+  "int": "I",
+  "long": "J",
+  "float": "F",
+  "double": "D",
+  "void": "V",
+  "String": "Ljava/lang/String;"
+}
+
+class AIDLMalformedSignatureException(Exception):
+  """Line containing AIDL signature is invalid"""
+
+def convert_type(aidl_type):
+  if aidl_type.endswith("[]"):
+    return "[" + convert_type(aidl_type[:-2])
+  if aidl_type in DEFAULT_TYPES_TO_JNI:
+    return DEFAULT_TYPES_TO_JNI[aidl_type]
+  elif aidl_type.startswith("List<") | aidl_type.startswith("java.util.List<"):
+    return "Ljava/util/List;"
+  else:
+    return "L" + aidl_type.replace(".", "/") + ";"
+
+def convert_method(aidl_signature):
+  aidl_signature = aidl_signature.split("|")
+  if len(aidl_signature) != 4:
+    raise AIDLMalformedSignatureException()
+  class_name, method_name, args, return_type = aidl_signature
+  # Filter out empty arguments since there will be trailing commas
+  args = [x for x in args.split(",") if x]
+  jni_signature = convert_type(class_name)
+  jni_signature += "->"
+  jni_signature += method_name
+  jni_signature += "("
+  params = [convert_type(x) for x in args]
+  jni_signature += "".join(params)
+  jni_signature += ")"
+  jni_signature += convert_type(return_type)
+  return jni_signature
+
+def main(argv):
+  if len(argv) != 3:
+    print("Usage: %s <aidl-mappings> <jni-signature-mappings>" % argv[0])
+    return -1
+
+  aidl_mappings, jni_signature_mappings = argv[1:]
+
+  line_index = 0
+  skip_line = False
+  with open(aidl_mappings) as input_file:
+    with open(jni_signature_mappings, "w") as output_file:
+      for line in input_file:
+        if skip_line:
+          skip_line = False
+        elif line_index % 2 == 1:
+          output_file.write(line)
+        else:
+          try:
+            stripped_line = line.strip()
+            output_file.write(convert_method(line.strip()))
+            output_file.write("\n")
+          except AIDLMalformedSignatureException:
+            print("Malformed signature %s . Skipping..." % stripped_line)
+            # The next line contains the location, need to skip it
+            skip_line = True
+        line_index += 1
+
+if __name__ == "__main__":
+  sys.exit(main(sys.argv))
diff --git a/generate_aidl_mappings.cpp b/generate_aidl_mappings.cpp
new file mode 100644
index 0000000..97958e3
--- /dev/null
+++ b/generate_aidl_mappings.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2019, The Android Open Source Project
+ *
+ * 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.
+ */
+
+#include "generate_aidl_mappings.h"
+#include "type_java.h"
+
+#include <sstream>
+
+namespace android {
+namespace aidl {
+namespace mappings {
+
+std::string dump_location(const AidlNode& method) {
+  return method.PrintLocation();
+}
+
+SignatureMap generate_mappings(const AidlDefinedType* defined_type) {
+  const AidlInterface* interface = defined_type->AsInterface();
+  SignatureMap mappings;
+  if (interface == nullptr) {
+    return mappings;
+  }
+  for (const auto& method : interface->GetMethods()) {
+    if (method->IsUserDefined()) {
+      std::stringstream signature;
+      signature << interface->GetCanonicalName() << "|";
+      signature << method->GetName() << "|";
+      for (const auto& arg : method->GetArguments()) {
+        signature << arg->GetType().ToString() << ",";
+      }
+      signature << "|";
+      signature << method->GetType().GetLanguageType<java::Type>()->JavaType();
+      mappings[signature.str()] = dump_location(*method);
+    }
+  }
+  return mappings;
+}
+
+}  // namespace mappings
+}  // namespace aidl
+}  // namespace android
diff --git a/generate_aidl_mappings.h b/generate_aidl_mappings.h
new file mode 100644
index 0000000..09f611e
--- /dev/null
+++ b/generate_aidl_mappings.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2019, The Android Open Source Project
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include "aidl_language.h"
+
+namespace android {
+namespace aidl {
+namespace mappings {
+
+using SignatureMap = std::unordered_map<std::string, std::string>;
+
+SignatureMap generate_mappings(const AidlDefinedType* iface);
+}  // namespace mappings
+}  // namespace aidl
+}  // namespace android
diff --git a/main.cpp b/main.cpp
index ffc30a1..d21819a 100644
--- a/main.cpp
+++ b/main.cpp
@@ -50,6 +50,8 @@
       return android::aidl::dump_api(options, io_delegate) ? 0 : 1;
     case Options::Task::CHECK_API:
       return android::aidl::check_api(options, io_delegate) ? 0 : 1;
+    case Options::Task::DUMP_MAPPINGS:
+      return android::aidl::dump_mappings(options, io_delegate) ? 0 : 1;
     default:
       LOG(FATAL) << "aidl: internal error" << std::endl;
       return 1;
diff --git a/options.cpp b/options.cpp
index 8b5f16e..166e8ac 100644
--- a/options.cpp
+++ b/options.cpp
@@ -96,6 +96,14 @@
        << "          tool, that part will not be traced." << endl
        << "  --transaction_names" << endl
        << "          Generate transaction names." << endl
+       << "  --apimapping" << endl
+       << "          Generates a mapping of declared aidl method signatures to" << endl
+       << "          the original line number. e.g.: " << endl
+       << "              If line 39 of foo/bar/IFoo.aidl contains:"
+       << "              void doFoo(int bar, String baz);" << endl
+       << "              Then the result would be:" << endl
+       << "              foo.bar.Baz|doFoo|int,String,|void" << endl
+       << "              foo/bar/IFoo.aidl:39" << endl
        << "  -v VER, --version=VER" << endl
        << "          Set the version of the interface and parcelable to VER." << endl
        << "          VER must be an interger greater than 0." << endl
@@ -152,6 +160,7 @@
         {"dumpapi", no_argument, 0, 'u'},
         {"checkapi", no_argument, 0, 'A'},
 #endif
+        {"apimapping", required_argument, 0, 'i'},
         {"include", required_argument, 0, 'I'},
         {"import", required_argument, 0, 'm'},
         {"preprocessed", required_argument, 0, 'p'},
@@ -279,6 +288,10 @@
       case 'e':
         std::cerr << GetUsage();
         exit(0);
+      case 'i':
+        output_file_ = Trim(optarg);
+        task_ = Task::DUMP_MAPPINGS;
+        break;
       default:
         std::cerr << GetUsage();
         exit(1);
@@ -341,7 +354,7 @@
                        << "got " << (argc - optind) << "." << endl;
         return;
       }
-      if (task_ != Options::Task::CHECK_API) {
+      if (task_ != Options::Task::CHECK_API && task_ != Options::Task::DUMP_MAPPINGS) {
         output_file_ = argv[optind++];
       }
     }
diff --git a/options.h b/options.h
index 11e06ef..403301d 100644
--- a/options.h
+++ b/options.h
@@ -61,7 +61,7 @@
  public:
   enum class Language { UNSPECIFIED, JAVA, CPP, NDK };
 
-  enum class Task { UNSPECIFIED, COMPILE, PREPROCESS, DUMP_API, CHECK_API };
+  enum class Task { UNSPECIFIED, COMPILE, PREPROCESS, DUMP_API, CHECK_API, DUMP_MAPPINGS };
 
   Options(int argc, const char* const argv[], Language default_lang = Language::UNSPECIFIED);
 
@@ -124,6 +124,8 @@
 
   string GetUsage() const;
 
+  bool GenApiMapping() const { return task_ == Task::DUMP_MAPPINGS; }
+
   // The following are for testability, but cannot be influenced on the command line.
   // Threshold of interface methods to enable outlining of onTransact cases.
   size_t onTransact_outline_threshold_{275u};