Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "def", "A4_vcmphgti", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "s8_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_643b4717", ",", "TypeALU64", ">", ",", "Enc_0d8adb", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}" ]

[ "rtx", "ix86_build_const_vector", "(", "machine_mode", "mode", ",", "bool", "vect", ",", "rtx", "value", ")", "{", "int", "i", ",", "n_elt", ";", "rtvec", "v", ";", "machine_mode", "scalar_mode", ";", "switch", "(", "mode", ")", "{", "case", "E_V64QImode", ":", "case", "E_V32QImode", ":", "case", "E_V16QImode", ":", "case", "E_V32HImode", ":", "case", "E_V16HImode", ":", "case", "E_V8HImode", ":", "case", "E_V16SImode", ":", "case", "E_V8SImode", ":", "case", "E_V4SImode", ":", "case", "E_V8DImode", ":", "case", "E_V4DImode", ":", "case", "E_V2DImode", ":", "gcc_assert", "(", "vect", ")", ";", "case", "E_V16SFmode", ":", "case", "E_V8SFmode", ":", "case", "E_V4SFmode", ":", "case", "E_V2SFmode", ":", "case", "E_V8DFmode", ":", "case", "E_V4DFmode", ":", "case", "E_V2DFmode", ":", "n_elt", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "v", "=", "rtvec_alloc", "(", "n_elt", ")", ";", "scalar_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "RTVEC_ELT", "(", "v", ",", "<NUM_LIT>", ")", "=", "value", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "n_elt", ";", "++", "i", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "vect", "?", "value", ":", "CONST0_RTX", "(", "scalar_mode", ")", ";", "return", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "v", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}" ]

[ "A", "subroutine", "of", "ix86_build_signbit_mask", ".", "If", "VECT", "is", "true", ",", "then", "replicate", "the", "value", "for", "all", "elements", "of", "the", "vector", "register", "." ]

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

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

[ "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "rotate", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "formatted_raw_ostream", "&", ",", "MCInstPrinter", "*", ",", "bool", ")", "{" ]

[ "static", "MCTargetStreamer", "*", "createTargetAsmStreamer", "(", "MCStreamer", "&", "S", "," ]

[ "static", "int", "rs6000_emit_p9_fp_cmove", "(", "rtx", "dest", ",", "rtx", "op", ",", "rtx", "true_cond", ",", "rtx", "false_cond", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "rtx", "op0", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "machine_mode", "result_mode", "=", "GET_MODE", "(", "dest", ")", ";", "rtx", "compare_rtx", ";", "rtx", "cmove_rtx", ";", "rtx", "clobber_rtx", ";", "if", "(", "!", "can_create_pseudo_p", "(", ")", ")", "return", "<NUM_LIT>", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "GE", ":", "case", "GT", ":", "break", ";", "case", "NE", ":", "case", "LT", ":", "case", "LE", ":", "code", "=", "swap_condition", "(", "code", ")", ";", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "break", ";", "default", ":", "return", "<NUM_LIT>", ";", "}", "compare_rtx", "=", "gen_rtx_fmt_ee", "(", "code", ",", "CCFPmode", ",", "op0", ",", "op1", ")", ";", "cmove_rtx", "=", "gen_rtx_SET", "(", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "result_mode", ",", "compare_rtx", ",", "true_cond", ",", "false_cond", ")", ")", ";", "clobber_rtx", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "V2DImode", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "cmove_rtx", ",", "clobber_rtx", ")", ")", ")", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "ISA", "3.0", "(", "power9", ")", "conditional", "move", "subcase", "to", "emit", "XSCMP", "{", "EQ", ",", "GE", ",", "GT", ",", "NE", "}", "DP", "and", "XXSEL", "instructions", "for", "SF/DF", "scalars", ".", "Move", "TRUE_COND", "to", "DEST", "if", "OP", "of", "the", "operands", "of", "the", "last", "comparison", "is", "nonzero/true", ",", "FALSE_COND", "if", "it", "is", "zero/false", ".", "Return", "0", "if", "the", "hardware", "has", "no", "such", "operation", "." ]

[ "<STR_LIT>", ")" ]

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

[ "<<", "<STR_LIT>", " operand\\n", "<STR_LIT>", ")", ";" ]

[ "if", "(", "SrcRC", "!=", "DstRC", ")", "{", "Register", "ExtSrc", "=", "MRI", ".", "createVirtualRegister", "(", "DstRC", ")", ";", "BuildMI", "(", "*", "I", ".", "getParent", "(", ")", ",", "I", ",", "I", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "SUBREG_TO_REG", ")", ")", ".", "addDef", "(", "ExtSrc", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "getSubRegIndex", "(", "SrcRC", ")", ")", ";", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "ExtSrc", ")", ";", "}", "}", "return", "true", ";", "}", "assert", "(", "(", "!", "Register", "::", "isPhysicalRegister", "(", "SrcReg", ")", "||", "I", ".", "isCopy", "(", ")", ")", "&&", "<STR_LIT>", "No phys reg on generic operators", "<STR_LIT>", ")", ";", "assert", "(", "(", "DstSize", "==", "SrcSize", "||", "(", "Register", "::", "isPhysicalRegister", "(", "SrcReg", ")", "&&", "DstSize", "<=", "RBI", ".", "getSizeInBits", "(", "SrcReg", ",", "MRI", ",", "TRI", ")", ")", ")", "&&", "<STR_LIT>", "Copy with different width?!", "<STR_LIT>", ")", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "getRegClass", "(", "MRI", ".", "getType", "(", "DstReg", ")", ",", "DstRegBank", ")", ";", "if", "(", "SrcRegBank", ".", "getID", "(", ")", "==", "X86", "::", "GPRRegBankID", "&&", "DstRegBank", ".", "getID", "(", ")", "==", "X86", "::", "GPRRegBankID", "&&", "SrcSize", ">", "DstSize", "&&", "Register", "::", "isPhysicalRegister", "(", "SrcReg", ")", ")", "{", "const", "TargetRegisterClass", "*", "SrcRC", "=", "getRegClassFromGRPhysReg", "(", "SrcReg", ")", ";", "if", "(", "DstRC", "!=", "SrcRC", ")", "{", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "setSubReg", "(", "getSubRegIndex", "(", "DstRC", ")", ")", ";", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "substPhysReg", "(", "SrcReg", ",", "TRI", ")", ";", "}", "}", "const", "TargetRegisterClass", "*", "OldRC", "=", "MRI", ".", "getRegClassOrNull", "(", "DstReg", ")", ";", "if", "(", "!", "OldRC", "||", "!", "DstRC", "->", "hasSubClassEq", "(", "OldRC", ")", ")", "{", "if", "(", "!", "RBI", ".", "constrainGenericRegister", "(", "DstReg", ",", "*", "DstRC", ",", "MRI", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Failed to constrain ", "<STR_LIT>", "<<", "TII", ".", "getName", "(", "I", ".", "getOpcode", "(", ")", ")" ]

[ ";" ]

[ "Op", "->", "Tok", ".", "Data", "=", "Str", ".", "data", "(", ")", ";", "Op", "->", "Tok", ".", "Length", "=", "Str", ".", "size", "(", ")", ";", "Op", "->", "StartLoc", "=", "Start", ";", "Op", "->", "EndLoc", "=", "Start", ";", "return", "Op" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "type", "rv", "=", "arch_atomic_", "#", "#", "opname", "(", "p", ",", "i", ")", ";", "\\", "<FIXE>" ]

[ "#", "define", "_", "_", "unused", "_", "_", "attribute__", "(", "(", "unused", ")", ")", "<BUGS>", "#", "define", "atomic_xor", "(", "mem", ",", "mask", ")", "_", "_", "atomic_update_cmpxchg", "(", "mem", ",", "mask", ",", "_", "_", "old", "^", "_", "_", "value", ")", "#", "define", "atomic_nand", "(", "mem", ",", "mask", ")", "_", "_", "atomic_update_cmpxchg", "(", "mem", ",", "mask", ",", "~", "(", "_", "_", "old", "&", "_", "_", "value", ")", ")", "<BUGE>", "#", "define", "_", "_", "atomic_fetch_and_do", "(", "type", ",", "size", ",", "opname", ")", "\\", "type", "\\", "_", "_", "atomic_fetch_", "#", "opname", "#", "_", "#", "size", "(", "type", "*", "p", ",", "type", "i", ",", "int", "model", ")", "\\", "{", "\\", "pre_atomic_barrier", "(", "model", ")", ";", "\\", "<BUGS>", "type", "rv", "=", "atomic_", "#", "opname", "(", "p", ",", "i", ")", ";", "\\", "<BUGE>", "post_atomic_barrier", "(", "model", ")", ";", "\\", "return", "rv", ";", "\\", "}" ]

[ "_", "_", "mmask16", ")", "-", "<NUM_LIT>", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "return", "(", "_", "_", "m512", ")", "_", "_", "builtin_ia32_getexpps512_mask", "(", "(", "_", "_", "v16sf", ")", "_", "_", "A", ",", "(", "_", "_", "v16sf", ")", "_", "mm512_undefined_ps", "(", ")", ",", "(" ]

[ "return", "false", ";" ]

[ "static", "bool", "expandAdjDynAlloc", "(", "SystemZAddressingMode", "&", "AM", ",", "bool", "IsBase", ",", "SDValue", "Value", ")", "{", "if", "(", "AM", ".", "isDynAlloc", "(", ")", "&&", "!", "AM", ".", "IncludesDynAlloc", ")", "{", "changeComponent", "(", "AM", ",", "IsBase", ",", "Value", ")", ";", "AM", ".", "IncludesDynAlloc", "=", "true", ";", "return", "true", ";", "}" ]

[ ":", "$", "Rn", ")", ",", "(", "extract_high_v16i8", "V128", ":", "$", "Rm", ")", ")", ")", ")", ")", ")", "]", ">", ";" ]

[ "def", "v16i8_v8i16", ":", "BaseSIMDDifferentThreeVectorTied", "<", "U", ",", "<NUM_LIT>", ",", "opc", ",", "V128", ",", "V128", ",", "V128", ",", "asm", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v8i16", "V128", ":", "$", "dst", ")", ",", "(", "add", "(", "v8i16", "V128", ":", "$", "Rd", ")", ",", "(", "zext", "(", "v8i8", "(", "OpNode", "(", "extract_high_v16i8", "V128" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "CC", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "compare", ":", "CC", "(", "sign_extend", ":", "EXTHI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "EXTHI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "if", "(", "JUMP_P", "(", "body", ")", ")", "{", "output_asm_insn", "(", "TARGET_DENSITY", "?", "<STR_LIT>", "nop.n", "<STR_LIT>", ":", "<STR_LIT>", "nop", "<STR_LIT>", ",", "operands", ")", ";", "done", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "(", "GET_CODE", "(", "body", ")", "!=", "USE", ")", "&&", "(", "GET_CODE", "(", "body", ")", "!=", "CLOBBER", ")", ")", "done", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "bool", "AMDGPURegBankSelect", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Assign register banks for: ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "Mode", "SaveOptMode", "=", "OptMode", ";", "if", "(", "F", ".", "hasOptNone", "(", ")", ")", "OptMode", "=", "Mode", "::", "Fast", ";", "init", "(", "MF", ")", ";", "assert", "(", "checkFunctionIsLegal", "(", "MF", ")", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "MachineCycleInfo", "&", "CycleInfo", "=", "getAnalysis", "<", "MachineCycleInfoWrapperPass", ">", "(", ")", ".", "getCycleInfo", "(", ")", ";", "MachineDominatorTree", "&", "DomTree", "=", "getAnalysis", "<", "MachineDominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "MachineUniformityInfo", "Uniformity", "=", "computeMachineUniformityInfo", "(", "MF", ",", "CycleInfo", ",", "DomTree", ".", "getBase", "(", ")", ",", "!", "ST", ".", "isSingleLaneExecution", "(", "F", ")", ")", ";", "(", "void", ")", "Uniformity", ";", "assignRegisterBanks", "(", "MF", ")", ";", "OptMode", "=", "SaveOptMode", ";", "return", "false", ";" ]

[ ";" ]

[ "def", "az_extloadi16_glue", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "ptr", ")", ",", "(", "az_extload_glue", "node", ":", "$", "ptr", ")", ",", "[", "{", "return", "cast", "<", "LoadSDNode", ">", "(", "N", ")", "-", ">", "getMemoryVT", "(", ")", "=", "=", "MVT", ":", ":", "i16", ";", "}", "]", ">", ";", "def", "sextloadi8_glue", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "ptr", ")", ",", "(", "sextload_glue", "node", ":", "$", "ptr", ")", ",", "[", "{", "return", "cast", "<", "LoadSDNode", ">", "(", "N", ")", "-", ">", "getMemoryVT", "(", ")", "=", "=", "MVT", ":", ":", "i8", ";", "}", "]", ">", ";", "def", "sextloadi16_glue", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "ptr", ")", ",", "(", "sextload_glue", "node", ":", "$", "ptr", ")", ",", "[", "{", "return", "cast", "<", "LoadSDNode", ">", "(", "N", ")", "-", ">", "getMemoryVT", "(", ")", "=", "=", "MVT", ":", ":", "i16", ";", "}", "]", ">" ]

[ "_", "_", "a", ";" ]

[ "vreinterpret_s16_s64", "(", "int64x1_t", "_", "_", "a", ")", "{", "return", "(", "int16x4_t", ")" ]

[ "m32r_punct_chars", "[", "'", "@", "'", "]", "=", "<NUM_LIT>", ";" ]

[ "memset", "(", "m32r_punct_chars", ",", "<NUM_LIT>", ",", "sizeof", "(", "m32r_punct_chars", ")", ")", ";", "m32r_punct_chars", "[", "'", "#", "'", "]", "=", "<NUM_LIT>", ";" ]

[ "target", ")", ";" ]

[ "case", "NIOS2_BUILTIN_wrctl", ":", "return", "nios2_expand_rdwrctl_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "case", "NIOS2_BUILTIN_rdprs", ":", "return", "nios2_expand_rdprs_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "case", "NIOS2_BUILTIN_flushd", ":", "case", "NIOS2_BUILTIN_flushda", ":", "return", "nios2_expand_cache_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "case", "NIOS2_BUILTIN_wrpie", ":", "return", "nios2_expand_wrpie_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "case", "NIOS2_BUILTIN_eni", ":", "return", "nios2_expand_eni_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "fcode", "<", "nios2_custom_builtin_base", ")", "return", "nios2_expand_fpu_builtin", "(", "exp", ",", "fcode", "-", "nios2_fpu_builtin_base", "," ]

[ "let", "MIOperandInfo", "=", "(", "ops", "GPR64sp", ":", "$", "base", ")", ";" ]

[ "def", "MemoryNoIndexOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "am_noindex", ":", "Operand", "<", "i64", ">", ",", "ComplexPattern", "<", "i64", ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "MemoryNoIndexOperand", ";" ]

[ "return", "MatchOperand_Success", ";" ]

[ "StringRef", "Kind", ";", "OperandMatchResultTy", "Res", "=", "tryParseVectorRegister", "(", "RegNum", ",", "Kind", ",", "RegKind", "::", "SVEDataVector", ")", ";", "if", "(", "Res", "!=", "MatchOperand_Success", ")", "return", "Res", ";", "if", "(", "ParseSuffix", "&&", "Kind", ".", "empty", "(", ")", ")", "return", "MatchOperand_NoMatch", ";", "const", "auto", "&", "KindRes", "=", "parseVectorKind", "(", "Kind", ",", "RegKind", "::", "SVEDataVector", ")", ";", "if", "(", "!", "KindRes", ")", "return", "MatchOperand_NoMatch", ";", "unsigned", "ElementWidth", "=", "KindRes", "->", "second", ";", "if", "(", "!", "ParseShiftExtend", "||", "getParser", "(", ")", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Operands", ".", "push_back", "(", "AArch64Operand", "::", "CreateVectorReg", "(", "RegNum", ",", "RegKind", "::", "SVEDataVector", ",", "ElementWidth", ",", "S", ",", "S", ",", "getContext", "(", ")", ")", ")", ";", "OperandMatchResultTy", "Res", "=", "tryParseVectorIndex", "(", "Operands", ")", ";", "if", "(", "Res", "==", "MatchOperand_ParseFail", ")", "return", "MatchOperand_ParseFail", ";" ]

[ "}" ]

[ "applyMnemonicAliases", "(", "Name", ",", "getAvailableFeatures", "(", ")", ",", "<NUM_LIT>", ")", ";", "Operands", ".", "push_back", "(", "SystemZOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "return", "true", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "return", "true", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "unexpected token in argument list", "<STR_LIT>", ")", ";", "}" ]

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

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

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "BI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", ":", "BI", "(", "not", ":", "BI", "(", "match_operator", ":", "BI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "DI", "<NUM_LIT>" ]

[ "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "unsigned", "PatmosRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "TM", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}" ]

[ "Debug", "information", "queries", "." ]

[ "bool", "WebAssemblySetP2AlignOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "<STR_LIT>", "********** Set p2align Operands **********\\n", "<STR_LIT>", "<<", "<STR_LIT>", "********** Function: ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "LOAD_I32", ":", "case", "WebAssembly", "::", "LOAD_I64", ":", "case", "WebAssembly", "::", "LOAD_F32", ":", "case", "WebAssembly", "::", "LOAD_F64", ":", "case", "WebAssembly", "::", "LOAD_v16i8", ":", "case", "WebAssembly", "::", "LOAD_v8i16", ":", "case", "WebAssembly", "::", "LOAD_v4i32", ":", "case", "WebAssembly", "::", "LOAD_v2i64", ":", "case", "WebAssembly", "::", "LOAD_v4f32", ":", "case", "WebAssembly", "::", "LOAD_v2f64", ":", "case", "WebAssembly", "::", "LOAD8_S_I32", ":", "case", "WebAssembly", "::", "LOAD8_U_I32", ":", "case", "WebAssembly", "::", "LOAD16_S_I32", ":", "case", "WebAssembly", "::", "LOAD16_U_I32", ":", "case", "WebAssembly", "::", "LOAD8_S_I64", ":", "case", "WebAssembly", "::", "LOAD8_U_I64", ":", "case", "WebAssembly", "::", "LOAD16_S_I64", ":", "case", "WebAssembly", "::", "LOAD16_U_I64", ":", "case", "WebAssembly", "::", "LOAD32_S_I64", ":", "case", "WebAssembly", "::", "LOAD32_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD8_U_I32", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD16_U_I32", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD8_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD16_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD32_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_ADD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_ADD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_SUB_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_SUB_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_AND_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_AND_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_OR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_OR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XOR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XOR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XCHG_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_CMPXCHG_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_CMPXCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_ADD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_ADD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_SUB_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_SUB_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_AND_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_AND_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_OR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_OR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XOR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XOR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XCHG_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_CMPXCHG_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_CMPXCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_ADD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_ADD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_SUB_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_SUB_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_AND_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_AND_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_OR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_OR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_XOR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_XOR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_XCHG_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_XCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_CMPXCHG_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_CMPXCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_ADD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_SUB_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_AND_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_OR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_XOR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_XCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_CMPXCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_NOTIFY", ":", "case", "WebAssembly", "::", "ATOMIC_WAIT_I32", ":", "case", "WebAssembly", "::", "ATOMIC_WAIT_I64", ":", "RewriteP2Align", "(", "MI", ",", "WebAssembly", "::", "LoadP2AlignOperandNo", ")", ";", "break", ";", "case", "WebAssembly", "::", "STORE_I32", ":", "case", "WebAssembly", "::", "STORE_I64", ":", "case", "WebAssembly", "::", "STORE_F32", ":", "case", "WebAssembly", "::", "STORE_F64", ":", "case", "WebAssembly", "::", "STORE_v16i8", ":", "case", "WebAssembly", "::", "STORE_v8i16", ":", "case", "WebAssembly", "::", "STORE_v4i32", ":", "case", "WebAssembly", "::", "STORE_v2i64", ":", "case", "WebAssembly", "::", "STORE_v4f32", ":", "case", "WebAssembly", "::", "STORE_v2f64", ":", "case", "WebAssembly", "::", "STORE8_I32", ":", "case", "WebAssembly", "::", "STORE16_I32", ":", "case", "WebAssembly", "::", "STORE8_I64", ":", "case", "WebAssembly", "::", "STORE16_I64", ":", "case", "WebAssembly", "::", "STORE32_I64", ":", "case", "WebAssembly", "::", "ATOMIC_STORE_I32", ":", "case", "WebAssembly", "::", "ATOMIC_STORE8_I32", ":", "case", "WebAssembly", "::", "ATOMIC_STORE16_I32", ":", "case", "WebAssembly", "::", "ATOMIC_STORE_I64", ":", "case", "WebAssembly", "::", "ATOMIC_STORE8_I64", ":", "case", "WebAssembly", "::", "ATOMIC_STORE16_I64", ":", "case", "WebAssembly", "::", "ATOMIC_STORE32_I64", ":", "RewriteP2Align", "(", "MI", ",", "WebAssembly", "::", "StoreP2AlignOperandNo", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "Changed", ";", "}" ]

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

[ "<FIXS>", "return", "isLoadInst", "(", "opcode", ")", "||", "isStoreInst", "(", "opcode", ")", "||", "instr", "->", "isCall", "(", ")", "||", "instr", "->", "isReturn", "(", ")", ";", "<FIXE>" ]

[ "bool", "memory_access", "(", "const", "MachineInstr", "*", "instr", ")", "{", "auto", "opcode", "=", "instr", "->", "getOpcode", "(", ")", ";", "<BUGS>", "return", "isLoadInst", "(", "opcode", ")", "||", "isStoreInst", "(", "opcode", ")", "||", "instr", "->", "isCall", "(", ")", "||", "instr", "->", "isReturn", "(", ")", "||", "opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "<BUGE>", "}", "unsigned", "latency", "(", "const", "MachineInstr", "*", "instr", ")", "{" ]

[ "}" ]

[ "class", "FalseLanesEnum", "<", "bits", "<", "<NUM_LIT>", ">", "val", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Value", "=", "val", ";" ]

[ "<FIXS>", "Inst", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "<FIXE>" ]

[ "report_fatal_error", "(", "<STR_LIT>", "unexpected instruction to relax: ", "<STR_LIT>", "+", "OS", ".", "str", "(", ")", ")", ";", "}", "<BUGS>", "Res", "=", "Inst", ";", "Res", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "<BUGE>", "}" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "<", "I2F", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "div", ":", "<", "I2F", ">", "(", "float", ":", "<", "I2F", ">", "(", "match_operand", ":", "VSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "<", "I2F", ">", "<NUM_LIT>" ]

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

[ "SDValue", "SICTargetLowering", "::", "lowerBRCOND", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG" ]

[ "b", ";" ]

[ "veorq_s64", "(", "int64x2_t", "_", "_", "a", ",", "int64x2_t", "_", "_", "b", ")", "{", "return", "_", "_", "a", "^", "_", "_" ]

[ "int64_t", "execute", "(", ")", "{", "while", "(", "!", "InfixOperatorStack", ".", "empty", "(", ")", ")", "{", "InfixCalculatorTok", "StackOp", "=", "InfixOperatorStack", ".", "pop_back_val", "(", ")", ";", "if", "(", "StackOp", "!=", "IC_LPAREN", "&&", "StackOp", "!=", "IC_RPAREN", ")", "PostfixStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "StackOp", ",", "<NUM_LIT>", ")", ")", ";", "}", "if", "(", "PostfixStack", ".", "empty", "(", ")", ")", "return", "<NUM_LIT>", ";", "SmallVector", "<", "ICToken", ",", "<NUM_LIT>", ">", "OperandStack", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "PostfixStack", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "ICToken", "Op", "=", "PostfixStack", "[", "i", "]", ";", "if", "(", "Op", ".", "first", "==", "IC_IMM", "||", "Op", ".", "first", "==", "IC_REGISTER", ")", "{", "OperandStack", ".", "push_back", "(", "Op", ")", ";", "}", "else", "{", "assert", "(", "OperandStack", ".", "size", "(", ")", ">", "<NUM_LIT>", "&&", "<STR_LIT>", "Too few operands.", "<STR_LIT>", ")", ";", "int64_t", "Val", ";", "ICToken", "Op2", "=", "OperandStack", ".", "pop_back_val", "(", ")", ";", "ICToken", "Op1", "=", "OperandStack", ".", "pop_back_val", "(", ")", ";", "switch", "(", "Op", ".", "first", ")", "{", "default", ":", "report_fatal_error", "(", "<STR_LIT>", "Unexpected operator!", "<STR_LIT>", ")", ";", "break", ";", "case", "IC_PLUS", ":", "Val", "=", "Op1", ".", "second", "+", "Op2", ".", "second", ";", "OperandStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "IC_IMM", ",", "Val", ")", ")", ";", "break", ";", "case", "IC_MINUS", ":", "Val", "=", "Op1", ".", "second", "-", "Op2", ".", "second", ";", "OperandStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "IC_IMM", ",", "Val", ")", ")", ";", "break", ";", "case", "IC_MULTIPLY", ":", "assert", "(", "Op1", ".", "first", "==", "IC_IMM", "&&", "Op2", ".", "first", "==", "IC_IMM", "&&", "<STR_LIT>", "Multiply operation with an immediate and a register!", "<STR_LIT>", ")", ";", "Val", "=", "Op1", ".", "second", "*", "Op2", ".", "second", ";", "OperandStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "IC_IMM", ",", "Val", ")", ")", ";", "break", ";", "case", "IC_DIVIDE", ":", "assert", "(", "Op1", ".", "first", "==", "IC_IMM", "&&", "Op2", ".", "first", "==", "IC_IMM", "&&", "<STR_LIT>", "Divide operation with an immediate and a register!", "<STR_LIT>", ")", ";", "assert", "(", "Op2", ".", "second", "!=", "<NUM_LIT>", "&&", "<STR_LIT>", "Division by zero!", "<STR_LIT>", ")", ";", "Val", "=", "Op1", ".", "second", "/", "Op2", ".", "second", ";", "OperandStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "IC_IMM", ",", "Val", ")", ")", ";", "break", ";", "case", "IC_OR", ":", "assert", "(", "Op1", ".", "first", "==", "IC_IMM", "&&", "Op2", ".", "first", "==", "IC_IMM", "&&", "<STR_LIT>", "Or operation with an immediate and a register!", "<STR_LIT>", ")", ";", "Val", "=", "Op1", ".", "second", "|", "Op2", ".", "second", ";", "OperandStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "IC_IMM", ",", "Val", ")", ")", ";", "break", ";", "case", "IC_XOR", ":", "assert", "(", "Op1", ".", "first", "==", "IC_IMM", "&&", "Op2", ".", "first", "==", "IC_IMM", "&&", "<STR_LIT>", "Xor operation with an immediate and a register!", "<STR_LIT>", ")", ";", "Val", "=", "Op1", ".", "second", "^", "Op2", ".", "second", ";", "OperandStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "IC_IMM", ",", "Val", ")", ")", ";", "break", ";", "case", "IC_AND", ":", "assert", "(", "Op1", ".", "first", "==", "IC_IMM", "&&", "Op2", ".", "first", "==", "IC_IMM", "&&", "<STR_LIT>", "And operation with an immediate and a register!", "<STR_LIT>", ")", ";", "Val", "=", "Op1", ".", "second", "&", "Op2", ".", "second", ";", "OperandStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "IC_IMM", ",", "Val", ")", ")", ";", "break", ";", "case", "IC_LSHIFT", ":", "assert", "(", "Op1", ".", "first", "==", "IC_IMM", "&&", "Op2", ".", "first", "==", "IC_IMM", "&&", "<STR_LIT>", "Left shift operation with an immediate and a register!", "<STR_LIT>", ")", ";", "Val", "=", "Op1", ".", "second", "<<", "Op2", ".", "second", ";", "OperandStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "IC_IMM", ",", "Val", ")", ")", ";", "break", ";", "case", "IC_RSHIFT", ":", "assert", "(", "Op1", ".", "first", "==", "IC_IMM", "&&", "Op2", ".", "first", "==", "IC_IMM", "&&", "<STR_LIT>", "Right shift operation with an immediate and a register!", "<STR_LIT>", ")", ";", "Val", "=", "Op1", ".", "second", ">>", "Op2", ".", "second", ";", "OperandStack", ".", "push_back", "(", "std", "::", "make_pair", "(", "IC_IMM", ",", "Val", ")", ")", ";", "break", ";", "}", "}", "}", "assert", "(", "OperandStack", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Expected a single result.", "<STR_LIT>", ")", ";", "return", "OperandStack", ".", "pop_back_val", "(", ")", ".", "second", ";", "}" ]

[ "Produce", "a", "widened", "version", "of", "the", "select", "instruction", "." ]

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

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

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

[ "(", "const_vector", ":", "V2SI", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ")", ")", ")" ]

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

[ "const", "TargetRegisterClass", "*", "RC", "=", "(", "RetVT", "==", "MVT", "::", "i64", ")", "?", "&", "<STR_LIT>", "::", "<STR_LIT>", ":", "&", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "unsigned", "AArch64FastISel", "::", "emitLSR_rr", "(", "MVT", "RetVT", ",", "unsigned", "Op0Reg", ",", "unsigned", "Op1Reg", ")", "{", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "bool", "NeedTrunc", "=", "false", ";", "uint64_t", "Mask", "=", "<NUM_LIT>", ";", "switch", "(", "RetVT", ".", "SimpleTy", ")", "{", "default", ":", "return", "<NUM_LIT>", ";", "case", "MVT", "::", "i8", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "NeedTrunc", "=", "true", ";", "Mask", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "i16", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "NeedTrunc", "=", "true", ";", "Mask", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "i32", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "MVT", "::", "i64", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}" ]

[ "<NUM_LIT>", ";" ]

[ "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "New Slot\\n", "<STR_LIT>", ")", ";", "assert", "(", "OccupedSlotsMask", "&&", "<STR_LIT>", "Slot wasn't filled", "<STR_LIT>", ")", ";", "OccupedSlotsMask", "=" ]

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

[ "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "static", "void", "rs6000_invalid_builtin", "(", "enum", "rs6000_builtins", "fncode", ")", "{", "size_t", "uns_fncode", "=", "(", "size_t", ")", "fncode", ";", "const", "char", "*", "name", "=", "rs6000_builtin_info", "[", "uns_fncode", "]", ".", "name", ";", "HOST_WIDE_INT", "fnmask", "=", "rs6000_builtin_info", "[", "uns_fncode", "]", ".", "mask", ";", "gcc_assert", "(", "name", "!=", "NULL", ")", ";", "if", "(", "(", "fnmask", "&", "RS6000_BTM_CELL", ")", "!=", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "%qs is only valid for the cell processor", "<STR_LIT>", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_VSX", ")", "!=", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mvsx", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_HTM", ")", "!=", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mhtm", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_ALTIVEC", ")", "!=", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-maltivec", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_DFP", "|", "RS6000_BTM_P8_VECTOR", ")", ")", "==", "(", "RS6000_BTM_DFP", "|", "RS6000_BTM_P8_VECTOR", ")", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs and %qs options", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mhard-dfp", "<STR_LIT>", ",", "<STR_LIT>", "-mpower8-vector", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_DFP", ")", "!=", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mhard-dfp", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_P8_VECTOR", ")", "!=", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mpower8-vector", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_P9_VECTOR", "|", "RS6000_BTM_64BIT", ")", ")", "==", "(", "RS6000_BTM_P9_VECTOR", "|", "RS6000_BTM_64BIT", ")", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs and %qs options", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mcpu=power9", "<STR_LIT>", ",", "<STR_LIT>", "-m64", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_P9_VECTOR", ")", "!=", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mcpu=power9", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_P9_MISC", "|", "RS6000_BTM_64BIT", ")", ")", "==", "(", "RS6000_BTM_P9_MISC", "|", "RS6000_BTM_64BIT", ")", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs and %qs options", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mcpu=power9", "<STR_LIT>", ",", "<STR_LIT>", "-m64", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_P9_MISC", ")", "==", "RS6000_BTM_P9_MISC", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mcpu=power9", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_P10", ")", "!=", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mcpu=power10", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_MMA", ")", "!=", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mmma", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_LDBL128", ")", "==", "RS6000_BTM_LDBL128", ")", "{", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mhard-float", "<STR_LIT>", ")", ";", "else", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "TARGET_IEEEQUAD", "?", "<STR_LIT>", "-mabi=ibmlongdouble", "<STR_LIT>", ":", "<STR_LIT>", "-mlong-double-128", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_HARD_FLOAT", ")", "!=", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mhard-float", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_FLOAT128_HW", ")", "!=", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "%qs requires ISA 3.0 IEEE 128-bit floating point", "<STR_LIT>", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_FLOAT128", ")", "!=", "<NUM_LIT>", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs option", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "%<-mfloat128%>", "<STR_LIT>", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_POPCNTD", "|", "RS6000_BTM_POWERPC64", ")", ")", "==", "(", "RS6000_BTM_POPCNTD", "|", "RS6000_BTM_POWERPC64", ")", ")", "error", "(", "<STR_LIT>", "%qs requires the %qs (or newer), and %qs or %qs options", "<STR_LIT>", ",", "name", ",", "<STR_LIT>", "-mcpu=power7", "<STR_LIT>", ",", "<STR_LIT>", "-m64", "<STR_LIT>", ",", "<STR_LIT>", "-mpowerpc64", "<STR_LIT>", ")", ";", "else", "error", "(", "<STR_LIT>", "%qs is not supported with the current options", "<STR_LIT>", ",", "name", ")", ";", "}" ]

[ "Raise", "an", "error", "message", "for", "a", "builtin", "function", "that", "is", "called", "without", "the", "appropriate", "target", "options", "being", "set", "." ]

[ "}" ]

[ "const", "static", "MCFixupKindInfo", "Infos", "[", "]", "=", "{", "{", "<STR_LIT>", "reloc_pcrel_4byte", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "*", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "reloc_pcrel_1byte", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "*", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "reloc_riprel_4byte", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "*", "<NUM_LIT>", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCCodeEmitter", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "<STR_LIT>", "Invalid kind!", "<STR_LIT>", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";" ]

[ "DAG", ".", "getContext", "(", ")", "->", "emitError", "(", "<STR_LIT>", "return address can be determined only for current frame", "<STR_LIT>", ")", ";" ]

[ "SDValue", "MipsTargetLowering", "::", "lowerRETURNADDR", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "verifyReturnAddressArgumentIsConstant", "(", "Op", ",", "DAG", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", "!=", "<NUM_LIT>", ")", "{" ]

[ ",", "JQ", ")", ";" ]

[ "Value", "*", "RCP", "=", "Builder", ".", "CreateFDiv", "(", "ConstantFP", "::", "get", "(", "F32Ty", ",", "<NUM_LIT>", ")", ",", "FB", ")", ";", "Value", "*", "FQM", "=", "Builder", ".", "CreateFMul", "(", "FA", ",", "RCP", ")", ";", "CallInst", "*", "FQ", "=", "Builder", ".", "CreateUnaryIntrinsic", "(", "Intrinsic", "::", "trunc", ",", "FQM", ")", ";", "FQ", "->", "copyFastMathFlags", "(", "Builder", ".", "getFastMathFlags", "(", ")", ")", ";", "Value", "*", "FQNeg", "=", "Builder", ".", "CreateFNeg", "(", "FQ", ")", ";", "Value", "*", "FR", "=", "Builder", ".", "CreateIntrinsic", "(", "Intrinsic", "::", "amdgcn_fmad_ftz", ",", "{", "FQNeg", "->", "getType", "(", ")", "}", ",", "{", "FQNeg", ",", "FB", ",", "FA", "}", ",", "FQ", ")", ";", "Value", "*", "IQ", "=", "IsSigned", "?", "Builder", ".", "CreateFPToSI", "(", "FQ", ",", "I32Ty", ")", ":", "Builder", ".", "CreateFPToUI", "(", "FQ", ",", "I32Ty", ")", ";", "FR", "=", "Builder", ".", "CreateUnaryIntrinsic", "(", "Intrinsic", "::", "fabs", ",", "FR", ",", "FQ", ")", ";", "FB", "=", "Builder", ".", "CreateUnaryIntrinsic", "(", "Intrinsic", "::", "fabs", ",", "FB", ",", "FQ", ")", ";", "Value", "*", "CV", "=", "Builder", ".", "CreateFCmpOGE", "(", "FR", ",", "FB", ")", ";", "JQ", "=", "Builder", ".", "CreateSelect", "(", "CV", ",", "JQ", ",", "Builder", ".", "getInt32", "(", "<NUM_LIT>", ")", ")", ";", "Value", "*", "Div", "=", "Builder", ".", "CreateAdd", "(", "IQ" ]

[ "getReg", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "if", "(", "NegateResult", "&&", "TrailingZeroes", ")", "return", "false", ";", "ApplyFn", "=", "[", "=", "]", "(", "MachineIRBuilder", "&", "B", ",", "Register", "DstReg", ")", "{", "auto", "Shift", "=", "B", ".", "buildConstant", "(", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ",", "ShiftAmt", ")", ";", "auto", "ShiftedVal", "=", "B", ".", "buildShl", "(", "Ty", ",", "LHS", ",", "Shift", ")", ";", "Register", "AddSubLHS", "=", "ShiftValUseIsLHS", "?", "ShiftedVal", ".", "getReg", "(", "<NUM_LIT>", ")", ":", "LHS", ";", "Register", "AddSubRHS", "=", "ShiftValUseIsLHS", "?", "LHS", ":", "ShiftedVal", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "auto", "Res", "=", "B", ".", "buildInstr", "(", "AddSubOpc", ",", "{", "Ty", "}", ",", "{", "AddSubLHS", ",", "AddSubRHS", "}", ")", ";", "assert", "(", "!", "(", "NegateResult", "&&", "TrailingZeroes", ")", "&&", "<STR_LIT>", "NegateResult and TrailingZeroes cannot both be true for now.", "<STR_LIT>", ")", ";", "if", "(", "NegateResult", ")", "{", "B", ".", "buildSub", "(", "DstReg", ",", "B", ".", "buildConstant", "(", "Ty", ",", "<NUM_LIT>", ")", ",", "Res", ")", ";", "return", ";", "}", "if", "(", "TrailingZeroes", ")", "{", "B", ".", "buildShl", "(", "DstReg", ",", "Res", ",", "B", ".", "buildConstant", "(", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ",", "TrailingZeroes", ")", ")", ";", "return", ";", "}", "B", ".", "buildCopy", "(", "DstReg", ",", "Res", "." ]

[ "void", "aarch64_init_builtin_rsqrt", "(", "void", ")", "{", "tree", "fndecl", "=", "NULL", ";", "tree", "ftype", "=", "NULL", ";", "tree", "V2SF_type_node", "=", "build_vector_type", "(", "float_type_node", ",", "<NUM_LIT>", ")", ";", "tree", "V2DF_type_node", "=", "build_vector_type", "(", "double_type_node", ",", "<NUM_LIT>", ")", ";", "tree", "V4SF_type_node", "=", "build_vector_type", "(", "float_type_node", ",", "<NUM_LIT>", ")", ";", "struct", "builtin_decls_data", "{", "tree", "type_node", ";", "const", "char", "*", "builtin_name", ";", "int", "function_code", ";", "}", ";", "builtin_decls_data", "bdda", "[", "]", "=", "{", "{", "double_type_node", ",", "<STR_LIT>", "__builtin_aarch64_rsqrt_df", "<STR_LIT>", ",", "AARCH64_BUILTIN_RSQRT_DF", "}", ",", "{", "float_type_node", ",", "<STR_LIT>", "__builtin_aarch64_rsqrt_sf", "<STR_LIT>", ",", "AARCH64_BUILTIN_RSQRT_SF", "}", ",", "{", "V2DF_type_node", ",", "<STR_LIT>", "__builtin_aarch64_rsqrt_v2df", "<STR_LIT>", ",", "AARCH64_BUILTIN_RSQRT_V2DF", "}", ",", "{", "V2SF_type_node", ",", "<STR_LIT>", "__builtin_aarch64_rsqrt_v2sf", "<STR_LIT>", ",", "AARCH64_BUILTIN_RSQRT_V2SF", "}", ",", "{", "V4SF_type_node", ",", "<STR_LIT>", "__builtin_aarch64_rsqrt_v4sf", "<STR_LIT>", ",", "AARCH64_BUILTIN_RSQRT_V4SF", "}", "}", ";", "builtin_decls_data", "*", "bdd", "=", "bdda", ";", "builtin_decls_data", "*", "bdd_end", "=", "bdd", "+", "(", "ARRAY_SIZE", "(", "bdda", ")", ")", ";", "for", "(", ";", "bdd", "<", "bdd_end", ";", "bdd", "++", ")", "{", "ftype", "=", "build_function_type_list", "(", "bdd", "->", "type_node", ",", "bdd", "->", "type_node", ",", "NULL_TREE", ")", ";", "tree", "attrs", "=", "aarch64_get_attributes", "(", "FLAG_FP", ",", "TYPE_MODE", "(", "bdd", "->", "type_node", ")", ")", ";", "fndecl", "=", "aarch64_general_add_builtin", "(", "bdd", "->", "builtin_name", ",", "ftype", ",", "bdd", "->", "function_code", ",", "attrs", ")", ";", "aarch64_builtin_decls", "[", "bdd", "->", "function_code", "]", "=", "fndecl", ";", "}", "}" ]

[ "Add", "builtins", "for", "reciprocal", "square", "root", "." ]

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

[ "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

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

[ "_", "_", "p", ")", "{" ]

[ "_", "_", "arm_vctp64q_m", "(", "uint32_t", "_", "_", "a", ",", "mve_pred16_t" ]

[ "}" ]

[ "if", "(", "selectAddrFrameIndex", "(", "Addr", ",", "Base", ",", "Offset", ")", ")", "return", "true", ";", "if", "(", "selectAddrFrameIndexOffset", "(", "Addr", ",", "Base", ",", "Offset", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "return", "true", ";", "return", "selectAddrDefault", "(", "Addr", ",", "Base", ",", "Offset", ")", ";" ]

[ "(", "ashiftrt", ":", "V2HI", "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "V4QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_concat", ":", "V4QI", "(", "truncate", ":", "V2QI" ]

[ ",", "_", "_", "m512i", "_", "_", "B", ",", "_", "_", "m512i", "_", "_", "C", ",", "const", "int", "_", "_", "imm", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_ternarylogic_epi64", "(", "_", "_", "m512i", "_", "_", "A" ]

[ "Value", "=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";" ]

[ "case", "Hexagon", "::", "S4_pstorerbtnew_abs", ":", "case", "Hexagon", "::", "S4_pstorerhf_abs", ":", "case", "Hexagon", "::", "S4_pstorerht_abs", ":", "case", "Hexagon", "::", "S4_pstorerhfnew_abs", ":", "case", "Hexagon", "::", "S4_pstorerhtnew_abs", ":", "case", "Hexagon", "::", "S4_pstorerif_abs", ":", "case", "Hexagon", "::", "S4_pstorerit_abs", ":", "case", "Hexagon", "::", "S4_pstorerifnew_abs", ":", "case", "Hexagon", "::", "S4_pstoreritnew_abs", ":", "Value", "=", "insn", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "DecodePredRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "Value", "=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "Value", "|=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Value", ")", ")", ";", "Value", "=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "DecodeIntRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "break", ";", "case", "Hexagon", "::", "L4_ploadrdf_abs", ":", "case", "Hexagon", "::", "L4_ploadrdt_abs", ":", "case", "Hexagon", "::", "L4_ploadrdfnew_abs", ":", "case", "Hexagon", "::", "L4_ploadrdtnew_abs", ":", "Value", "=", "insn", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "DecodeDoubleRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "Value", "=", "(", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ")", ";", "DecodePredRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "Value", "=", "(", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ")", ";", "Value", "|=", "(", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Value", ")", ")", ";", "break", ";", "case", "Hexagon", "::", "L4_ploadrbf_abs", ":", "case", "Hexagon", "::", "L4_ploadrbt_abs", ":", "case", "Hexagon", "::", "L4_ploadrbfnew_abs", ":", "case", "Hexagon", "::", "L4_ploadrbtnew_abs", ":", "case", "Hexagon", "::", "L4_ploadrhf_abs", ":", "case", "Hexagon", "::", "L4_ploadrht_abs", ":", "case", "Hexagon", "::", "L4_ploadrhfnew_abs", ":", "case", "Hexagon", "::", "L4_ploadrhtnew_abs", ":", "case", "Hexagon", "::", "L4_ploadrubf_abs", ":", "case", "Hexagon", "::", "L4_ploadrubt_abs", ":", "case", "Hexagon", "::", "L4_ploadrubfnew_abs", ":", "case", "Hexagon", "::", "L4_ploadrubtnew_abs", ":", "case", "Hexagon", "::", "L4_ploadruhf_abs", ":", "case", "Hexagon", "::", "L4_ploadruht_abs", ":", "case", "Hexagon", "::", "L4_ploadruhfnew_abs", ":", "case", "Hexagon", "::", "L4_ploadruhtnew_abs", ":", "case", "Hexagon", "::", "L4_ploadrif_abs", ":", "case", "Hexagon", "::", "L4_ploadrit_abs", ":", "case", "Hexagon", "::", "L4_ploadrifnew_abs", ":", "case", "Hexagon", "::", "L4_ploadritnew_abs", ":", "Value", "=", "insn", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "DecodeIntRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "Value", "=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "DecodePredRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "Value", "=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "Value", "|=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Value", ")", ")", ";", "break", ";", "case", "(", "Hexagon", "::", "PS_loadriabs", ")", ":", "++", "shift", ";", "case", "Hexagon", "::", "PS_loadrhabs", ":", "case", "Hexagon", "::", "PS_loadruhabs", ":", "++", "shift", ";", "case", "Hexagon", "::", "PS_loadrbabs", ":", "case", "Hexagon", "::", "PS_loadrubabs", ":", "Value", "|=", "insn", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "DecodeIntRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "Value", "=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "Value", "|=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "Value", "|=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Value", "<<", "shift", ")", ")", ";", "break", ";", "case", "Hexagon", "::", "PS_loadrdabs", ":", "Value", "=", "insn", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "DecodeDoubleRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "Value", "=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "Value", "|=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "Value", "|=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Value", "<<", "<NUM_LIT>", ")", ")", ";", "break", ";", "case", "Hexagon", "::", "PS_storerdabs", ":", "Value", "=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "Value", "|=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "Value", "|=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "Value", "|=", "insn", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "Value", "<<", "<NUM_LIT>", ")", ")", ";", "Value", "=", "(", "insn", ">>", "<NUM_LIT>", ")", "&", "UINT64_C", "(", "<NUM_LIT>", ")", ";", "DecodeDoubleRegsRegisterClass", "(", "MI", ",", "Value", ",", "<NUM_LIT>", ",", "nullptr", ")", ";", "break", ";", "case", "Hexagon", "::", "PS_storerinewabs", ":", "++", "shift", ";", "case", "Hexagon", "::", "PS_storerhnewabs", ":", "++", "shift", ";", "case", "Hexagon", "::", "PS_storerbnewabs", ":" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "div", ":", "V2SF", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "{", "rtx", "op2", "=", "gen_reg_rtx", "(", "V4SFmode", ")", "rtx", "op1", "=", "gen_reg_rtx", "(", "V4SFmode", ")" ]

[ "}" ]

[ "int", "FPGATTIImpl", "::", "getExtractWithExtendCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Dst", ",", "VectorType", "*", "VecTy", ",", "unsigned", "Index", ")", "{", "return", "TTI", "::", "TCC_Free", ";" ]

[ ";" ]

[ "class", "BaseCondSelect", "<", "bit", "op", ",", "bits", "<", "<NUM_LIT>", ">", "op2", ",", "RegisterClass", "regtype", ",", "string", "asm", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "regtype", ":", "$", "Rn", ",", "regtype", ":", "$", "Rm", ",", "ccode", ":", "$", "cond", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "regtype", ":", "$", "Rd", ",", "(", "ARM64csel", "regtype", ":", "$", "Rn", ",", "regtype", ":", "$", "Rm", ",", "(", "i32", "imm", ":", "$", "cond", ")", ",", "CPSR", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteI", "]", ">", "{", "let", "Uses", "=", "[", "CPSR", "]", ";", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn" ]

[ ")", "return", "false", ";" ]

[ "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")" ]

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

[ "if", "(", "!", "<STR_LIT>", "::", "<STR_LIT>", "(", "Val", ")", "&&", "!", "<STR_LIT>", "::", "<STR_LIT>", "(", "Val", ")", "&&", "!", "isInt", "<", "<NUM_LIT>", ">", "(", "Val", ")", ")", "{", "splitLargeImmediate", "(", "ISD", "::", "OR", ",", "Node", ",", "SDValue", "(", ")", ",", "Val", "-", "uint32_t", "(", "Val", ")", ",", "uint32_t", "(", "Val", ")", ")", ";", "return", ";", "}", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SDValue", "Op0", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op1", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "Op1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "LOAD", "&&", "Op0", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "LOAD", ")", "||", "(", "Subtarget", "->", "hasLoadStoreOnCond2", "(", ")", "&&", "Node", "->", "getValueType", "(", "<NUM_LIT>", ")", ".", "isInteger", "(", ")", "&&", "Op1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "&&", "isInt", "<", "<NUM_LIT>", ">", "(", "cast", "<", "ConstantSDNode", ">", "(", "Op1", ")", "->", "getSExtValue", "(", ")", ")", "&&", "!", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "&&", "isInt", "<", "<NUM_LIT>", ">", "(", "cast", "<", "ConstantSDNode", ">", "(", "Op0", ")", "->", "getSExtValue", "(", ")", ")", ")", ")", ")", "{", "SDValue", "CCValid", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "CCMask", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "uint64_t", "ConstCCValid", "=", "cast", "<", "ConstantSDNode", ">", "(", "CCValid", ".", "getNode", "(", ")", ")", "->", "getZExtValue", "(", ")", ";", "uint64_t", "ConstCCMask", "=", "cast", "<", "ConstantSDNode", ">", "(", "CCMask", ".", "getNode", "(", ")", ")", "->", "getZExtValue", "(", ")", ";", "CCMask", "=", "CurDAG", "->", "getConstant", "(", "ConstCCValid", "^", "ConstCCMask", ",", "SDLoc", "(", "Node", ")", ",", "CCMask", ".", "getValueType", "(", ")", ")", ";", "SDValue", "Op4", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDNode", "*", "UpdatedNode", "=", "CurDAG", "->", "UpdateNodeOperands", "(", "Node", ",", "Op1", ",", "Op0", ",", "CCValid", ",", "CCMask", ",", "Op4", ")", ";", "if", "(", "UpdatedNode", "!=", "Node", ")", "{", "ReplaceNode", "(", "Node", ",", "UpdatedNode", ")", ";", "Node", "=", "UpdatedNode", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "{", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "unsigned", "ElemBitSize", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "if", "(", "ElemBitSize", "==", "<NUM_LIT>", ")", "{", "if", "(", "tryGather", "(", "Node", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", ";", "}", "else", "if", "(", "ElemBitSize", "==", "<NUM_LIT>", ")", "{", "if", "(", "tryGather", "(", "Node", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "return", ";", "}", "break", ";", "}", "case", "ISD", "::", "STORE", ":", "{", "if", "(", "tryFoldLoadStoreIntoMemOperand", "(", "Node", ")", ")", "return", ";", "auto", "*", "Store", "=", "cast", "<", "StoreSDNode", ">" ]

[ "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cmplt_epi8", "(" ]

[ "QI", "]", ")" ]

[ "(", "define_mode_iterator", "HQI", "[", "HI" ]

[ "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint16x8_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";" ]

[ "poly16x8x2_t", "_", "_", "rv", ";", "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint16x8_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";" ]

[ "let", "isExtentSigned", "=", "<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>", ";" ]

[ "return", "outliner", "::", "InstrType", "::", "Illegal", ";" ]

[ "for", "(", "const", "MachineOperand", "&", "MOP", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MOP", ".", "isGlobal", "(", ")", ")", "{", "Callee", "=", "dyn_cast", "<", "Function", ">", "(", "MOP", ".", "getGlobal", "(", ")", ")", ";", "break", ";", "}", "}", "if", "(", "Callee", "&&", "(", "Callee", "->", "getName", "(", ")", "==", "<STR_LIT>", "\\01__gnu_mcount_nc", "<STR_LIT>", "||", "Callee", "->", "getName", "(", ")", "==", "<STR_LIT>", "\\01mcount", "<STR_LIT>", "||", "Callee", "->", "getName", "(", ")", "==", "<STR_LIT>", "__mcount", "<STR_LIT>", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "auto", "UnknownCallOutlineType", "=", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "Opc", "==", "ARM", "::", "BL", "||", "Opc", "==", "ARM", "::", "tBL", "||", "Opc", "==", "ARM", "::", "BLX", "||", "Opc", "==", "ARM", "::", "BLX_noip", "||", "Opc", "==", "ARM", "::", "tBLXr", "||", "Opc", "==", "ARM", "::", "tBLXr_noip", "||", "Opc", "==", "ARM", "::", "tBLXi", ")", "UnknownCallOutlineType", "=", "outliner", "::", "InstrType", "::", "LegalTerminator", ";", "if", "(", "!", "Callee", ")", "return", "UnknownCallOutlineType", ";", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineFunction", "*", "CalleeMF", "=", "MF", "->", "getMMI", "(", ")", ".", "getMachineFunction", "(", "*", "Callee", ")", ";", "if", "(", "!", "CalleeMF", ")", "return", "UnknownCallOutlineType", ";", "MachineFrameInfo", "&", "MFI", "=", "CalleeMF", "->", "getFrameInfo", "(", ")", ";", "if", "(", "!", "MFI", ".", "isCalleeSavedInfoValid", "(", ")", "||", "MFI", ".", "getStackSize", "(", ")", ">", "<NUM_LIT>", "||", "MFI", ".", "getNumObjects", "(", ")", ">", "<NUM_LIT>", ")", "return", "UnknownCallOutlineType", ";", "return", "outliner", "::", "InstrType", "::", "Legal", ";", "}", "if", "(", "MI", ".", "modifiesRegister", "(", "ARM", "::", "LR", ",", "TRI", ")", "||", "MI", ".", "modifiesRegister", "(", "ARM", "::", "PC", ",", "TRI", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "ARM", "::", "SP", ",", "TRI", ")", "||", "MI", ".", "readsRegister", "(", "ARM", "::", "SP", ",", "TRI", ")", ")", "{", "bool", "MightNeedStackFixUp", "=", "(", "Flags", "&", "(", "MachineOutlinerMBBFlags", "::", "LRUnavailableSomewhere", "|", "MachineOutlinerMBBFlags", "::", "HasCalls", ")", ")", ";", "if", "(", "!", "MightNeedStackFixUp", ")", "return", "outliner", "::", "InstrType", "::", "Legal", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "ARM", "::", "SP", ",", "TRI", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "checkAndUpdateStackOffset", "(", "&", "MI", ",", "Subtarget", ".", "getStackAlignment", "(", ")", ".", "value", "(", ")", ",", "false", ")", ")", "return", "outliner", "::", "InstrType", "::", "Legal", ";" ]

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

[ "def", "v8i16_indexed", ":", "BaseSIMDIndexed", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "opc", ",", "V128", ",", "V128", ",", "V128_lo", ",", "VectorIndexH", ",", "asm", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v4i32", "V128", ":", "$", "Rd", ")", ",", "(", "OpNode", "(", "extract_high_v8i16", "V128", ":", "$", "Rn", ")", ",", "(", "extract_high_v8i16", "(", "ARM64duplane16", "(", "v8i16", "V128_lo", ":", "$", "Rm", ")", ",", "VectorIndexH", ":", "$", "idx", ")", ")", ")", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "idx", ";" ]

[ "<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", "=" ]

[ "(", "&", "BranchRelaxationPassID", ")", ";" ]

[ "if", "(", "BranchRelaxation", ")", "addPass" ]

[ "NULL_TREE", ";" ]

[ "warning", "(", "OPT_Wattributes", ",", "<STR_LIT>", "%qE attribute only applies to variables", "<STR_LIT>", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return" ]

[ "let", "ParserMatchClass", "=", "LogicalVecShifterOperand", ";" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "EncoderMethod", "=", "<STR_LIT>", ";" ]

[ "<FIXS>", "return", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "return", "<NUM_LIT>", ";", "<FIXE>" ]

[ "index", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "tmp", "=", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "tmp", ")", "!=", "CONST_INT", ")", "<BUGS>", "return", "FALSE", ";", "<BUGE>", "scale", "=", "INTVAL", "(", "tmp", ")", ";", "if", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "scale", ">", "<NUM_LIT>", ")", "<BUGS>", "return", "FALSE", ";", "<BUGE>", "scale", "=", "<NUM_LIT>", "<<", "scale", ";", "}", "elsedisp", "=", "addr", ";" ]

[ "}" ]

[ "def", "ro_indexed8", ":", "ro_indexed", "<", "<NUM_LIT>", ">", ",", "ComplexPattern", "<", "i64", ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "let", "ParserMatchClass", "=", "MemROAsmOperand8", ";" ]

[ "<FIXS>", "Register", "DefReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<FIXE>" ]

[ "auto", "SinkCheckToSingleUse", "=", "[", "&", "]", "(", "MachineInstr", "&", "MI", ")", "->", "Optional", "MachineInstr", "*", ">", "{", "<BUGS>", "unsigned", "DefReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<BUGE>" ]

[ "MBB", "=", "RegionBegin", "->", "getParent", "(", ")", ";" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "All regions recorded, starting actual scheduling.\\n", "<STR_LIT>", ")", ";", "LiveIns", ".", "resize", "(", "Regions", ".", "size", "(", ")", ")", ";", "Pressure", ".", "resize", "(", "Regions", ".", "size", "(", ")", ")", ";", "RescheduleRegions", ".", "resize", "(", "Regions", ".", "size", "(", ")", ")", ";", "RegionsWithClusters", ".", "resize", "(", "Regions", ".", "size", "(", ")", ")", ";", "RegionsWithHighRP", ".", "resize", "(", "Regions", ".", "size", "(", ")", ")", ";", "RescheduleRegions", ".", "set", "(", ")", ";", "RegionsWithClusters", ".", "reset", "(", ")", ";", "RegionsWithHighRP", ".", "reset", "(", ")", ";", "if", "(", "!", "Regions", ".", "empty", "(", ")", ")", "BBLiveInMap", "=", "getBBLiveInMap", "(", ")", ";", "std", "::", "vector", "<", "std", "::", "unique_ptr", "<", "ScheduleDAGMutation", ">>", "SavedMutations", ";", "do", "{", "Stage", "++", ";", "RegionIdx", "=", "<NUM_LIT>", ";", "MachineBasicBlock", "*", "MBB", "=", "nullptr", ";", "if", "(", "Stage", ">", "InitialSchedule", ")", "{", "if", "(", "!", "LIS", ")", "break", ";", "if", "(", "Stage", "==", "UnclusteredReschedule", ")", "{", "if", "(", "RescheduleRegions", ".", "none", "(", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Retrying function scheduling without clustering.\\n", "<STR_LIT>", ")", ";", "}", "if", "(", "Stage", "==", "ClusteredLowOccupancyReschedule", ")", "{", "if", "(", "StartingOccupancy", "<=", "MinOccupancy", ")", "break", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Retrying function scheduling with lowest recorded occupancy ", "<STR_LIT>", "<<", "MinOccupancy", "<<", "<STR_LIT>", ".\\n", "<STR_LIT>", ")", ";", "}", "}", "if", "(", "Stage", "==", "UnclusteredReschedule", ")", "SavedMutations", ".", "swap", "(", "Mutations", ")", ";", "for", "(", "auto", "Region", ":", "Regions", ")", "{", "if", "(", "(", "Stage", "==", "UnclusteredReschedule", "&&", "!", "RescheduleRegions", "[", "RegionIdx", "]", ")", "||", "(", "Stage", "==", "ClusteredLowOccupancyReschedule", "&&", "!", "RegionsWithClusters", "[", "RegionIdx", "]", "&&", "!", "RegionsWithHighRP", "[", "RegionIdx", "]", ")", ")", "{", "++", "RegionIdx", ";", "continue", ";", "}", "RegionBegin", "=", "Region", ".", "first", ";", "RegionEnd", "=", "Region", ".", "second", ";", "if", "(", "RegionBegin", "->", "getParent", "(", ")", "!=", "MBB", ")", "{", "if", "(", "MBB", ")", "finishBlock", "(", ")", ";" ]

[ "_", "_", "b", ",", "mve_pred16_t", "_", "_", "p", ")", "{" ]

[ "_", "_", "arm_vqmovnbq_m", "(", "uint16x8_t", "_", "_", "a", ",", "uint32x4_t" ]

[ ")" ]

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

[ "(", "match_dup", "<NUM_LIT>", ")" ]

[ "(", "match_operand", ":", "V4QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "(", "vec_duplicate", ":", "V2HI", "(", "extend", ":", "HI", "(", "vec_select", ":", "QI" ]

[ "<STR_LIT>", ";" ]

[ "InBundle", "=", "true", ";", "}", "else", "{", "O", "<<", "<STR_LIT>", " ", "<STR_LIT>", ";", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "Desc", ".", "isPredicable", "(", ")", ")", "{", "printPredicateOperand", "(", "MI", ",", "Desc", ".", "getNumDefs", "(", ")", ",", "O", ",", "<STR_LIT>", "guard", "<STR_LIT>", ")", ";", "}", "else", "{", "printDefaultGuard", "(", "O", ",", "true", ")", ";", "}", "O", "<<", "<STR_LIT>" ]

[ "return", "reverse", "(", "Sz", ",", "<NUM_LIT>", ")", ";" ]

[ "assert", "(", "Sz", ">", "<NUM_LIT>", ")", ";", "if", "(", "Sz", "==", "<NUM_LIT>", ")", "return", "xchgTop", "(", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "machine_mode", "tmode", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "machine_mode", "mode0", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "machine_mode", "mode1", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "<FIXE>" ]

[ "rtx", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "rtx", "op1", "=", "expand_normal", "(", "arg1", ")", ";", "rtx", "op2", ";", "<BUGS>", "enum", "machine_mode", "tmode", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "enum", "machine_mode", "mode0", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "enum", "machine_mode", "mode1", "=", "insn_data", "[", "d", "->", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "<BUGE>", "enum", "rtx_code", "comparison", "=", "d", "->", "comparison", ";", "if", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")" ]

[ "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ")", "return", "false", ";" ]

[ "}", "else", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "<NUM_LIT>", ";", "++", "i", ")", "if", "(", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", ")", ",", "i", "*", "<NUM_LIT>", "+", "<NUM_LIT>", ")", "||", "!", "isConstantOrUndef", "(", "N", "->", "getMaskElt", "(", "i", "+", "<NUM_LIT>", ")", ",", "i" ]

[ "<NUM_LIT>", ";" ]

[ "def", "A2_subri", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "s32_0Imm", ":", "$", "Ii", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_2op", ">", ",", "Enc_140c83", ",", "PredNewRel", ",", "ImmRegRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ "Index", ")", ">", ";" ]

[ "def", "TTMP", "#", "Index", "#", "_gfx9", ":", "SIReg", "<", "<STR_LIT>", "#", "Index", ",", "!", "add", "(", "<NUM_LIT>", "," ]

[ "static", "int", "mips_symbol_insns", "(", "enum", "mips_symbol_type", "type", ",", "machine_mode", "mode", ")", "{", "return", "mips_symbol_insns_1", "(", "type", ",", "mode", ")", "*", "(", "TARGET_MIPS16", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "}" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "load", "a", "symbol", "of", "the", "given", "type", "into", "a", "register", ".", "If", "valid", "in", "an", "address", ",", "the", "same", "number", "of", "instructions", "are", "needed", "for", "loads", "and", "stores", ".", "Treat", "extended", "mips16", "instructions", "as", "two", "instructions", "." ]

[ "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=" ]

[ "def", "lo16AllZero", ":", "PatLeaf", "<", "(", "i32", "imm", ")", ",", "[", "{" ]

[ "}", "]", ">", ";", "def", "sext_16_node", ":", "PatLeaf", "<", "(", "i32", "GPR", ":", "$", "a", ")", ",", "[", "{", "return", "CurDAG", "-", ">", "ComputeNumSignBits", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ")", ">", "=", "<NUM_LIT>", ";", "}", "]", ">", ";", "def", "hi16", ":", "SDNodeXForm", "<", "imm", ",", "[", "{", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "(", "uint32_t", ")", "N", "-", ">", "getZExtValue", "(", ")", ">", ">", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ";" ]

[ ",", "<STR_LIT>", ",", "VBR", ">", ";" ]

[ "def", "LDCVBR", ":", "LD", "<", "<STR_LIT>", ",", "<NUM_LIT>" ]

[ "}" ]

[ "return", "-", "Imm", ">", "=", "<NUM_LIT>", "&", "&", "-", "Imm", "<", "<NUM_LIT>", ";", "}", "]", ">", ";", "def", "Imm0_65535ExprAsmOperand", ":", "ImmAsmOperand", "{", "let", "Name", "=", "<STR_LIT>", ";", "}", "def", "imm0_65535_expr", ":", "Operand", "<", "i32", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "Imm0_65535ExprAsmOperand", ";" ]

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

[ "def", "L4_loadrub_rr", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ",", "u2_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_bf061958", ",", "TypeLD", ">", ",", "Enc_da664b", ",", "AddrModeRel", ",", "ImmRegShl", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ "(", "sign_extend", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]" ]

[ "(", "subreg", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<NUM_LIT>", ";" ]

[ "def", "Xi", ":", "BaseMoveImmediate", "<", "opc", ",", "GPR64", ",", "movimm64_shift", ",", "asm", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=" ]

[ ")", ";" ]

[ "B", ".", "buildFExp2", "(", "Dst", ",", "Mul", ",", "Flags", ")", ";", "}", "else", "if", "(", "Ty", "==", "F16", ")", "{", "auto", "Log", "=", "B", ".", "buildFLog2", "(", "F16", ",", "Src0", ",", "Flags", ")", ";", "auto", "Ext0", "=", "B", ".", "buildFPExt", "(", "F32", ",", "Log", ",", "Flags", ")", ";", "auto", "Ext1", "=", "B", ".", "buildFPExt", "(", "F32", ",", "Src1", ",", "Flags", ")", ";", "auto", "Mul", "=", "B", ".", "buildIntrinsic", "(", "Intrinsic", "::", "amdgcn_fmul_legacy", ",", "{", "F32", "}", ")", ".", "addUse", "(", "Ext0", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ".", "addUse", "(", "Ext1", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ".", "setMIFlags", "(", "Flags", ")", ";", "B", ".", "buildFExp2", "(", "Dst", ",", "B", ".", "buildFPTrunc", "(", "F16", ",", "Mul", ")", ",", "Flags", ")", ";", "}", "else", "return", "false", ";", "MI", ".", "eraseFromParent", "(" ]

[ "optype", ";" ]

[ "let", "OutOperandList", "=", "(", "outs", "SRF", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "!", "if", "(", "hasImm", ",", "(", "ins", "SRF", ":", "$", "op1", ",", "TPCImm", "<", "i32imm", ">", ":", "$", "op2", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "SRF", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ",", "(", "ins", "SRF", ":", "$", "op1", ",", "SRF", ":", "$", "op2", ",", "DataType", ":", "$", "optype", ",", "SwitchSet", ":", "$", "sw", ",", "SRF", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ")", ";", "let", "Itinerary", "=", "IIC_ScalarOp", ";", "let", "isNotUsedInDisasm", "=", "!", "if", "(", "hasImm", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "op1", ";", "let", "SrcB", "=", "op2", ";", "let", "Switches", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Switches", "{", "<NUM_LIT>", "}", "=", "sw", "{", "<NUM_LIT>", "}", ";", "let", "HasImm", "=", "hasImm", ";", "let", "immOpNum", "=", "<NUM_LIT>", ";", "let", "OperandType", "=" ]

[ ")", ";" ]

[ "static", "uint64_t", "getConstant", "(", "const", "Value", "*", "IndexValue", ")", "{", "const", "ConstantInt", "*", "CV", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "IndexValue", ")", ";", "assert", "(", "CV" ]

[ "COM_FIr", ",", "UCOM_FIPr", ",", "UCOM_FIr", ")", ">", ";" ]

[ "def", ":", "InstRW", "<", "[", "HWWrite3P01", "]", ",", "(", "instrs", "COM_FIPr", "," ]

[ "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extract", ":", "SI", "(", "mem", ":", "SI", "(", "plus", ":", "DI", "(", "ior", ":", "DI" ]

[ "}" ]

[ "StringRef", "IntKind", "=", "F", "->", "getFnAttribute", "(", "<STR_LIT>", "interrupt", "<STR_LIT>", ")", ".", "getValueAsString", "(", ")", ";", "int64_t", "LROffset", ";", "if", "(", "IntKind", "==", "<STR_LIT>", "<STR_LIT>", "||", "IntKind", "==", "<STR_LIT>", "IRQ", "<STR_LIT>", "||", "IntKind", "==", "<STR_LIT>", "FIQ", "<STR_LIT>", "||", "IntKind", "==", "<STR_LIT>", "ABORT", "<STR_LIT>", ")", "LROffset", "=", "<NUM_LIT>", ";", "else", "if", "(", "IntKind", "==", "<STR_LIT>", "SWI", "<STR_LIT>", "||", "IntKind", "==", "<STR_LIT>", "UNDEF", "<STR_LIT>", ")", "LROffset", "=", "<NUM_LIT>", ";", "else", "report_fatal_error", "(", "<STR_LIT>", "Unsupported interrupt attribute. If present, value ", "<STR_LIT>", "<STR_LIT>", "must be one of: IRQ, FIQ, SWI, ABORT or UNDEF", "<STR_LIT>", ")", ";", "RetOps", ".", "insert", "(", "RetOps", ".", "begin", "(", ")", "+", "<NUM_LIT>", ",", "DAG", ".", "getConstant", "(", "LROffset", ",", "MVT", "::", "i32", ",", "false", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";" ]

[ "static", "inline", "tree", "def_builtin_pure", "(", "HOST_WIDE_INT", "mask", ",", "HOST_WIDE_INT", "mask2", ",", "const", "char", "*", "name", ",", "enum", "ix86_builtin_func_type", "tcode", ",", "enum", "ix86_builtins", "code", ")", "{", "tree", "decl", "=", "def_builtin", "(", "mask", ",", "mask2", ",", "name", ",", "tcode", ",", "code", ")", ";", "if", "(", "decl", ")", "DECL_PURE_P", "(", "decl", ")", "=", "<NUM_LIT>", ";", "else", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "pure_p", "=", "true", ";", "return", "decl", ";", "}" ]

[ "Like", "def_builtin", ",", "but", "also", "marks", "the", "function", "decl", "``", "pure", "''", "." ]

[ "bool", "SITargetLowering", "::", "getAddrModeArguments", "(", "IntrinsicInst", "*", "II", ",", "SmallVectorImpl", "<", "Value", "*", ">", "&", "Ops", ",", "Type", "*", "&", "AccessTy", ")", "const", "{", "switch", "(", "II", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_atomic_fadd", ":", "case", "Intrinsic", "::", "amdgcn_atomic_fmin", ":", "case", "Intrinsic", "::", "amdgcn_atomic_fmax", ":", "{", "Value", "*", "Ptr", "=", "II", "->", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "AccessTy", "=", "II", "->", "getType", "(", ")", ";", "Ops", ".", "push_back", "(", "Ptr", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}" ]

[ "CodeGenPrepare", "sinks", "address", "calculations", "into", "the", "same", "BB", "as", "Load/Store", "instructions", "reading", "the", "address", "." ]

[ "}" ]

[ "let", "Latency", "=", "!", "add", "(", "Lat", ",", "LoadLat", ")", ";", "let", "ResourceCycles", "=", "!", "listconcat", "(", "[", "<NUM_LIT>", "]", ",", "Res", ")", ";", "let", "NumMicroOps", "=", "!", "add", "(", "UOps", ",", "<NUM_LIT>", ")", ";" ]

[ "}" ]

[ "unsigned", "long", "int", "first", ";", "unsigned", "long", "int", "last", ";", "int", "i", ";", "static", "char", "buff", "[", "<NUM_LIT>", "]", ";", "if", "(", "count", "<=", "<NUM_LIT>", ")", "{", "error", "(", "<STR_LIT>", "bogus JR construction: %d", "<STR_LIT>", ",", "count", ")", ";", "return", "NULL", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", "==", "PLUS", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", ")", ";", "stack_bytes", "=", "INTVAL", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ",", "<NUM_LIT>", ")", ")", ";", "stack_bytes", "-=", "(", "count", "-", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ";", "if", "(", "stack_bytes", "!=", "<NUM_LIT>", "&&", "stack_bytes", "!=", "<NUM_LIT>", ")", "{", "error", "(", "<STR_LIT>", "bad amount of stack space removal: %d", "<STR_LIT>", ",", "stack_bytes", ")", ";", "return", "NULL", ";", "}", "mask", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "count", ";", "i", "++", ")", "{", "rtx", "vector_element", "=", "XVECEXP", "(", "op", ",", "<NUM_LIT>", ",", "i", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "vector_element", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_DEST", "(", "vector_element", ")", ")", "==", "REG", ")", ";", "gcc_assert", "(", "register_is_ok_for_epilogue", "(", "SET_DEST", "(", "vector_element", ")", ",", "SImode", ")", ")", ";", "mask", "|=", "<NUM_LIT>", "<<", "REGNO", "(", "SET_DEST", "(", "vector_element", ")", ")", ";", "}", "for", "(", "first", "=", "<NUM_LIT>", ";", "first", "<", "<NUM_LIT>", ";", "first", "++", ")", "{", "if", "(", "mask", "&", "(", "<NUM_LIT>", "<<", "first", ")", ")", "break", ";", "}", "gcc_assert", "(", "first", "<", "<NUM_LIT>", ")", ";", "if", "(", "mask", "&", "(", "<NUM_LIT>", "<<", "LINK_POINTER_REGNUM", ")", ")", "{", "gcc_assert", "(", "stack_bytes", "==", "<NUM_LIT>", ")", ";", "last", "=", "LINK_POINTER_REGNUM", ";", "}", "else", "{", "gcc_assert", "(", "!", "stack_bytes", ")", ";", "gcc_assert", "(", "mask", "&", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ")", ";", "last", "=", "<NUM_LIT>", ";" ]