[clang] [llvm] [clangd] Add support for the c2000 architecture (PR #125663)
via cfe-commits
cfe-commits at lists.llvm.org
Tue Feb 4 02:27:40 PST 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang-driver
Author: None (student433)
<details>
<summary>Changes</summary>
Fixes #<!-- -->114979, adding support for the cl2000 compiler to the clang frontend to get clangd working as discussed in https://discourse.llvm.org/t/ti-c2000-target-not-supported-in-clangd-lsp/83015
---
Patch is 39.21 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/125663.diff
15 Files Affected:
- (modified) clang/include/clang/Driver/Driver.h (+5-1)
- (modified) clang/include/clang/Driver/Options.h (+1)
- (modified) clang/include/clang/Driver/Options.td (+64-10)
- (modified) clang/lib/Basic/CMakeLists.txt (+1)
- (modified) clang/lib/Basic/Targets.cpp (+4)
- (added) clang/lib/Basic/Targets/C2000.cpp (+356)
- (added) clang/lib/Basic/Targets/C2000.h (+100)
- (modified) clang/lib/Driver/CMakeLists.txt (+1)
- (modified) clang/lib/Driver/Driver.cpp (+13)
- (modified) clang/lib/Driver/ToolChain.cpp (+1)
- (added) clang/lib/Driver/ToolChains/Arch/C2000.cpp (+85)
- (added) clang/lib/Driver/ToolChains/Arch/C2000.h (+22)
- (modified) clang/lib/Driver/ToolChains/CommonArgs.cpp (+5)
- (modified) llvm/include/llvm/TargetParser/Triple.h (+1)
- (modified) llvm/lib/TargetParser/Triple.cpp (+7)
``````````diff
diff --git a/clang/include/clang/Driver/Driver.h b/clang/include/clang/Driver/Driver.h
index f4a52cc529b79c..55da823598f9b1 100644
--- a/clang/include/clang/Driver/Driver.h
+++ b/clang/include/clang/Driver/Driver.h
@@ -107,7 +107,8 @@ class Driver {
CPPMode,
CLMode,
FlangMode,
- DXCMode
+ DXCMode,
+ C2000Mode
} Mode;
enum SaveTempsMode {
@@ -253,6 +254,9 @@ class Driver {
/// Whether the driver should follow dxc.exe like behavior.
bool IsDXCMode() const { return Mode == DXCMode; }
+ // Whether the driver should follow cl2000.exe like behaviour.
+ bool IsC2000Mode() const { return Mode == C2000Mode; }
+
/// Only print tool bindings, don't build any jobs.
LLVM_PREFERRED_TYPE(bool)
unsigned CCCPrintBindings : 1;
diff --git a/clang/include/clang/Driver/Options.h b/clang/include/clang/Driver/Options.h
index 0797410e9940e2..1613810a5bf741 100644
--- a/clang/include/clang/Driver/Options.h
+++ b/clang/include/clang/Driver/Options.h
@@ -39,6 +39,7 @@ enum ClangVisibility {
FlangOption = (1 << 4),
FC1Option = (1 << 5),
DXCOption = (1 << 6),
+ CL2000Option = (1 << 7)
};
enum ID {
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index d38dd2b4e3cf09..44ce3c3413b09b 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -97,6 +97,10 @@ def FC1Option : OptionVisibility;
// are made available when the driver is running in DXC compatibility mode.
def DXCOption : OptionVisibility;
+// CL2000Option - This is a cl2000.exe compatibility option. Options with this flag
+// are made available when the driver is running in cl2000 compatibility mode.
+def CL2000Option : OptionVisibility;
+
/////////
// Docs
@@ -201,6 +205,9 @@ def hlsl_Group : OptionGroup<"<HLSL group>">, Group<f_Group>,
DocName<"HLSL options">,
Visibility<[ClangOption]>;
+def cl2000_group : OptionGroup<"<cl2000 group>">,
+ Visibility<[CL2000Option]>;
+
// Feature groups - these take command line options that correspond directly to
// target specific features and can be translated directly from command line
// options.
@@ -672,7 +679,7 @@ class InternalDriverOpt : Group<internal_driver_Group>,
Flags<[NoXarchOption, HelpHidden]>;
def driver_mode : Joined<["--"], "driver-mode=">, Group<internal_driver_Group>,
Flags<[NoXarchOption, HelpHidden]>,
- Visibility<[ClangOption, FlangOption, CLOption, DXCOption]>,
+ Visibility<[ClangOption, FlangOption, CLOption, DXCOption, CL2000Option]>,
HelpText<"Set the driver mode to either 'gcc', 'g++', 'cpp', 'cl' or 'flang'">;
def rsp_quoting : Joined<["--"], "rsp-quoting=">, Group<internal_driver_Group>,
Flags<[NoXarchOption, HelpHidden]>,
@@ -843,7 +850,7 @@ def C : Flag<["-"], "C">, Visibility<[ClangOption, CC1Option]>,
HelpText<"Include comments in preprocessed output">,
MarshallingInfoFlag<PreprocessorOutputOpts<"ShowComments">>;
def D : JoinedOrSeparate<["-"], "D">, Group<Preprocessor_Group>,
- Visibility<[ClangOption, CC1Option, FlangOption, FC1Option, DXCOption]>,
+ Visibility<[ClangOption, CC1Option, FlangOption, FC1Option, DXCOption, CL2000Option]>,
MetaVarName<"<macro>=<value>">,
HelpText<"Define <macro> to <value> (or 1 if <value> omitted)">;
def E : Flag<["-"], "E">, Flags<[NoXarchOption]>,
@@ -929,7 +936,7 @@ def ObjCXX : Flag<["-"], "ObjC++">, Flags<[NoXarchOption]>,
def ObjC : Flag<["-"], "ObjC">, Flags<[NoXarchOption]>,
HelpText<"Treat source input files as Objective-C inputs">;
def O : Joined<["-"], "O">, Group<O_Group>,
- Visibility<[ClangOption, CC1Option, FC1Option, FlangOption]>;
+ Visibility<[ClangOption, CC1Option, FC1Option, FlangOption, CL2000Option]>;
def O_flag : Flag<["-"], "O">, Visibility<[ClangOption, CC1Option, FC1Option]>,
Alias<O>, AliasArgs<["1"]>;
def Ofast : Joined<["-"], "Ofast">, Group<O_Group>,
@@ -1035,10 +1042,10 @@ def Xassembler : Separate<["-"], "Xassembler">,
Group<CompileOnly_Group>;
def Xclang : Separate<["-"], "Xclang">,
HelpText<"Pass <arg> to clang -cc1">, MetaVarName<"<arg>">,
- Flags<[NoXarchOption]>, Visibility<[ClangOption, CLOption, DXCOption]>,
+ Flags<[NoXarchOption]>, Visibility<[ClangOption, CLOption, DXCOption, CL2000Option]>,
Group<CompileOnly_Group>;
def : Joined<["-"], "Xclang=">, Group<CompileOnly_Group>,
- Flags<[NoXarchOption]>, Visibility<[ClangOption, CLOption, DXCOption]>,
+ Flags<[NoXarchOption]>, Visibility<[ClangOption, CLOption, DXCOption, CL2000Option]>,
Alias<Xclang>,
HelpText<"Alias for -Xclang">, MetaVarName<"<arg>">;
def Xcuda_fatbinary : Separate<["-"], "Xcuda-fatbinary">,
@@ -4023,7 +4030,7 @@ def fdriver_only : Flag<["-"], "fdriver-only">, Flags<[NoXarchOption]>,
Group<Action_Group>, HelpText<"Only run the driver.">;
def fsyntax_only : Flag<["-"], "fsyntax-only">,
Flags<[NoXarchOption]>,
- Visibility<[ClangOption, CLOption, DXCOption, CC1Option, FC1Option, FlangOption]>,
+ Visibility<[ClangOption, CLOption, DXCOption, CC1Option, FC1Option, FlangOption, CL2000Option]>,
Group<Action_Group>,
HelpText<"Run the preprocessor, parser and semantic analysis stages">;
def ftabstop_EQ : Joined<["-"], "ftabstop=">, Group<f_Group>;
@@ -4470,7 +4477,7 @@ defm emit_compact_unwind_non_canonical : BoolFOption<"emit-compact-unwind-non-ca
"Try emitting Compact-Unwind for non-canonical entries. Maybe overridden by other constraints">,
NegFlag<SetFalse>>;
def g_Flag : Flag<["-"], "g">, Group<g_Group>,
- Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>,
+ Visibility<[ClangOption, CLOption, DXCOption, FlangOption, CL2000Option]>,
HelpText<"Generate source-level debug information">;
def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<gN_Group>,
Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>,
@@ -5817,11 +5824,11 @@ def rdynamic : Flag<["-"], "rdynamic">, Group<Link_Group>,
Visibility<[ClangOption, FlangOption]>;
def resource_dir : Separate<["-"], "resource-dir">,
Flags<[NoXarchOption, HelpHidden]>,
- Visibility<[ClangOption, CC1Option, CLOption, DXCOption, FlangOption, FC1Option]>,
+ Visibility<[ClangOption, CC1Option, CLOption, DXCOption, FlangOption, FC1Option, CL2000Option]>,
HelpText<"The directory which holds the compiler resource files">,
MarshallingInfoString<HeaderSearchOpts<"ResourceDir">>;
def resource_dir_EQ : Joined<["-"], "resource-dir=">, Flags<[NoXarchOption]>,
- Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>,
+ Visibility<[ClangOption, CLOption, DXCOption, FlangOption, CL2000Option]>,
Alias<resource_dir>;
def rpath : Separate<["-"], "rpath">, Flags<[LinkerInput]>, Group<Link_Group>,
Visibility<[ClangOption, FlangOption]>;
@@ -6020,7 +6027,7 @@ def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">,
MarshallingInfoFlag<DiagnosticOpts<"IgnoreWarnings">>;
def x : JoinedOrSeparate<["-"], "x">,
Flags<[NoXarchOption]>,
- Visibility<[ClangOption, CC1Option, FlangOption, FC1Option, CLOption]>,
+ Visibility<[ClangOption, CC1Option, FlangOption, FC1Option, CLOption, CL2000Option]>,
HelpText<"Treat subsequent input files as having type <language>">,
MetaVarName<"<language>">;
def y : Joined<["-"], "y">;
@@ -9111,3 +9118,50 @@ def wasm_opt : Flag<["--"], "wasm-opt">,
Group<m_Group>,
HelpText<"Enable the wasm-opt optimizer (default)">,
MarshallingInfoNegativeFlag<LangOpts<"NoWasmOpt">>;
+
+
+
+//===----------------------------------------------------------------------===//
+// cl2000 Options
+//===----------------------------------------------------------------------===//
+
+
+
+
+def cl2000_include_path : Joined<["--"], "include_path=">, Group<cl2000_group>,
+ HelpText<"specify include search paths for cl2000 driver mode">, Alias<isystem>;
+
+def eabi : Joined<["--"], "abi=">, Group<cl2000_group>,
+ HelpText<"abi">;
+def strict_ansi : Joined<["--"], "strict_ansi">, Group<cl2000_group>,
+ HelpText<"strict ANSI/ISO Mode">;
+def fp_mode : Joined<["--"], "fp_mode=">, Group<cl2000_group>,
+ HelpText<"fp mode">;
+def cla_support : Joined<["--"], "cla_support=">, Group<cl2000_group>,
+ HelpText<"cla Support">;
+def float_support : Joined<["--"], "float_support=">, Group<cl2000_group>,
+ HelpText<"Float Support">;
+def idiv_support : Joined<["--"], "idiv_support=">, Group<cl2000_group>,
+ HelpText<"idiv Support">;
+def tmu_support : Joined<["--"], "tmu_support=">, Group<cl2000_group>,
+ HelpText<"tmu Support">;
+def vcu_support : Joined<["--"], "vcu_support=">, Group<cl2000_group>,
+ HelpText<"vcu Support">;
+def opt_level : Joined<["--"], "opt_level=">, Group<cl2000_group>,
+ HelpText<"opt level">, Alias<O>;
+def silicon_version : Joined<["-"], "v28">, Group<cl2000_group>,
+ HelpText<"silicon version">;
+def large_model : Joined<["-"], "ml">, Group<cl2000_group>,
+ HelpText<"large model">;
+def unified_memory : Joined<["-"], "mt">, Group<cl2000_group>,
+ HelpText<"unified memory">;
+def output_file : Joined<["--"], "output_file=">, Group<cl2000_group>,
+ HelpText<"output file">, Alias<o>;
+def source_file : Joined<["--"], "">, Group<cl2000_group>,
+ HelpText<"source file">;
+def symdebug_dwarf : Joined<["--"], "symdebug:dwarf">, Group<cl2000_group>,
+ HelpText<"Alias for -g">, Alias<g_Flag>;
+def relaxed_ansi : Joined<["--"], "relaxed_ansi">, Group<cl2000_group>,
+ HelpText<"relaxed ansi mode">;
+def compile_only : Joined<["--"], "compile_only">, Group<cl2000_group>,
+ HelpText<"compile only">, Alias<c>;
diff --git a/clang/lib/Basic/CMakeLists.txt b/clang/lib/Basic/CMakeLists.txt
index 331dfbb3f4b67e..bc71f93fe101a2 100644
--- a/clang/lib/Basic/CMakeLists.txt
+++ b/clang/lib/Basic/CMakeLists.txt
@@ -99,6 +99,7 @@ add_clang_library(clangBasic
Targets/ARM.cpp
Targets/AVR.cpp
Targets/BPF.cpp
+ Targets/C2000.cpp
Targets/CSKY.cpp
Targets/DirectX.cpp
Targets/Hexagon.cpp
diff --git a/clang/lib/Basic/Targets.cpp b/clang/lib/Basic/Targets.cpp
index 281aebdb1c35d3..9f5045a73b2d83 100644
--- a/clang/lib/Basic/Targets.cpp
+++ b/clang/lib/Basic/Targets.cpp
@@ -19,6 +19,7 @@
#include "Targets/ARM.h"
#include "Targets/AVR.h"
#include "Targets/BPF.h"
+#include "Targets/C2000.h"
#include "Targets/CSKY.h"
#include "Targets/DirectX.h"
#include "Targets/Hexagon.h"
@@ -272,6 +273,9 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple,
case llvm::Triple::msp430:
return std::make_unique<MSP430TargetInfo>(Triple, Opts);
+ case llvm::Triple::c2000:
+ return std::make_unique<C2000TargetInfo>(Triple, Opts);
+
case llvm::Triple::mips:
switch (os) {
case llvm::Triple::Linux:
diff --git a/clang/lib/Basic/Targets/C2000.cpp b/clang/lib/Basic/Targets/C2000.cpp
new file mode 100644
index 00000000000000..5fe53377f10878
--- /dev/null
+++ b/clang/lib/Basic/Targets/C2000.cpp
@@ -0,0 +1,356 @@
+#include "C2000.h"
+#include "Targets.h"
+#include "clang/Basic/Builtins.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/MacroBuilder.h"
+#include "clang/Basic/TargetBuiltins.h"
+
+using namespace clang;
+using namespace clang::targets;
+
+const char *const C2000TargetInfo::GCCRegNames[] = {
+ "ACC", "XAR0", "XAR1", "XAR2", "XAR3", "XAR4", "XAR5", "XAR6", "XAR7"};
+
+ArrayRef<const char *> C2000TargetInfo::getGCCRegNames() const {
+ return llvm::ArrayRef(GCCRegNames);
+}
+
+bool C2000TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
+ DiagnosticsEngine &Diags) {
+
+ for (const auto &Feature : Features) {
+ if (Feature == "+eabi") {
+ eabi = true;
+ continue;
+ }
+ if (Feature == "+strict_ansi") {
+ strict = true;
+ continue;
+ }
+ if (Feature == "+cla_support") {
+ cla_support = true;
+ }
+ if (Feature == "+cla0") {
+ cla0 = true;
+ continue;
+ }
+ if (Feature == "+cla1") {
+ cla1 = true;
+ continue;
+ }
+ if (Feature == "+cla2") {
+ cla2 = true;
+ continue;
+ }
+ if (Feature == "+relaxed") {
+ relaxed = true;
+ continue;
+ }
+ if (Feature == "+fpu64") {
+ fpu64 = true;
+ continue;
+ }
+ if (Feature == "+fpu32") {
+ fpu32 = true;
+ continue;
+ }
+ if (Feature == "+tmu_support") {
+ tmu_support = true;
+ }
+ if (Feature == "+tmu1") {
+ tmu1 = true;
+ continue;
+ }
+ if (Feature == "+idiv0") {
+ idiv0 = true;
+ continue;
+ }
+ if (Feature == "+vcu_support") {
+ vcu_support = true;
+ }
+ if (Feature == "+vcu2") {
+ vcu2 = true;
+ continue;
+ }
+ if (Feature == "+vcrc") {
+ vcrc = true;
+ continue;
+ }
+ if (Feature == "+opt_level") {
+ opt = true;
+ continue;
+ }
+ }
+ return true;
+}
+
+bool C2000TargetInfo::hasFeature(StringRef Feature) const {
+ return llvm::StringSwitch<bool>(Feature)
+ .Case("eabi", eabi)
+ .Case("strict_ansi", strict)
+ .Case("cla-support", cla_support)
+ .Case("cla0", cla0)
+ .Case("cla1", cla1)
+ .Case("cla2", cla2)
+ .Case("relaxed", relaxed)
+ .Case("fpu64", fpu64)
+ .Case("fpu32", fpu32)
+ .Case("tmu-support", tmu_support)
+ .Case("tmu1", tmu1)
+ .Case("vcu-support", vcu_support)
+ .Case("vcu2", vcu2)
+ .Case("vcrc", vcrc)
+ .Case("opt-level", opt)
+ .Default(false);
+}
+
+void C2000TargetInfo::getTargetDefines(const LangOptions &Opts,
+ MacroBuilder &Builder) const {
+ Builder.undefineMacro("__CHAR_BIT__"); // FIXME: Implement 16-bit char
+ Builder.defineMacro("__CHAR_BIT__", "16");
+ Builder.defineMacro("__TMS320C2000__");
+ Builder.defineMacro("_TMS320C2000");
+ Builder.defineMacro("__TMS320C28XX__");
+ Builder.defineMacro("_TMS320C28XX");
+ Builder.defineMacro("__TMS320C28X__");
+ Builder.defineMacro("_TMS320C28X");
+ Builder.defineMacro("__TI_STRICT_FP_MODE__");
+ Builder.defineMacro("__COMPILER_VERSION__");
+ Builder.defineMacro("__TI_COMPILER_VERSION__");
+ Builder.defineMacro("__TI_COMPILER_VERSION__QUAL_ID");
+ Builder.defineMacro("__TI_COMPILER_VERSION__QUAL__", "QUAL_LETTER");
+ Builder.defineMacro("__little_endian__");
+ Builder.defineMacro("__PTRDIFF_T_TYPE__", "signed long");
+ Builder.defineMacro("__SIZE_T_TYPE__", "unsigned long");
+ Builder.defineMacro("__WCHAR_T_TYPE__", "long unsigned");
+ Builder.defineMacro("__TI_WCHAR_T_BITS", "16");
+ Builder.defineMacro("__TI_C99_COMPLEX_ENABLED");
+ Builder.defineMacro("__TI_GNU_ATTRIBUTE_SUPPORT__");
+ Builder.defineMacro("__LARGE_MODEL__");
+ Builder.defineMacro("__signed_chars__");
+ Builder.defineMacro("__OPTIMIZE_FOR_SPACE");
+
+ if (hasFeature("eabi"))
+ Builder.defineMacro("__TI_EABI__");
+ if (hasFeature("strict_ansi"))
+ Builder.defineMacro("__TI_STRICT_ANSI_MODE__");
+ if (hasFeature("cla-support"))
+ Builder.defineMacro("__TMS320C28XX_CLA__");
+
+ if (hasFeature("cla0"))
+ Builder.defineMacro("__TMS320C28XX_CLA0__");
+ else if (hasFeature("cla1"))
+ Builder.defineMacro("__TMS320C28XX_CLA1__");
+ else if (hasFeature("cla2"))
+ Builder.defineMacro("__TMS320C28XX_CLA2__");
+
+ if (hasFeature("fpu64")) {
+ Builder.defineMacro("__TMS320C28XX_FPU64__");
+ Builder.defineMacro("__TMS320C28XX_FPU32__");
+ } else if (hasFeature("fpu32"))
+ Builder.defineMacro("__TMS320C28XX_FPU32__");
+ if (hasFeature("idiv0"))
+ Builder.defineMacro("__TMS320C28XX_IDIV__");
+ if (hasFeature("tmu1"))
+ Builder.defineMacro("__TMS320C28XX_TMU1__");
+ if (hasFeature("tmu-support")) {
+ Builder.defineMacro("__TMS320C28XX_TMU0__");
+ Builder.defineMacro("__TMS320C28XX_TMU__");
+ }
+ if (hasFeature("vcu-support"))
+ Builder.defineMacro("__TMS320C28XX_VCU0__");
+ if (hasFeature("vcu2"))
+ Builder.defineMacro("__TMS320C28XX_VCU2__");
+ else if (hasFeature("vcrc"))
+ Builder.defineMacro("__TMS320C28XX_VCRC__");
+ if (hasFeature("opt-level"))
+ Builder.defineMacro("_INLINE");
+ if (hasFeature("relaxed"))
+ Builder.undefineMacro("__TI_STRICT_FP_MODE__");
+
+ Builder.defineMacro("__cregister", "");
+ Builder.defineMacro("interrupt", "");
+ Builder.defineMacro("__interrupt", "");
+
+ // Assembly Instrinsics
+
+ Builder.append("int __abs16_sat( int src );");
+ Builder.append("void __add( int *m, int b );");
+ Builder.append("long __addcu( long src1, unsigned int src2 );");
+ Builder.append("void __addl( long *m, long b );");
+ Builder.append("void __and(int *m, int b);");
+ Builder.append("int *__byte_func( int *array, unsigned int byte_index );");
+ Builder.defineMacro("__byte(array, byte_index)",
+ "*__byte_func(array, byte_index)");
+ Builder.append("unsigned long *__byte_peripheral_32_func(unsigned long *x);");
+ Builder.defineMacro("__byte_peripheral_32(x)",
+ "*__byte_peripheral_32_func(x)");
+ Builder.append("void __dec( int *m );");
+
+ // dmac needs macro magic
+ Builder.append("unsigned int __disable_interrupts( );");
+ Builder.append("void __eallow( void );");
+ Builder.append("void __edis( void );");
+ Builder.append("unsigned int __enable_interrupts( );");
+ Builder.append("int __flip16(int src);");
+ Builder.append("long __flip32(long src);");
+ Builder.append("long long __flip64(long long src);");
+ Builder.append("void __inc( int *m );");
+ Builder.append("long __IQ( long double A , int N );");
+ Builder.append("long __IQmpy( long A, long B , int N );");
+ Builder.append("long __IQsat( long A, long max, long min );");
+ Builder.append("long __IQxmpy(long A , long B, int N);");
+ Builder.append("long long __llmax(long long dst, long long src);");
+ Builder.append("long long __llmin(long long dst, long long src);");
+ Builder.append("long __lmax(long dst, long src);");
+ Builder.append("long __lmin(long dst, long src);");
+ Builder.append("int __max(int dst, int src);");
+ Builder.append("int __min(int dst, int src);");
+ Builder.append("int __mov_byte( int *src, unsigned int n );");
+ Builder.append("long __mpy( int src1, int src2 );");
+ Builder.append("long __mpyb( int src1, unsigned int src2 );");
+ Builder.append("long __mpy_mov_t( int src1, int src2, int * dst2 );");
+ Builder.append("unsigned long __mpyu(unsigned int src2, unsigned int srt2);");
+ Builder.append("long __mpyxu( int src1, unsigned int src2 );");
+ Builder.append("long __norm32(long src, int * shift );");
+ Builder.append("long long __norm64(long long src, int * shift );");
+ Builder.append("void __or(int *m, int b);");
+ Builder.append("long __qmpy32( long src32a, long src32b, int q );");
+ Builder.append("long __qmpy32by16(long src32, int src16, int q);");
+ Builder.append("void __restore_interrupts(unsigned int val );");
+ Builder.append("long __rol( long src );");
+ Builder.append("long __ror( long src );");
+ Builder.append("void * __rpt_mov_imm(void * dst , int src ,int count );");
+ Builder.append("int __rpt_norm_inc( long src, int dst, int count );");
+ Builder.append("int __rpt_norm_dec(long src, int dst, int count);");
+ Builder.append("long __rpt_rol(long src, int count);");
+ Builder.append("long __rpt_ror(long src, int count);");
+ Builder.append("long __rpt_subcu(long dst, int src, int count);");
+ Builder.append("unsigned long __rpt_subcul(unsigned long num, unsigned long "
+ "den, unsigned long remainder, int count);");
+ Builder.append("long __sat( long src );");
+ Builder.append("long __sat32( long src, long limit );");
+ Builder.append("long __sathigh16(long src, int limit);");
+ Builder.append("long __satlow16( long src );");
+ Builder.append("long __sbbu( long src1 , unsigned int src2 );");
+ Builder.append("void __sub( int * m, int b );");
+ Builder.append("long __subcu( long src1, int src2 );");
+ Builder.append("unsigned long __subcul(unsigned long num, unsigned long den, "
+ "unsigned long remainder);");
+ Builder.append("void __subl( long * m, long b )...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/125663
More information about the cfe-commits
mailing list