Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "}" ]

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

[ "static", "bool", "s390_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "machine_mode", "inner", ";", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", "||", "!", "TARGET_VX", "||", "GET_MODE_SIZE", "(", "mode", ")", ">", "<NUM_LIT>", ")", "return", "false", ";", "inner", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "switch", "(", "inner", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "case", "SImode", ":", "case", "DImode", ":", "case", "TImode", ":", "case", "SFmode", ":", "case", "DFmode", ":", "case", "TFmode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}" ]

[ "Return", "true", "if", "the", "back", "end", "supports", "vector", "mode", "MODE", "." ]

[ "static", "bool", "aapcs_vfp_is_call_or_return_candidate", "(", "enum", "arm_pcs", "pcs_variant", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "machine_mode", "*", "base_mode", ",", "int", "*", "count", ")", "{", "machine_mode", "new", "_", "mode", "=", "VOIDmode", ";", "if", "(", "type", ")", "{", "int", "ag_count", "=", "aapcs_vfp_sub_candidate", "(", "type", ",", "&", "new", "_", "mode", ")", ";", "if", "(", "ag_count", ">", "<NUM_LIT>", "&&", "ag_count", "<=", "<NUM_LIT>", ")", "*", "count", "=", "ag_count", ";", "else", "return", "false", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_FLOAT", ")", "{", "*", "count", "=", "<NUM_LIT>", ";", "new", "_", "mode", "=", "mode", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "{", "*", "count", "=", "<NUM_LIT>", ";", "new", "_", "mode", "=", "(", "mode", "==", "DCmode", "?", "DFmode", ":", "SFmode", ")", ";", "}", "else", "return", "false", ";", "if", "(", "!", "use_vfp_abi", "(", "pcs_variant", ",", "ARM_NUM_REGS", "(", "new", "_", "mode", ")", ">", "<NUM_LIT>", ")", ")", "return", "false", ";", "*", "base_mode", "=", "new", "_", "mode", ";", "if", "(", "TARGET_GENERAL_REGS_ONLY", ")", "error", "(", "<STR_LIT>", "argument of type %qT not permitted with -mgeneral-regs-only", "<STR_LIT>", ",", "type", ")", ";", "return", "true", ";", "}" ]

[ "Return", "true", "if", "an", "argument", "whose", "type", "is", "TYPE", ",", "or", "mode", "is", "MODE", ",", "is", "suitable", "for", "passing", "or", "returning", "in", "VFP", "registers", "for", "the", "PCS", "variant", "selected", ".", "If", "it", "is", ",", "then", "*", "BASE_MODE", "is", "updated", "to", "contain", "a", "machine", "mode", "describing", "each", "element", "of", "the", "argument", "'s", "type", "and", "*", "COUNT", "to", "hold", "the", "number", "of", "such", "elements", "." ]

[ ")", ";" ]

[ "return", "true", ";", "}", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "Opc", ")", ")", ";", "}", "if", "(", "Opc", "==", "AMDGPU", "::", "S_SETREG_B32", "&&", "OpToFold", "->", "isImm", "(", ")", ")", "{", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "AMDGPU", "::", "S_SETREG_IMM32_B32", ")", ")", ";", "FoldList", ".", "push_back", "(", "FoldCandidate", "(", "MI", ",", "OpNo", ",", "OpToFold", ")", ")", ";", "return", "true", ";", "}", "if", "(", "isUseMIInFoldList", "(", "FoldList", ",", "MI", ")", ")", "return", "false", ";", "unsigned", "CommuteOpNo", "=", "OpNo", ";", "unsigned", "CommuteIdx0", "=", "TargetInstrInfo", "::", "CommuteAnyOperandIndex", ";", "unsigned", "CommuteIdx1", "=", "TargetInstrInfo", "::", "CommuteAnyOperandIndex", ";", "bool", "CanCommute", "=", "TII", "->", "findCommutedOpIndices", "(", "*", "MI", ",", "CommuteIdx0", ",", "CommuteIdx1", ")", ";", "if", "(", "CanCommute", ")", "{", "if", "(", "CommuteIdx0", "==", "OpNo", ")", "CommuteOpNo", "=", "CommuteIdx1", ";", "else", "if", "(", "CommuteIdx1", "==", "OpNo", ")", "CommuteOpNo", "=", "CommuteIdx0", ";", "}", "if", "(", "CanCommute", "&&", "(", "!", "MI", "->", "getOperand", "(", "CommuteIdx0", ")", ".", "isReg", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "CommuteIdx1", ")", ".", "isReg", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "CanCommute", "||", "!", "TII", "->", "commuteInstruction", "(", "*", "MI", ",", "false", ",", "CommuteIdx0", ",", "CommuteIdx1", ")", ")", "return", "false", ";", "if", "(", "!", "TII", "->", "isOperandLegal", "(", "*", "MI", ",", "CommuteOpNo", ",", "OpToFold", ")", ")", "{", "if", "(", "(", "Opc", "==", "AMDGPU", "::", "V_ADD_I32_e64", "||", "Opc", "==", "AMDGPU", "::", "V_SUB_I32_e64", "||", "Opc", "==", "AMDGPU", "::", "V_SUBREV_I32_e64", ")", "&&", "OpToFold", "->", "isImm", "(", ")", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "OtherIdx", "=", "CommuteOpNo", "==", "CommuteIdx0", "?", "CommuteIdx1", ":", "CommuteIdx0", ";", "MachineOperand", "&", "OtherOp", "=", "MI", "->", "getOperand", "(", "OtherIdx" ]

[ "return", "BB", ";" ]

[ "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SEB", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", "BB", ";", "}", "if", "(", "Subtarget", "->", "hasMips32r2", "(", ")", "&&", "Size", "==", "<NUM_LIT>", ")", "{", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SEH", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", "BB", ";", "}", "MachineFunction", "*", "MF", "=", "BB", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "getRegClassFor", "(", "MVT", "::", "i32", ")", ";", "unsigned", "ScrReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "assert", "(", "Size", "<", "<NUM_LIT>", ")", ";", "int64_t", "ShiftImm", "=", "<NUM_LIT>", "-", "(", "Size", "*", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SLL", ")", ",", "ScrReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "ShiftImm", ")", ";", "BuildMI", "(", "BB", ",", "DL", ",", "TII", "->", "get", "(", "Mips", "::", "SRA", ")", ",", "DstReg", ")", ".", "addReg", "(", "ScrReg", ")", ".", "addImm", "(", "ShiftImm", ")", ";" ]

[ "(", "machine_mode", "mode", ")", "{" ]

[ "static", "unsigned", "int", "cris_atomic_align_for_mode" ]

[ ":", "DFP", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "DFP", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "DFP", "[", "(", "match_operand" ]

[ "static", "bool", "arm_evpc_neon_vrev", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "j", ",", "diff", ",", "nelt", "=", "d", "->", "perm", ".", "length", "(", ")", ";", "rtx", "(", "*", "gen", ")", "(", "machine_mode", ",", "rtx", ",", "rtx", ")", ";", "if", "(", "!", "d", "->", "one_vector_p", ")", "return", "false", ";", "diff", "=", "d", "->", "perm", "[", "<NUM_LIT>", "]", ";", "switch", "(", "diff", ")", "{", "case", "<NUM_LIT>", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V16QImode", ":", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vrev64", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V16QImode", ":", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vrev32", ";", "break", ";", "case", "E_V8HImode", ":", "case", "E_V4HImode", ":", "case", "E_V8HFmode", ":", "case", "E_V4HFmode", ":", "gen", "=", "gen_neon_vrev64", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "E_V16QImode", ":", "case", "E_V8QImode", ":", "gen", "=", "gen_neon_vrev16", ";", "break", ";", "case", "E_V8HImode", ":", "case", "E_V4HImode", ":", "gen", "=", "gen_neon_vrev32", ";", "break", ";", "case", "E_V4SImode", ":", "case", "E_V2SImode", ":", "case", "E_V4SFmode", ":", "case", "E_V2SFmode", ":", "gen", "=", "gen_neon_vrev64", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "default", ":", "return", "false", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nelt", ";", "i", "+=", "diff", "+", "<NUM_LIT>", ")", "for", "(", "j", "=", "<NUM_LIT>", ";", "j", "<=", "diff", ";", "j", "+=", "<NUM_LIT>", ")", "{", "gcc_assert", "(", "i", "+", "j", "<", "nelt", ")", ";", "if", "(", "d", "->", "perm", "[", "i", "+", "j", "]", "!=", "i", "+", "diff", "-", "j", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "emit_insn", "(", "gen", "(", "d", "->", "vmode", ",", "d", "->", "target", ",", "d", "->", "op0", ")", ")", ";", "return", "true", ";", "}" ]

[ "Recognize", "patterns", "for", "the", "VREV", "insns", "." ]

[ ")", ";" ]

[ "bool", "ARMAsmParser", "::", "parseDirectiveArch", "(", "SMLoc", "L", ")", "{", "StringRef", "Arch", "=", "getParser", "(", ")", ".", "parseStringToEndOfStatement", "(", ")", ".", "trim", "(", ")", ";", "unsigned", "ID", "=", "ARM", "::", "parseArch", "(", "Arch", ")", ";", "if", "(", "ID", "==", "ARM", "::", "AK_INVALID", ")", "{", "Error", "(", "L", ",", "<STR_LIT>", "Unknown arch name", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "Triple", "T", ";", "STI", ".", "setDefaultFeatures", "(", "T", ".", "getARMCPUForArch", "(", "Arch", ")", ")", ";", "setAvailableFeatures", "(", "ComputeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")" ]

[ "return", "<STR_LIT>", "sui", "<STR_LIT>", ";" ]

[ "break", ";", "case", "TRAP_SUFFIX_V_SV_SVI", ":", "switch", "(", "alpha_fptm", ")", "{", "case", "ALPHA_FPTM_N", ":", "return", "NULL", ";", "case", "ALPHA_FPTM_U", ":", "return", "<STR_LIT>", "v", "<STR_LIT>", ";", "case", "ALPHA_FPTM_SU", ":", "return", "<STR_LIT>", "sv", "<STR_LIT>", ";", "case", "ALPHA_FPTM_SUI", ":", "return", "<STR_LIT>", "svi", "<STR_LIT>", ";", "}", "break", ";", "case", "TRAP_SUFFIX_U_SU_SUI", ":", "switch", "(", "alpha_fptm", ")", "{", "case", "ALPHA_FPTM_N", ":", "return", "NULL", ";", "case", "ALPHA_FPTM_U", ":", "return", "<STR_LIT>", "u", "<STR_LIT>", ";", "case", "ALPHA_FPTM_SU", ":", "return", "<STR_LIT>", "su", "<STR_LIT>", ";", "case", "ALPHA_FPTM_SUI", ":" ]

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

[ "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

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

[ "case", "Intrinsic", "::", "aarch64_sve_index", ":", "return", "LowerSVEIntrinsicIndex", "(", "N", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_dup", ":", "return", "LowerSVEIntrinsicDUP", "(", "N", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_ext", ":", "return", "LowerSVEIntrinsicEXT", "(", "N", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmpeq_wide", ":", "return", "tryConvertSVEWideCompare", "(", "N", ",", "Intrinsic", "::", "aarch64_sve_cmpeq", ",", "false", ",", "DCI", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmpne_wide", ":", "return", "tryConvertSVEWideCompare", "(", "N", ",", "Intrinsic", "::", "aarch64_sve_cmpne", ",", "false", ",", "DCI", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmpge_wide", ":", "return", "tryConvertSVEWideCompare", "(", "N", ",", "Intrinsic", "::", "aarch64_sve_cmpge", ",", "false", ",", "DCI", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmpgt_wide", ":", "return", "tryConvertSVEWideCompare", "(", "N", ",", "Intrinsic", "::", "aarch64_sve_cmpgt", ",", "false", ",", "DCI", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmplt_wide", ":", "return", "tryConvertSVEWideCompare", "(", "N", ",", "Intrinsic", "::", "aarch64_sve_cmpgt", ",", "true", ",", "DCI", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmple_wide", ":", "return", "tryConvertSVEWideCompare", "(", "N", ",", "Intrinsic", "::", "aarch64_sve_cmpge", ",", "true", ",", "DCI", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmphs_wide", ":", "return", "tryConvertSVEWideCompare", "(", "N", ",", "Intrinsic", "::", "aarch64_sve_cmphs", ",", "false", ",", "DCI", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmphi_wide", ":", "return", "tryConvertSVEWideCompare", "(", "N", ",", "Intrinsic", "::", "aarch64_sve_cmphi", ",", "false", ",", "DCI", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmplo_wide", ":", "return", "tryConvertSVEWideCompare", "(", "N", ",", "Intrinsic", "::", "aarch64_sve_cmphi", ",", "true", ",", "DCI", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_cmpls_wide", ":", "return", "tryConvertSVEWideCompare", "(", "N", ",", "Intrinsic", "::", "aarch64_sve_cmphs", ",", "true", ",", "DCI", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_ptest_any", ":", "return", "getPTest", "(", "DAG", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>" ]

[ "}" ]

[ "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "Pred", ".", "push_back", "(", "MO", ")", ";", "flag", "=", "true", ";" ]

[ "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "abs", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "getTheThumbBETarget", "(", ")", ",", "createThumbBEAsmBackend", ")", ";" ]

[ "TargetRegistry", "::", "RegisterMCInstPrinter", "(", "*", "T", ",", "createARMMCInstPrinter", ")", ";", "TargetRegistry", "::", "RegisterMCRelocationInfo", "(", "*", "T", ",", "createARMMCRelocationInfo", ")", ";", "}", "for", "(", "Target", "*", "T", ":", "{", "&", "getTheARMLETarget", "(", ")", ",", "&", "getTheARMBETarget", "(", ")", "}", ")", "TargetRegistry", "::", "RegisterMCInstrAnalysis", "(", "*", "T", ",", "createARMMCInstrAnalysis", ")", ";", "for", "(", "Target", "*", "T", ":", "{", "&", "getTheThumbLETarget", "(", ")", ",", "&", "getTheThumbBETarget", "(", ")", "}", ")", "TargetRegistry", "::", "RegisterMCInstrAnalysis", "(", "*", "T", ",", "createThumbMCInstrAnalysis", ")", ";", "for", "(", "Target", "*", "T", ":", "{", "&", "getTheARMLETarget", "(", ")", ",", "&", "getTheThumbLETarget", "(", ")", "}", ")", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "*", "T", ",", "createARMLEMCCodeEmitter", ")", ";", "for", "(", "Target", "*", "T", ":", "{", "&", "getTheARMBETarget", "(", ")", ",", "&", "getTheThumbBETarget", "(", ")", "}", ")", "TargetRegistry", "::", "RegisterMCCodeEmitter", "(", "*", "T", ",", "createARMBEMCCodeEmitter", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "getTheARMLETarget", "(", ")", ",", "createARMLEAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "getTheARMBETarget", "(", ")", ",", "createARMBEAsmBackend", ")", ";", "TargetRegistry", "::", "RegisterMCAsmBackend", "(", "getTheThumbLETarget", "(", ")", ",", "createThumbLEAsmBackend", ")", ";" ]

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

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

[ "}" ]

[ "MVT", "::", "SimpleValueType", "Z80TargetLowering", "::", "getCmpLibcallReturnType", "(", ")", "const", "{", "return", "MVT", "::", "Other", ";" ]

[ "<NUM_LIT>", ";" ]

[ "def", "A2_addsp", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_679309b8", ",", "TypeALU64", ">", "{", "let", "isPseudo", "=" ]

[ ":", "$", "R1", ",", "bdxaddr12only", ":", "$", "XBD2", ")", ")", "]", ">", "{" ]

[ "class", "TestRXE", "<", "string", "mnemonic", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "SDPatternOperator", "operator", ",", "RegisterOperand", "cls", ">", ":", "InstRXE", "<", "opcode", ",", "(", "outs", ")", ",", "(", "ins", "cls", ":", "$", "R1", ",", "bdxaddr12only", ":", "$", "XBD2", ")", ",", "mnemonic", "#", "<STR_LIT>", ",", "[", "(", "set", "CC", ",", "(", "operator", "cls" ]

[ ";" ]

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

[ "<STR_LIT>", ":" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineFOr", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineFMinFMax", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "FMINNUM", ":", "case", "ISD", "::", "FMAXNUM", ":", "return", "combineFMinNumFMaxNum", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineX86INT_TO_FP", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineBT", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "combineZext", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "combineSext", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "combineSignExtendInReg", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "combineSetCC", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineX86SetCC", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineBrCond", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineVectorPack", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineVectorShiftVar", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineVectorShiftImm", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "combineVectorInsert", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::" ]

[ "break", ";" ]

[ "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "invalid fixup kind!", "<STR_LIT>", ")", ";", "case", "PPC", "::", "fixup_ppc_br24", ":", "Type", "=", "ELF", "::", "R_PPC_ADDR24", ";", "break", ";", "case", "PPC", "::", "fixup_ppc_brcond14", ":", "Type", "=", "ELF", "::", "R_PPC_ADDR14", ";", "break", ";", "case", "PPC", "::", "fixup_ppc_ha16", ":", "switch", "(", "Modifier", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported Modifier", "<STR_LIT>", ")", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL16_HA", ":", "Type", "=", "ELF", "::", "R_PPC_TPREL16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL16_HA", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_None", ":", "Type", "=", "ELF", "::", "R_PPC_ADDR16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TOC16_HA", ":", "Type", "=", "ELF", "::", "R_PPC64_TOC16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TPREL16_HA", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TPREL16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TLSGD16_HA", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TLSGD16_HA", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_GOT_TLSLD16_HA", ":", "Type", "=", "ELF", "::", "R_PPC64_GOT_TLSLD16_HA", ";", "break", ";", "}", "break", ";", "case", "PPC", "::", "fixup_ppc_lo16", ":", "switch", "(", "Modifier", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported Modifier", "<STR_LIT>", ")", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_TPREL16_LO", ":", "Type", "=", "ELF", "::", "R_PPC_TPREL16_LO", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_PPC_DTPREL16_LO", ":", "Type", "=", "ELF", "::", "R_PPC64_DTPREL16_LO", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_None", ":", "Type", "=", "ELF", "::", "R_PPC_ADDR16_LO", ";" ]

[ "}" ]

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

[ ")", ";" ]

[ "void", "ARMPassConfig", "::", "addPreEmitPass2", "(", ")", "{", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "addPass", "(", "createARMLowOverheadLoopsPass", "(", ")" ]

[ "}" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ ",", "_", "_", "m256", "_", "_", "Y", ",", "const", "int", "_", "_", "P", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask8", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_mask_cmp_ps_mask", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256", "_", "_", "X" ]

[ ".", "isPowerOf2", "(", ")", "||", "(", "-", "(", "MulC", "+", "<NUM_LIT>", ")", ")", ".", "isPowerOf2", "(", ")", ";" ]

[ "if", "(", "!", "ISD", "::", "isConstantSplatVector", "(", "C", ".", "getNode", "(", ")", ",", "MulC", ")", ")", "return", "false", ";", "if", "(", "isOperationLegal", "(", "ISD", "::", "MUL", ",", "VT", ")", ")", "return", "false", ";", "return", "(", "MulC", "+", "<NUM_LIT>", ")", ".", "isPowerOf2", "(", ")", "||", "(", "MulC", "-", "<NUM_LIT>", ")", ".", "isPowerOf2", "(", ")", "||", "(", "<NUM_LIT>", "-", "MulC", ")" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "src", ";", "let", "SrcExtra", "=", "{", "<NUM_LIT>", ",", "optype", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "sw", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";", "let", "OutOfSlotData", "=", "<NUM_LIT>", ";" ]

[ "void", "AArch64AsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid fixup offset!", "<STR_LIT>", ")", ";", "unsigned", "FulleSizeInBytes", "=", "getFixupKindContainereSizeInBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "FulleSizeInBytes", "==", "<NUM_LIT>", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ")", ";", "}", "}", "else", "{", "assert", "(", "(", "Offset", "+", "FulleSizeInBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid fixup size!", "<STR_LIT>", ")", ";", "assert", "(", "NumBytes", "<=", "FulleSizeInBytes", "&&", "<STR_LIT>", "Invalid fixup size!", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "FulleSizeInBytes", "-", "<NUM_LIT>", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "<NUM_LIT>", ")", ")", "&", "<NUM_LIT>", ")", ";", "}", "}", "}" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "<FIXS>", "FuncInfo", "->", "setVarArgsFrameIndex", "(", "MFI", "->", "CreateFixedObject", "(", "<NUM_LIT>", ",", "StackSize", ",", "true", ")", ")", ";", "<FIXE>" ]

[ "if", "(", "isVarArg", ")", "{", "if", "(", "Is64Bit", "||", "(", "CallConv", "!=", "CallingConv", "::", "X86_FastCall", "&&", "CallConv", "!=", "CallingConv", "::", "X86_ThisCall", ")", ")", "{", "<BUGS>", "FuncInfo", "->", "setVarArgsFrameIndex", "(", "MFI", "->", "CreateFixedObject", "(", "<NUM_LIT>", ",", "StackSize", ",", "true", ",", "false", ")", ")", ";", "<BUGE>", "}", "if", "(", "Is64Bit", ")", "{", "unsigned", "TotalNumIntRegs", "=", "<NUM_LIT>", ",", "TotalNumXMMRegs", "=", "<NUM_LIT>", ";" ]

[ "return", "Waitcnt", ";" ]

[ "Waitcnt", "=", "encodeExpcnt", "(", "Version", ",", "Waitcnt", ",", "Expcnt", ")", ";", "Waitcnt", "=", "encodeLgkmcnt", "(", "Version", ",", "Waitcnt", ",", "Lgkmcnt", ")", ";" ]

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

[ "setLoadExtAction", "(", "ISD", "::", "ZEXTLOAD", ",", "VT", ",", "MVT", "::", "i1", ",", "Promote", ")", ";", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "VT", ",", "MVT", "::", "i1", ",", "Promote", ")", ";", "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "VT", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setLoadExtAction", "(", "ISD", "::", "ZEXTLOAD", ",", "VT", ",", "MVT", "::", "i16", ",", "Expand", ")", ";", "}", "setOperationAction", "(", "ISD", "::", "LOAD", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VAEND", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "VACOPY", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "VAARG", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VASTART", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "STACKSAVE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "STACKRESTORE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "DYNAMIC_STACKALLOC", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "EH_RETURN", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "FRAME_TO_ARGS_OFFSET", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "ATOMIC_FENCE", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INIT_TRAMPOLINE", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "ADJUST_TRAMPOLINE", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INTRINSIC_WO_CHAIN", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "MaxStoresPerMemset", "=", "MaxStoresPerMemsetOptSize", "=", "<NUM_LIT>", ";", "MaxStoresPerMemmove", "=", "MaxStoresPerMemmoveOptSize", "=", "MaxStoresPerMemcpy", "=", "MaxStoresPerMemcpyOptSize", "=", "<NUM_LIT>", ";", "setTargetDAGCombine", "(", "{", "ISD", "::", "STORE", ",", "ISD", "::", "ADD", ",", "ISD", "::", "INTRINSIC_VOID", ",", "ISD", "::", "INTRINSIC_W_CHAIN", "}", ")", ";", "setMinFunctionAlignment", "(", "Align", "(", "<NUM_LIT>", ")", ")", ";", "setPrefFunctionAlignment", "(", "Align", "(", "<NUM_LIT>" ]

[ "<STR_LIT>", ")" ]

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

[ "consumer", ",", "def_reg2", ")", ")", ";" ]

[ "if", "(", "GET_CODE", "(", "PATTERN", "(", "producer", ")", ")", "==", "SET", ")", "{", "rtx", "dest", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "PATTERN", "(", "producer", ")", ")", ";", "if", "(", "(", "REG_P", "(", "dest", ")", "||", "GET_CODE", "(", "dest", ")", "==", "SUBREG", ")", "&&", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "src", ")", "==", "HIGH", ")", ")", "return", "false", ";", "}", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "break", ";", "case", "TYPE_MUL", ":", "case", "TYPE_MAC", ":", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "break", ";", "case", "TYPE_DIV", ":", "if", "(", "divmod_p", "(", "producer", ")", ")", "{", "rtx", "def_reg1", "=", "SET_DEST", "(", "parallel_element", "(", "producer", ",", "<NUM_LIT>", ")", ")", ";", "rtx", "def_reg2", "=", "SET_DEST", "(", "parallel_element", "(", "producer", ",", "<NUM_LIT>", ")", ")", ";", "return", "(", "e8_consumed_by_addr_in_p", "(", "consumer", ",", "def_reg1", ")", "||", "e8_consumed_by_addr_in_p", "(" ]

[ "TmpInst0", ".", "addOperand", "(", "MCOp", ")", ";" ]

[ "TmpInst0", ".", "setOpcode", "(", "Mips", "::", "JALR64", ")", ";", "HasLinkReg", "=", "true", ";", "}", "else", "if", "(", "Subtarget", "->", "hasMips32r6", "(", ")", ")", "{", "TmpInst0", ".", "setOpcode", "(", "Mips", "::", "JALR", ")", ";", "HasLinkReg", "=", "true", ";", "}", "else", "if", "(", "Subtarget", "->", "inMicroMipsMode", "(", ")", ")", "TmpInst0", ".", "setOpcode", "(", "Mips", "::", "JR_MM", ")", ";", "else", "{", "TmpInst0", ".", "setOpcode", "(", "Mips", "::", "JR", ")", ";", "}", "MCOperand", "MCOp", ";", "if", "(", "HasLinkReg", ")", "{", "unsigned", "ZeroReg", "=", "Subtarget", "->", "isGP64bit", "(", ")", "?", "Mips", "::", "ZERO_64", ":", "Mips", "::", "ZERO", ";", "TmpInst0", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "ZeroReg", ")", ")", ";", "}", "lowerOperand", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "MCOp", ")", ";" ]

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

[ "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "if_then_else", "(", "match_test", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")" ]

[ "<FIXS>", ".", "legalForCartesianProduct", "(", "{", "s8", ",", "s16", ",", "s32", ",", "s64", "}", ",", "{", "s1", ",", "s8", ",", "s16", ",", "s32", "}", ")", ";", "<FIXE>" ]

[ "getActionDefinitionsBuilder", "(", "{", "G_ZEXT", ",", "G_SEXT", ",", "G_ANYEXT", "}", ")", "<BUGS>", ".", "legalFor", "(", "{", "s1", ",", "s8", ",", "s16", ",", "s32", ",", "s64", "}", ")", ".", "maxScalar", "(", "<NUM_LIT>", ",", "s64", ")", ".", "widenScalarToNextPow2", "(", "<NUM_LIT>", ")", ";", "<BUGE>", "getActionDefinitionsBuilder", "(", "G_FPTRUNC", ")", ".", "legalFor", "(" ]

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

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

[ "const", "override", "{" ]

[ "MachineFunctionProperties", "getRequiredProperties", "(", ")" ]

[ "SDValue", "CCR", "=", "DAG", ".", "getRegister", "(", "ARM", "::", "CPSR", ",", "MVT", "::", "i32", ")", ";" ]

[ "SDValue", "Chain", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "LHS", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "RHS", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "ISD", "::", "CondCode", "CC", "=", "cast", "<", "CondCodeSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "get", "(", ")", ";", "bool", "IsSignaling", "=", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "STRICT_FSETCCS", ";", "if", "(", "isUnsupportedFloatingType", "(", "LHS", ".", "getValueType", "(", ")", ")", ")", "{", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "softenSetCCOperands", "(", "DAG", ",", "LHS", ".", "getValueType", "(", ")", ",", "LHS", ",", "RHS", ",", "CC", ",", "dl", ",", "LHS", ",", "RHS", ",", "Chain", ",", "IsSignaling", ")", ";", "if", "(", "!", "RHS", ".", "getNode", "(", ")", ")", "{", "RHS", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "LHS", ".", "getValueType", "(", ")", ")", ";", "CC", "=", "ISD", "::", "SETNE", ";", "}", "SDValue", "Result", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SETCC", ",", "dl", ",", "VT", ",", "LHS", ",", "RHS", ",", "DAG", ".", "getCondCode", "(", "CC", ")", ")", ";", "return", "DAG", ".", "getMergeValues", "(", "{", "Result", ",", "Chain", "}", ",", "dl", ")", ";", "}", "<STR_LIT>", "::", "<STR_LIT>", "CondCode", ",", "CondCode2", ";", "FPCCToARMCC", "(", "CC", ",", "CondCode", ",", "CondCode2", ")", ";", "SDValue", "True", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ";", "SDValue", "False", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ";", "SDValue", "ARMcc", "=", "DAG", ".", "getConstant", "(", "CondCode", ",", "dl", ",", "MVT", "::", "i32", ")", ";" ]

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

[ "if", "(", "!", "tls_get_addr_libfunc", ")", "tls_get_addr_libfunc", "=", "init_one_libfunc", "(" ]

[ "void", "R600TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "AMDGPUTargetLowering", "::", "ReplaceNodeResults", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "if", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "i1", ")", "{", "Results", ".", "push_back", "(", "lowerFP_TO_UINT", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ")", ")", ";", "return", ";", "}", "LLVM_FALLTHROUGH", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "{", "if", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "i1", ")", "{", "Results", ".", "push_back", "(", "lowerFP_TO_SINT", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ")", ")", ";", "return", ";", "}", "SDValue", "Result", ";", "if", "(", "expandFP_TO_SINT", "(", "N", ",", "Result", ",", "DAG", ")", ")", "Results", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "case", "ISD", "::", "SDIVREM", ":", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ";", "SDValue", "RES", "=", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "Results", ".", "push_back", "(", "RES", ")", ";", "Results", ".", "push_back", "(", "RES", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "UDIVREM", ":", "{", "SDValue", "Op", "=", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ";", "LowerUDIVREM64", "(", "Op", ",", "DAG", ",", "Results", ")", ";", "break", ";", "}", "}", "}" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

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

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

[ "Result", "=", "DAG", ".", "getLoad", "(", "DstVT", ",", "DL", ",", "Chain", ",", "StackSlot", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "SSFI", ")", ")", ";" ]

[ "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "SSFISize", "=", "DstVT", ".", "getStoreSize", "(", ")", ";", "int", "SSFI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "SSFISize", ",", "Align", "(", "SSFISize", ")", ",", "false", ")", ";", "auto", "PtrVT", "=", "getPointerTy", "(", "MF", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "StackSlot", "=", "DAG", ".", "getFrameIndex", "(", "SSFI", ",", "PtrVT", ")", ";", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ")", ";", "SDValue", "FSTOps", "[", "]", "=", "{", "Chain", ",", "Result", ",", "StackSlot", "}", ";", "MachineMemOperand", "*", "StoreMMO", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "SSFI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "SSFISize", ",", "Align", "(", "SSFISize", ")", ")", ";", "Chain", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Tys", ",", "FSTOps", ",", "DstVT", ",", "StoreMMO", ")", ";" ]

[ "if", "(", "Sel", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SELECT_CC", ")", "std", "::", "swap", "(", "Sel", ",", "Other", ")", ";" ]

[ "if", "(", "isOneConstant", "(", "Other", ")", "&&", "ISD", "::", "isOverflowIntrOpRes", "(", "Sel", ")", ")", "{", "if", "(", "!", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "isTypeLegal", "(", "Sel", "->", "getValueType", "(", "<NUM_LIT>", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "TVal", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDValue", "FVal", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "<STR_LIT>", "::", "<STR_LIT>", "CC", ";", "SDValue", "Value", ",", "Overflow", ";", "std", "::", "tie", "(", "Value", ",", "Overflow", ")", "=", "getAArch64XALUOOp", "(", "CC", ",", "Sel", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "DAG", ")", ";", "SDValue", "CCVal", "=", "DAG", ".", "getConstant", "(", "getInvertedCondCode", "(", "CC", ")", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "TVal", ",", "FVal", ",", "CCVal", ",", "Overflow", ")", ";", "}" ]

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

[ "bool", "avr_has_nibble_0xf", "(", "rtx", "ival", ")", "{", "unsigned", "int", "map", "=", "UINTVAL", "(", "ival", ")", "&", "GET_MODE_MASK", "(", "SImode", ")", ";", "return", "avr_map_metric", "(", "map", ",", "MAP_MASK_PREIMAGE_F", ")", "!=", "<NUM_LIT>", ";", "}" ]

[ "Return", "true", "if", "IVAL", "has", "a", "0xf", "in", "its", "hexadecimal", "representation", "and", "false", ",", "otherwise", ".", "Only", "nibbles", "0", "..", "7", "are", "taken", "into", "account", ".", "Used", "as", "constraint", "helper", "for", "C0f", "and", "Cxf", "." ]

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

[ ")", ";" ]

[ "using", "RPOTType", "=", "ReversePostOrderTraversal", "<", "const", "MachineFunction", "*", ">", ";", "RPOTType", "RPOT", "(", "MFN", ")", ";", "unsigned", "RPON", "=", "<NUM_LIT>", ";", "for", "(", "const", "auto", "&", "I", ":", "RPOT", ")", "RPO", "[", "I", "->", "getNumber", "(", ")", "]", "=", "RPON", "++", ";", "PairMapType", "Memo", ";", "for", "(", "const", "auto", "&", "I", ":", "IFMap", ")", "pruneUsesTooFar", "(", "I", ".", "first", ",", "RPO", ",", "Memo", ")", ";", "pruneEmptyLists", "(" ]

[ "break", ";" ]

[ "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "StackPtr", ",", "PtrOff", ")", ";", "if", "(", "isPPC64", "&&", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "i32", ")", "{", "unsigned", "ExtOp", "=", "Flags", ".", "isSExt", "(", ")", "?", "ISD", "::", "SIGN_EXTEND", ":", "ISD", "::", "ZERO_EXTEND", ";", "Arg", "=", "DAG", ".", "getNode", "(", "ExtOp", ",", "dl", ",", "MVT", "::", "i64", ",", "Arg", ")", ";", "}", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "unsigned", "Size", "=", "Flags", ".", "getByValSize", "(", ")", ";", "if", "(", "Size", "==", "<NUM_LIT>", "||", "Size", "==", "<NUM_LIT>", ")", "{", "EVT", "VT", "=", "(", "Size", "==", "<NUM_LIT>", ")", "?", "MVT", "::", "i8", ":", "MVT", "::", "i16", ";", "if", "(", "GPR_idx", "!=", "NumGPRs", ")", "{", "SDValue", "Load", "=", "DAG", ".", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "PtrVT", ",", "Chain", ",", "Arg", ",", "MachinePointerInfo", "(", ")", ",", "VT", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOpChains", ".", "push_back", "(", "Load", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPR", "[", "GPR_idx", "++", "]", ",", "Load", ")", ")", ";", "ArgOffset", "+=", "PtrByteSize", ";", "}", "else", "{", "SDValue", "Const", "=", "DAG", ".", "getConstant", "(", "PtrByteSize", "-", "Size", ",", "PtrOff", ".", "getValueType", "(", ")", ")", ";", "SDValue", "AddPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "PtrOff", ",", "Const", ")", ";", "Chain", "=", "CallSeqStart", "=", "createMemcpyOutsideCallSeq", "(", "Arg", ",", "AddPtr", ",", "CallSeqStart", ",", "Flags", ",", "DAG", ",", "dl", ")", ";", "ArgOffset", "+=", "PtrByteSize", ";", "}", "continue", ";", "}", "Chain", "=", "CallSeqStart", "=", "createMemcpyOutsideCallSeq", "(", "Arg", ",", "PtrOff", ",", "CallSeqStart", ",", "Flags", ",", "DAG", ",", "dl", ")", ";", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ";", "j", "<", "Size", ";", "j", "+=", "PtrByteSize", ")", "{", "SDValue", "Const", "=", "DAG", ".", "getConstant", "(", "j", ",", "PtrOff", ".", "getValueType", "(", ")", ")", ";", "SDValue", "AddArg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "Arg", ",", "Const", ")", ";", "if", "(", "GPR_idx", "!=", "NumGPRs", ")", "{", "SDValue", "Load", "=", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "Chain", ",", "AddArg", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOpChains", ".", "push_back", "(", "Load", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPR", "[", "GPR_idx", "++", "]", ",", "Load", ")", ")", ";", "ArgOffset", "+=", "PtrByteSize", ";", "}", "else", "{", "ArgOffset", "+=", "(", "(", "Size", "-", "j", "+", "PtrByteSize", "-", "<NUM_LIT>", ")", "/", "PtrByteSize", ")", "*", "PtrByteSize", ";", "break", ";", "}", "}", "continue", ";", "}", "switch", "(", "Arg", ".", "getSimpleValueType", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected ValueType for argument!", "<STR_LIT>", ")", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "if", "(", "GPR_idx", "!=", "NumGPRs", ")", "{", "if", "(", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "i1", ")", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "PtrVT", ",", "Arg", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPR", "[", "GPR_idx", "++", "]", ",", "Arg", ")", ")", ";", "}", "else", "{", "LowerMemOpCallTo", "(", "DAG", ",", "MF", ",", "Chain", ",", "Arg", ",", "PtrOff", ",", "SPDiff", ",", "ArgOffset", ",", "isPPC64", ",", "isTailCall", ",", "false", ",", "MemOpChains", ",", "TailCallArguments", ",", "dl", ")", ";", "}", "ArgOffset", "+=", "PtrByteSize", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "if", "(", "FPR_idx", "!=", "NumFPRs", ")", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "FPR", "[", "FPR_idx", "++", "]", ",", "Arg", ")", ")", ";", "if", "(", "isVarArg", ")", "{", "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Arg", ",", "PtrOff", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOpChains", ".", "push_back", "(", "Store", ")", ";", "if", "(", "GPR_idx", "!=", "NumGPRs", ")", "{", "SDValue", "Load", "=", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "Store", ",", "PtrOff", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOpChains", ".", "push_back", "(", "Load", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPR", "[", "GPR_idx", "++", "]", ",", "Load", ")", ")", ";", "}", "if", "(", "GPR_idx", "!=", "NumGPRs", "&&", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "f64", "&&", "!", "isPPC64", ")", "{", "SDValue", "ConstFour", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "PtrOff", ".", "getValueType", "(", ")", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "PtrOff", ",", "ConstFour", ")", ";", "SDValue", "Load", "=", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "Store", ",", "PtrOff", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOpChains", ".", "push_back", "(", "Load", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPR", "[", "GPR_idx", "++", "]", ",", "Load", ")", ")", ";", "}", "}", "else", "{", "if", "(", "GPR_idx", "!=", "NumGPRs", ")", "++", "GPR_idx", ";", "if", "(", "GPR_idx", "!=", "NumGPRs", "&&", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "f64", "&&", "!", "isPPC64", ")", "++", "GPR_idx", ";", "}", "}", "else", "LowerMemOpCallTo", "(", "DAG", ",", "MF", ",", "Chain", ",", "Arg", ",", "PtrOff", ",", "SPDiff", ",", "ArgOffset", ",", "isPPC64", ",", "isTailCall", ",", "false", ",", "MemOpChains", ",", "TailCallArguments", ",", "dl", ")", ";", "if", "(", "isPPC64", ")", "ArgOffset", "+=", "<NUM_LIT>", ";", "else", "ArgOffset", "+=", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";" ]

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

[ "if", "(", "!", "isTypeLegal", "(", "CFP", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "VT", "!=", "MVT", "::", "f32", "&&", "VT", "!=", "MVT", "::", "f64", ")", "return", "<NUM_LIT>", ";", "bool", "Is64Bit", "=", "(", "VT", "==", "MVT", "::", "f64", ")", ";", "unsigned", "ZReg", "=", "Is64Bit", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "Opc", "=", "Is64Bit", "?", "<STR_LIT>", "::" ]

[ "cached_can_issue_more", ";" ]

[ "if", "(", "rs6000_tune", "==", "PROCESSOR_POWER6", "&&", "last_scheduled_insn", ")", "return", "power6_sched_reorder2", "(", "ready", ",", "*", "pn_ready", "-", "<NUM_LIT>", ")", ";", "if", "(", "rs6000_tune", "==", "PROCESSOR_POWER9", "&&", "last_scheduled_insn", "&&", "recog_memoized", "(", "last_scheduled_insn", ")", ">=", "<NUM_LIT>", ")", "return", "power9_sched_reorder2", "(", "ready", ",", "*", "pn_ready", "-", "<NUM_LIT>", ")", ";", "if", "(", "rs6000_tune", "==", "PROCESSOR_POWER10", "&&", "last_scheduled_insn", ")", "return", "power10_sched_reorder", "(", "ready", ",", "*", "pn_ready", "-", "<NUM_LIT>", ")", ";", "return" ]

[ ")", ";" ]

[ "ConstantFP", "*", "Val", "=", "cast", "<", "ConstantFP", ">", "(", "Constant", "::", "getNullValue", "(", "Type", "::", "getDoubleTy", "(", "MF", ".", "getFunction", "(", ")", ".", "getContext", "(", ")", ")", ")", ")", ";", "MI", "->", "addOperand", "(", "MachineOperand", "::", "CreateFPImm", "(", "Val", ")", ")", ";", "}", "else", "if", "(", "RegClass", "==", "&", "WebAssembly", "::", "V128RegClass", ")", "{", "unsigned", "TempReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "WebAssembly", "::", "SPLAT_v4i32", ")", ")", ";", "MI", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "TempReg", ",", "false", ")", ")", ";", "MachineInstr", "*", "Const", "=", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "TempReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "LIS", ".", "InsertMachineInstrInMaps", "(", "*", "Const", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected reg class", "<STR_LIT>" ]

[ "bits", "<", "<NUM_LIT>", ">", "Inst", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "rs", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";" ]

[ "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "HasIndex", ";" ]

[ "let", "Size", "=", "size", ";", "let", "Pattern", "=", "pattern", ";", "let", "AsmString", "=", "asmstr", ";", "let", "hasSideEffects", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "mayStore", "=", "<NUM_LIT>", ";", "string", "DispKey", "=", "<STR_LIT>", ";", "string", "DispSize", "=", "<STR_LIT>", ";", "string", "OpKey", "=", "<STR_LIT>", ";", "string", "OpType", "=", "<STR_LIT>", ";", "string", "MemKey", "=", "<STR_LIT>", ";", "string", "MemType", "=", "<STR_LIT>", ";", "string", "NumOpsKey", "=", "<STR_LIT>", ";", "string", "NumOpsValue", "=", "<STR_LIT>", ";", "bit", "SimpleBDXLoad", "=", "<NUM_LIT>", ";", "bit", "SimpleBDXStore", "=", "<NUM_LIT>", ";", "bit", "Has20BitOffset", "=", "<NUM_LIT>", ";", "bit", "HasIndex", "=", "<NUM_LIT>", ";", "bit", "Is128Bit", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "AccessBytes", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "CCValues", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "CompareZeroCCMask", "=", "<NUM_LIT>", ";", "bit", "CCMaskFirst", "=", "<NUM_LIT>", ";", "bit", "CCMaskLast", "=", "<NUM_LIT>", ";", "bit", "IsLogical", "=", "<NUM_LIT>", ";", "bit", "CCIfNoSignedWrap", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "SimpleBDXLoad", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "SimpleBDXStore", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "Has20BitOffset", ";" ]

[ "static", "int", "check_constant_argument", "(", "enum", "insn_code", "icode", ",", "int", "opnum", ",", "rtx", "opval", ")", "{", "if", "(", "GET_CODE", "(", "opval", ")", "!=", "CONST_INT", ")", "{", "error", "(", "<STR_LIT>", "%qs expects a constant argument", "<STR_LIT>", ",", "insn_data", "[", "icode", "]", ".", "name", ")", ";", "return", "false", ";", "}", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ".", "predicate", ")", "(", "opval", ",", "VOIDmode", ")", ")", "{", "error", "(", "<STR_LIT>", "constant argument out of range for %qs", "<STR_LIT>", ",", "insn_data", "[", "icode", "]", ".", "name", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Return", "true", "if", "OPVAL", "can", "be", "used", "for", "operand", "OPNUM", "of", "instruction", "ICODE", ".", "The", "instruction", "should", "require", "a", "constant", "operand", "of", "some", "sort", ".", "The", "function", "prints", "an", "error", "if", "OPVAL", "is", "not", "valid", "." ]

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

[ "(", "define_code_iterator", "any_div", "[", "div", "udiv", "]", ")", "(", "define_code_attr", "paired_mod", "[", "(", "div", "<STR_LIT>", ")", "(", "udiv" ]

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

[ "static", "bool", "needsFPReturnHelper", "(", "Function", "&", "F", ")", "{", "Type", "*", "RetType", "=", "F", "." ]

[ ";" ]

[ "if", "(", "isFrameStoreOpcode", "(", "MI", ".", "getOpcode", "(", ")", ",", "MemBytes", ")", ")", "if", "(", "MI", ".", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "getSubReg", "(", ")", "==", "<NUM_LIT>", "&&", "isFrameOperand", "(", "MI", ",", "<NUM_LIT>", ",", "FrameIndex", ")", ")", "return", "MI", ".", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "getReg", "(", ")", ";", "return", "<NUM_LIT>" ]

[ "}", "else", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", "{" ]

[ "assert", "(", "Directive", "<=", "PPC", "::", "DIR_64", "&&", "<STR_LIT>", "Directive out of range.", "<STR_LIT>", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "<STR_LIT>", "\\t.machine ", "<STR_LIT>", "+", "Twine", "(", "CPUDirectives", "[", "Directive", "]", ")", ")", ";", "TargetLoweringObjectFileMachO", "&", "TLOFMacho", "=", "static_cast", "<", "TargetLoweringObjectFileMachO", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "TLOFMacho", ".", "getTextCoalSection", "(", ")", ")", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "OutContext", ".", "getMachOSection", "(", "<STR_LIT>", "__TEXT", "<STR_LIT>", ",", "<STR_LIT>", "__picsymbolstub1", "<STR_LIT>", ",", "MCSectionMachO", "::", "S_SYMBOL_STUBS", "|", "MCSectionMachO", "::", "S_ATTR_PURE_INSTRUCTIONS", ",", "<NUM_LIT>", ",", "SectionKind", "::", "getText", "(", ")", ")", ")", ";" ]

[ "]", ")" ]

[ "(", "V4SF", "\t", "<STR_LIT>", ")", "(", "V2DF", "\t", "<STR_LIT>", ")" ]

[ "static", "bool", "ix86_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "mode1", "==", "mode2", ")", "return", "true", ";", "if", "(", "ix86_tieable_integer_mode_p", "(", "mode1", ")", "&&", "ix86_tieable_integer_mode_p", "(", "mode2", ")", ")", "return", "true", ";", "if", "(", "mode2", "==", "XFmode", ")", "return", "mode1", "==", "SFmode", "||", "mode1", "==", "DFmode", ";", "if", "(", "mode2", "==", "DFmode", ")", "return", "mode1", "==", "SFmode", ";", "if", "(", "GET_MODE_SIZE", "(", "mode2", ")", "==", "<NUM_LIT>", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode2", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode1", ")", "==", "<NUM_LIT>", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode1", ")", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode2", ")", "==", "<NUM_LIT>", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode2", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode1", ")", "==", "<NUM_LIT>", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode1", ")", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode2", ")", "==", "<NUM_LIT>", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode2", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode1", ")", "==", "<NUM_LIT>", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_SSE_REG", ",", "mode1", ")", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode2", ")", "==", "<NUM_LIT>", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_MMX_REG", ",", "mode2", ")", ")", "return", "(", "GET_MODE_SIZE", "(", "mode1", ")", "==", "<NUM_LIT>", "&&", "ix86_hard_regno_mode_ok", "(", "FIRST_MMX_REG", ",", "mode1", ")", ")", ";", "if", "(", "(", "mode1", "==", "E_SCmode", "&&", "mode2", "==", "E_DImode", ")", "||", "(", "mode1", "==", "E_DImode", "&&", "mode2", "==", "E_SCmode", ")", ")", "return", "TARGET_64BIT", ";", "if", "(", "(", "mode1", "==", "E_SCmode", "&&", "mode2", "==", "E_V2SFmode", ")", "||", "(", "mode1", "==", "E_V2SFmode", "&&", "mode2", "==", "E_SCmode", ")", "||", "(", "mode1", "==", "E_DCmode", "&&", "mode2", "==", "E_V2DFmode", ")", "||", "(", "mode1", "==", "E_V2DFmode", "&&", "mode2", "==", "E_DCmode", ")", ")", "return", "true", ";", "return", "false", ";", "}" ]

[ "Return", "true", "if", "MODE1", "is", "accessible", "in", "a", "register", "that", "can", "hold", "MODE2", "without", "copying", ".", "That", "is", ",", "all", "register", "classes", "that", "can", "hold", "MODE2", "can", "also", "hold", "MODE1", "." ]

[ ",", "<STR_LIT>", ",", "v2i64", ",", "NEONvsri", ">", ";" ]

[ "def", "v2i64", ":", "N2VQShIns", "<", "op24", ",", "op23", ",", "op11_8", ",", "<NUM_LIT>", ",", "op4", ",", "shr_imm64", ",", "N2RegVShRFrm", ",", "OpcodeStr" ]

[ ")" ]

[ "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "DI", "(", "sign_extend", ":", "DI", "(", "vec_select", ":", "SI", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "sign_extend", ":", "DI", "(", "vec_select", ":", "SI", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "<FIXS>", "Type", "*", "Ty", "=", "MemVT", ".", "getTypeForEVT", "(", "*", "DCI", ".", "DAG", ".", "getContext", "(", ")", ")", ";", "AddrMode", "AM", ";", "AM", ".", "HasBaseReg", "=", "true", ";", "AM", ".", "BaseOffs", "=", "Offset", ".", "getSExtValue", "(", ")", ";", "if", "(", "!", "isLegalAddressingMode", "(", "DCI", ".", "DAG", ".", "getDataLayout", "(", ")", ",", "AM", ",", "Ty", ",", "AddrSpace", ")", ")", "<FIXE>" ]

[ "APInt", "Offset", "=", "CAdd", "->", "getAPIntValue", "(", ")", "<<", "CN1", "->", "getAPIntValue", "(", ")", ";", "<BUGS>", "if", "(", "!", "canFoldOffset", "(", "Offset", ".", "getZExtValue", "(", ")", ",", "AddrSpace", ",", "*", "getSubtarget", "(", ")", ")", ")", "<BUGE>", "return", "SDValue", "(", ")", ";", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";" ]

[ "}" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "MemRegOffsetAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "GPR", ":", "$", "base", ",", "GPRnopc", ":", "$", "offsreg", ",", "i32imm", ":", "$", "shift", ")", ";" ]

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

[ "def", "AArch64Extr", ":", "SDNode", "<" ]

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

[ "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "neg", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", ":", "SI", "(", "mult", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>" ]

[ "}" ]

[ "if", "(", "!", "Root", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "Options", ".", "UnsafeFPMath", ")", "return", "false", ";", "bool", "Commute", ";", "if", "(", "isReassocCandidate", "(", "Root", ",", "Commute", ")", ")", "{", "if", "(", "Commute", ")", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MC_REASSOC_AX_YB", ")", ";", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MC_REASSOC_XA_YB", ")", ";", "}", "else", "{", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MC_REASSOC_AX_BY", ")", ";", "Patterns", ".", "push_back", "(", "MachineCombinerPattern", "::", "MC_REASSOC_XA_BY", ")", ";" ]

[ "if", "(", "isMatchingUpdateInsn", "(", "MI", ",", "BaseReg", ",", "RegSize", ")", ")", "return", "MBBI", ";" ]

[ "const", "MachineFunction", "&", "MF", "=", "*", "MemMI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "unsigned", "DestReg", "=", "getLdStRegOp", "(", "MemMI", ")", ".", "getReg", "(", ")", ";", "unsigned", "BaseReg", "=", "getLdStBaseOp", "(", "MemMI", ")", ".", "getReg", "(", ")", ";", "int", "Offset", "=", "getLdStOffsetOp", "(", "MemMI", ")", ".", "getImm", "(", ")", ";", "unsigned", "RegSize", "=", "TII", "->", "getRegClass", "(", "MemMI", "->", "getDesc", "(", ")", ",", "<NUM_LIT>", ",", "TRI", ",", "MF", ")", "->", "getSize", "(", ")", ";", "if", "(", "MBBI", "==", "B", "||", "Offset", "!=", "<NUM_LIT>", ")", "return", "E", ";", "if", "(", "DestReg", "==", "BaseReg", "||", "TRI", "->", "isSubRegister", "(", "BaseReg", ",", "DestReg", ")", ")", "return", "E", ";", "BitVector", "ModifiedRegs", ",", "UsedRegs", ";", "ModifiedRegs", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "UsedRegs", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "--", "MBBI", ";", "for", "(", "unsigned", "Count", "=", "<NUM_LIT>", ";", "MBBI", "!=", "B", ";", "--", "MBBI", ")", "{", "MachineInstr", "*", "MI", "=", "MBBI", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "continue", ";", "++", "Count", ";" ]

[ "<FIXS>", "unsigned", "OptLevel", ",", "bool", "Verbose", ")", ";", "<FIXE>" ]

[ "FunctionPass", "*", "createXCoreISelDag", "(", "XCoreTargetMachine", "&", "TM", ")", ";", "FunctionPass", "*", "createXCoreCodePrinterPass", "(", "raw_ostream", "&", "OS", ",", "XCoreTargetMachine", "&", "TM", ",", "<BUGS>", "bool", "Fast", ",", "bool", "Verbose", ")", ";", "<BUGE>", "}" ]

[ "}" ]

[ "bool", "LanaiTargetObjectFile", "::", "isGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "return", "(", "isGlobalInSmallSectionImpl", "(", "GV", ",", "TM", ")", "&&", "(", "Kind", ".", "isData", "(", ")", "||", "Kind", ".", "isBSS", "(", ")", "||", "Kind", ".", "isCommon", "(", ")", ")", ")", ";" ]

[ "<FIXS>", "MachineBasicBlock", "*", "Mips16TargetLowering", "::", "emitSeliT16", "(", "unsigned", "Opc1", ",", "unsigned", "Opc2", ",", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "<FIXE>", "<FIXS>", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "<FIXE>" ]

[ "}", "<BUGS>", "MachineBasicBlock", "*", "Mips16TargetLowering", "::", "emitSeliT16", "(", "unsigned", "Opc1", ",", "unsigned", "Opc2", ",", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "<BUGE>", "if", "(", "DontExpandCondPseudos16", ")", "return", "BB", ";", "<BUGS>", "const", "TargetInstrInfo", "*", "TII", "=", "getTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "<BUGE>", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";" ]

[ "let", "Dest", "=", "dest", ";" ]

[ "class", "SpuInstConvertIntGen2", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "string", "asmstr", ",", "bit", "hasImm", ">", ":", "ScalarInstBase", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", "SRF", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "!", "if", "(", "hasImm", ",", "(", "ins", "SRF", ":", "$", "op1", ",", "TPCImm", "<", "i32imm", ">", ":", "$", "op2", ",", "SwitchSet", ":", "$", "sw", ",", "SRF", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ",", "(", "ins", "SRF", ":", "$", "op1", ",", "SRF", ":", "$", "op2", ",", "SwitchSet", ":", "$", "sw", ",", "SRF", ":", "$", "income", ",", "SPred", ":", "$", "pred", ")", ")", ";", "let", "Itinerary", "=", "IIC_ScalarOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";" ]

[ "SDValue", "ARMTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "bool", "isThisReturn", ",", "SDValue", "ThisVal", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "ARMCCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ",", "Call", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "CCAssignFnForNode", "(", "CallConv", ",", "true", ",", "isVarArg", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "i", "==", "<NUM_LIT>", "&&", "isThisReturn", ")", "{", "assert", "(", "!", "VA", ".", "needsCustom", "(", ")", "&&", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i32", "&&", "<STR_LIT>", "unexpected return calling convention register assignment", "<STR_LIT>", ")", ";", "InVals", ".", "push_back", "(", "ThisVal", ")", ";", "continue", ";", "}", "SDValue", "Val", ";", "if", "(", "VA", ".", "needsCustom", "(", ")", ")", "{", "SDValue", "Lo", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "MVT", "::", "i32", ",", "InFlag", ")", ";", "Chain", "=", "Lo", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InFlag", "=", "Lo", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "VA", "=", "RVLocs", "[", "++", "i", "]", ";", "SDValue", "Hi", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "MVT", "::", "i32", ",", "InFlag", ")", ";", "Chain", "=", "Hi", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InFlag", "=", "Hi", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "f64", ",", "Lo", ",", "Hi", ")", ";", "if", "(", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "v2f64", ")", "{", "SDValue", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "UNDEF", ",", "dl", ",", "MVT", "::", "v2f64", ")", ";", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "dl", ",", "MVT", "::", "v2f64", ",", "Vec", ",", "Val", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "VA", "=", "RVLocs", "[", "++", "i", "]", ";", "Lo", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "MVT", "::", "i32", ",", "InFlag", ")", ";", "Chain", "=", "Lo", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InFlag", "=", "Lo", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "VA", "=", "RVLocs", "[", "++", "i", "]", ";", "Hi", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "MVT", "::", "i32", ",", "InFlag", ")", ";", "Chain", "=", "Hi", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InFlag", "=", "Hi", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "f64", ",", "Lo", ",", "Hi", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "dl", ",", "MVT", "::", "v2f64", ",", "Vec", ",", "Val", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "}", "}", "else", "{", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown loc info!", "<STR_LIT>", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "}", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "<NUM_LIT>", ";" ]

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

[ ";" ]

[ "PointerType", "*", "VecPtrTy", "=", "PointerType", "::", "get", "(", "Vec", "->", "getType", "(", ")", ",", "AddrSpace", ")", ";", "Value", "*", "PtrCast", "=", "IC", ".", "Builder", ".", "CreateBitCast", "(", "Ptr", ",", "VecPtrTy", ",", "<STR_LIT>", "castvec", "<STR_LIT>", ")", ";", "IC", ".", "Builder", ".", "CreateMaskedStore", "(", "Vec", ",", "PtrCast", ",", "Align", "(", "<NUM_LIT>", ")", ",", "BoolMask", ")", ";", "IC", ".", "eraseInstFromFunction", "(", "II", ")", ";", "return", "true" ]

[ "(", "unspec_volatile", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_MFSPR", ")", ")", "]" ]

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

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<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", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<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>", ";" ]

[ "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", "isPredicatedFalse", "=", "<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", "isMoveImm", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign" ]

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

[ "class", "BaseSIMDModifiedImmVectorShift", "<", "bit", "Q", ",", "bit", "op", ",", "bits", "<", "<NUM_LIT>", ">", "b15_b12", ",", "RegisterOperand", "vectype", ",", "string", "asm", ",", "string", "kind", ",", "list", "<", "dag", ">", "pattern", ">", ":", "BaseSIMDModifiedImmVector", "<", "Q", ",", "op", ",", "<NUM_LIT>", ",", "vectype", ",", "imm0_255", ",", "(", "ins", "logical_vec_shift", ":", "$", "shift", ")", ",", "<STR_LIT>", ",", "asm", ",", "kind", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">", "shift", ";" ]

[ ")", ")" ]

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

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

[ "if", "(", "SCVMinus1", ".", "isPowerOf2", "(", ")", ")", "{", "ShiftAmt", "=", "SCVMinus1", ".", "logBase2", "(", ")", ";", "AddSubOpc", "=", "TargetOpcode", "::", "G_ADD", ";", "}", "else", "if", "(", "CVPlus1", ".", "isPowerOf2", "(", ")", ")", "{", "ShiftAmt", "=", "CVPlus1", ".", "logBase2", "(", ")", ";", "AddSubOpc", "=", "TargetOpcode", "::", "G_SUB", ";", "}", "else", "return", "false", ";", "}", "else", "{", "APInt", "CVNegPlus1", "=", "-", "ConstValue", "+", "<NUM_LIT>", ";", "APInt", "CVNegMinus1", "=", "-", "ConstValue", "-", "<NUM_LIT>", ";", "if", "(", "CVNegPlus1", ".", "isPowerOf2", "(", ")", ")", "{", "ShiftAmt", "=", "CVNegPlus1", ".", "logBase2", "(", ")", ";", "AddSubOpc", "=", "TargetOpcode", "::", "G_SUB", ";", "ShiftValUseIsLHS", "=", "false", ";", "}", "else", "if", "(", "CVNegMinus1", ".", "isPowerOf2", "(", ")", ")", "{", "ShiftAmt", "=", "CVNegMinus1", ".", "logBase2", "(", ")", ";", "AddSubOpc", "=", "TargetOpcode", "::", "G_ADD", ";", "NegateResult", "=", "true", ";", "}", "else", "return", "false", ";", "}", "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", "." ]

[ "return", "DstReg", ";" ]

[ "SRegs", ".", "push_back", "(", "SGPR", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "UseMI", ".", "getParent", "(", ")", ",", "UseMI", ",", "UseMI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "AMDGPU", "::", "REG_SEQUENCE", ")", ",", "DstReg", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "SubRegs", ";", "++", "i", ")", "{", "MIB", ".", "addReg", "(", "SRegs", "[", "i", "]", ")", ";", "MIB", ".", "addImm", "(", "RI", ".", "getSubRegFromChannel", "(", "i", ")", ")", ";", "}" ]

[ ")", ";" ]

[ "FunctionType", "*", "TrampolineTy", "=", "FunctionType", "::", "get", "(", "Int32Ty", ",", "makeArrayRef", "(", "&", "ArgTys", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "false", ")", ";", "FunctionType", "*", "TargetFuncTy", "=", "FunctionType", "::", "get", "(", "Int32Ty", ",", "makeArrayRef", "(", "&", "ArgTys", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "false", ")", ";", "Function", "*", "Trampoline", "=", "Function", "::", "Create", "(", "TrampolineTy", ",", "GlobalValue", "::", "InternalLinkage", ",", "Twine", "(", "<STR_LIT>", "__ehhandler$", "<STR_LIT>", ")", "+", "GlobalValue", "::", "getRealLinkageName", "(", "ParentFunc", "->", "getName", "(", ")", ")", ",", "TheModule", ")", ";", "BasicBlock", "*", "EntryBB", "=", "BasicBlock", "::", "Create", "(", "Context", ",", "<STR_LIT>", "entry", "<STR_LIT>", ",", "Trampoline", ")", ";", "IRBuilder", "<", ">", "Builder", "(", "EntryBB", ")", ";", "Value", "*", "LSDA", "=", "emitEHLSDA", "(", "Builder", ",", "ParentFunc", ")", ";", "Value", "*", "CastPersonality", "=", "Builder", ".", "CreateBitCast", "(", "PersonalityFn", ",", "TargetFuncTy", "->", "getPointerTo", "(", ")", ")", ";", "auto", "AI", "=", "Trampoline", "->", "arg_begin", "(", ")", ";", "Value", "*", "Args", "[", "<NUM_LIT>", "]", "=", "{", "LSDA", ",", "&", "*", "AI", "++", ",", "&", "*", "AI", "++", ",", "&", "*", "AI", "++", ",", "&", "*", "AI", "++", "}", ";", "CallInst", "*", "Call", "=", "Builder", ".", "CreateCall", "(", "CastPersonality", ",", "Args", ")", ";", "Call", "->", "setTailCall", "(", "true", ")", ";", "Call", "->", "addAttribute", "(", "<NUM_LIT>", ",", "Attribute", "::", "InReg", ")", ";", "Builder", ".", "CreateRet", "(", "Call" ]

[ "<NUM_LIT>", "-", "offs", ")", ";" ]

[ "else", "if", "(", "offs", ">", "GET_MODE_SIZE", "(", "SImode", ")", "&&", "offs", "<", "GET_MODE_SIZE", "(", "DImode", ")", ")", "offs", "=", "GET_MODE_SIZE", "(", "DImode", ")", ";", "return", "gen_rtx_REG", "(", "BLKmode", ",", "avr_ret_register", "(", ")", "+" ]

[ "insn", "=", "emit_frame_insn", "(", "gen_movsf", "(", "mem", ",", "tmp", ")", ")", ";" ]

[ "{", "rtx", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "volatile_p", ";", "emit_frame_insn", "(", "gen_movsi", "(", "mem", ",", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ")", ")", ";", "}", "break", ";", "case", "mdb", ":", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "DImode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "DImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "volatile_p", ";", "emit_insn", "(", "gen_movdi", "(", "tmp", ",", "reg", ")", ")", ";", "if", "(", "volatile_p", ")", "emit_insn", "(", "gen_movdi", "(", "mem", ",", "tmp", ")", ")", ";", "else", "{", "insn", "=", "emit_frame_insn", "(", "gen_movdi", "(", "mem", ",", "tmp", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "}", "break", ";", "case", "mdc", ":", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "SImode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "volatile_p", ";", "emit_insn", "(", "gen_movsi", "(", "tmp", ",", "reg", ")", ")", ";", "insn", "=", "emit_frame_insn", "(", "gen_movsi", "(", "mem", ",", "tmp", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "break", ";", "case", "floating", ":", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "SFmode", ",", "PROLOGUE_TMP_REGNUM", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "SFmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "SFmode", ",", "regno", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "volatile_p", ";", "emit_insn", "(", "gen_movsf", "(", "tmp", ",", "reg", ")", ")", ";" ]

[ "inline", "tree", "function_instance", "::", "displacement_vector_type", "(", ")", "const", "{", "return", "acle_vector_types", "[", "<NUM_LIT>", "]", "[", "mode_suffix", "(", ")", ".", "displacement_vector_type", "]", ";", "}" ]

[ "Return", "the", "type", "of", "the", "function", "'s", "vector", "index", "or", "offset", "argument", ",", "or", "null", "if", "does", "n't", "have", "a", "vector", "index", "or", "offset", "argument", "." ]

[ "void", "XCoreRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "if", "(", "FP", ")", "{", "unsigned", "FramePtr", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "FramePtr", ")", ";", "}", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "assert", "(", "FrameSize", "%", "<NUM_LIT>", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Misaligned frame size", "<STR_LIT>", ")", ";", "FrameSize", "/", "=", "<NUM_LIT>", ";", "bool", "isU6", "=", "isImmU6", "(", "FrameSize", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "FrameSize", ")", ")", "{", "std", "::", "string", "msg", ";", "raw_string_ostream", "Msg", "(", "msg", ")", ";", "Msg", "<<", "<STR_LIT>", "emitEpilogue Frame size too big: ", "<STR_LIT>", "<<", "FrameSize", ";", "llvm_report_error", "(", "Msg", ".", "str", "(", ")", ")", ";", "}", "if", "(", "FrameSize", ")", "{", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "if", "(", "FP", ")", "{", "int", "FPSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getFPSpillSlot", "(", ")", ")", ";", "FPSpillOffset", "+=", "FrameSize", "*", "<NUM_LIT>", ";", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "FPSpillOffset", ",", "dl", ")", ";", "}", "bool", "restoreLR", "=", "XFI", "->", "getUsesLR", "(", ")", ";", "if", "(", "restoreLR", "&&", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", "!=", "<NUM_LIT>", ")", "{", "int", "LRSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", ";", "LRSpillOffset", "+=", "FrameSize", "*", "<NUM_LIT>", ";", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "LRSpillOffset", ",", "dl", ")", ";", "restoreLR", "=", "false", ";", "}", "if", "(", "restoreLR", ")", "{", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "int", "Opcode", "=", "(", "isU6", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "FrameSize", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "else", "{", "int", "Opcode", "=", "(", "isU6", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "}", "}" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "true", ";" ]

[ "for", "(", "auto", "&", "GV", ":", "M", ".", "globals", "(", ")", ")", "{", "if", "(", "GV", ".", "isThreadLocal", "(", ")", ")", "{", "Stripped", "=" ]

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

[ "static", "std", "::", "unique_ptr", "<", "AArch64Operand", ">", "CreatePrefetch", "(", "unsigned", "Val", ",", "StringRef", "Str", ",", "SMLoc", "S", ",", "MCContext", "&", "Ctx", ")", "{", "auto", "Op", "=", "std", "::", "make_unique", "<", "AArch64Operand", ">", "(", "k_Prefetch", ",", "Ctx", ")", ";", "Op", "->", "Prefetch", ".", "Val", "=", "Val", ";", "Op", "->", "Barrier", ".", "Data", "=", "Str", ".", "data", "(", ")", ";", "Op", "->", "Barrier", ".", "Length", "=", "Str", ".", "size", "(", ")", ";", "Op", "->", "StartLoc", "=", "S", ";" ]

[ "<NUM_LIT>", ";" ]

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

[ "static", "void", "symbian_add_attribute", "(", "tree", "node", ",", "const", "char", "*", "attr_name", ")", "{", "tree", "attrs", ";", "tree", "attr", ";", "attrs", "=", "DECL_P", "(", "node", ")", "?", "DECL_ATTRIBUTES", "(", "node", ")", ":", "TYPE_ATTRIBUTES", "(", "node", ")", ";", "if", "(", "lookup_attribute", "(", "attr_name", ",", "attrs", ")", "!=", "NULL_TREE", ")", "return", ";", "attr", "=", "get_identifier", "(", "attr_name", ")", ";", "if", "(", "DECL_P", "(", "node", ")", ")", "DECL_ATTRIBUTES", "(", "node", ")", "=", "tree_cons", "(", "attr", ",", "NULL_TREE", ",", "attrs", ")", ";", "else", "TYPE_ATTRIBUTES", "(", "node", ")", "=", "tree_cons", "(", "attr", ",", "NULL_TREE", ",", "attrs", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "propogate %s attribute", "<STR_LIT>", ",", "attr_name", ")", ";", "print_node_brief", "(", "stderr", ",", "<STR_LIT>", " to", "<STR_LIT>", ",", "node", ",", "<NUM_LIT>", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "}" ]

[ "Add", "the", "named", "attribute", "to", "the", "given", "node", ".", "Copes", "with", "both", "DECLs", "and", "TYPEs", ".", "Will", "only", "add", "the", "attribute", "if", "it", "is", "not", "already", "present", "." ]

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

[ "(", "smin", "<STR_LIT>", ")", "(", "umax", "<STR_LIT>", ")", "(", "umin", "<STR_LIT>", ")", "(", "ss_minus", "<STR_LIT>", ")", "(", "ss_plus", "<STR_LIT>", ")", "(", "us_minus", "<STR_LIT>", ")", "(", "us_plus", "<STR_LIT>", ")", "(", "and", "<STR_LIT>", ")", "(", "ior", "<STR_LIT>", ")", "(", "xor", "<STR_LIT>", ")", "(", "bswap", "<STR_LIT>", ")", "(", "clz", "<STR_LIT>", ")", "(", "ctz", "<STR_LIT>", ")" ]

[ ";" ]

[ "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "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>" ]

[ "}" ]

[ "void", "SystemZCopyPhysRegs", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";" ]

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

[ "UNSPEC_VPDPBSUD", "UNSPEC_VPDPBSUDS", "UNSPEC_VPDPBUUD" ]

[ ")", ";" ]

[ "if", "(", "MF", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "<STR_LIT>", "Can only return in registers!", "<STR_LIT>", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "Tile64MachineFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "Tile64MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "FI", "->", "getSRetReturnReg", "(" ]

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

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VSIBADDR", ")", "]", ")", "(", "mem", ":", "BLK", "(", "scratch", ")", ")", "(", "match_operand", ":", "<", "VEC_GATHER_SRCDI", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_GATHER", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "VI4F_256", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]