maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Hexagon backend support 

llvm-svn: 146413
This commit is contained in:
Tony Linthicum 2011-12-12 21:14:55 +00:00
parent 1213a7a57f
commit 76329bf83f
15 changed files with 3355 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

689
clang/include/clang/Basic/BuiltinsHexagon.def Normal file
View File

@ -0,0 +1,689 @@
//==--- BuiltinsHexagon.def - Hexagon Builtin function database --*- C++ -*-==//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the X86-specific builtin function database. Users of
// this file must define the BUILTIN macro to make use of this information.
//
//===----------------------------------------------------------------------===//
BUILTIN(__builtin_HEXAGON_C2_cmpeq, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_cmpgt, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_cmpgtu, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_cmpeqp, "bLLiLLi", "")
BUILTIN(__builtin_HEXAGON_C2_cmpgtp, "bLLiLLi", "")
BUILTIN(__builtin_HEXAGON_C2_cmpgtup, "bLLiLLi", "")
BUILTIN(__builtin_HEXAGON_C2_bitsset, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_bitsclr, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_cmpeqi, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_cmpgti, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_cmpgtui, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_cmpgei, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_cmpgeui, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_cmplt, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_cmpltu, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_bitsclri, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_and, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_or, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_xor, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_andn, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_not, "bi", "")
BUILTIN(__builtin_HEXAGON_C2_orn, "bii", "")
BUILTIN(__builtin_HEXAGON_C2_pxfer_map, "bi", "")
BUILTIN(__builtin_HEXAGON_C2_any8, "bi", "")
BUILTIN(__builtin_HEXAGON_C2_all8, "bi", "")
BUILTIN(__builtin_HEXAGON_C2_vitpack, "iii", "")
BUILTIN(__builtin_HEXAGON_C2_mux, "iiii", "")
BUILTIN(__builtin_HEXAGON_C2_muxii, "iiii", "")
BUILTIN(__builtin_HEXAGON_C2_muxir, "iiii", "")
BUILTIN(__builtin_HEXAGON_C2_muxri, "iiii", "")
BUILTIN(__builtin_HEXAGON_C2_vmux, "LLiiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_C2_mask, "LLii", "")
BUILTIN(__builtin_HEXAGON_A2_vcmpbeq, "bLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vcmpbgtu, "bLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vcmpheq, "bLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vcmphgt, "bLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vcmphgtu, "bLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vcmpweq, "bLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vcmpwgt, "bLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vcmpwgtu, "bLLiLLi", "")
BUILTIN(__builtin_HEXAGON_C2_tfrpr, "ii", "")
BUILTIN(__builtin_HEXAGON_C2_tfrrp, "bi", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_hh_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_hh_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_hl_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_hl_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_lh_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_lh_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_ll_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_ll_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_hh_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_hh_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_hl_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_hl_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_lh_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_lh_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_ll_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_ll_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_hh_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_hh_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_hl_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_hl_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_lh_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_lh_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_ll_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_acc_sat_ll_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_hh_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_hh_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_hl_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_hl_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_lh_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_lh_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_ll_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_nac_sat_ll_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_hh_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_hh_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_hl_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_hl_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_lh_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_lh_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_ll_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_ll_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_hh_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_hh_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_hl_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_hl_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_lh_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_lh_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_ll_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_ll_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_hh_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_hh_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_hl_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_hl_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_lh_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_lh_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_ll_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_rnd_ll_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_hh_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_hh_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_hl_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_hl_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_lh_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_lh_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_ll_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_sat_rnd_ll_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_hh_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_hh_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_hl_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_hl_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_lh_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_lh_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_ll_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_acc_ll_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_hh_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_hh_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_hl_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_hl_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_lh_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_lh_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_ll_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_nac_ll_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_hh_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_hh_s1, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_hl_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_hl_s1, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_lh_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_lh_s1, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_ll_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_ll_s1, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_hh_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_hh_s1, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_hl_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_hl_s1, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_lh_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_lh_s1, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_ll_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyd_rnd_ll_s1, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_hh_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_hh_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_hl_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_hl_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_lh_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_lh_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_ll_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_acc_ll_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_hh_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_hh_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_hl_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_hl_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_lh_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_lh_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_ll_s0, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_nac_ll_s1, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_hh_s0, "Uiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_hh_s1, "Uiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_hl_s0, "Uiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_hl_s1, "Uiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_lh_s0, "Uiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_lh_s1, "Uiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_ll_s0, "Uiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_ll_s1, "Uiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_hh_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_hh_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_hl_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_hl_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_lh_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_lh_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_ll_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_acc_ll_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_hh_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_hh_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_hl_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_hl_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_lh_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_lh_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_ll_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_nac_ll_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_hh_s0, "ULLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_hh_s1, "ULLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_hl_s0, "ULLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_hl_s1, "ULLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_lh_s0, "ULLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_lh_s1, "ULLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_ll_s0, "ULLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyud_ll_s1, "ULLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpysmi, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_macsip, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_macsin, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_dpmpyss_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_dpmpyss_acc_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_dpmpyss_nac_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_dpmpyuu_s0, "ULLiii", "")
BUILTIN(__builtin_HEXAGON_M2_dpmpyuu_acc_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_dpmpyuu_nac_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_mpy_up, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyu_up, "Uiii", "")
BUILTIN(__builtin_HEXAGON_M2_dpmpyss_rnd_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyi, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mpyui, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_maci, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_acci, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_accii, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_nacci, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_naccii, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_subacc, "iiii", "")
BUILTIN(__builtin_HEXAGON_M2_vmpy2s_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_vmpy2s_s1, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_vmac2s_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_vmac2s_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_vmpy2s_s0pack, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_vmpy2s_s1pack, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_vmac2, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_vmpy2es_s0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vmpy2es_s1, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vmac2es_s0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vmac2es_s1, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vmac2es, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vrmac_s0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vrmpy_s0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vdmpyrs_s0, "iLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vdmpyrs_s1, "iLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vdmacs_s0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vdmacs_s1, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vdmpys_s0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vdmpys_s1, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_cmpyrs_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_cmpyrs_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_cmpyrsc_s0, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_cmpyrsc_s1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_cmacs_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cmacs_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cmacsc_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cmacsc_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cmpys_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cmpys_s1, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cmpysc_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cmpysc_s1, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cnacs_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cnacs_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cnacsc_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cnacsc_s1, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_vrcmpys_s1, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_M2_vrcmpys_acc_s1, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_M2_vrcmpys_s1rp, "iLLii", "")
BUILTIN(__builtin_HEXAGON_M2_mmacls_s0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmacls_s1, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmachs_s0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmachs_s1, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyl_s0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyl_s1, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyh_s0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyh_s1, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmacls_rs0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmacls_rs1, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmachs_rs0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmachs_rs1, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyl_rs0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyl_rs1, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyh_rs0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyh_rs1, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_hmmpyl_rs1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_hmmpyh_rs1, "iii", "")
BUILTIN(__builtin_HEXAGON_M2_mmaculs_s0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmaculs_s1, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmacuhs_s0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmacuhs_s1, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyul_s0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyul_s1, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyuh_s0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyuh_s1, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmaculs_rs0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmaculs_rs1, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmacuhs_rs0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmacuhs_rs1, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyul_rs0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyul_rs1, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyuh_rs0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_mmpyuh_rs1, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vrcmaci_s0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vrcmacr_s0, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vrcmaci_s0c, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vrcmacr_s0c, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_cmaci_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cmacr_s0, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_M2_vrcmpyi_s0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vrcmpyr_s0, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vrcmpyi_s0c, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vrcmpyr_s0c, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_cmpyi_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_cmpyr_s0, "LLiii", "")
BUILTIN(__builtin_HEXAGON_M2_vcmpy_s0_sat_i, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vcmpy_s0_sat_r, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vcmpy_s1_sat_i, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vcmpy_s1_sat_r, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vcmac_s0_sat_i, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vcmac_s0_sat_r, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_vcrotate, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_A2_add, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_sub, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addsat, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subsat, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addi, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addh_l16_ll, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addh_l16_hl, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addh_l16_sat_ll, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addh_l16_sat_hl, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subh_l16_ll, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subh_l16_hl, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subh_l16_sat_ll, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subh_l16_sat_hl, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addh_h16_ll, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addh_h16_lh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addh_h16_hl, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addh_h16_hh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addh_h16_sat_ll, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addh_h16_sat_lh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addh_h16_sat_hl, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_addh_h16_sat_hh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subh_h16_ll, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subh_h16_lh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subh_h16_hl, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subh_h16_hh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subh_h16_sat_ll, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subh_h16_sat_lh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subh_h16_sat_hl, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_subh_h16_sat_hh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_aslh, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_asrh, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_addp, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_addpsat, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_addsp, "LLiiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_subp, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_neg, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_negsat, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_abs, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_abssat, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_vconj, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_negp, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_absp, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_max, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_maxu, "Uiii", "")
BUILTIN(__builtin_HEXAGON_A2_min, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_minu, "Uiii", "")
BUILTIN(__builtin_HEXAGON_A2_maxp, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_maxup, "ULLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_minp, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_minup, "ULLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_tfr, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_tfrsi, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_tfrp, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_tfrpi, "LLii", "")
BUILTIN(__builtin_HEXAGON_A2_zxtb, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_sxtb, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_zxth, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_sxth, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_combinew, "LLiii", "")
BUILTIN(__builtin_HEXAGON_A2_combineii, "LLiii", "")
BUILTIN(__builtin_HEXAGON_A2_combine_hh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_combine_hl, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_combine_lh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_combine_ll, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_tfril, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_tfrih, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_and, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_or, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_xor, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_not, "ii", "")
BUILTIN(__builtin_HEXAGON_M2_xor_xacc, "iiii", "")
BUILTIN(__builtin_HEXAGON_A2_subri, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_andir, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_orir, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_andp, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_orp, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_xorp, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_notp, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_sxtw, "LLii", "")
BUILTIN(__builtin_HEXAGON_A2_sat, "iLLi", "")
BUILTIN(__builtin_HEXAGON_A2_sath, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_satuh, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_satub, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_satb, "ii", "")
BUILTIN(__builtin_HEXAGON_A2_vaddub, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vaddubs, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vaddh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vaddhs, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vadduhs, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vaddw, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vaddws, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_svavgh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_svavghs, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_svnavgh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_svaddh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_svaddhs, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_svadduhs, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_svsubh, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_svsubhs, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_svsubuhs, "iii", "")
BUILTIN(__builtin_HEXAGON_A2_vraddub, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vraddub_acc, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vradduh, "iLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vsubub, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vsububs, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vsubh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vsubhs, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vsubuhs, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vsubw, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vsubws, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vabsh, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vabshsat, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vabsw, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vabswsat, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vabsdiffw, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M2_vabsdiffh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vrsadub, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vrsadub_acc, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vavgub, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vavguh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vavgh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vnavgh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vavgw, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vnavgw, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vavgwr, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vnavgwr, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vavgwcr, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vnavgwcr, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vavghcr, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vnavghcr, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vavguw, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vavguwr, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vavgubr, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vavguhr, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vavghr, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vnavghr, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vminh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vmaxh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vminub, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vmaxub, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vminuh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vmaxuh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vminw, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vmaxw, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vminuw, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A2_vmaxuw, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_r, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_r, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_r_r, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_lsl_r_r, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_p, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_p, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_r_p, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsl_r_p, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_r_acc, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_r_acc, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_r_r_acc, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsl_r_r_acc, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_p_acc, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_p_acc, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_acc, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_acc, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_r_nac, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_r_nac, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_r_r_nac, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsl_r_r_nac, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_p_nac, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_p_nac, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_nac, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_nac, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_r_and, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_r_and, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_r_r_and, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsl_r_r_and, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_r_or, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_r_or, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_r_r_or, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsl_r_r_or, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_p_and, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_p_and, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_and, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_and, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_p_or, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_p_or, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_r_p_or, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsl_r_p_or, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_r_sat, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_r_sat, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_r, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_r, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_r, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_p, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_p, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_p, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_r_acc, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_acc, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_r_acc, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_p_acc, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_acc, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_p_acc, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_r_nac, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_nac, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_r_nac, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_p_nac, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_nac, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_p_nac, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_xacc, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_r_xacc, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_xacc, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_p_xacc, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_r_and, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_and, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_r_and, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_r_or, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_r_or, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_r_or, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_p_and, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_and, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_p_and, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_p_or, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_p_or, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_p_or, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_r_sat, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_r_rnd, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_r_rnd_goodsyntax, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_addasl_rrri, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_valignib, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_valignrb, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_vspliceib, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_vsplicerb, "LLiLLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_vsplatrh, "LLii", "")
BUILTIN(__builtin_HEXAGON_S2_vsplatrb, "ii", "")
BUILTIN(__builtin_HEXAGON_S2_insert, "iiiii", "")
BUILTIN(__builtin_HEXAGON_S2_tableidxb_goodsyntax, "iiiii", "")
BUILTIN(__builtin_HEXAGON_S2_tableidxh_goodsyntax, "iiiii", "")
BUILTIN(__builtin_HEXAGON_S2_tableidxw_goodsyntax, "iiiii", "")
BUILTIN(__builtin_HEXAGON_S2_tableidxd_goodsyntax, "iiiii", "")
BUILTIN(__builtin_HEXAGON_S2_extractu, "iiii", "")
BUILTIN(__builtin_HEXAGON_S2_insertp, "LLiLLiLLiii", "")
BUILTIN(__builtin_HEXAGON_S2_extractup, "LLiLLiii", "")
BUILTIN(__builtin_HEXAGON_S2_insert_rp, "iiiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_extractu_rp, "iiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_insertp_rp, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_extractup_rp, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_tstbit_i, "bii", "")
BUILTIN(__builtin_HEXAGON_S2_setbit_i, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_togglebit_i, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_clrbit_i, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_tstbit_r, "bii", "")
BUILTIN(__builtin_HEXAGON_S2_setbit_r, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_togglebit_r, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_clrbit_r, "iii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_vh, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_vh, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_vh, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_vh, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_vh, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_r_vh, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsl_r_vh, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_vw, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_i_svw_trun, "iLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_svw_trun, "iLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_i_vw, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_i_vw, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asr_r_vw, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_asl_r_vw, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsr_r_vw, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_lsl_r_vw, "LLiLLii", "")
BUILTIN(__builtin_HEXAGON_S2_vrndpackwh, "iLLi", "")
BUILTIN(__builtin_HEXAGON_S2_vrndpackwhs, "iLLi", "")
BUILTIN(__builtin_HEXAGON_S2_vsxtbh, "LLii", "")
BUILTIN(__builtin_HEXAGON_S2_vzxtbh, "LLii", "")
BUILTIN(__builtin_HEXAGON_S2_vsathub, "iLLi", "")
BUILTIN(__builtin_HEXAGON_S2_svsathub, "ii", "")
BUILTIN(__builtin_HEXAGON_S2_svsathb, "ii", "")
BUILTIN(__builtin_HEXAGON_S2_vsathb, "iLLi", "")
BUILTIN(__builtin_HEXAGON_S2_vtrunohb, "iLLi", "")
BUILTIN(__builtin_HEXAGON_S2_vtrunewh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_vtrunowh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_vtrunehb, "iLLi", "")
BUILTIN(__builtin_HEXAGON_S2_vsxthw, "LLii", "")
BUILTIN(__builtin_HEXAGON_S2_vzxthw, "LLii", "")
BUILTIN(__builtin_HEXAGON_S2_vsatwh, "iLLi", "")
BUILTIN(__builtin_HEXAGON_S2_vsatwuh, "iLLi", "")
BUILTIN(__builtin_HEXAGON_S2_packhl, "LLiii", "")
BUILTIN(__builtin_HEXAGON_A2_swiz, "ii", "")
BUILTIN(__builtin_HEXAGON_S2_vsathub_nopack, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_vsathb_nopack, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_vsatwh_nopack, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_vsatwuh_nopack, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_shuffob, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_shuffeb, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_shuffoh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_shuffeh, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_parityp, "iLLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_lfsp, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_clbnorm, "ii", "")
BUILTIN(__builtin_HEXAGON_S2_clb, "ii", "")
BUILTIN(__builtin_HEXAGON_S2_cl0, "ii", "")
BUILTIN(__builtin_HEXAGON_S2_cl1, "ii", "")
BUILTIN(__builtin_HEXAGON_S2_clbp, "iLLi", "")
BUILTIN(__builtin_HEXAGON_S2_cl0p, "iLLi", "")
BUILTIN(__builtin_HEXAGON_S2_cl1p, "iLLi", "")
BUILTIN(__builtin_HEXAGON_S2_brev, "ii", "")
BUILTIN(__builtin_HEXAGON_S2_ct0, "ii", "")
BUILTIN(__builtin_HEXAGON_S2_ct1, "ii", "")
BUILTIN(__builtin_HEXAGON_S2_interleave, "LLiLLi", "")
BUILTIN(__builtin_HEXAGON_S2_deinterleave, "LLiLLi", "")
BUILTIN(__builtin_SI_to_SXTHI_asrh, "ii", "")
BUILTIN(__builtin_M2_vrcmpys_s1, "LLiLLii", "")
BUILTIN(__builtin_M2_vrcmpys_acc_s1, "LLiLLiLLii", "")
BUILTIN(__builtin_M2_vrcmpys_s1rp, "iLLii", "")
BUILTIN(__builtin_M2_vradduh, "iLLiLLi", "")
BUILTIN(__builtin_A2_addsp, "LLiiLLi", "")
BUILTIN(__builtin_A2_addpsat, "LLiLLiLLi", "")
BUILTIN(__builtin_A2_maxp, "LLiLLiLLi", "")
BUILTIN(__builtin_A2_maxup, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A4_orn, "iii", "")
BUILTIN(__builtin_HEXAGON_A4_andn, "iii", "")
BUILTIN(__builtin_HEXAGON_A4_ornp, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A4_andnp, "LLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_A4_combineir, "LLiii", "")
BUILTIN(__builtin_HEXAGON_A4_combineri, "LLiii", "")
BUILTIN(__builtin_HEXAGON_C4_cmpneqi, "bii", "")
BUILTIN(__builtin_HEXAGON_C4_cmpneq, "bii", "")
BUILTIN(__builtin_HEXAGON_C4_cmpltei, "bii", "")
BUILTIN(__builtin_HEXAGON_C4_cmplte, "bii", "")
BUILTIN(__builtin_HEXAGON_C4_cmplteui, "bii", "")
BUILTIN(__builtin_HEXAGON_C4_cmplteu, "bii", "")
BUILTIN(__builtin_HEXAGON_A4_rcmpneq, "iii", "")
BUILTIN(__builtin_HEXAGON_A4_rcmpneqi, "iii", "")
BUILTIN(__builtin_HEXAGON_A4_rcmpeq, "iii", "")
BUILTIN(__builtin_HEXAGON_A4_rcmpeqi, "iii", "")
BUILTIN(__builtin_HEXAGON_C4_fastcorner9, "bii", "")
BUILTIN(__builtin_HEXAGON_C4_fastcorner9_not, "bii", "")
BUILTIN(__builtin_HEXAGON_C4_and_andn, "biii", "")
BUILTIN(__builtin_HEXAGON_C4_and_and, "biii", "")
BUILTIN(__builtin_HEXAGON_C4_and_orn, "biii", "")
BUILTIN(__builtin_HEXAGON_C4_and_or, "biii", "")
BUILTIN(__builtin_HEXAGON_C4_or_andn, "biii", "")
BUILTIN(__builtin_HEXAGON_C4_or_and, "biii", "")
BUILTIN(__builtin_HEXAGON_C4_or_orn, "biii", "")
BUILTIN(__builtin_HEXAGON_C4_or_or, "biii", "")
BUILTIN(__builtin_HEXAGON_S4_addaddi, "iiii", "")
BUILTIN(__builtin_HEXAGON_S4_subaddi, "iiii", "")
BUILTIN(__builtin_HEXAGON_M4_xor_xacc, "LLiLLiLLiLLi", "")
BUILTIN(__builtin_HEXAGON_M4_and_and, "iiii", "")
BUILTIN(__builtin_HEXAGON_M4_and_or, "iiii", "")
BUILTIN(__builtin_HEXAGON_M4_and_xor, "iiii", "")
BUILTIN(__builtin_HEXAGON_M4_and_andn, "iiii", "")
BUILTIN(__builtin_HEXAGON_M4_xor_and, "iiii", "")
BUILTIN(__builtin_HEXAGON_M4_xor_or, "iiii", "")
BUILTIN(__builtin_HEXAGON_M4_xor_andn, "iiii", "")
BUILTIN(__builtin_HEXAGON_M4_or_and, "iiii", "")
BUILTIN(__builtin_HEXAGON_M4_or_or, "iiii", "")
BUILTIN(__builtin_HEXAGON_M4_or_xor, "iiii", "")
BUILTIN(__builtin_HEXAGON_M4_or_andn, "iiii", "")
BUILTIN(__builtin_HEXAGON_S4_or_andix, "iiii", "")
BUILTIN(__builtin_HEXAGON_S4_or_andi, "iiii", "")
BUILTIN(__builtin_HEXAGON_S4_or_ori, "iiii", "")
BUILTIN(__builtin_HEXAGON_A4_modwrapu, "iii", "")
BUILTIN(__builtin_HEXAGON_A4_cround_ri, "iii", "")
BUILTIN(__builtin_HEXAGON_A4_cround_rr, "iii", "")
BUILTIN(__builtin_HEXAGON_A4_round_ri, "iii", "")
BUILTIN(__builtin_HEXAGON_A4_round_rr, "iii", "")
BUILTIN(__builtin_HEXAGON_A4_round_ri_sat, "iii", "")
BUILTIN(__builtin_HEXAGON_A4_round_rr_sat, "iii", "")
#undef BUILTIN

1
clang/include/clang/Basic/LangOptions.def
View File

@ -128,6 +128,7 @@ LANGOPT(SinglePrecisionConstants , 1, 0, "treating double-precision floating poi
LANGOPT(FastRelaxedMath , 1, 0, "OpenCL fast relaxed math")
LANGOPT(DefaultFPContract , 1, 0, "FP_CONTRACT")
LANGOPT(NoBitFieldTypeAlign , 1, 0, "bit-field type alignment")
LANGOPT(HexagonQdsp6Compat , 1, 0, "hexagon-qdsp6 backward compatibility")
LANGOPT(ObjCAutoRefCount , 1, 0, "Objective-C automated reference counting")
LANGOPT(ObjCRuntimeHasWeak , 1, 0, "__weak support in the ARC runtime")
LANGOPT(FakeAddressSpaceMap , 1, 0, "OpenCL fake address space map")

9
clang/include/clang/Basic/TargetBuiltins.h
View File

@ -96,6 +96,15 @@ namespace clang {
bool isQuad() const { return (Flags & QuadFlag) != 0; }
};
/// Hexagon builtins
namespace Hexagon {
enum {
LastTIBuiltin = clang::Builtin::FirstTSBuiltin-1,
#define BUILTIN(ID, TYPE, ATTRS) BI##ID,
#include "clang/Basic/BuiltinsHexagon.def"
LastTSBuiltin
};
}
} // end namespace clang.
#endif

2
clang/include/clang/Driver/CC1Options.td
View File

@ -721,6 +721,8 @@ def undef : Flag<"-undef">, MetaVarName<"<macro>">,
HelpText<"undef all system defines">;
def detailed_preprocessing_record : Flag<"-detailed-preprocessing-record">,
HelpText<"include a detailed record of preprocessing actions">;
def mqdsp6_compat : Flag<"-mqdsp6-compat">,
HelpText<"Enable hexagon-qdsp6 backward compatibility">;
//===----------------------------------------------------------------------===//
// Preprocessed Output Options

6
clang/include/clang/Driver/Options.td
View File

@ -145,6 +145,7 @@ def D : JoinedOrSeparate<"-D">, Group<CompileOnly_Group>;
def E : Flag<"-E">, Flags<[DriverOption]>,
HelpText<"Only run the preprocessor">;
def F : JoinedOrSeparate<"-F">, Flags<[RenderJoined]>;
def G : Separate<"-G">, Flags<[DriverOption]>;
def H : Flag<"-H">;
def I_ : Flag<"-I-">, Group<I_Group>;
def I : JoinedOrSeparate<"-I">, Group<I_Group>;
@ -557,6 +558,10 @@ def i : Joined<"-i">, Group<i_Group>;
def keep__private__externs : Flag<"-keep_private_externs">;
def l : JoinedOrSeparate<"-l">, Flags<[LinkerInput, RenderJoined]>;
def m32 : Flag<"-m32">, Group<m_Group>, Flags<[DriverOption]>;
def mv2 : Flag<"-mv2">, Group<m_Group>, Flags<[DriverOption]>;
def mv3 : Flag<"-mv3">, Group<m_Group>, Flags<[DriverOption]>;
def mv4 : Flag<"-mv4">, Group<m_Group>, Flags<[DriverOption]>;
def mqdsp6_compat : Flag<"-mqdsp6-compat">, Group<m_Group>, Flags<[DriverOption]>;
def m3dnowa : Flag<"-m3dnowa">, Group<m_x86_Features_Group>;
def m3dnow : Flag<"-m3dnow">, Group<m_x86_Features_Group>;
def m64 : Flag<"-m64">, Group<m_Group>, Flags<[DriverOption]>;
@ -615,6 +620,7 @@ def mred_zone : Flag<"-mred-zone">, Group<m_Group>;
def mregparm_EQ : Joined<"-mregparm=">, Group<m_Group>;
def mrelax_all : Flag<"-mrelax-all">, Group<m_Group>;
def mrtd: Flag<"-mrtd">, Group<m_Group>;
def msmall_data_threshold_EQ : Joined <"-msmall-data-threshold=">, Group<m_Group>;
def msoft_float : Flag<"-msoft-float">, Group<m_Group>;
def msse2 : Flag<"-msse2">, Group<m_x86_Features_Group>;
def msse3 : Flag<"-msse3">, Group<m_x86_Features_Group>;

135
clang/lib/Basic/Targets.cpp
View File

@ -2774,7 +2774,6 @@ const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
};
} // end anonymous namespace.
namespace {
class DarwinARMTargetInfo :
public DarwinTargetInfo<ARMTargetInfo> {
@ -2795,6 +2794,137 @@ public:
};
} // end anonymous namespace.
namespace {
// Hexagon abstract base class
class HexagonTargetInfo : public TargetInfo {
static const Builtin::Info BuiltinInfo[];
static const char * const GCCRegNames[];
static const TargetInfo::GCCRegAlias GCCRegAliases[];
std::string CPU;
public:
HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
DescriptionString = ("e-p:32:32:32-"
"i64:64:64-i32:32:32-"
"i16:16:16-i1:32:32-a:0:0");
// {} in inline assembly are packet specifiers, not assembly variant
// specifiers.
NoAsmVariants = true;
}
virtual void getTargetBuiltins(const Builtin::Info *&Records,
unsigned &NumRecords) const {
Records = BuiltinInfo;
NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
}
virtual bool validateAsmConstraint(const char *&Name,
TargetInfo::ConstraintInfo &Info) const {
return true;
}
virtual void getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const;
virtual const char *getVAListDeclaration() const {
return "typedef char* __builtin_va_list;";
}
virtual void getGCCRegNames(const char * const *&Names,
unsigned &NumNames) const;
virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
unsigned &NumAliases) const;
virtual const char *getClobbers() const {
return "";
}
virtual bool setCPU(const std::string &Name) {
CPU = Name;
return true;
}
};
void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
MacroBuilder &Builder) const {
Builder.defineMacro("qdsp6");
Builder.defineMacro("__qdsp6", "1");
Builder.defineMacro("__qdsp6__", "1");
Builder.defineMacro("hexagon");
Builder.defineMacro("__hexagon", "1");
Builder.defineMacro("__hexagon__", "1");
if(CPU == "hexagonv1") {
Builder.defineMacro("__HEXAGON_V1__");
Builder.defineMacro("__HEXAGON_ARCH__", "1");
if(Opts.HexagonQdsp6Compat) {
Builder.defineMacro("__QDSP6_V1__");
Builder.defineMacro("__QDSP6_ARCH__", "1");
}
}
else if(CPU == "hexagonv2") {
Builder.defineMacro("__HEXAGON_V2__");
Builder.defineMacro("__HEXAGON_ARCH__", "2");
if(Opts.HexagonQdsp6Compat) {
Builder.defineMacro("__QDSP6_V2__");
Builder.defineMacro("__QDSP6_ARCH__", "2");
}
}
else if(CPU == "hexagonv3") {
Builder.defineMacro("__HEXAGON_V3__");
Builder.defineMacro("__HEXAGON_ARCH__", "3");
if(Opts.HexagonQdsp6Compat) {
Builder.defineMacro("__QDSP6_V3__");
Builder.defineMacro("__QDSP6_ARCH__", "3");
}
}
else if(CPU == "hexagonv4") {
Builder.defineMacro("__HEXAGON_V4__");
Builder.defineMacro("__HEXAGON_ARCH__", "4");
if(Opts.HexagonQdsp6Compat) {
Builder.defineMacro("__QDSP6_V4__");
Builder.defineMacro("__QDSP6_ARCH__", "4");
}
}
}
const char * const HexagonTargetInfo::GCCRegNames[] = {
"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
"p0", "p1", "p2", "p3",
"sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
};
void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
unsigned &NumNames) const {
Names = GCCRegNames;
NumNames = llvm::array_lengthof(GCCRegNames);
}
const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
{ { "sp" }, "r29" },
{ { "fp" }, "r30" },
{ { "lr" }, "r31" },
};
void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
unsigned &NumAliases) const {
Aliases = GCCRegAliases;
NumAliases = llvm::array_lengthof(GCCRegAliases);
}
const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
ALL_LANGUAGES },
#include "clang/Basic/BuiltinsHexagon.def"
};
}
namespace {
class SparcV8TargetInfo : public TargetInfo {
static const TargetInfo::GCCRegAlias GCCRegAliases[];
@ -3459,6 +3589,9 @@ static TargetInfo *AllocateTarget(const std::string &T) {
default:
return NULL;
case llvm::Triple::hexagon:
return new HexagonTargetInfo(T);
case llvm::Triple::arm:
case llvm::Triple::thumb:
if (Triple.isOSDarwin())

1989
clang/lib/CodeGen/CGBuiltin.cpp
View File

File diff suppressed because it is too large Load Diff

1
clang/lib/CodeGen/CodeGenFunction.h
View File

@ -2206,6 +2206,7 @@ public:
llvm::Value *BuildVector(const SmallVectorImpl<llvm::Value*> &Ops);
llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
llvm::Value *EmitHexagonBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
llvm::Value *EmitPPCBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
llvm::Value *EmitObjCProtocolExpr(const ObjCProtocolExpr *E);

144
clang/lib/CodeGen/TargetInfo.cpp
View File

@ -3321,6 +3321,148 @@ void TCETargetCodeGenInfo::SetTargetAttributes(const Decl *D,
}
//===----------------------------------------------------------------------===//
// Hexagon ABI Implementation
//===----------------------------------------------------------------------===//
namespace {
class HexagonABIInfo : public ABIInfo {
public:
HexagonABIInfo(CodeGenTypes &CGT) : ABIInfo(CGT) {}
private:
ABIArgInfo classifyReturnType(QualType RetTy) const;
ABIArgInfo classifyArgumentType(QualType RetTy) const;
virtual void computeInfo(CGFunctionInfo &FI) const;
virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
CodeGenFunction &CGF) const;
};
class HexagonTargetCodeGenInfo : public TargetCodeGenInfo {
public:
HexagonTargetCodeGenInfo(CodeGenTypes &CGT)
:TargetCodeGenInfo(new HexagonABIInfo(CGT)) {}
int getDwarfEHStackPointer(CodeGen::CodeGenModule &M) const {
return 29;
}
};
}
void HexagonABIInfo::computeInfo(CGFunctionInfo &FI) const {
FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
for (CGFunctionInfo::arg_iterator it = FI.arg_begin(), ie = FI.arg_end();
it != ie; ++it)
it->info = classifyArgumentType(it->type);
}
ABIArgInfo HexagonABIInfo::classifyArgumentType(QualType Ty) const {
if (!isAggregateTypeForABI(Ty)) {
// Treat an enum type as its underlying type.
if (const EnumType *EnumTy = Ty->getAs<EnumType>())
Ty = EnumTy->getDecl()->getIntegerType();
return (Ty->isPromotableIntegerType() ?
ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
}
// Ignore empty records.
if (isEmptyRecord(getContext(), Ty, true))
return ABIArgInfo::getIgnore();
// Structures with either a non-trivial destructor or a non-trivial
// copy constructor are always indirect.
if (isRecordWithNonTrivialDestructorOrCopyConstructor(Ty))
return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
uint64_t Size = getContext().getTypeSize(Ty);
if (Size > 64)
return ABIArgInfo::getIndirect(0, /*ByVal=*/true);
// Pass in the smallest viable integer type.
else if (Size > 32)
return ABIArgInfo::getDirect(llvm::Type::getInt64Ty(getVMContext()));
else if (Size > 16)
return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
else if (Size > 8)
return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
else
return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
}
ABIArgInfo HexagonABIInfo::classifyReturnType(QualType RetTy) const {
if (RetTy->isVoidType())
return ABIArgInfo::getIgnore();
// Large vector types should be returned via memory.
if (RetTy->isVectorType() && getContext().getTypeSize(RetTy) > 64)
return ABIArgInfo::getIndirect(0);
if (!isAggregateTypeForABI(RetTy)) {
// Treat an enum type as its underlying type.
if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
RetTy = EnumTy->getDecl()->getIntegerType();
return (RetTy->isPromotableIntegerType() ?
ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
}
// Structures with either a non-trivial destructor or a non-trivial
// copy constructor are always indirect.
if (isRecordWithNonTrivialDestructorOrCopyConstructor(RetTy))
return ABIArgInfo::getIndirect(0, /*ByVal=*/false);
if (isEmptyRecord(getContext(), RetTy, true))
return ABIArgInfo::getIgnore();
// Aggregates <= 8 bytes are returned in r0; other aggregates
// are returned indirectly.
uint64_t Size = getContext().getTypeSize(RetTy);
if (Size <= 64) {
// Return in the smallest viable integer type.
if (Size <= 8)
return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
if (Size <= 16)
return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
if (Size <= 32)
return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
return ABIArgInfo::getDirect(llvm::Type::getInt64Ty(getVMContext()));
}
return ABIArgInfo::getIndirect(0, /*ByVal=*/true);
}
llvm::Value *HexagonABIInfo::EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
CodeGenFunction &CGF) const {
// FIXME: Need to handle alignment
llvm::Type *BP = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
llvm::Type *BPP = llvm::PointerType::getUnqual(BP);
CGBuilderTy &Builder = CGF.Builder;
llvm::Value *VAListAddrAsBPP = Builder.CreateBitCast(VAListAddr, BPP,
"ap");
llvm::Value *Addr = Builder.CreateLoad(VAListAddrAsBPP, "ap.cur");
llvm::Type *PTy =
llvm::PointerType::getUnqual(CGF.ConvertType(Ty));
llvm::Value *AddrTyped = Builder.CreateBitCast(Addr, PTy);
uint64_t Offset =
llvm::RoundUpToAlignment(CGF.getContext().getTypeSize(Ty) / 8, 4);
llvm::Value *NextAddr =
Builder.CreateGEP(Addr, llvm::ConstantInt::get(CGF.Int32Ty, Offset),
"ap.next");
Builder.CreateStore(NextAddr, VAListAddrAsBPP);
return AddrTyped;
}
const TargetCodeGenInfo &CodeGenModule::getTargetCodeGenInfo() {
if (TheTargetCodeGenInfo)
return *TheTargetCodeGenInfo;
@ -3404,5 +3546,7 @@ const TargetCodeGenInfo &CodeGenModule::getTargetCodeGenInfo() {
HasAVX));
}
}
case llvm::Triple::hexagon:
return *(TheTargetCodeGenInfo = new HexagonTargetCodeGenInfo(Types));
}
}

5
clang/lib/Driver/HostInfo.cpp
View File

@ -575,6 +575,11 @@ ToolChain *LinuxHostInfo::CreateToolChain(const ArgList &Args,
ToolChain *&TC = ToolChains[ArchName];
if (!TC && !Arch.compare ("hexagon")) {
llvm::Triple TCTriple (getTriple());
TC = new toolchains::Hexagon_TC (*this, TCTriple);
}
if (!TC) {
llvm::Triple TCTriple(getTriple());
TCTriple.setArchName(ArchName);

67
clang/lib/Driver/ToolChains.cpp
View File

@ -1406,6 +1406,73 @@ const char *Generic_GCC::GetDefaultRelocationModel() const {
const char *Generic_GCC::GetForcedPicModel() const {
return 0;
}
/// Hexagon Toolchain
Hexagon_TC::Hexagon_TC(const HostInfo &Host, const llvm::Triple& Triple)
: ToolChain(Host, Triple) {
getProgramPaths().push_back(getDriver().getInstalledDir());
if (getDriver().getInstalledDir() != getDriver().Dir.c_str())
getProgramPaths().push_back(getDriver().Dir);
}
Hexagon_TC::~Hexagon_TC() {
// Free tool implementations.
for (llvm::DenseMap<unsigned, Tool*>::iterator
it = Tools.begin(), ie = Tools.end(); it != ie; ++it)
delete it->second;
}
Tool &Hexagon_TC::SelectTool(const Compilation &C,
const JobAction &JA,
const ActionList &Inputs) const {
Action::ActionClass Key;
// if (JA.getKind () == Action::CompileJobClass)
// Key = JA.getKind ();
// else
if (getDriver().ShouldUseClangCompiler(C, JA, getTriple()))
Key = Action::AnalyzeJobClass;
else
Key = JA.getKind();
// if ((JA.getKind () == Action::CompileJobClass)
// && (JA.getType () != types::TY_LTO_BC)) {
// Key = JA.getKind ();
// }
Tool *&T = Tools[Key];
if (!T) {
switch (Key) {
case Action::InputClass:
case Action::BindArchClass:
assert(0 && "Invalid tool kind.");
case Action::AnalyzeJobClass:
T = new tools::Clang(*this); break;
case Action::AssembleJobClass:
T = new tools::hexagon::Assemble(*this); break;
case Action::LinkJobClass:
T = new tools::hexagon::Link(*this); break;
default:
assert(false && "Unsupported action for Hexagon target.");
}
}
return *T;
}
bool Hexagon_TC::IsUnwindTablesDefault() const {
// FIXME: Gross; we should probably have some separate target
// definition, possibly even reusing the one in clang.
return getArchName() == "x86_64";
}
const char *Hexagon_TC::GetDefaultRelocationModel() const {
return "static";
}
const char *Hexagon_TC::GetForcedPicModel() const {
return 0;
} // End Hexagon
/// TCEToolChain - A tool chain using the llvm bitcode tools to perform
/// all subcommands. See http://tce.cs.tut.fi for our peculiar target.

18
clang/lib/Driver/ToolChains.h
View File

@ -136,7 +136,23 @@ protected:
/// @}
};
/// Darwin - The base Darwin tool chain.
class LLVM_LIBRARY_VISIBILITY Hexagon_TC : public ToolChain {
protected:
mutable llvm::DenseMap<unsigned, Tool*> Tools;
public:
Hexagon_TC(const HostInfo &Host, const llvm::Triple& Triple);
~Hexagon_TC();
virtual Tool &SelectTool(const Compilation &C, const JobAction &JA,
const ActionList &Inputs) const;
virtual bool IsUnwindTablesDefault() const;
virtual const char *GetDefaultRelocationModel() const;
virtual const char *GetForcedPicModel() const;
};
/// Darwin - The base Darwin tool chain.
class LLVM_LIBRARY_VISIBILITY Darwin : public ToolChain {
public:
/// The host version.

256
clang/lib/Driver/Tools.cpp
View File

@ -944,6 +944,81 @@ void Clang::AddX86TargetArgs(const ArgList &Args,
}
}
static Arg* getLastHexagonArchArg (const ArgList &Args)
{
Arg * A = NULL;
for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); it != ie; ++it) {
if ((*it)->getOption().matches(options::OPT_mv2) ||
(*it)->getOption().matches(options::OPT_mv3) ||
(*it)->getOption().matches(options::OPT_mv4) ||
(*it)->getOption().matches(options::OPT_march_EQ) ||
(*it)->getOption().matches(options::OPT_mcpu_EQ)) {
A = *it;
A->claim();
}
}
return A;
}
static const char *getHexagonTargetCPU(const ArgList &Args)
{
Arg *A;
llvm::StringRef WhichHexagon;
if ((A = getLastHexagonArchArg (Args))) {
if ((A->getOption().matches(options::OPT_march_EQ)) ||
(A->getOption().matches(options::OPT_mcpu_EQ))) {
WhichHexagon = A->getValue(Args);
if (WhichHexagon == "v2")
return "hexagonv2";
else if (WhichHexagon == "v3")
return "hexagonv3";
else if (WhichHexagon == "v4")
return "hexagonv4";
else
assert (0 && "Unknown -march or -mcpu value");
}
else {
if (A->getOption().matches(options::OPT_mv2))
return "hexagonv2";
else if (A->getOption().matches(options::OPT_mv3))
return "hexagonv3";
else if (A->getOption().matches(options::OPT_mv4))
return "hexagonv4";
else
assert(0 && "Unknown -m argument.");
}
}
else
return "hexagonv2";
}
void Clang::AddHexagonTargetArgs(const ArgList &Args,
ArgStringList &CmdArgs) const {
llvm::Triple Triple = getToolChain().getTriple();
CmdArgs.push_back("-target-cpu");
CmdArgs.push_back(getHexagonTargetCPU(Args));
CmdArgs.push_back("-fno-signed-char");
CmdArgs.push_back("-nobuiltininc");
if (Args.hasArg(options::OPT_mqdsp6_compat))
CmdArgs.push_back("-mqdsp6-compat");
if (Arg *A = Args.getLastArg(options::OPT_G,
options::OPT_msmall_data_threshold_EQ)) {
std::string SmallDataThreshold="-small-data-threshold=";
SmallDataThreshold += A->getValue(Args);
CmdArgs.push_back ("-mllvm");
CmdArgs.push_back(Args.MakeArgString(SmallDataThreshold));
A->claim();
}
CmdArgs.push_back ("-mllvm");
CmdArgs.push_back ("-machine-sink-split=0");
}
static bool
shouldUseExceptionTablesForObjCExceptions(unsigned objcABIVersion,
const llvm::Triple &Triple) {
@ -1438,8 +1513,14 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
case llvm::Triple::x86_64:
AddX86TargetArgs(Args, CmdArgs);
break;
case llvm::Triple::hexagon:
AddHexagonTargetArgs(Args, CmdArgs);
break;
}
// Pass the linker version in use.
if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) {
CmdArgs.push_back("-target-linker-version");
@ -1872,10 +1953,11 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti))
CmdArgs.push_back("-fno-rtti");
// -fshort-enums=0 is default.
// FIXME: Are there targers where -fshort-enums is on by default ?
// -fshort-enums=0 is default for all architectures except Hexagon.
if (Args.hasFlag(options::OPT_fshort_enums,
options::OPT_fno_short_enums, false))
options::OPT_fno_short_enums,
getToolChain().getTriple().getArch() ==
llvm::Triple::hexagon))
CmdArgs.push_back("-fshort-enums");
// -fsigned-char is default.
@ -1892,7 +1974,9 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
if (KernelOrKext ||
!Args.hasFlag(options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit,
getToolChain().getTriple().getOS() != llvm::Triple::Cygwin &&
getToolChain().getTriple().getOS() != llvm::Triple::MinGW32))
getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 &&
getToolChain().getTriple().getArch() !=
llvm::Triple::hexagon))
CmdArgs.push_back("-fno-use-cxa-atexit");
// -fms-extensions=0 is default.
@ -2475,6 +2559,8 @@ void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
CmdArgs.push_back("-fsyntax-only");
}
Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA,
options::OPT_Xassembler);
// Only pass -x if gcc will understand it; otherwise hope gcc
// understands the suffix correctly. The main use case this would go
@ -2574,6 +2660,168 @@ void gcc::Link::RenderExtraToolArgs(const JobAction &JA,
// The types are (hopefully) good enough.
}
// Hexagon tools start.
void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA,
ArgStringList &CmdArgs) const {
}
void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
const InputInfo &Output,
const InputInfoList &Inputs,
const ArgList &Args,
const char *LinkingOutput) const {
const Driver &D = getToolChain().getDriver();
ArgStringList CmdArgs;
std::string MarchString = "-march=";
MarchString += getHexagonTargetCPU(Args);
CmdArgs.push_back(Args.MakeArgString(MarchString));
RenderExtraToolArgs(JA, CmdArgs);
if (Output.isFilename()) {
CmdArgs.push_back("-o");
CmdArgs.push_back(Output.getFilename());
} else {
assert(Output.isNothing() && "Unexpected output");
CmdArgs.push_back("-fsyntax-only");
}
// Only pass -x if gcc will understand it; otherwise hope gcc
// understands the suffix correctly. The main use case this would go
// wrong in is for linker inputs if they happened to have an odd
// suffix; really the only way to get this to happen is a command
// like '-x foobar a.c' which will treat a.c like a linker input.
//
// FIXME: For the linker case specifically, can we safely convert
// inputs into '-Wl,' options?
for (InputInfoList::const_iterator
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
const InputInfo &II = *it;
// Don't try to pass LLVM or AST inputs to a generic gcc.
if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
D.Diag(clang::diag::err_drv_no_linker_llvm_support)
<< getToolChain().getTripleString();
else if (II.getType() == types::TY_AST)
D.Diag(clang::diag::err_drv_no_ast_support)
<< getToolChain().getTripleString();
if (II.isFilename())
CmdArgs.push_back(II.getFilename());
else
// Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
II.getInputArg().render(Args, CmdArgs);
}
const char *GCCName = "hexagon-as";
const char *Exec =
Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
}
void hexagon::Link::RenderExtraToolArgs(const JobAction &JA,
ArgStringList &CmdArgs) const {
// The types are (hopefully) good enough.
}
void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA,
const InputInfo &Output,
const InputInfoList &Inputs,
const ArgList &Args,
const char *LinkingOutput) const {
const Driver &D = getToolChain().getDriver();
ArgStringList CmdArgs;
for (ArgList::const_iterator
it = Args.begin(), ie = Args.end(); it != ie; ++it) {
Arg *A = *it;
if (A->getOption().hasForwardToGCC()) {
// Don't forward any -g arguments to assembly steps.
if (isa<AssembleJobAction>(JA) &&
A->getOption().matches(options::OPT_g_Group))
continue;
// It is unfortunate that we have to claim here, as this means
// we will basically never report anything interesting for
// platforms using a generic gcc, even if we are just using gcc
// to get to the assembler.
A->claim();
A->render(Args, CmdArgs);
}
}
RenderExtraToolArgs(JA, CmdArgs);
// Add Arch Information
Arg *A;
if ((A = getLastHexagonArchArg (Args))) {
if ((A->getOption().matches(options::OPT_march_EQ)) ||
(A->getOption().matches(options::OPT_mcpu_EQ))) {
llvm::StringRef WhichHexagon = A->getValue(Args);
if (WhichHexagon == "v2")
CmdArgs.push_back("-mv2");
else if (WhichHexagon == "v3")
CmdArgs.push_back ("-mv3");
else if (WhichHexagon == "v4")
CmdArgs.push_back ("-mv4");
else
assert (0 && "Unknown -march or -mcpu value");
}
else {
if (A->getOption().matches(options::OPT_mv2) ||
A->getOption().matches(options::OPT_mv3) ||
A->getOption().matches(options::OPT_mv4))
A->render(Args, CmdArgs);
else
assert(0 && "Unknown -m argument.");
}
}
CmdArgs.push_back("-mqdsp6-compat");
const char *GCCName;
if (C.getDriver().CCCIsCXX)
GCCName = "hexagon-g++";
else
GCCName = "hexagon-gcc";
const char *Exec =
Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
if (Output.isFilename()) {
CmdArgs.push_back("-o");
CmdArgs.push_back(Output.getFilename());
}
for (InputInfoList::const_iterator
it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) {
const InputInfo &II = *it;
// Don't try to pass LLVM or AST inputs to a generic gcc.
if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR ||
II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC)
D.Diag(clang::diag::err_drv_no_linker_llvm_support)
<< getToolChain().getTripleString();
else if (II.getType() == types::TY_AST)
D.Diag(clang::diag::err_drv_no_ast_support)
<< getToolChain().getTripleString();
if (II.isFilename())
CmdArgs.push_back(II.getFilename());
else
// Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ?
II.getInputArg().render(Args, CmdArgs);
}
C.addCommand(new Command(JA, *this, Exec, CmdArgs));
}
// Hexagon tools end.
const char *darwin::CC1::getCC1Name(types::ID Type) const {
switch (Type) {
default:

38
clang/lib/Driver/Tools.h
View File

@ -41,6 +41,7 @@ namespace tools {
void AddMIPSTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
void AddSparcTargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
void AddX86TargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const;
void AddHexagonTargetArgs (const ArgList &Args, ArgStringList &CmdArgs) const;
public:
Clang(const ToolChain &TC) : Tool("clang", "clang frontend", TC) {}
@ -152,6 +153,43 @@ namespace gcc {
};
} // end namespace gcc
namespace hexagon {
// For Hexagon, we do not need to instantiate tools for PreProcess, PreCompile and Compile.
// We simply use "clang -cc1" for those actions.
class LLVM_LIBRARY_VISIBILITY Assemble : public Tool {
public:
Assemble(const ToolChain &TC) : Tool("hexagon::Assemble",
"hexagon-as", TC) {}
virtual bool hasIntegratedCPP() const { return false; }
virtual void RenderExtraToolArgs(const JobAction &JA,
ArgStringList &CmdArgs) const;
virtual void ConstructJob(Compilation &C, const JobAction &JA,
const InputInfo &Output,
const InputInfoList &Inputs,
const ArgList &TCArgs,
const char *LinkingOutput) const;
};
class LLVM_LIBRARY_VISIBILITY Link : public Tool {
public:
Link(const ToolChain &TC) : Tool("hexagon::Link",
"hexagon-ld", TC) {}
virtual bool hasIntegratedCPP() const { return false; }
virtual void RenderExtraToolArgs(const JobAction &JA,
ArgStringList &CmdArgs) const;
virtual void ConstructJob(Compilation &C, const JobAction &JA,
const InputInfo &Output,
const InputInfoList &Inputs,
const ArgList &TCArgs,
const char *LinkingOutput) const;
};
} // end namespace hexagon.
namespace darwin {
class LLVM_LIBRARY_VISIBILITY DarwinTool : public Tool {
protected:

1
clang/lib/Frontend/CompilerInvocation.cpp
View File

@ -1818,6 +1818,7 @@ static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
Opts.MRTD = Args.hasArg(OPT_mrtd);
Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat);
Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);