Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ ")", ")", "==", "<NUM_LIT>", ";" ]

[ "if", "(", "regs_ever_live", "[", "<NUM_LIT>", "]", "||", "current_function_profile", ")", "return", "<NUM_LIT>", ";", "return_type", "=", "DECL_RESULT", "(", "current_function_decl", ")", ";", "if", "(", "TARGET_MIPS16", "&&", "mips16_hard_float", "&&", "!", "aggregate_value_p", "(", "return_type", ",", "current_function_decl", ")", "&&", "GET_MODE_CLASS", "(", "DECL_MODE", "(", "return_type", ")", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_SIZE", "(", "DECL_MODE", "(", "return_type", ")", ")", "<=", "UNITS_PER_FPVALUE", ")", "return", "<NUM_LIT>", ";", "if", "(", "cfun", "->", "machine", "->", "frame", ".", "initialized", ")", "return", "cfun", "->", "machine", "->", "frame", ".", "total_size", "==", "<NUM_LIT>", ";", "return", "compute_frame_size", "(", "get_frame_size", "(" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "let", "offsetBits", "=", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ")", ")", ")", ";", "let", "hasNewValue", "=", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "MajOp", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "src1", ";" ]

[ "}" ]

[ "let", "RenderMethod", "=", "<STR_LIT>", ";", "let", "PredicateMethod", "=", "<STR_LIT>", "#", "Low", "#", "<STR_LIT>", "#", "High", "#", "<STR_LIT>", ";" ]

[ "let", "isPredicable", "=", "<NUM_LIT>", ";" ]

[ "def", "A2_tfrp", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_2op", ">", ",", "PredNewRel", "{", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "offset", "{", "<NUM_LIT>", "}", ";" ]

[ "def", "_POST", ":", "AI3ldstidx", "<", "op", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "GPR", ":", "$", "Rt", ",", "GPR", ":", "$", "Rn_wb", ")", ",", "(", "ins", "addr_offset_none", ":", "$", "addr", ",", "am3offset", ":", "$", "offset", ")", ",", "IndexModePost", ",", "LdMiscFrm", ",", "itin", ",", "opc", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "bits", "<", "<NUM_LIT>", ">", "addr", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "offset", "{", "<NUM_LIT>", "}", ";" ]

[ "<STR_LIT>", ";" ]

[ "else", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "<NUM_LIT>", ")", ";", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "<STR_LIT>", "pop25\\t%%0, %%1", "<STR_LIT>", ")", ";", "}", "else", "{", "int", "pop_en4_only_p", "=", "<NUM_LIT>", ";", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "rb_callee_saved", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "re_callee_saved", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "fp_size", "&&", "!", "cfun", "->", "machine", "->", "gp_size", "&&", "!", "cfun", "->", "machine", "->", "lp_size", "&&", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "SP_REGNUM", "&&", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "SP_REGNUM", ")", "{", "return", "<STR_LIT>", "<STR_LIT>", ";", "}", "else", "{", "if", "(", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "SP_REGNUM", "&&", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "SP_REGNUM", ")", "pop_en4_only_p", "=", "<NUM_LIT>", ";", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "<STR_LIT>", "pop.s\\t%s{%s%s%s }", "<STR_LIT>", ",", "pop_en4_only_p", "?", "<STR_LIT>", "<STR_LIT>", ":", "<STR_LIT>", "%0, %1, ", "<STR_LIT>", ",", "cfun", "->", "machine", "->", "fp_size", "?", "<STR_LIT>", " $fp", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ",", "cfun", "->", "machine", "->", "gp_size", "?", "<STR_LIT>", " $gp", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ",", "cfun", "->", "machine", "->", "lp_size", "?", "<STR_LIT>", " $lp", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", ";", "}", "}", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "<STR_LIT>" ]

[ "}" ]

[ "static", "MachineInstr", "*", "findFirstPredicateSetterFrom", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "{", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "isPredicateSetter", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "return", "&", "MI", ";", "}", "return", "nullptr", ";" ]

[ "MipsSubtarget", "&", "MipsSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "&", "TM", ")", "{", "std", "::", "string", "CPUName", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "TM", ".", "getTargetTriple", "(", ")", ",", "CPU", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "InMips16Mode", "&&", "!", "TM", ".", "Options", ".", "UseSoftFloat", ")", "InMips16HardFloat", "=", "true", ";", "return", "*", "this", ";", "}" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "<STR_LIT>", "xray_sled_", "<STR_LIT>", ",", "true", ")", ";" ]

[ "void", "AArch64AsmPrinter", "::", "EmitSled", "(", "const", "MachineInstr", "&", "MI", ",", "SledKind", "Kind", ")", "{", "static", "const", "int8_t", "NoopsInSledCount", "=", "<NUM_LIT>", ";", "OutStreamer", "->", "emitCodeAlignment", "(", "<NUM_LIT>", ")", ";", "auto", "CurSled", "=", "OutContext", ".", "createTempSymbol", "(" ]

[ "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "Constraints", "=" ]

[ "<FIXS>", "Register", "DR", "=", "UseI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<FIXE>" ]

[ "continue", ";", "if", "(", "UseI", "->", "isPHI", "(", ")", ")", "{", "assert", "(", "!", "UseI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSubReg", "(", ")", ")", ";", "<BUGS>", "unsigned", "DR", "=", "UseI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<BUGE>", "if", "(", "DR", "==", "R", ")", "continue", ";", "}" ]

[ "Op", "->", "EndLoc", "=", "E", ";" ]

[ "auto", "Op", "=", "std", "::", "make_unique", "<", "AMDGPUOperand", ">", "(", "Register", ",", "AsmParser", ")", ";", "Op", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Op", "->", "Reg", ".", "Mods", "=", "Modifiers", "(", ")", ";", "Op", "->", "StartLoc", "=", "S", ";" ]

[ "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "def", "J4_cmpeqn1_t_jumpnv_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Ns8", ",", "n1Const", ":", "$", "n1", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_bd8382d1", ",", "TypeNCJ", ">", ",", "Enc_4aca3a", ",", "PredRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "bool", "SILowerControlFlow", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "BoolRC", "=", "TRI", "->", "getBoolRC", "(", ")", ";", "InsertKillCleanups", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_PS", ";", "if", "(", "ST", ".", "isWave32", "(", ")", ")", "{", "AndOpc", "=", "AMDGPU", "::", "S_AND_B32", ";", "OrOpc", "=", "AMDGPU", "::", "S_OR_B32", ";", "XorOpc", "=", "AMDGPU", "::", "S_XOR_B32", ";", "MovTermOpc", "=", "AMDGPU", "::", "S_MOV_B32_term", ";", "Andn2TermOpc", "=", "AMDGPU", "::", "S_ANDN2_B32_term", ";", "XorTermrOpc", "=", "AMDGPU", "::", "S_XOR_B32_term", ";", "OrTermrOpc", "=", "AMDGPU", "::", "S_OR_B32_term", ";", "OrSaveExecOpc", "=", "AMDGPU", "::", "S_OR_SAVEEXEC_B32", ";", "Exec", "=", "AMDGPU", "::", "EXEC_LO", ";", "}", "else", "{", "AndOpc", "=", "AMDGPU", "::", "S_AND_B64", ";", "OrOpc", "=", "AMDGPU", "::", "S_OR_B64", ";", "XorOpc", "=", "AMDGPU", "::", "S_XOR_B64", ";", "MovTermOpc", "=", "AMDGPU", "::", "S_MOV_B64_term", ";", "Andn2TermOpc", "=", "AMDGPU", "::", "S_ANDN2_B64_term", ";", "XorTermrOpc", "=", "AMDGPU", "::", "S_XOR_B64_term", ";", "OrTermrOpc", "=", "AMDGPU", "::", "S_OR_B64_term", ";", "OrSaveExecOpc", "=", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ";", "Exec", "=", "AMDGPU", "::", "EXEC", ";", "}", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "Worklist", ";", "MachineFunction", "::", "iterator", "NextBB", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ";", "BI", "!=", "MF", ".", "end", "(", ")", ";", "BI", "=", "NextBB", ")", "{", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "&", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "E", ",", "Next", ";", "E", "=", "MBB", "->", "end", "(", ")", ";", "for", "(", "I", "=", "MBB", "->", "begin", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "MachineBasicBlock", "*", "SplitMBB", "=", "MBB", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_IF", ":", "SplitMBB", "=", "process", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_ELSE", ":", "case", "AMDGPU", "::", "SI_IF_BREAK", ":", "case", "AMDGPU", "::", "SI_LOOP", ":", "case", "AMDGPU", "::", "SI_END_CF", ":", "if", "(", "InsertKillCleanups", ")", "Worklist", ".", "push_back", "(", "&", "MI", ")", ";", "else", "SplitMBB", "=", "process", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INIT_EXEC", ":", "case", "AMDGPU", "::", "SI_INIT_EXEC_FROM_INPUT", ":", "lowerInitExec", "(", "MBB", ",", "MI", ")", ";", "if", "(", "LIS", ")", "LIS", "->", "removeAllRegUnitsForPhysReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "SplitMBB", "!=", "MBB", ")", "{", "MBB", "=", "Next", "->", "getParent", "(", ")", ";", "E", "=", "MBB", "->", "end", "(", ")", ";", "}", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "Worklist", ")", "process", "(", "*", "MI", ")", ";", "optimizeEndCf", "(", ")", ";", "LoweredEndCf", ".", "clear", "(", ")", ";", "LoweredIf", ".", "clear", "(", ")", ";", "NeedsKillCleanup", ".", "clear", "(", ")", ";", "return", "true", ";", "}" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "static", "void", "replace_swapped_load_constant", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx", "swap_insn", ")", "{", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "swap_insn", ")", ";", "rtx_insn", "*", "load_insn", ";", "df_ref", "use", "=", "DF_INSN_INFO_USES", "(", "insn_info", ")", ";", "struct", "df_link", "*", "def_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "gcc_assert", "(", "def_link", "&&", "!", "def_link", "->", "next", ")", ";", "load_insn", "=", "DF_REF_INSN", "(", "def_link", "->", "ref", ")", ";", "gcc_assert", "(", "load_insn", ")", ";", "insn_info", "=", "DF_INSN_INFO_GET", "(", "load_insn", ")", ";", "use", "=", "DF_INSN_INFO_USES", "(", "insn_info", ")", ";", "def_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "gcc_assert", "(", "def_link", "&&", "!", "def_link", "->", "next", ")", ";", "rtx_insn", "*", "tocrel_insn", "=", "DF_REF_INSN", "(", "def_link", "->", "ref", ")", ";", "gcc_assert", "(", "tocrel_insn", ")", ";", "rtx", "base", ",", "offset", ";", "rtx", "tocrel_expr", "=", "SET_SRC", "(", "PATTERN", "(", "tocrel_insn", ")", ")", ";", "const_rtx", "tocrel_base", ";", "if", "(", "GET_CODE", "(", "tocrel_expr", ")", "==", "MEM", ")", "tocrel_expr", "=", "XEXP", "(", "tocrel_expr", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "toc_relative_expr_p", "(", "tocrel_expr", ",", "false", ",", "&", "tocrel_base", ",", "NULL", ")", ")", "gcc_unreachable", "(", ")", ";", "split_const", "(", "XVECEXP", "(", "tocrel_base", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "&", "base", ",", "&", "offset", ")", ";", "rtx", "const_vector", "=", "get_pool_constant", "(", "base", ")", ";", "if", "(", "GET_CODE", "(", "const_vector", ")", "==", "SYMBOL_REF", ")", "const_vector", "=", "get_pool_constant", "(", "const_vector", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "const_vector", ")", "==", "CONST_VECTOR", ")", ";", "rtx", "new", "_", "mem", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "const_vector", ")", ";", "if", "(", "mode", "==", "V1TImode", ")", "return", ";", "else", "if", "(", "mode", "==", "V16QImode", ")", "{", "rtx", "vals", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "<NUM_LIT>", ")", ")", ";", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "XVECEXP", "(", "vals", ",", "<NUM_LIT>", ",", "(", "(", "i", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ")", ")", "=", "XVECEXP", "(", "const_vector", ",", "<NUM_LIT>", ",", "i", ")", ";", "rtx", "new", "_", "const_vector", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "<NUM_LIT>", ")", ")", ";", "new", "_", "mem", "=", "force_const_mem", "(", "mode", ",", "new", "_", "const_vector", ")", ";", "}", "else", "if", "(", "(", "mode", "==", "V8HImode", ")", "||", "(", "mode", "==", "V8HFmode", ")", ")", "{", "rtx", "vals", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "<NUM_LIT>", ")", ")", ";", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "XVECEXP", "(", "vals", ",", "<NUM_LIT>", ",", "(", "(", "i", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ")", ")", "=", "XVECEXP", "(", "const_vector", ",", "<NUM_LIT>", ",", "i", ")", ";", "rtx", "new", "_", "const_vector", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "<NUM_LIT>", ")", ")", ";", "new", "_", "mem", "=", "force_const_mem", "(", "mode", ",", "new", "_", "const_vector", ")", ";", "}", "else", "if", "(", "(", "mode", "==", "V4SImode", ")", "||", "(", "mode", "==", "V4SFmode", ")", ")", "{", "rtx", "vals", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "<NUM_LIT>", ")", ")", ";", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "XVECEXP", "(", "vals", ",", "<NUM_LIT>", ",", "(", "(", "i", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ")", ")", "=", "XVECEXP", "(", "const_vector", ",", "<NUM_LIT>", ",", "i", ")", ";", "rtx", "new", "_", "const_vector", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "<NUM_LIT>", ")", ")", ";", "new", "_", "mem", "=", "force_const_mem", "(", "mode", ",", "new", "_", "const_vector", ")", ";", "}", "else", "if", "(", "(", "mode", "==", "V2DImode", ")", "||", "(", "mode", "==", "V2DFmode", ")", ")", "{", "rtx", "vals", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "<NUM_LIT>", ")", ")", ";", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "XVECEXP", "(", "vals", ",", "<NUM_LIT>", ",", "(", "(", "i", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", ")", ")", "=", "XVECEXP", "(", "const_vector", ",", "<NUM_LIT>", ",", "i", ")", ";", "rtx", "new", "_", "const_vector", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "<NUM_LIT>", ")", ")", ";", "new", "_", "mem", "=", "force_const_mem", "(", "mode", ",", "new", "_", "const_vector", ")", ";", "}", "else", "{", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "REG_P", "(", "XEXP", "(", "new", "_", "mem", ",", "<NUM_LIT>", ")", ")", ")", "{", "rtx", "base_reg", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "new", "_", "mem", ",", "<NUM_LIT>", ")", ")", ";", "XEXP", "(", "new", "_", "mem", ",", "<NUM_LIT>", ")", "=", "base_reg", ";", "rtx_insn", "*", "force_insn", "=", "get_last_insn", "(", ")", ";", "remove_insn", "(", "force_insn", ")", ";", "rtx_insn", "*", "before_load_insn", "=", "PREV_INSN", "(", "load_insn", ")", ";", "add_insn_after", "(", "force_insn", ",", "before_load_insn", ",", "BLOCK_FOR_INSN", "(", "load_insn", ")", ")", ";", "df_insn_rescan", "(", "before_load_insn", ")", ";", "df_insn_rescan", "(", "force_insn", ")", ";", "}", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "load_insn", ")", ")", ",", "<NUM_LIT>", ")", "=", "new", "_", "mem", ";", "INSN_CODE", "(", "load_insn", ")", "=", "-", "<NUM_LIT>", ";", "df_insn_rescan", "(", "load_insn", ")", ";", "unsigned", "int", "uid", "=", "INSN_UID", "(", "swap_insn", ")", ";", "mark_swaps_for_removal", "(", "insn_entry", ",", "uid", ")", ";", "replace_swap_with_copy", "(", "insn_entry", ",", "uid", ")", ";", "}" ]

[ "Given", "that", "SWAP_INSN", "represents", "a", "swap", "of", "a", "load", "of", "a", "constant", "vector", "value", ",", "replace", "with", "a", "single", "instruction", "that", "loads", "a", "swapped", "variant", "of", "the", "original", "constant", ".", "The", "``", "natural", "''", "representation", "of", "a", "byte", "array", "in", "memory", "is", "the", "same", "for", "big", "endian", "and", "little", "endian", ".", "unsigned", "char", "byte_array", "[", "]", "=", "{", "0", ",", "1", ",", "2", ",", "3", ",", "4", ",", "5", ",", "6", ",", "7", ",", "8", ",", "9", ",", "a", ",", "b", ",", "c", ",", "d", ",", "e", ",", "f", "}", ";", "However", ",", "when", "loaded", "into", "a", "vector", "register", ",", "the", "representation", "depends", "on", "endian", "conventions", ".", "In", "big-endian", "mode", ",", "the", "register", "holds", ":", "MSB", "LSB", "[", "0", ",", "1", ",", "2", ",", "3", ",", "4", ",", "5", ",", "6", ",", "7", ",", "8", ",", "9", ",", "a", ",", "b", ",", "c", ",", "d", ",", "e", ",", "f", "]", "In", "little-endian", "mode", ",", "the", "register", "holds", ":", "MSB", "LSB", "[", "f", ",", "e", ",", "d", ",", "c", ",", "b", ",", "a", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", "]", "Word", "arrays", "require", "different", "handling", ".", "Consider", "the", "word", "array", ":", "unsigned", "int", "word_array", "[", "]", "=", "{", "0x00010203", ",", "0x04050607", ",", "0x08090a0b", ",", "0x0c0d0e0f", "}", ";", "The", "in-memory", "representation", "depends", "on", "endian", "configuration", ".", "The", "equivalent", "array", ",", "declared", "as", "a", "byte", "array", ",", "in", "memory", "would", "be", ":", "unsigned", "char", "big_endian_word_array_data", "[", "]", "=", "{", "0", ",", "1", ",", "2", ",", "3", ",", "4", ",", "5", ",", "6", ",", "7", ",", "8", ",", "9", ",", "a", ",", "b", ",", "c", ",", "d", ",", "e", ",", "f", "}", "unsigned", "char", "little_endian_word_array_data", "[", "]", "=", "{", "3", ",", "2", ",", "1", ",", "0", ",", "7", ",", "6", ",", "5", ",", "4", ",", "b", ",", "a", ",", "9", ",", "8", ",", "f", ",", "e", ",", "d", ",", "c", "}", "In", "big-endian", "mode", ",", "the", "register", "holds", ":", "MSB", "LSB", "[", "0", ",", "1", ",", "2", ",", "3", ",", "4", ",", "5", ",", "6", ",", "7", ",", "8", ",", "9", ",", "a", ",", "b", ",", "c", ",", "d", ",", "e", ",", "f", "]", "In", "little-endian", "mode", ",", "the", "register", "holds", ":", "MSB", "LSB", "[", "c", ",", "d", ",", "e", ",", "f", ",", "8", ",", "9", ",", "a", ",", "b", ",", "4", ",", "5", ",", "6", ",", "7", ",", "0", ",", "1", ",", "2", ",", "3", "]", "Similar", "transformations", "apply", "to", "the", "vector", "of", "half-word", "and", "vector", "of", "double-word", "representations", ".", "For", "now", ",", "do", "n't", "handle", "vectors", "of", "quad-precision", "values", ".", "Just", "return", ".", "A", "better", "solution", "is", "to", "fix", "the", "code", "generator", "to", "emit", "lvx/stvx", "for", "those", "." ]

[ "<FIXS>", "SM", "(", "*", "this", ")", "{", "}", "<FIXE>" ]

[ "public", ":", "AArch64AsmPrinter", "(", "TargetMachine", "&", "TM", ",", "std", "::", "unique_ptr", "MCStreamer", ">", "Streamer", ")", ":", "AsmPrinter", "(", "TM", ",", "std", "::", "move", "(", "Streamer", ")", ")", ",", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ",", "<BUGS>", "SM", "(", "*", "this", ")", ",", "AArch64FI", "(", "nullptr", ")", "{", "}", "<BUGE>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "AArch64 Assembly Printer", "<STR_LIT>", ";", "}" ]

[ "<FIXS>", "if", "(", "ARM_DOUBLEWORD_ALIGN", "&&", "fix", "->", "fix_size", "==", "<NUM_LIT>", "&&", "mp", "->", "fix_size", "!=", "<NUM_LIT>", ")", "<FIXE>" ]

[ "{", "<BUGS>", "if", "(", "TARGET_REALLY_IWMMXT", "&&", "fix", "->", "fix_size", "==", "<NUM_LIT>", "&&", "mp", "->", "fix_size", "!=", "<NUM_LIT>", ")", "<BUGE>", "return", "NULL", ";", "elsemin_mp", "=", "mp", ";" ]

[ "SDValue", "Ops", "[", "]", "=", "{", "LN", "->", "getChain", "(", ")", ",", "LN", "->", "getBasePtr", "(", ")", "}", ";" ]

[ "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "APInt", "KnownUndef", ",", "KnownZero", ";", "APInt", "DemandedElts", "=", "APInt", "::", "getAllOnesValue", "(", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "if", "(", "TLI", ".", "SimplifyDemandedVectorElts", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "DemandedElts", ",", "KnownUndef", ",", "KnownZero", ",", "DCI", ")", ")", "return", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ";", "SDValue", "In", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "MVT", "InVT", "=", "In", ".", "getSimpleValueType", "(", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "<", "InVT", ".", "getVectorNumElements", "(", ")", "&&", "ISD", "::", "isNormalLoad", "(", "In", ".", "getNode", "(", ")", ")", "&&", "In", ".", "hasOneUse", "(", ")", ")", "{", "assert", "(", "InVT", ".", "is128BitVector", "(", ")", "&&", "<STR_LIT>", "Expected 128-bit input vector", "<STR_LIT>", ")", ";", "LoadSDNode", "*", "LN", "=", "cast", "<", "LoadSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "LN", "->", "isSimple", "(", ")", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "unsigned", "NumBits", "=", "InVT", ".", "getScalarSizeInBits", "(", ")", "*", "VT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "MemVT", "=", "MVT", "::", "getIntegerVT", "(", "NumBits", ")", ";", "MVT", "LoadVT", "=", "MVT", "::", "getVectorVT", "(", "MemVT", ",", "<NUM_LIT>", "/", "NumBits", ")", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "LoadVT", ",", "MVT", "::", "Other", ")", ";" ]

[ "}" ]

[ "const", "TargetOperandInfo", "*", "OpInfo", "=", "ARMInsts", "[", "Opcode", "]", ".", "OpInfo", ";", "assert", "(", "NumOps", ">=", "<NUM_LIT>", "&&", "(", "OpInfo", "[", "<NUM_LIT>", "]", ".", "RegClass", "==", "ARM", "::", "DPRRegClassID", "||", "OpInfo", "[", "<NUM_LIT>", "]", ".", "RegClass", "==", "ARM", "::", "QPRRegClassID", ")", "&&", "OpInfo", "[", "<NUM_LIT>", "]", ".", "RegClass", "==", "ARM", "::", "GPRRegClassID", "&&", "<STR_LIT>", "Expect >= 2 operands and first 2 as reg operand", "<STR_LIT>", ")", ";", "unsigned", "RegClass", "=", "OpInfo", "[", "<NUM_LIT>", "]", ".", "RegClass", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "getRegisterEnum", "(", "B", ",", "RegClass", ",", "decodeNEONRn", "(", "insn", ")", ")", ")", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "getRegisterEnum", "(", "B", ",", "ARM", "::", "GPRRegClassID", ",", "decodeRd", "(", "insn", ")", ")", ")", ")", ";", "NumOpsAdded", "=", "<NUM_LIT>", ";", "return", "true", ";" ]

[ ")", "return", "true", ";" ]

[ "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", "<<", "StringRef", "(", "utohexstr", "(", "MO", ".", "getImm", "(", ")", ")", ")", ".", "lower", "(", ")", ";", "return", "false", ";", "case", "'", "x", "'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", "<<", "StringRef", "(", "utohexstr", "(", "MO", ".", "getImm", "(", ")", "&", "<NUM_LIT>", ")", ")", ".", "lower", "(", ")", ";", "return", "false", ";", "case", "'", "d", "'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "'", "m", "'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "MO", ".", "getImm", "(", ")", "-", "<NUM_LIT>", ";", "return", "false", ";", "case", "'", "z", "'", ":", "{", "if", "(", "MO", ".", "getType", "(", ")", "!=", "MachineOperand", "::", "MO_Immediate" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pv4", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "class", "Enc_865390", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Ii", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Pv4", ";" ]

[ ")", ")" ]

[ "<STR_LIT>", "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")" ]

[ "}" ]

[ "bool", "SPIRVAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "ModuleSectionsEmitted", "=", "false", ";", "return", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";" ]

[ "<FIXS>", "h8sx_classify_shift", "(", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "op", ")", "<FIXE>" ]

[ "enum", "h8sx_shift_type", "<BUGS>", "h8sx_classify_shift", "(", "enum", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "op", ")", "<BUGE>", "{", "if", "(", "!", "TARGET_H8300SX", ")", "return", "H8SX_SHIFT_NONE", ";" ]

[ "return", "(", "ScalarVT", "=", "=", "MVT", ":", ":", "i16", "|", "|", "ScalarVT", "=", "=", "MVT", ":", ":", "f16", ")", "&", "&", "St", "-", ">", "getAlignment", "(", ")", ">", "=", "<NUM_LIT>", ";" ]

[ "}", "]", ">", ";", "def", "aligned_pre_truncmaskedstvi16", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "val", ",", "node", ":", "$", "base", ",", "node", ":", "$", "offset", ",", "node", ":", "$", "pred", ")", ",", "(", "pre_truncmaskedst", "node", ":", "$", "val", ",", "node", ":", "$", "base", ",", "node", ":", "$", "offset", ",", "node", ":", "$", "pred", ")", ",", "[", "{", "auto", "*", "St", "=", "cast", "<", "MaskedStoreSDNode", ">", "(", "N", ")", ";", "EVT", "ScalarVT", "=", "St", "-", ">", "getMemoryVT", "(", ")", ".", "getScalarType", "(", ")", ";", "return", "(", "ScalarVT", "=", "=", "MVT", ":", ":", "i16", "|", "|", "ScalarVT", "=", "=", "MVT", ":", ":", "f16", ")", "&", "&", "St", "-", ">", "getAlignment", "(", ")", ">", "=", "<NUM_LIT>", ";", "}", "]", ">", ";", "def", "post_truncmaskedst", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "val", ",", "node", ":", "$", "base", ",", "node", ":", "$", "offset", ",", "node", ":", "$", "postd", ")", ",", "(", "masked_st", "node", ":", "$", "val", ",", "node", ":", "$", "base", ",", "node", ":", "$", "offset", ",", "node", ":", "$", "postd", ")", ",", "[", "{", "ISD", ":", ":", "MemIndexedMode", "AM", "=", "cast", "<", "MaskedStoreSDNode", ">", "(", "N", ")", "-", ">", "getAddressingMode", "(", ")", ";", "return", "cast", "<", "MaskedStoreSDNode", ">", "(", "N", ")", "-", ">", "isTruncatingStore", "(", ")", "&", "&", "(", "AM", "=", "=", "ISD", ":", ":", "POST_INC", "|", "|", "AM", "=", "=", "ISD", ":", ":", "POST_DEC", ")", ";", "}", "]", ">", ";", "def", "aligned_post_truncmaskedstvi8", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "val", ",", "node", ":", "$", "base", ",", "node", ":", "$", "offset", ",", "node", ":", "$", "postd", ")", ",", "(", "post_truncmaskedst", "node", ":", "$", "val", ",", "node", ":", "$", "base", ",", "node", ":", "$", "offset", ",", "node", ":", "$", "postd", ")", ",", "[", "{", "return", "cast", "<", "MaskedStoreSDNode", ">", "(", "N", ")", "-", ">", "getMemoryVT", "(", ")", ".", "getScalarType", "(", ")", "=", "=", "MVT", ":", ":", "i8", ";", "}", "]", ">", ";", "def", "aligned_post_truncmaskedstvi16", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "val", ",", "node", ":", "$", "base", ",", "node", ":", "$", "offset", ",", "node", ":", "$", "postd", ")", ",", "(", "post_truncmaskedst", "node", ":", "$", "val", ",", "node", ":", "$", "base", ",", "node", ":", "$", "offset", ",", "node", ":", "$", "postd", ")", ",", "[", "{", "auto", "*", "St", "=", "cast", "<", "MaskedStoreSDNode", ">", "(", "N", ")", ";", "EVT", "ScalarVT", "=", "St", "-", ">", "getMemoryVT", "(", ")", ".", "getScalarType", "(", ")", ";" ]

[ "(", ")", ";" ]

[ "MCAsmLexer", "&", "getLexer", "(", ")", "const", "{", "return", "Parser", ".", "getLexer" ]

[ "(", "match_test", "<STR_LIT>", ")", ")", ")" ]

[ "<STR_LIT>", "(", "and", "(", "match_code", "<STR_LIT>", ")" ]

[ "<FIXS>", "def", "LWAUX", ":", "XForm_1", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "G8RC", ":", "$", "rD", ",", "ptr_rc", ":", "$", "ea_result", ")", ",", "<FIXE>" ]

[ "<STR_LIT>", ",", "LdStLHAU", ",", "[", "]", ">", ",", "RegConstraint", "<STR_LIT>", ">", ",", "NoEncode", "<STR_LIT>", ">", ";", "<BUGS>", "def", "LWAUX", ":", "XForm_1", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "G8RC", ":", "$", "rD", ",", "ptr_rc", ":", "$", "ea_result", ")", ",", "<BUGE>", "(", "ins", "memrr", ":", "$", "addr", ")", ",", "<STR_LIT>", ",", "LdStLHAU", ",", "[", "]", ">", ",", "RegConstraint", "<STR_LIT>", ">", "," ]

[ "getKillRegState", "(", "isKill", ")", ")", ";" ]

[ "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "SrcReg", "," ]

[ ".", "getImm", "(", ")", ";" ]

[ "void", "getLiteral", "(", "MachineInstr", "*", "MI", ",", "std", "::", "vector", "<", "int64_t", ">", "&", "Lits", ")", "const", "{", "unsigned", "LiteralRegs", "[", "]", "=", "{", "AMDGPU", "::", "ALU_LITERAL_X", ",", "AMDGPU", "::", "ALU_LITERAL_Y", ",", "AMDGPU", "::", "ALU_LITERAL_Z", ",", "AMDGPU", "::", "ALU_LITERAL_W", "}", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "MO", ".", "getReg", "(", ")", "!=", "AMDGPU", "::", "ALU_LITERAL_X", ")", "continue", ";", "unsigned", "ImmIdx", "=", "TII", "->", "getOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "int64_t", "Imm", "=", "MI", "->", "getOperand", "(", "ImmIdx", ")" ]

[ "return", "true", ";" ]

[ "bool", "M68kInstrInfo", "::", "getStackSlotRange", "(", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "SubIdx", ",", "unsigned", "&", "Size", ",", "unsigned", "&", "Offset", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "Size", "=", "<NUM_LIT>", ";", "Offset", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "static", "bool", "CC_ARM_APCS_Custom_f64", "(", "unsigned", "&", "ValNo", ",", "MVT", "&", "ValVT", ",", "MVT", "&", "LocVT", ",", "<FIXE>", "<FIXS>", "static", "bool", "CC_ARM_AAPCS_Custom_f64", "(", "unsigned", "&", "ValNo", ",", "MVT", "&", "ValVT", ",", "MVT", "&", "LocVT", ",", "<FIXE>", "<FIXS>", "static", "bool", "RetCC_ARM_APCS_Custom_f64", "(", "unsigned", "&", "ValNo", ",", "MVT", "&", "ValVT", ",", "MVT", "&", "LocVT", ",", "<FIXE>", "<FIXS>", "static", "bool", "RetCC_ARM_AAPCS_Custom_f64", "(", "unsigned", "&", "ValNo", ",", "MVT", "&", "ValVT", ",", "MVT", "&", "LocVT", ",", "<FIXE>" ]

[ "#", "include", "<STR_LIT>", "llvm/Support/MathExtras.h", "<STR_LIT>", "using", "namespace", "llvm", ";", "<BUGS>", "static", "bool", "CC_ARM_APCS_Custom_f64", "(", "unsigned", "&", "ValNo", ",", "MVT", "&", "ValVT", ",", "MVT", "&", "LocVT", ",", "<BUGE>", "CCValAssign", "::", "LocInfo", "&", "LocInfo", ",", "ISD", "::", "ArgFlagsTy", "&", "ArgFlags", ",", "CCState", "&", "State", ")", ";", "<BUGS>", "static", "bool", "CC_ARM_AAPCS_Custom_f64", "(", "unsigned", "&", "ValNo", ",", "MVT", "&", "ValVT", ",", "MVT", "&", "LocVT", ",", "<BUGE>", "CCValAssign", "::", "LocInfo", "&", "LocInfo", ",", "ISD", "::", "ArgFlagsTy", "&", "ArgFlags", ",", "CCState", "&", "State", ")", ";", "<BUGS>", "static", "bool", "RetCC_ARM_APCS_Custom_f64", "(", "unsigned", "&", "ValNo", ",", "MVT", "&", "ValVT", ",", "MVT", "&", "LocVT", ",", "<BUGE>", "CCValAssign", "::", "LocInfo", "&", "LocInfo", ",", "ISD", "::", "ArgFlagsTy", "&", "ArgFlags", ",", "CCState", "&", "State", ")", ";", "<BUGS>", "static", "bool", "RetCC_ARM_AAPCS_Custom_f64", "(", "unsigned", "&", "ValNo", ",", "MVT", "&", "ValVT", ",", "MVT", "&", "LocVT", ",", "<BUGE>", "CCValAssign", "::", "LocInfo", "&", "LocInfo", ",", "ISD", "::", "ArgFlagsTy", "&", "ArgFlags", ",", "CCState", "&", "State", ")", ";" ]

[ "<NUM_LIT>", ";" ]

[ "def", "A2_vadduhs", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_a56825", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "m256i", "_", "_", "lasx_xvsle_bu", "(", "_", "_", "m256i", "_", "<NUM_LIT>", ",", "_", "_", "m256i", "_", "<NUM_LIT>", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_lasx_xvsle_bu", "(", "(", "v32u8", ")", "_", "<NUM_LIT>", ",", "(", "v32u8", ")", "_", "<NUM_LIT>", ")", ";" ]

[ "MVT", "::", "i32", ")", ";" ]

[ "<STR_LIT>", "::", "<STR_LIT>", "CondCode", ",", "Alternative", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "CondCode", "=", "FPCCToA64CC", "(", "CC", ",", "Alternative", ")", ";", "SDValue", "A64cc", "=", "DAG", ".", "getConstant", "(", "CondCode", ",", "MVT", "::", "i32", ")", ";", "SDValue", "SetCC", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "LHS", ",", "RHS", ",", "DAG", ".", "getCondCode", "(", "CC", ")", ")", ";", "SDValue", "A64BR_CC", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "SetCC", ",", "A64cc", ",", "DestBB", ")", ";", "if", "(", "Alternative", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "A64cc", "=", "DAG", ".", "getConstant", "(", "Alternative", "," ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Added edge to: ", "<STR_LIT>", ";", "DAG", "->", "dumpNode", "(", "*", "SUnitB", ")", ";", ")", ";" ]

[ "auto", "StageA", "=", "PipelineOrder", "[", "i", "]", ";", "for", "(", "int", "j", "=", "i", "+", "<NUM_LIT>", ";", "j", "<", "(", "int", ")", "PipelineOrder", ".", "size", "(", ")", ";", "j", "++", ")", "{", "auto", "StageB", "=", "PipelineOrder", "[", "j", "]", ";", "for", "(", "auto", "SUnitA", ":", "StageA", "->", "Collection", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Adding edges for: ", "<STR_LIT>", ";", "DAG", "->", "dumpNode", "(", "*", "SUnitA", ")", ";", ")", ";", "for", "(", "auto", "SUnitB", ":", "StageB", "->", "Collection", ")", "{", "if", "(", "DAG", "->", "canAddEdge", "(", "SUnitB", ",", "SUnitA", ")", ")", "{", "DAG", "->", "addEdge", "(", "SUnitB", ",", "SDep", "(", "SUnitA", ",", "SDep", "::", "Artificial", ")", ")", ";" ]

[ "match_code", "<STR_LIT>", ")" ]

[ "(", "and", "(" ]

[ "let", "PredicateMethod", "=", "<STR_LIT>", "#", "width", "#", "<STR_LIT>", ";" ]

[ "class", "LogicalShifterOperand", "<", "int", "width", ">", ":", "AsmOperandClass", "{", "let", "SuperClasses", "=", "[", "ShifterOperand", "]", ";", "let", "Name", "=", "<STR_LIT>", "#", "width", ";" ]

[ "case", "Hexagon", "::", "Sched", "::", "tc_ef84f62f", ":" ]

[ "case", "Hexagon", "::", "Sched", "::", "tc_41d5298e", ":", "case", "Hexagon", "::", "Sched", "::", "tc_5ba5997d", ":", "case", "Hexagon", "::", "Sched", "::", "tc_84df2cd3", ":", "case", "Hexagon", "::", "Sched", "::", "tc_87735c3b", ":", "case", "Hexagon", "::", "Sched", "::", "tc_897d1a9d", ":", "case", "Hexagon", "::", "Sched", "::", "tc_976ddc4f", ":", "case", "Hexagon", "::", "Sched", "::", "tc_b44c6e2a", ":", "case", "Hexagon", "::", "Sched", "::", "tc_b9c4623f", ":", "case", "Hexagon", "::", "Sched", "::", "tc_c2f7d806", ":", "case", "Hexagon", "::", "Sched", "::", "tc_c74f796f", ":", "case", "Hexagon", "::", "Sched", "::", "tc_d088982c", ":" ]

[ "InstrItinClass", "Itinerary", "=", "itin", ";" ]

[ "dag", "OutOperandList", "=", "(", "outs", "FGROpnd", ":", "$", "fd", ")", ";", "dag", "InOperandList", "=", "(", "ins", "FGROpnd", ":", "$", "fs", ",", "FGROpnd", ":", "$", "ft", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "]", ";" ]

[ "<STR_LIT>", ")", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>" ]

[ "::", "i32", ")", ";" ]

[ "SDValue", "Value", "=", "ST", "->", "getValue", "(", ")", ";", "SDNode", "*", "OffsetNode", "=", "Offset", ".", "getNode", "(", ")", ";", "int32_t", "Val", "=", "cast", "<", "ConstantSDNode", ">", "(", "OffsetNode", ")", "->", "getSExtValue", "(", ")", ";", "EVT", "StoredVT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "EVT", "ValueVT", "=", "Value", ".", "getValueType", "(", ")", ";", "if", "(", "HII", "->", "isValidAutoIncImm", "(", "StoredVT", ",", "Val", ")", ")", "{", "unsigned", "Opcode", "=", "<NUM_LIT>", ";", "if", "(", "StoredVT", "==", "MVT", "::", "i64", ")", "Opcode", "=", "Hexagon", "::", "S2_storerd_pi", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "i32", ")", "Opcode", "=", "Hexagon", "::", "S2_storeri_pi", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "i16", ")", "Opcode", "=", "Hexagon", "::", "S2_storerh_pi", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "i8", ")", "Opcode", "=", "Hexagon", "::", "S2_storerb_pi", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "v16i32", "||", "StoredVT", "==", "MVT", "::", "v8i64", "||", "StoredVT", "==", "MVT", "::", "v32i16", "||", "StoredVT", "==", "MVT", "::", "v64i8", ")", "{", "if", "(", "isAlignedMemNode", "(", "ST", ")", ")", "Opcode", "=", "Hexagon", "::", "V6_vS32b_pi", ";", "else", "Opcode", "=", "Hexagon", "::", "V6_vS32Ub_pi", ";", "}", "else", "if", "(", "StoredVT", "==", "MVT", "::", "v32i32", "||", "StoredVT", "==", "MVT", "::", "v16i64", "||", "StoredVT", "==", "MVT", "::", "v64i16", "||", "StoredVT", "==", "MVT", "::", "v128i8", ")", "{", "if", "(", "HST", "->", "useHVXOps", "(", ")", ")", "Opcode", "=", "isAlignedMemNode", "(", "ST", ")", "?", "Hexagon", "::", "V6_vS32b_pi_128B", ":", "Hexagon", "::", "V6_vS32Ub_pi_128B", ";", "}", "else", "llvm_unreachable", "(", "<STR_LIT>", "unknown memory type", "<STR_LIT>", ")", ";", "if", "(", "ST", "->", "isTruncatingStore", "(", ")", "&&", "ValueVT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "assert", "(", "StoredVT", ".", "getSizeInBits", "(", ")", "<", "<NUM_LIT>", "&&", "<STR_LIT>", "Not a truncating store", "<STR_LIT>", ")", ";", "Value", "=", "CurDAG", "->", "getTargetExtractSubreg", "(", "Hexagon", "::", "subreg_loreg", ",", "dl", ",", "MVT", "::", "i32", ",", "Value", ")", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "Base", ",", "CurDAG", "->", "getTargetConstant", "(", "Val", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "Value", ",", "Chain", "}", ";", "SDNode", "*", "Result", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Ops", ")", ";", "MachineSDNode", "::", "mmo_iterator", "MemOp", "=", "MF", "->", "allocateMemRefsArray", "(", "<NUM_LIT>", ")", ";", "MemOp", "[", "<NUM_LIT>", "]", "=", "ST", "->", "getMemOperand", "(", ")", ";", "cast", "<", "MachineSDNode", ">", "(", "Result", ")", "->", "setMemRefs", "(", "MemOp", ",", "MemOp", "+", "<NUM_LIT>", ")", ";", "ReplaceUses", "(", "ST", ",", "Result", ")", ";", "ReplaceUses", "(", "SDValue", "(", "ST", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "Result", ",", "<NUM_LIT>", ")", ")", ";", "CurDAG", "->", "RemoveDeadNode", "(", "ST", ")", ";", "return", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "Base", ",", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "Value", ",", "Chain", "}", ";", "unsigned", "Opcode", "=", "<NUM_LIT>", ";", "if", "(", "StoredVT", "==", "MVT", "::", "i64", ")", "Opcode", "=", "Hexagon", "::", "S2_storerd_io", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "i32", ")", "Opcode", "=", "Hexagon", "::", "S2_storeri_io", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "i16", ")", "Opcode", "=", "Hexagon", "::", "S2_storerh_io", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "i8", ")", "Opcode", "=", "Hexagon", "::", "S2_storerb_io", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "v16i32", "||", "StoredVT", "==", "MVT", "::", "v8i64", "||", "StoredVT", "==", "MVT", "::", "v32i16", "||", "StoredVT", "==", "MVT", "::", "v64i8", ")", "{", "if", "(", "isAlignedMemNode", "(", "ST", ")", ")", "Opcode", "=", "Hexagon", "::", "V6_vS32b_ai", ";", "else", "Opcode", "=", "Hexagon", "::", "V6_vS32Ub_ai", ";", "}", "else", "if", "(", "StoredVT", "==", "MVT", "::", "v32i32", "||", "StoredVT", "==", "MVT", "::", "v16i64", "||", "StoredVT", "==", "MVT", "::", "v64i16", "||", "StoredVT", "==", "MVT", "::", "v128i8", ")", "{", "if", "(", "isAlignedMemNode", "(", "ST", ")", ")", "Opcode", "=", "Hexagon", "::", "V6_vS32b_ai_128B", ";", "else", "Opcode", "=", "Hexagon", "::", "V6_vS32Ub_ai_128B", ";", "}", "else", "llvm_unreachable", "(", "<STR_LIT>", "unknown memory type", "<STR_LIT>", ")", ";", "SDValue", "TargetConstVal", "=", "CurDAG", "->", "getTargetConstant", "(", "Val", ",", "dl", ",", "MVT" ]

[ "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "static", "std", "::", "map", "<", "StringRef", ",", "Hexagon", "::", "ArchEnum", ">", "CpuTable", "{", "{", "<STR_LIT>", "hexagonv4", "<STR_LIT>", ",", "Hexagon", "::", "ArchEnum", "::", "V4", "}", ",", "{", "<STR_LIT>", "hexagonv5", "<STR_LIT>", ",", "Hexagon", "::", "ArchEnum", "::", "V5", "}", ",", "{", "<STR_LIT>", "hexagonv55", "<STR_LIT>", ",", "Hexagon", "::", "ArchEnum", "::", "V55", "}", ",", "{", "<STR_LIT>", "hexagonv60", "<STR_LIT>", ",", "Hexagon", "::", "ArchEnum", "::", "V60", "}", ",", "{", "<STR_LIT>", "hexagonv62", "<STR_LIT>", ",", "Hexagon", "::", "ArchEnum", "::", "V62", "}", ",", "{", "<STR_LIT>", "hexagonv65", "<STR_LIT>", ",", "Hexagon", "::", "ArchEnum", "::", "V65", "}", ",", "}", ";", "auto", "FoundIt", "=", "CpuTable", ".", "find", "(", "CPUString", ")", ";", "if", "(", "FoundIt", "!=", "CpuTable", ".", "end", "(", ")", ")", "HexagonArchVersion", "=", "FoundIt", "->", "second", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "Unrecognized Hexagon processor version", "<STR_LIT>", ")", ";", "UseHVX128BOps", "=", "false", ";", "UseHVX64BOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "UseBSBScheduling", "=", "hasV60TOps", "(", ")", "&&", "EnableBSBSched", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "FeatureBitset", "Features", "=", "getFeatureBits", "(", ")", ";", "if", "(", "HexagonDisableDuplex", ")", "setFeatureBits", "(", "Features", ".", "set", "(", "Hexagon", "::", "FeatureDuplex", ",", "false", ")", ")", ";", "setFeatureBits", "(", "Hexagon_MC", "::", "completeHVXFeatures", "(", "Features", ")", ")", ";", "return", "*", "this", ";", "}" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "<STR_LIT>" ]

[ "(", "unspec", ":", "CC", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_MOVESI_TO_CR", ")", ")", "]" ]

[ "return", "true", ";" ]

[ "static", "bool", "aarch64_handle_attr_cpu", "(", "const", "char", "*", "str", ")", "{", "const", "struct", "processor", "*", "tmp_cpu", "=", "NULL", ";", "enum", "aarch64_parse_opt_result", "parse_res", "=", "aarch64_parse_cpu", "(", "str", ",", "&", "tmp_cpu", ",", "&", "aarch64_isa_flags", ")", ";", "if", "(", "parse_res", "==", "AARCH64_PARSE_OK", ")", "{", "gcc_assert", "(", "tmp_cpu", ")", ";", "selected_tune", "=", "tmp_cpu", ";", "explicit_tune_core", "=", "selected_tune", "->", "ident", ";", "selected_arch", "=", "&", "all_architectures", "[", "tmp_cpu", "->", "arch", "]", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";" ]

[ "<FIXS>", "DISP_3SLOTS_1C", ",", "DISP_3SLOTS_1C", "]", ",", "<FIXE>" ]

[ "def", ":", "InstRW", "[", "P9_ALU_2C", ",", "P9_ALU_2C", ",", "IP_EXEC_1C", ",", "IP_EXEC_1C", ",", "<BUGS>", "DISP_1C", ",", "DISP_1C", ",", "DISP_1C", ",", "DISP_1C", ",", "DISP_1C", ",", "DISP_1C", "]", ",", "<BUGE>", "(", "instrsMTCRF", ",", "MTCRF8" ]

[ "MVT", "::", "v4i32", ":", "MVT", "::", "v4f32", ";" ]

[ "Offset", "=", "Ptr", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "Ptr", "=", "Ptr", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "return", "SDValue", "(", ")", ";", "}", "SDValue", "Chain", "=", "LD", "->", "getChain", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "if", "(", "DAG", ".", "InferPtrAlignment", "(", "Ptr", ")", "<", "<NUM_LIT>", ")", "{", "if", "(", "MFI", "->", "isFixedObjectIndex", "(", "FI", ")", ")", "{", "return", "SDValue", "(", ")", ";", "}", "else", "{", "MFI", "->", "setObjectAlignment", "(", "FI", ",", "<NUM_LIT>", ")", ";", "}", "}", "if", "(", "Offset", "<", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "if", "(", "(", "Offset", "%", "<NUM_LIT>", ")", "&", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "int64_t", "StartOffset", "=", "Offset", "&", "~", "<NUM_LIT>", ";", "if", "(", "StartOffset", ")", "Ptr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "Ptr", ".", "getDebugLoc", "(", ")", ",", "Ptr", ".", "getValueType", "(", ")", ",", "Ptr", ",", "DAG", ".", "getConstant", "(", "StartOffset", ",", "Ptr", ".", "getValueType", "(", ")", ")", ")", ";", "int", "EltNo", "=", "(", "Offset", "-", "StartOffset", ")", ">>", "<NUM_LIT>", ";", "int", "Mask", "[", "<NUM_LIT>", "]", "=", "{", "EltNo", ",", "EltNo", ",", "EltNo", ",", "EltNo", "}", ";", "EVT", "VT", "=", "(", "PVT", "==", "MVT", "::", "i32", ")", "?" ]

[ "<FIXS>", "{", "if", "(", "!", "TARGET_64BIT", ")", "cum", "->", "nregs", "=", "<NUM_LIT>", ";", "cum", "->", "maybe_vaarg", "=", "true", ";", "}", "<FIXE>" ]

[ "{", "next_param", "=", "TREE_CHAIN", "(", "param", ")", ";", "if", "(", "next_param", "==", "<NUM_LIT>", "&&", "TREE_VALUE", "(", "param", ")", "!=", "void_type_node", ")", "<BUGS>", "cum", "->", "nregs", "=", "<NUM_LIT>", ";", "<BUGE>", "}", "}", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", ", nregs=%d )\\n", "<STR_LIT>", ",", "cum", "->", "nregs", ")", ";" ]

[ "<FIXS>", "fputs", "(", "cond_string", "(", "GET_CODE", "(", "x", ")", ")", ",", "file", ")", ";", "<FIXE>", "<FIXS>", "fputs", "(", "cond_string", "(", "reverse_condition", "(", "GET_CODE", "(", "x", ")", ")", ")", ",", "file", ")", ";", "<FIXE>" ]

[ "}", "break", ";", "case", "'", "j", "'", ":", "<BUGS>", "asm_fprintf", "(", "file", ",", "cond_string", "(", "GET_CODE", "(", "x", ")", ")", ")", ";", "<BUGE>", "break", ";", "case", "'", "k", "'", ":", "<BUGS>", "asm_fprintf", "(", "file", ",", "cond_string", "(", "reverse_condition", "(", "GET_CODE", "(", "x", ")", ")", ")", ")", ";", "<BUGE>", "break", ";", "case", "'", "s", "'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")" ]

[ "void", "ia64_expand_vecint_cmov", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "bool", "negate", ";", "rtx", "cmp", ",", "x", ",", "ot", ",", "of", ";", "cmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "negate", "=", "ia64_expand_vecint_compare", "(", "code", ",", "mode", ",", "cmp", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "ot", "=", "operands", "[", "<NUM_LIT>", "+", "negate", "]", ";", "of", "=", "operands", "[", "<NUM_LIT>", "-", "negate", "]", ";", "if", "(", "ot", "==", "CONST0_RTX", "(", "mode", ")", ")", "{", "if", "(", "of", "==", "CONST0_RTX", "(", "mode", ")", ")", "{", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "ot", ")", ";", "return", ";", "}", "x", "=", "gen_rtx_NOT", "(", "mode", ",", "cmp", ")", ";", "x", "=", "gen_rtx_AND", "(", "mode", ",", "x", ",", "of", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "<NUM_LIT>", "]", ",", "x", ")", ")", ";", "}", "else", "if", "(", "of", "==", "CONST0_RTX", "(", "mode", ")", ")", "{", "x", "=", "gen_rtx_AND", "(", "mode", ",", "cmp", ",", "ot", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "<NUM_LIT>", "]", ",", "x", ")", ")", ";", "}", "else", "{", "rtx", "t", ",", "f", ";", "t", "=", "gen_reg_rtx", "(", "mode", ")", ";", "x", "=", "gen_rtx_AND", "(", "mode", ",", "cmp", ",", "operands", "[", "<NUM_LIT>", "+", "negate", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "t", ",", "x", ")", ")", ";", "f", "=", "gen_reg_rtx", "(", "mode", ")", ";", "x", "=", "gen_rtx_NOT", "(", "mode", ",", "cmp", ")", ";", "x", "=", "gen_rtx_AND", "(", "mode", ",", "x", ",", "operands", "[", "<NUM_LIT>", "-", "negate", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "f", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_IOR", "(", "mode", ",", "t", ",", "f", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "<NUM_LIT>", "]", ",", "x", ")", ")", ";", "}", "}" ]

[ "Emit", "an", "integral", "vector", "conditional", "move", "." ]

[ ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";" ]

[ "SDLoc", "DL", "(", "Op", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "DL", ",", "Op", ".", "getValueType", "(", ")", ",", "DAG", ".", "getUNDEF", "(", "Op", ".", "getValueType", "(", ")", ")" ]

[ "SDValue", "And", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i32", ",", "N0", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "C1", ">>", "C2", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";" ]

[ "if", "(", "!", "C2", "||", "C2", ">=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "if", "(", "LeftShift", ")", "C1", "&=", "(", "-", "<NUM_LIT>", "U", "<<", "C2", ")", ";", "else", "C1", "&=", "(", "-", "<NUM_LIT>", "U", ">>", "C2", ")", ";", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDLoc", "DL", "(", "N", ")", ";", "if", "(", "!", "LeftShift", "&&", "isMask_32", "(", "C1", ")", ")", "{", "uint32_t", "C3", "=", "llvm", "::", "countl_zero", "(", "C1", ")", ";", "if", "(", "C2", "<", "C3", ")", "{", "SDValue", "SHL", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "MVT", "::", "i32", ",", "N0", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "C3", "-", "C2", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i32", ",", "SHL", ",", "DAG", ".", "getConstant", "(", "C3", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "}", "}", "if", "(", "LeftShift", "&&", "isMask_32", "(", "~", "C1", ")", ")", "{", "uint32_t", "C3", "=", "llvm", "::", "countr_zero", "(", "C1", ")", ";", "if", "(", "C2", "<", "C3", ")", "{", "SDValue", "SHL", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i32", ",", "N0", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "C3", "-", "C2", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "MVT", "::", "i32", ",", "SHL", ",", "DAG", ".", "getConstant", "(", "C3", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "}", "}", "if", "(", "LeftShift", "&&", "isShiftedMask_32", "(", "C1", ")", ")", "{", "uint32_t", "Trailing", "=", "llvm", "::", "countr_zero", "(", "C1", ")", ";", "uint32_t", "C3", "=", "llvm", "::", "countl_zero", "(", "C1", ")", ";", "if", "(", "Trailing", "==", "C2", "&&", "C2", "+", "C3", "<", "<NUM_LIT>", ")", "{", "SDValue", "SHL", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "MVT", "::", "i32", ",", "N0", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "C2", "+", "C3", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i32", ",", "SHL", ",", "DAG", ".", "getConstant", "(", "C3", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "}", "}", "if", "(", "!", "LeftShift", "&&", "isShiftedMask_32", "(", "C1", ")", ")", "{", "uint32_t", "Leading", "=", "llvm", "::", "countl_zero", "(", "C1", ")", ";", "uint32_t", "C3", "=", "llvm", "::", "countr_zero", "(", "C1", ")", ";", "if", "(", "Leading", "==", "C2", "&&", "C2", "+", "C3", "<", "<NUM_LIT>", ")", "{", "SDValue", "SHL", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i32", ",", "N0", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "C2", "+", "C3", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "MVT", "::", "i32", ",", "SHL", ",", "DAG", ".", "getConstant", "(", "C3", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "}", "}", "if", "(", "LeftShift", "&&", "HasLowerConstantMaterializationCost", "(", "C1", ">>", "C2", ",", "C1", ",", "Subtarget", ")", ")", "{" ]

[ "!=", "<NUM_LIT>", ";" ]

[ "static", "bool", "xtensa_tls_symbol_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "targetm", ".", "have_tls", ")", "return", "false", ";", "return", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")" ]

[ "Succ", ")", ")", "{" ]

[ "MachineInstr", "*", "End", "=", "LoLoop", ".", "End", ";", "MachineBasicBlock", "*", "MBB", "=", "End", "->", "getParent", "(", ")", ";", "unsigned", "Opc", "=", "LoLoop", ".", "IsTailPredicationLegal", "(", ")", "?", "ARM", "::", "MVE_LETP", ":", "ARM", "::", "t2LEUpdate", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "End", ",", "End", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Opc", ")", ")", ";", "MIB", ".", "addDef", "(", "ARM", "::", "LR", ")", ";", "unsigned", "Off", "=", "LoLoop", ".", "Dec", "==", "LoLoop", ".", "End", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "MIB", ".", "add", "(", "End", "->", "getOperand", "(", "Off", "+", "<NUM_LIT>", ")", ")", ";", "MIB", ".", "add", "(", "End", "->", "getOperand", "(", "Off", "+", "<NUM_LIT>", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Inserted LE: ", "<STR_LIT>", "<<", "*", "MIB", ")", ";", "LoLoop", ".", "ToRemove", ".", "insert", "(", "LoLoop", ".", "Dec", ")", ";", "LoLoop", ".", "ToRemove", ".", "insert", "(", "End", ")", ";", "return", "&", "*", "MIB", ";", "}", ";", "auto", "RemoveDeadBranch", "=", "[", "]", "(", "MachineInstr", "*", "I", ")", "{", "MachineBasicBlock", "*", "BB", "=", "I", "->", "getParent", "(", ")", ";", "MachineInstr", "*", "Terminator", "=", "&", "BB", "->", "instr_back", "(", ")", ";", "if", "(", "Terminator", "->", "isUnconditionalBranch", "(", ")", "&&", "I", "!=", "Terminator", ")", "{", "MachineBasicBlock", "*", "Succ", "=", "Terminator", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "if", "(", "BB", "->", "isLayoutSuccessor", "(" ]

[ "<STR_LIT>", ")", ")", ")", "]" ]

[ "(", "neg", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>" ]

[ "(", ")", ";" ]

[ "MBB", "=", "LoopMBB", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "OldVal", ")", ".", "addReg", "(", "OrigVal", ")", ".", "addMBB", "(", "StartMBB", ")", ".", "addReg", "(", "Dest", ")", ".", "addMBB", "(", "LoopMBB", ")", ";", "if", "(", "IsSubWord", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "RotatedOldVal", ")", ".", "addReg", "(", "OldVal", ")", ".", "addReg", "(", "BitShift", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "Invert", ")", "{", "unsigned", "Tmp", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "BinOpcode", ")", ",", "Tmp", ")", ".", "addReg", "(", "RotatedOldVal", ")", ".", "addOperand", "(", "Src2", ")", ";", "if", "(", "BitSize", "<", "<NUM_LIT>", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "RotatedNewVal", ")", ".", "addReg", "(", "Tmp", ")", ".", "addImm", "(", "uint32_t", "(", "~", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "BitSize", ")", ")", ")", ";", "else", "if", "(", "BitSize", "==", "<NUM_LIT>", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "RotatedNewVal", ")", ".", "addReg", "(", "Tmp", ")", ".", "addImm", "(", "~", "uint32_t", "(", "<NUM_LIT>", ")", ")", ";", "else", "{", "unsigned", "Tmp2", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "Tmp2", ")", ".", "addReg", "(", "Tmp", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "RotatedNewVal", ")", ".", "addReg", "(", "Tmp2", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ";", "}", "}", "else", "if", "(", "BinOpcode", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "BinOpcode", ")", ",", "RotatedNewVal", ")", ".", "addReg", "(", "RotatedOldVal", ")", ".", "addOperand", "(", "Src2", ")", ";", "else", "if", "(", "IsSubWord", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "RotatedNewVal", ")", ".", "addReg", "(", "RotatedOldVal", ")", ".", "addReg", "(", "Src2", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", "+", "BitSize", ")", ".", "addImm", "(", "<NUM_LIT>", "-", "BitSize", ")", ";", "if", "(", "IsSubWord", ")", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "NewVal", ")", ".", "addReg", "(", "RotatedNewVal", ")", ".", "addReg", "(", "NegBitShift", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "CSOpcode", ")", ",", "Dest", ")", ".", "addReg", "(", "OldVal", ")", ".", "addReg", "(", "NewVal", ")", ".", "addOperand", "(", "Base", ")", ".", "addImm", "(", "Disp", ")", ";", "BuildMI", "(", "MBB", ",", "DL", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "MaskNE", ")", ".", "addMBB", "(", "LoopMBB", ")", ";", "MBB", "->", "addSuccessor", "(", "LoopMBB", ")", ";", "MBB", "->", "addSuccessor", "(", "DoneMBB", ")", ";", "MI", "->", "eraseFromParent" ]

[ "case", "MVT", "::", "f64", ":" ]

[ "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f32", ":" ]

[ "RV_REGNUM", ")", ";" ]

[ "return", "gen_rtx_REG", "(", "mode", "," ]

[ ")", ";" ]

[ "void", "aarch64_simd_lane_bounds", "(", "rtx", "operand", ",", "HOST_WIDE_INT", "low", ",", "HOST_WIDE_INT", "high", ",", "const_tree", "exp", ")", "{", "HOST_WIDE_INT", "lane", ";", "gcc_assert", "(", "CONST_INT_P", "(", "operand", ")" ]

[ "return", "(", "value", ">=", "low", "&&", "value", "<=", "high", ")", ";" ]

[ "if", "(", "!", "CONST_INT_P", "(", "elem0", ")", ")", "return", "false", ";", "value", "=", "INTVAL", "(", "elem0", ")", ";" ]

[ "=", "flags", ";" ]

[ "const", "char", "*", "symname", ";", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "!", "MEM_P", "(", "rtl", ")", ")", "return", ";", "symbol", "=", "XEXP", "(", "rtl", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "!=", "SYMBOL_REF", ")", "return", ";", "flags", "=", "SYMBOL_REF_FLAGS", "(", "symbol", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "DECL_THREAD_LOCAL_P", "(", "decl", ")", ")", "flags", "&=", "~", "SYMBOL_FLAG_HAS_BLOCK_INFO", ";", "SYMBOL_REF_FLAGS", "(", "symbol", ")" ]

[ "return", "TLSOffset", ";" ]

[ "char", "*", "X86JITInfo", "::", "allocateThreadLocalMemory", "(", "size_t", "size", ")", "{", "TLSOffset", "-=", "size", ";" ]

[ "dst", ",", "GR64", ":", "$", "src", ")", ",", "<NUM_LIT>", ">", ";" ]

[ "def", ":", "InstAlias", "<", "<STR_LIT>", ",", "(", "MOV64toPQIrr", "VR128", ":", "$" ]

[ "R2", ";" ]

[ "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "V1", ";", "bits", "<", "<NUM_LIT>", ">", "R2", ";", "bits", "<", "<NUM_LIT>", ">", "R3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "class", "MVE_VSHLL_imm", "<", "string", "iname", ",", "string", "suffix", ",", "bit", "U", ",", "bit", "th", ",", "Operand", "immtype", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "MVE_shift_imm", "<", "(", "outs", "MQPR", ":", "$", "Qd", ")", ",", "(", "ins", "MQPR", ":", "$", "Qm", ",", "immtype", ":", "$", "imm", ")", ",", "iname", ",", "suffix", ",", "<STR_LIT>", ",", "vpred_r", ",", "<STR_LIT>", ",", "pattern", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";" ]

[ "Bits", ")", ";" ]

[ "uint32_t", "Lower6", "=", "static_cast", "<", "uint32_t", ">", "(", "Value", ">>", "Alignment", ")", "&", "<NUM_LIT>", ";", "int64_t", "Bits", ";", "bool", "Success", "=", "Extender", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getExpr", "(", ")", "->", "evaluateAsAbsolute", "(", "Bits", ")", ";", "assert", "(", "Success", ")", ";", "(", "void", ")", "Success", ";", "uint32_t", "Upper26", "=", "static_cast", "<", "uint32_t", ">", "(" ]

[ "::", "AFL_REG_32", ";" ]

[ "if", "(", "FpABI", "==", "FpABIKind", "::", "XX", ")", "return", "(", "uint8_t", ")", "Mips" ]

[ "const", "int", "_", "_", "b", ")", "{" ]

[ "vqshluq_n_s64", "(", "int64x2_t", "_", "_", "a", "," ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qs4", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Vv32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Vv32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Qs4", ";" ]

[ "<FIXS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", "<FIXE>" ]

[ "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", "<BUGE>", ")", "(", "define_insn", "<STR_LIT>" ]

[ "let", "Uses", "=", "[", "USR", "]", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isFP", "=", "<NUM_LIT>", ";" ]

[ "static", "bool", "mep_get_intrinsic_insn", "(", "int", "intrinsic", "ATTRIBUTE_UNUSED", ",", "const", "struct", "cgen_insn", "*", "*", "insn_ptr", "ATTRIBUTE_UNUSED", ")", "{", "int", "i", ";", "i", "=", "mep_intrinsic_insn", "[", "intrinsic", "]", ";", "while", "(", "i", ">=", "<NUM_LIT>", "&&", "!", "CGEN_ENABLE_INSN_P", "(", "i", ")", ")", "i", "=", "mep_intrinsic_chain", "[", "i", "]", ";", "if", "(", "i", ">=", "<NUM_LIT>", ")", "{", "*", "insn_ptr", "=", "&", "cgen_insns", "[", "i", "]", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "See", "if", "any", "implementation", "of", "INTRINSIC", "is", "available", "to", "the", "current", "function", ".", "If", "so", ",", "store", "the", "most", "general", "implementation", "in", "*", "INSN_PTR", "and", "return", "true", ".", "Return", "false", "otherwise", "." ]

[ ")", "{" ]

[ "SystemZElimCompare", "(", ")", ":", "MachineFunctionPass", "(", "ID" ]

[ "(", "N", ",", "Ty", ",", "DAG", ")", ";" ]

[ "EVT", "Ty", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", "&&", "!", "Subtarget", ".", "isABI_N64", "(", ")", ")", "return", "getAddrNonPIC" ]

[ "static", "tree", "ia64_gimplify_va_arg", "(", "tree", "valist", ",", "tree", "type", ",", "gimple_seq", "*", "pre_p", ",", "gimple_seq", "*", "post_p", ")", "{", "if", "(", "pass_va_arg_by_reference", "(", "type", ")", ")", "{", "tree", "ptrtype", "=", "build_pointer_type", "(", "type", ")", ";", "tree", "addr", "=", "std_gimplify_va_arg_expr", "(", "valist", ",", "ptrtype", ",", "pre_p", ",", "post_p", ")", ";", "return", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}", "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "INTEGER_TYPE", ")", "?", "int_size_in_bytes", "(", "type", ")", ">", "<NUM_LIT>", ":", "TYPE_ALIGN", "(", "type", ")", ">", "<NUM_LIT>", "*", "BITS_PER_UNIT", ")", "{", "tree", "t", "=", "fold_build_pointer_plus_hwi", "(", "valist", ",", "<NUM_LIT>", "*", "UNITS_PER_WORD", "-", "<NUM_LIT>", ")", ";", "t", "=", "build2", "(", "BIT_AND_EXPR", ",", "TREE_TYPE", "(", "t", ")", ",", "t", ",", "build_int_cst", "(", "TREE_TYPE", "(", "t", ")", ",", "-", "<NUM_LIT>", "*", "UNITS_PER_WORD", ")", ")", ";", "gimplify_assign", "(", "unshare_expr", "(", "valist", ")", ",", "t", ",", "pre_p", ")", ";", "}", "return", "std_gimplify_va_arg_expr", "(", "valist", ",", "type", ",", "pre_p", ",", "post_p", ")", ";", "}" ]

[ "Implement", "va_arg", "." ]

[ "<FIXS>", "(", "v8i64", "immAllZerosV", ")", ",", "<FIXE>" ]

[ "def", ":", "Pat", "(", "v8i64", "(", "vselect", "(", "xor", "VK8", ":", "$", "mask", ",", "(", "v8i1", "immAllOnesV", ")", ")", ",", "<BUGS>", "(", "bc_v8i64", "(", "v16i32", "immAllZerosV", ")", ")", ",", "<BUGE>", "(", "v8i64", "VR512", ":", "$", "src", ")", ")", ")", ",", "(", "VMOVDQA64Zrrkz", "VK8", ":", "$", "mask", ",", "VR512", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "v16i32", "(", "vselect", "(", "xor", "VK16", ":", "$", "mask", ",", "(", "v16i1", "immAllOnesV", ")", ")", "," ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "bit_28", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "bit_12", ";" ]

[ ")", ";" ]

[ "MCSymbol", "*", "DLXMCInstLower", "::", "GetBlockAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "return", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")" ]

[ "}" ]

[ "}", "case", "ISD", "::", "LOAD", ":", "if", "(", "tryIndexedLoad", "(", "Node", ")", ")", "return", ";", "break", ";", "case", "ISD", "::", "ADD", ":", "if", "(", "tryIndexedBinOp", "(", "Node", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", ";", "else", "if", "(", "tryIndexedBinOp", "(", "Node", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", ";", "break", ";", "case", "ISD", "::", "SUB", ":", "if", "(", "tryIndexedBinOp", "(", "Node", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", ";", "break", ";", "case", "ISD", "::", "AND", ":", "if", "(", "tryIndexedBinOp", "(", "Node", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", ";", "else", "if", "(", "tryIndexedBinOp", "(", "Node", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", ";", "break", ";", "case", "ISD", "::", "OR", ":", "if", "(", "tryIndexedBinOp", "(", "Node", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", ";", "else", "if", "(", "tryIndexedBinOp", "(", "Node", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", ";", "break", ";", "case", "ISD", "::", "XOR", ":", "if", "(", "tryIndexedBinOp", "(", "Node", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", ";", "else", "if", "(", "tryIndexedBinOp", "(", "Node", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", ";", "break", ";", "}", "SelectCode", "(", "Node", ")", ";" ]

[ "}" ]

[ "if", "(", "crtl", "-", ">", "args", ".", "pops_args", ")", "{", "rtx", "popc", "=", "GEN_INT", "(", "crtl", "-", ">", "args", ".", "pops_args", ")", "emit_jump_insn", "(", "gen_simple_return_pop_internal", "(", "popc", ")", ")", "DONE" ]

[ "<FIXS>", "{", "ISD", "::", "SADDSAT", ",", "MVT", "::", "v2i64", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "ISD", "::", "SADDSAT", ",", "MVT", "::", "v4i32", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "ISD", "::", "SADDSAT", ",", "MVT", "::", "v8i16", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "ISD", "::", "SADDSAT", ",", "MVT", "::", "v16i8", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "<FIXE>" ]

[ "{", "ISD", "::", "CTTZ", ",", "MVT", "::", "v4i32", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "ISD", "::", "CTTZ", ",", "MVT", "::", "v8i16", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "ISD", "::", "CTTZ", ",", "MVT", "::", "v16i8", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "<BUGS>", "{", "ISD", "::", "SADDSAT", ",", "MVT", "::", "v8i16", ",", "{", "<NUM_LIT>", "}", "}", ",", "{", "ISD", "::", "SADDSAT", ",", "MVT", "::", "v16i8", ",", "{", "<NUM_LIT>", "}", "}", ",", "<BUGE>", "{", "ISD", "::", "SMAX", ",", "MVT", "::", "v2i64", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "ISD", "::", "SMAX", ",", "MVT", "::", "v4i32", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ",", "{", "ISD", "::", "SMAX", ",", "MVT", "::", "v8i16", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", "," ]

[ "}" ]

[ "static", "std", "::", "string", "getAutosSectionName", "(", "const", "std", "::", "string", "&", "Func", ")", "{", "std", "::", "string", "Func1", "=", "addPrefix", "(", "Func", ")", ";", "std", "::", "string", "tag", "=", "getTagName", "(", "AUTOS_SECTION", ")", ";", "return", "Func1", "+", "tag", "+", "<STR_LIT>", "# UDATA_OVR", "<STR_LIT>", ";" ]

[ "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "GP", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "(", ")", "const", "{" ]

[ "const", "MCExpr", "*", "getImm" ]

[ "AArch64 Conditional Compares", "<STR_LIT>", ";" ]

[ "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>" ]

[ "static", "void", "rs6000_darwin_file_start", "(", "void", ")", "{", "static", "const", "struct", "{", "const", "char", "*", "arg", ";", "const", "char", "*", "name", ";", "HOST_WIDE_INT", "if_set", ";", "}", "mapping", "[", "]", "=", "{", "{", "<STR_LIT>", "ppc64", "<STR_LIT>", ",", "<STR_LIT>", "ppc64", "<STR_LIT>", ",", "MASK_64BIT", "}", ",", "{", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "ppc970", "<STR_LIT>", ",", "OPTION_MASK_PPC_GPOPT", "|", "OPTION_MASK_MFCRF", "\\", "|", "MASK_POWERPC64", "}", ",", "{", "<STR_LIT>", "power4", "<STR_LIT>", ",", "<STR_LIT>", "ppc970", "<STR_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "G5", "<STR_LIT>", ",", "<STR_LIT>", "ppc970", "<STR_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "ppc7450", "<STR_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "ppc7400", "<STR_LIT>", ",", "OPTION_MASK_ALTIVEC", "}", ",", "{", "<STR_LIT>", "G4", "<STR_LIT>", ",", "<STR_LIT>", "ppc7400", "<STR_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "ppc750", "<STR_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "ppc750", "<STR_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "G3", "<STR_LIT>", ",", "<STR_LIT>", "ppc750", "<STR_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "ppc604e", "<STR_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "ppc604", "<STR_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "ppc603", "<STR_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "ppc603", "<STR_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "ppc601", "<STR_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "NULL", ",", "<STR_LIT>", "ppc", "<STR_LIT>", ",", "<NUM_LIT>", "}", "}", ";", "const", "char", "*", "cpu_id", "=", "<STR_LIT>", "<STR_LIT>", ";", "size_t", "i", ";", "rs6000_file_start", "(", ")", ";", "darwin_file_start", "(", ")", ";", "if", "(", "rs6000_default_cpu", "!=", "<NUM_LIT>", "&&", "rs6000_default_cpu", "[", "<NUM_LIT>", "]", "!=", "'", "\\0", "'", ")", "cpu_id", "=", "rs6000_default_cpu", ";", "if", "(", "OPTION_SET_P", "(", "rs6000_cpu_index", ")", ")", "cpu_id", "=", "processor_target_table", "[", "rs6000_cpu_index", "]", ".", "name", ";", "i", "=", "<NUM_LIT>", ";", "while", "(", "mapping", "[", "i", "]", ".", "arg", "!=", "NULL", "&&", "strcmp", "(", "mapping", "[", "i", "]", ".", "arg", ",", "cpu_id", ")", "!=", "<NUM_LIT>", "&&", "(", "mapping", "[", "i", "]", ".", "if_set", "&", "rs6000_isa_flags", ")", "==", "<NUM_LIT>", ")", "i", "++", ";", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\t.machine %s\\n", "<STR_LIT>", ",", "mapping", "[", "i", "]", ".", "name", ")", ";", "}" ]

[ "Output", "a", ".machine", "directive", "for", "the", "Darwin", "assembler", ",", "and", "call", "the", "generic", "start_file", "routine", "." ]

[ ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ "if", "(", "Mips", "::", "CPU16RegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "Mips", "::", "SwRxSpImmX16", ";", "assert", "(", "Opc", "&&", "<STR_LIT>", "Register class not handled!", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "Offset", ")" ]

[ "}", "]", ",", "trailingZeros_xform", ">", ";" ]

[ "int64_t", "value", "=", "N", "-", ">", "getSExtValue", "(", ")", ";", "return", "value", "%", "<NUM_LIT>", "=", "=", "<NUM_LIT>", "&", "&", "isInt", "<", "<NUM_LIT>", ">", "(", "value", ")", ";", "}", "]", ">", ";", "def", "imm18m4", ":", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "int64_t", "value", "=", "N", "-", ">", "getSExtValue", "(", ")", ";", "return", "value", "%", "<NUM_LIT>", "=", "=", "<NUM_LIT>", "&", "&", "isInt", "<", "<NUM_LIT>", ">", "(", "value", ")", ";", "}", "]", ">", ";", "def", "uimm5mask", ":", "Operand", "<", "i32", ">", ",", "PatLeaf", "<", "(", "imm", ")", ",", "[", "{", "return", "isPowerOf2_32", "(", "N", "-", ">", "getZExtValue", "(", ")", ")", ";" ]

[ "<FIXS>", "hp", "=", "gen_reg_rtx", "(", "V4DImode", ")", ";", "<FIXE>", "<FIXS>", "emit_insn", "(", "gen_avx2_permv4di_1", "(", "hp", ",", "op", ",", "const2_rtx", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "const0_rtx", ",", "<FIXE>" ]

[ "emit_insn", "(", "gen_avx2_pshufbv32qi3", "(", "h", ",", "op", ",", "vperm", ")", ")", ";", "<BUGS>", "hp", "=", "gen_reg_rtx", "(", "V32QImode", ")", ";", "<BUGE>", "op", "=", "gen_lowpart", "(", "V4DImode", ",", "h", ")", ";", "<BUGS>", "emit_insn", "(", "gen_avx2_permv4di_1", "(", "gen_lowpart", "(", "V4DImode", ",", "hp", ")", ",", "op", ",", "const2_rtx", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "const0_rtx", ",", "<BUGE>", "const1_rtx", ")", ")", ";", "vperm", "=", "gen_rtx_CONST_VECTOR", "(", "V32QImode", ",", "gen_rtvec_v", "(", "<NUM_LIT>", ",", "rperm", "[", "<NUM_LIT>", "]", ")", ")", ";" ]

[ "dl", ",", "MVT", "::", "f64", ",", "Int64Tmp", ")", ";" ]

[ "}", "SDValue", "FloatTmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "floatVT", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "IntToFloatOpcode", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "FloatTmp", ")", ";", "}", "if", "(", "OpVT", "==", "MVT", "::", "i32", "&&", "Subtarget", "->", "is64Bit", "(", ")", ")", "{", "SDValue", "Int64Tmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i64", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Float64Tmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", "," ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "zero_extend", ":", "SI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "UNSPEC_REAL_MULT", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "case", "AMDGPU", "::", "BUFFER_LOAD_SBYTE_D16_HI_OFFEN", ":" ]

[ "case", "AMDGPU", "::", "BUFFER_LOAD_DWORDX2_OFFEN", ":", "return", "AMDGPU", "::", "BUFFER_LOAD_DWORDX2_OFFSET", ";", "case", "AMDGPU", "::", "BUFFER_LOAD_DWORDX3_OFFEN", ":", "return", "AMDGPU", "::", "BUFFER_LOAD_DWORDX3_OFFSET", ";", "case", "AMDGPU", "::", "BUFFER_LOAD_DWORDX4_OFFEN", ":", "return", "AMDGPU", "::", "BUFFER_LOAD_DWORDX4_OFFSET", ";", "case", "AMDGPU", "::", "BUFFER_LOAD_UBYTE_D16_OFFEN", ":", "return", "AMDGPU", "::", "BUFFER_LOAD_UBYTE_D16_OFFSET", ";", "case", "AMDGPU", "::", "BUFFER_LOAD_UBYTE_D16_HI_OFFEN", ":", "return", "AMDGPU", "::", "BUFFER_LOAD_UBYTE_D16_HI_OFFSET", ";", "case", "AMDGPU", "::", "BUFFER_LOAD_SBYTE_D16_OFFEN", ":", "return", "AMDGPU", "::", "BUFFER_LOAD_SBYTE_D16_OFFSET", ";" ]

[ ",", "[", "]", ">", ";" ]

[ "def", "ORAdpindiriy", ":", "Group1", "<", "OpGrp1ORA", ",", "AddrModeGrp1DPIndirIdxY", ",", "(", "outs", "AccRegs", ":", "$", "dst", ")", ",", "(", "ins", "AccRegs", ":", "$", "src1", ",", "MEMdp", ":", "$", "src2", ",", "IndexYRegs", ":", "$", "src3", ")", ",", "<STR_LIT>" ]

[ "MatchResult", ")", "{" ]

[ "bool", "MipsAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "MCInst", "Inst", ";", "unsigned", "Kind", ";", "unsigned", "ErrorInfo", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "std", "::", "string", ">", ",", "<NUM_LIT>", ">", "MapAndConstraints", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Kind", ",", "Inst", ",", "MapAndConstraints", ",", "ErrorInfo", ",", "false", ")", ";", "switch", "(" ]

[ "PM", ")", "{" ]

[ "TargetPassConfig", "*", "OR1KTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&" ]

[ "}" ]

[ "tree", "endlink", "=", "void_list_node", ";", "lang_hooks", ".", "builtin_function", "(", "<STR_LIT>", "fast_ftoi", "<STR_LIT>", ",", "build_function_type", "(", "integer_type_node", ",", "tree_cons", "(", "NULL_TREE", ",", "double_type_node", ",", "endlink", ")", ")", ",", "C4X_BUILTIN_FIX", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "lang_hooks", ".", "builtin_function", "(", "<STR_LIT>", "ansi_ftoi", "<STR_LIT>", ",", "build_function_type", "(", "integer_type_node", ",", "tree_cons", "(", "NULL_TREE", ",", "double_type_node", ",", "endlink", ")", ")", ",", "C4X_BUILTIN_FIX_ANSI", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "if", "(", "TARGET_C3X", ")", "lang_hooks", ".", "builtin_function", "(", "<STR_LIT>", "fast_imult", "<STR_LIT>", ",", "build_function_type", "(", "integer_type_node", ",", "tree_cons", "(", "NULL_TREE", ",", "integer_type_node", ",", "tree_cons", "(", "NULL_TREE", ",", "integer_type_node", ",", "endlink", ")", ")", ")", ",", "C4X_BUILTIN_MPYI", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "else", "{", "lang_hooks", ".", "builtin_function", "(", "<STR_LIT>", "toieee", "<STR_LIT>", ",", "build_function_type", "(", "double_type_node", ",", "tree_cons", "(", "NULL_TREE", ",", "double_type_node", ",", "endlink", ")", ")", ",", "C4X_BUILTIN_TOIEEE", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "lang_hooks", ".", "builtin_function", "(", "<STR_LIT>", "frieee", "<STR_LIT>", ",", "build_function_type", "(", "double_type_node", ",", "tree_cons", "(", "NULL_TREE", ",", "double_type_node", ",", "endlink", ")", ")", ",", "C4X_BUILTIN_FRIEEE", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "lang_hooks", ".", "builtin_function", "(", "<STR_LIT>", "fast_invf", "<STR_LIT>", ",", "build_function_type", "(", "double_type_node", ",", "tree_cons", "(", "NULL_TREE", ",", "double_type_node", ",", "endlink", ")", ")", ",", "C4X_BUILTIN_RCPF", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";" ]

[ "<FIXS>", "bool", "StreamingCompatibleSVEMode", "=", "false", ",", "bool", "HasMinSize", "=", "false", ")", ";", "<FIXE>" ]

[ "unsigned", "MinSVEVectorSizeInBitsOverride", "=", "<NUM_LIT>", ",", "unsigned", "MaxSVEVectorSizeInBitsOverride", "=", "<NUM_LIT>", ",", "bool", "StreamingSVEMode", "=", "false", ",", "<BUGS>", "bool", "StreamingCompatibleSVEMode", "=", "false", ")", ";", "<BUGE>", "#", "define", "GET_SUBTARGETINFO_MACRO", "(", "ATTRIBUTE", ",", "DEFAULT", ",", "GETTER", ")", "\\" ]

[ "FPR32", ">", ";" ]

[ "def", "LDRSpre_isel", ":", "LoadPreIdxPseudo", "<" ]

[ "<FIXS>", "if", "(", "!", "REG_P", "(", "SET_SRC", "(", "set", ")", ")", "||", "!", "fixed_reg_p", "(", "REGNO", "(", "SET_SRC", "(", "set", ")", ")", ")", ")", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "<NUM_LIT>", ";", "<FIXE>" ]

[ "{", "rtx", "set", "=", "XVECEXP", "(", "real", ",", "<NUM_LIT>", ",", "i", ")", ";", "<BUGS>", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "<NUM_LIT>", ";", "<BUGE>", "}", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "return", "insn", ";" ]

[ "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]