Update prebuilt Clang to r416183b from Android.
https://android.googlesource.com/platform/prebuilts/clang/host/
linux-x86/+/06a71ddac05c22edb2d10b590e1769b3f8619bef
clang 12.0.5 (based on r416183b) from build 7284624.
Change-Id: I277a316abcf47307562d8b748b84870f31a72866
Signed-off-by: Olivier Deprez <olivier.deprez@arm.com>
diff --git a/linux-x64/clang/include/polly/CodeGen/PerfMonitor.h b/linux-x64/clang/include/polly/CodeGen/PerfMonitor.h
new file mode 100644
index 0000000..81aa4c7
--- /dev/null
+++ b/linux-x64/clang/include/polly/CodeGen/PerfMonitor.h
@@ -0,0 +1,142 @@
+//===--- PerfMonitor.h --- Monitor time spent in scops --------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef PERF_MONITOR_H
+#define PERF_MONITOR_H
+
+#include "polly/CodeGen/IRBuilder.h"
+
+namespace polly {
+
+class PerfMonitor {
+public:
+ /// Create a new performance monitor.
+ ///
+ /// @param S The scop for which to generate fine-grained performance
+ /// monitoring information.
+ /// @param M The module for which to generate the performance monitor.
+ PerfMonitor(const Scop &S, llvm::Module *M);
+
+ /// Initialize the performance monitor.
+ ///
+ /// Ensure that all global variables, functions, and callbacks needed to
+ /// manage the performance monitor are initialized and registered.
+ void initialize();
+
+ /// Mark the beginning of a timing region.
+ ///
+ /// @param InsertBefore The instruction before which the timing region starts.
+ void insertRegionStart(llvm::Instruction *InsertBefore);
+
+ /// Mark the end of a timing region.
+ ///
+ /// @param InsertBefore The instruction before which the timing region starts.
+ void insertRegionEnd(llvm::Instruction *InsertBefore);
+
+private:
+ llvm::Module *M;
+ PollyIRBuilder Builder;
+
+ // The scop to profile against.
+ const Scop &S;
+
+ /// Indicates if performance profiling is supported on this architecture.
+ bool Supported;
+
+ /// The cycle counter at the beginning of the program execution.
+ llvm::Value *CyclesTotalStartPtr;
+
+ /// The total number of cycles spent in the current scop S.
+ llvm::Value *CyclesInCurrentScopPtr;
+
+ /// The total number of times the current scop S is executed.
+ llvm::Value *TripCountForCurrentScopPtr;
+
+ /// The total number of cycles spent within scops.
+ llvm::Value *CyclesInScopsPtr;
+
+ /// The value of the cycle counter at the beginning of the last scop.
+ llvm::Value *CyclesInScopStartPtr;
+
+ /// A global variable, that keeps track if the performance monitor
+ /// initialization has already been run.
+ llvm::Value *AlreadyInitializedPtr;
+
+ llvm::Function *insertInitFunction(llvm::Function *FinalReporting);
+
+ /// Add Function @p to list of global constructors
+ ///
+ /// If no global constructors are available in this current module, insert
+ /// a new list of global constructors containing @p Fn as only global
+ /// constructor. Otherwise, append @p Fn to the list of global constructors.
+ ///
+ /// All functions listed as global constructors are executed before the
+ /// main() function is called.
+ ///
+ /// @param Fn Function to add to global constructors
+ void addToGlobalConstructors(llvm::Function *Fn);
+
+ /// Add global variables to module.
+ ///
+ /// Insert a set of global variables that are used to track performance,
+ /// into the module (or obtain references to them if they already exist).
+ void addGlobalVariables();
+
+ /// Add per-scop tracking to module.
+ ///
+ /// Insert the global variable which is used to track the number of cycles
+ /// this scop runs.
+ void addScopCounter();
+
+ /// Get a reference to the intrinsic "{ i64, i32 } @llvm.x86.rdtscp()".
+ ///
+ /// The rdtscp function returns the current value of the processor's
+ /// time-stamp counter as well as the current CPU identifier. On modern x86
+ /// systems, the returned value is independent of the dynamic clock frequency
+ /// and consistent across multiple cores. It can consequently be used to get
+ /// accurate and low-overhead timing information. Even though the counter is
+ /// wrapping, it can be reliably used even for measuring longer time
+ /// intervals, as on a 1 GHz processor the counter only wraps every 545 years.
+ ///
+ /// The RDTSCP instruction is "pseudo" serializing:
+ ///
+ /// "“The RDTSCP instruction waits until all previous instructions have been
+ /// executed before reading the counter. However, subsequent instructions may
+ /// begin execution before the read operation is performed.”
+ ///
+ /// To ensure that no later instructions are scheduled before the RDTSCP
+ /// instruction it is often recommended to schedule a cpuid call after the
+ /// RDTSCP instruction. We do not do this yet, trading some imprecision in
+ /// our timing for a reduced overhead in our timing.
+ ///
+ /// @returns A reference to the declaration of @llvm.x86.rdtscp.
+ llvm::Function *getRDTSCP();
+
+ /// Get a reference to "int atexit(void (*function)(void))" function.
+ ///
+ /// This function allows to register function pointers that must be executed
+ /// when the program is terminated.
+ ///
+ /// @returns A reference to @atexit().
+ llvm::Function *getAtExit();
+
+ /// Create function "__polly_perf_final_reporting".
+ ///
+ /// This function finalizes the performance measurements and prints the
+ /// results to stdout. It is expected to be registered with 'atexit()'.
+ llvm::Function *insertFinalReporting();
+
+ /// Append Scop reporting data to "__polly_perf_final_reporting".
+ ///
+ /// This function appends the current scop (S)'s information to the final
+ /// printing function.
+ void AppendScopReporting();
+};
+} // namespace polly
+
+#endif