Add a one-pass baseline compiler for arm64.

Currently handles 50% of methods by supporting methods that:
- don't branch
- don't have try/catch
- don't have float/double
- <= 8 registers
- opcodes are
  const/invokes/iget/iput/const-string/new-instance/checkcast.

Cost of compilation is 10 times less than current baseline compiler.
Performance of generated code: jit-baseline-cc configuration shows no
impact on go/lem

Test: test.py

Change-Id: I8c99b8a8a7552c09c900c5c3e831e8897aef73e5

1 files changed, 97 insertions, 0 deletions

diff --git a/compiler/optimizing/fast_compiler.h b/compiler/optimizing/fast_compiler.h
new file mode 100644
index 0000000000..65d1380eb8
--- /dev/null
+++ b/compiler/optimizing/fast_compiler.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2023 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.
+ */
+
+#ifndef ART_COMPILER_OPTIMIZING_FAST_COMPILER_H_
+#define ART_COMPILER_OPTIMIZING_FAST_COMPILER_H_
+
+#include <memory>
+#include <vector>
+
+#include "arch/instruction_set.h"
+#include "base/array_ref.h"
+#include "base/macros.h"
+#include "base/scoped_arena_containers.h"
+#include "driver/compiler_options.h"
+#include "handle_scope.h"
+
+namespace art HIDDEN {
+
+class ArenaAllocator;
+class ArtMethod;
+class DexCompilationUnit;
+class VariableSizedHandleScope;
+
+namespace mirror {
+class Object;
+}
+
+/**
+ * A lightweight, one-pass compiler. Goes over each dex instruction and emits
+ * native code for it.
+ */
+class FastCompiler {
+ public:
+  static std::unique_ptr<FastCompiler> Compile(
+      ArtMethod* method,
+      [[maybe_unused]] ArenaAllocator* allocator,
+      [[maybe_unused]] ArenaStack* arena_stack,
+      [[maybe_unused]] VariableSizedHandleScope* handles,
+      [[maybe_unused]] const CompilerOptions& compiler_options,
+      [[maybe_unused]] const DexCompilationUnit& dex_compilation_unit) {
+    if (method == nullptr) {
+      return nullptr;
+    }
+    switch (compiler_options.GetInstructionSet()) {
+#ifdef ART_ENABLE_CODEGEN_arm64
+      case InstructionSet::kArm64:
+        return CompileARM64(method,
+                            allocator,
+                            arena_stack,
+                            handles,
+                            compiler_options,
+                            dex_compilation_unit);
+#endif
+      default:
+        return nullptr;
+    }
+  }
+
+  virtual ArrayRef<const uint8_t> GetCode() const = 0;
+  virtual ScopedArenaVector<uint8_t> GetStackMaps() const = 0;
+  virtual ArrayRef<const uint8_t> GetCfiData() const = 0;
+  virtual int32_t GetFrameSize() const = 0;
+  virtual uint32_t GetNumberOfJitRoots() const = 0;
+  virtual void EmitJitRoots(uint8_t* code,
+                            const uint8_t* roots_data,
+                            /*out*/std::vector<Handle<mirror::Object>>* roots)
+      REQUIRES_SHARED(Locks::mutator_lock_) = 0;
+
+  virtual ~FastCompiler() = default;
+
+ private:
+#ifdef ART_ENABLE_CODEGEN_arm64
+  static std::unique_ptr<FastCompiler> CompileARM64(ArtMethod* method,
+                                                    ArenaAllocator* allocator,
+                                                    ArenaStack* arena_stack,
+                                                    VariableSizedHandleScope* handles,
+                                                    const CompilerOptions& compiler_options,
+                                                    const DexCompilationUnit& dex_compilation_unit);
+#endif
+};
+
+}  // namespace art
+
+#endif  // ART_COMPILER_OPTIMIZING_FAST_COMPILER_H_