Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "(", "MMOBegin", ",", "MMOEnd", ")", ";" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Addr", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MIB", ".", "addOperand", "(", "Addr", "[", "i", "]", ")", ";", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "(", "*", "MIB", ")", ".", "setMemRefs" ]

[ "<FIXS>", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "<FIXE>" ]

[ "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "hard_frame_pointer_rtx", ",", "<BUGS>", "plus_constant", "(", "stack_pointer_rtx", ",", "<BUGE>", "size", ")", ")", ")", ";", "}" ]

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

[ "if", "(", "rgn", "==", "CONTAINING_RGN", "(", "e", "->", "src", "->", "index", ")", "&&", "BLOCK_TO_BB", "(", "bb", "->", "index", ")", ">", "BLOCK_TO_BB", "(", "e", "->", "src", "->", "index", ")", ")", "add_dependee_for_func_arg", "(", "first_arg", ",", "e", "->", "src", ")", ";", "}", "}", "insn", "=", "first_arg", ";", "if", "(", "insn", "==", "head", ")", "break", ";", "}", "}", "else", "if", "(", "first_arg", ")", "avoid_func_arg_motion", "(", "first_arg" ]

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

[ "def", "VLD1d16T", ":", "VLD1D3", "<", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "?", "}", ",", "<STR_LIT>" ]

[ "}" ]

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

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

[ "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "TARGET_V32", "&", "&", "MEM_P", "(", "operands" ]

[ "}" ]

[ "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "return", "FramePtr", ";", "return", "ARM", "::", "SP", ";" ]

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

[ "SDValue", "Base", "=", "LD", "->", "getBasePtr", "(", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Base", ",", "getAL", "(", "CurDAG", ",", "SDLoc", "(", "N", ")", ")", ",", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "Chain", "}", ";", "SDNode", "*", "New", "=", "CurDAG", "->", "getMachineNode", "(", "ARM", "::", "tLDR_postidx", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Ops", ")", ";", "transferMemOperands", "(", "N", ",", "New", ")", ";", "ReplaceNode", "(", "N", "," ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "immr", ";", "bits", "<", "<NUM_LIT>", ">", "imms", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "immr", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imms", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "<STR_LIT>", ")" ]

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

[ ")", "{" ]

[ "static", "inline", "bool", "IsImageType", "(", "StringRef", "TypeString" ]

[ "<STR_LIT>" ]

[ "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "(", "unspec", ":", "DI", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_CALLEE_ABI", ")", "(", "clobber", "(", "reg", ":", "DI", "LR_REGNUM", ")", ")", "]", ")", "]", "<STR_LIT>" ]

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

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

[ "<FIXS>", "def", ":", "Pat", "(", "v2i64", "(", "InVecOp", "(", "loadv8i16", "addr", ":", "$", "src", ")", ")", ")", ",", "<FIXE>" ]

[ "(", "!", "cast", "I", ">", "(", "OpcPrefix", "#", "WQZ128rm", ")", "addr", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "v2i64", "(", "InVecOp", "(", "v8i16", "(", "vzload_v2i64", "addr", ":", "$", "src", ")", ")", ")", ")", ",", "(", "!", "cast", "I", ">", "(", "OpcPrefix", "#", "WQZ128rm", ")", "addr", ":", "$", "src", ")", ">", ";", "<BUGS>", "def", ":", "Pat", "(", "v2i64", "(", "InVecOp", "(", "bc_v8i16", "(", "loadv2i64", "addr", ":", "$", "src", ")", ")", ")", ")", ",", "<BUGE>", "(", "!", "cast", "I", ">", "(", "OpcPrefix", "#", "WQZ128rm", ")", "addr", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "v2i64", "(", "InVecOp", "(", "bc_v4i32", "(", "v2i64", "(", "scalar_to_vector", "(", "loadi64", "addr", ":", "$", "src", ")", ")", ")", ")", ")", ")", "," ]

[ "if", "(", "VT", "==", "MVT", "::", "i32", "||", "(", "VT", "==", "MVT", "::", "i16", "&&", "Subtarget", "->", "hasMed3_16", "(", ")", ")", ")", "return", "DAG", ".", "getNode", "(", "Med3Opc", ",", "SL", ",", "VT", ",", "Src", ",", "MaxVal", ",", "MinVal", ")", ";" ]

[ "ConstantSDNode", "*", "MaxK", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "MaxVal", ")", ";", "if", "(", "!", "MinK", "||", "!", "MaxK", ")", "return", "SDValue", "(", ")", ";", "if", "(", "Signed", ")", "{", "if", "(", "MaxK", "->", "getAPIntValue", "(", ")", ".", "sge", "(", "MinK", "->", "getAPIntValue", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "}", "else", "{", "if", "(", "MaxK", "->", "getAPIntValue", "(", ")", ".", "uge", "(", "MinK", "->", "getAPIntValue", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "}", "EVT", "VT", "=", "MinK", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "unsigned", "Med3Opc", "=", "Signed", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "}" ]

[ "static", "int", "sh_symbian_get_strip_length", "(", "int", "c", ")", "{", "return", "(", "c", "==", "SH_SYMBIAN_FLAG_CHAR", "[", "<NUM_LIT>", "]", ")", "?", "strlen", "(", "DLL_EXPORT_PREFIX", ")", ":", "<NUM_LIT>", ";" ]

[ "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "const", "MipsTargetMachine", "*", "_", "TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "ABI", "(", "MipsABIInfo", "::", "Unknown", "(", ")", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFPXX", "(", "false", ")", ",", "NoABICalls", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "UseOddSPReg", "(", "true", ")", ",", "IsNaN2008bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasCnMips", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasMips3_32", "(", "false", ")", ",", "HasMips3_32r2", "(", "false", ")", ",", "HasMips4_32", "(", "false", ")", ",", "HasMips4_32r2", "(", "false", ")", ",", "HasMips5_32r2", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "TM", "(", "_", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "DL", "(", "computeDataLayout", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ",", "TM", ")", ")", ")", ",", "TSInfo", "(", "DL", ")", ",", "InstrInfo", "(", "MipsInstrInfo", "::", "create", "(", "*", "this", ")", ")", ",", "FrameLowering", "(", "MipsFrameLowering", "::", "create", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "MipsTargetLowering", "::", "create", "(", "*", "TM", ",", "*", "this", ")", ")", "{", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "if", "(", "MipsArchVersion", "==", "Mips1", ")", "report_fatal_error", "(", "<STR_LIT>", "Code generation for MIPS-I is not implemented", "<STR_LIT>", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips2", ")", "report_fatal_error", "(", "<STR_LIT>", "Code generation for MIPS-II is not implemented", "<STR_LIT>", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips3", ")", "report_fatal_error", "(", "<STR_LIT>", "Code generation for MIPS-III is not implemented", "<STR_LIT>", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips5", ")", "report_fatal_error", "(", "<STR_LIT>", "Code generation for MIPS-V is not implemented", "<STR_LIT>", ",", "false", ")", ";", "assert", "(", "ABI", ".", "IsKnown", "(", ")", ")", ";", "assert", "(", "(", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureO32", ")", "!=", "<NUM_LIT>", ")", "+", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureEABI", ")", "!=", "<NUM_LIT>", ")", "+", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureN32", ")", "!=", "<NUM_LIT>", ")", "+", "(", "(", "getFeatureBits", "(", ")", "&", "Mips", "::", "FeatureN64", ")", "!=", "<NUM_LIT>", ")", ")", "==", "<NUM_LIT>", ")", ";", "assert", "(", "(", "(", "!", "isGP64bit", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "isGP64bit", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "<STR_LIT>", "Invalid Arch & ABI pair.", "<STR_LIT>", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "MSA requires a 64-bit FPU register file (FR=1 mode). ", "<STR_LIT>", "<STR_LIT>", "See -mattr=+fp64.", "<STR_LIT>", ",", "false", ")", ";", "if", "(", "!", "isABI_O32", "(", ")", "&&", "!", "useOddSPReg", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "-mattr=+nooddspreg requires the O32 ABI.", "<STR_LIT>", ",", "false", ")", ";", "if", "(", "IsFPXX", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "FPXX is not permitted for the N32/N64 ABI's.", "<STR_LIT>", ",", "false", ")", ";", "if", "(", "hasMips32r6", "(", ")", ")", "{", "StringRef", "ISA", "=", "hasMips64r6", "(", ")", "?", "<STR_LIT>", "MIPS64r6", "<STR_LIT>", ":", "<STR_LIT>", "MIPS32r6", "<STR_LIT>", ";", "assert", "(", "isFP64bit", "(", ")", ")", ";", "assert", "(", "isNaN2008", "(", ")", ")", ";", "if", "(", "hasDSP", "(", ")", ")", "report_fatal_error", "(", "ISA", "+", "<STR_LIT>", " is not compatible with the DSP ASE", "<STR_LIT>", ",", "false", ")", ";", "}", "if", "(", "TT", ".", "find", "(", "<STR_LIT>", "linux", "<STR_LIT>", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "UseSmallSection", "=", "!", "IsLinux", "&&", "(", "TM", "->", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", ";", "}" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

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

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

[ "}" ]

[ "asm_fprintf", "(", "f", ",", "<STR_LIT>", "\\tmfusr\\t$r16,$pc\\n", "<STR_LIT>", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "\\tlwi\\t$r15,[$r16 + 20] ", "<STR_LIT>", "<STR_LIT>", "! load nested function address\\n", "<STR_LIT>", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "\\tlwi\\t$r16,[$r16 + 16] ", "<STR_LIT>", "<STR_LIT>", "! load chain_value\\n", "<STR_LIT>", ")", ";", "asm_fprintf", "(", "f", ",", "<STR_LIT>", "\\tjr\\t$r15\\n", "<STR_LIT>", ")", ";" ]

[ "<FIXS>", "class", "MFHI_DESC", ":", "MFHI_DESC_BASE", "<STR_LIT>", ",", "ACC64DSPOpnd", ",", "MipsExtractHI", ",", "NoItinerary", ">", ";", "class", "MFLO_DESC", ":", "MFHI_DESC_BASE", "<STR_LIT>", ",", "ACC64DSPOpnd", ",", "MipsExtractLO", ",", "NoItinerary", ">", ";", "<FIXE>" ]

[ "Defs", "[", "DSPOutFlag16_19", "]", ">", ";", "<BUGS>", "class", "MFHI_DESC", ":", "MFHI_DESC_BASE", "<STR_LIT>", ",", "HI32DSPOpnd", ",", "NoItinerary", ">", ";", "class", "MFLO_DESC", ":", "MFHI_DESC_BASE", "<STR_LIT>", ",", "LO32DSPOpnd", ",", "NoItinerary", ">", ";", "<BUGE>", "class", "MTHI_DESC", ":", "MTHI_DESC_BASE", "<STR_LIT>", ",", "HI32DSPOpnd", ",", "NoItinerary", ">", ";", "class", "MTLO_DESC", ":", "MTHI_DESC_BASE", "<STR_LIT>", ",", "LO32DSPOpnd", ",", "NoItinerary", ">", ";" ]

[ "assert", "(", "Opc", "&&", "<STR_LIT>", "Unknown register class", "<STR_LIT>", ")", ";" ]

[ "else", "assert", "(", "SrcReg", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register store without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register store without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register store without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register store without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register store without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register store without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "}" ]

[ ";" ]

[ "if", "(", "(", "i", "==", "-", "<NUM_LIT>", ")", "||", "(", "i", ">=", "<NUM_LIT>", "&&", "i", "<=", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "}", "return", "<NUM_LIT>" ]

[ "(", "NewMask", ")", ",", "NewOp2", ")", ")", ";" ]

[ "SDValue", "NewOp1", "=", "BITCAST", "(", "A", ",", "MVT", "::", "v4i32", ")", ";", "SDValue", "NewOp2", "=", "BITCAST", "(", "B", ",", "MVT", "::", "v4i32", ")", ";", "SDValue", "R", "=", "OR", "(", "AND", "(", "NewMask", ",", "NewOp1", ")", ",", "AND", "(", "NOT" ]

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

[ "addr", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "addr", "&&", "CONSTANT_ADDRESS_P", "(", "addr", ")", ")", "<BUGS>", "return", "DATA_OR_EXTENDED_REGS", ";", "<BUGE>", "}" ]

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

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

[ "<FIXS>", "{", "fprintf", "(", "file", ",", "<STR_LIT>", "\\t%s\\t%s,", "<STR_LIT>", ",", "(", "TARGET_SINGLE_FLOAT", "?", "(", "store_p", "?", "<STR_LIT>", "s.s", "<STR_LIT>", ":", "<STR_LIT>", "l.s", "<STR_LIT>", ")", ":", "(", "store_p", "?", "<STR_LIT>", "s.d", "<STR_LIT>", ":", "<STR_LIT>", "l.d", "<STR_LIT>", ")", ")", ",", "reg_names", "[", "regno", "]", ")", ";", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "fp_offset", "-", "base_offset", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "(%s)\\n", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "base_reg_rtx", ")", "]", ")", ";", "}", "<FIXE>" ]

[ "emit_move_insn", "(", "reg_rtx", ",", "mem_rtx", ")", ";", "}", "else", "<BUGS>", "fprintf", "(", "file", ",", "<STR_LIT>", "\\t%s\\t%s,%ld(%s)\\n", "<STR_LIT>", ",", "(", "TARGET_SINGLE_FLOAT", "?", "(", "store_p", "?", "<STR_LIT>", "s.s", "<STR_LIT>", ":", "<STR_LIT>", "l.s", "<STR_LIT>", ")", ":", "(", "store_p", "?", "<STR_LIT>", "s.d", "<STR_LIT>", ":", "<STR_LIT>", "l.d", "<STR_LIT>", ")", ")", ",", "reg_names", "[", "regno", "]", ",", "fp_offset", "-", "base_offset", ",", "reg_names", "[", "REGNO", "(", "base_reg_rtx", ")", "]", ")", ";", "<BUGE>", "fp_offset", "-=", "fp_size", ";", "}" ]

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

[ "bool", "isVectorIndex64", "(" ]

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

[ "return", "AMDGPU", "::", "IsaInfo", "::", "getMaxWavesPerEU" ]

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

[ "let", "Name", "=", "<STR_LIT>", ";", "let", "ParserMethod", "=", "<STR_LIT>", ";" ]

[ "}" ]

[ "for", "(", "const", "auto", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", "&&", "MO", ".", "isDef", "(", ")", ")", "return", "true", ";", "return", "false", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_cvtusepi16_storeu_epi8", "(", "void", "*", "_", "_", "P", ",", "_", "_", "mmask32", "_", "_", "M", ",", "_", "_", "m512i", "_", "_", "A", ")", "{", "_", "_", "builtin_ia32_pmovuswb512mem_mask", "(", "(", "_", "_", "v32qi", "*", ")", "_", "_", "P", ",", "(", "_", "_", "v32hi", ")", "_", "_", "A", ",", "_", "_", "M", ")", ";" ]

[ "<FIXS>", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "global_options_set", ",", "&", "cur_target", ")", ";", "<FIXE>" ]

[ "break", ";", "}", "<BUGS>", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "cur_target", ")", ";", "<BUGE>", "if", "(", "predicate_list", "&&", "arg_str", "==", "NULL", ")", "{" ]

[ "[", "P0", "]", ";" ]

[ "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", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=" ]

[ "Op", ".", "getFPImm", "(", ")", ")", ")", ")", ";" ]

[ "}", "else", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "assert", "(", "(", "OpNo", "<", "Desc", ".", "getNumOperands", "(", ")", "||", "(", "Desc", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "&&", "<STR_LIT>", "WebAssemblyII::VariableOpIsImmediate should be set for ", "<STR_LIT>", "<STR_LIT>", "variable_ops immediate ops", "<STR_LIT>", ")", ";", "(", "void", ")", "Desc", ";", "O", "<<", "Op", ".", "getImm", "(", ")", ";", "}", "else", "if", "(", "Op", ".", "isFPImm", "(", ")", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "assert", "(", "OpNo", "<", "Desc", ".", "getNumOperands", "(", ")", "&&", "<STR_LIT>", "Unexpected floating-point immediate as a non-fixed operand", "<STR_LIT>", ")", ";", "assert", "(", "Desc", ".", "TSFlags", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "WebAssembly variable_ops floating point ops don't use TSFlags", "<STR_LIT>", ")", ";", "const", "MCOperandInfo", "&", "Info", "=", "Desc", ".", "OpInfo", "[", "OpNo", "]", ";", "if", "(", "Info", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_F32IMM", ")", "{", "O", "<<", "toString", "(", "APFloat", "(", "float", "(" ]

[ "if", "(", "CntName", "==", "<STR_LIT>", "vmcnt", "<STR_LIT>", ")", "IntVal", "=", "encodeVmcnt", "(", "ISA", ",", "IntVal", ",", "CntVal", ")", ";" ]

[ "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Integer", ")", ")", "return", "true", ";", "if", "(", "getParser", "(", ")", ".", "parseAbsoluteExpression", "(", "CntVal", ")", ")", "return", "true", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "RParen", ")", ")", "return", "true", ";", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Amp", ")", "||", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "AMDGPU", "::", "IsaInfo", "::", "IsaVersion", "ISA", "=", "AMDGPU", "::", "IsaInfo", "::", "getIsaVersion", "(", "getFeatureBits", "(", ")", ")", ";" ]

[ "case", "<NUM_LIT>", ":", "return", "V4BImode", ";" ]

[ "case", "<NUM_LIT>", ":", "return", "V16BImode", ";", "case", "<NUM_LIT>", ":", "return", "V8BImode", ";" ]

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

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

[ "class", "BaseLoadStorePreIdx", "<", "bits", "<", "<NUM_LIT>", ">", "sz", ",", "bit", "V", ",", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "dag", "oops", ",", "dag", "iops", ",", "string", "asm", ",", "string", "cstr", ",", "list", "<", "dag", ">", "pat", ">", ":", "I", "<", "oops", ",", "iops", ",", "asm", ",", "<STR_LIT>", ",", "cstr", ",", "pat", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "def", "CMLSvvv_2D", ":", "NeonI_compare_aliases", "<", "<STR_LIT>", ",", "<STR_LIT>", ",", "CMHSvvv_2D" ]

[ "]", ">", ",", "VEX", ",", "VEX_WIG", ";" ]

[ "def", "VMOVLPSmr", ":", "VPSI", "<", "<NUM_LIT>", ",", "MRMDestMem", ",", "(", "outs", ")", ",", "(", "ins", "f64mem", ":", "$", "dst", ",", "VR128", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "(", "store", "(", "f64", "(", "extractelt", "(", "bc_v2f64", "(", "v4f32", "VR128", ":", "$", "src", ")", ")", ",", "(", "iPTR", "<NUM_LIT>", ")", ")", ")", ",", "addr", ":", "$", "dst", ")" ]

[ "_", "_", "m128", "_", "_", "A", ",", "const", "int", "_", "_", "imm", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask8", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_fpclass_ps_mask", "(", "_", "_", "mmask8", "_", "_", "U", "," ]

[ "<FIXS>", "if", "(", "type", "==", "CLOBBER", ")", "return", "(", "a", "==", "SHIFT_LOOP", "||", "lr", "==", "SHIFT_LOOP", "||", "ar", "==", "SHIFT_LOOP", "||", "(", "TARGET_H8300H", "&&", "mode", "==", "SImode", "&&", "count", "==", "<NUM_LIT>", ")", ")", ";", "else", "if", "(", "type", "==", "ASHIFT", ")", "return", "(", "a", "==", "SHIFT_LOOP", "||", "(", "TARGET_H8300H", "&&", "mode", "==", "SImode", "&&", "count", "==", "<NUM_LIT>", ")", ")", ";", "else", "if", "(", "type", "==", "LSHIFTRT", ")", "return", "(", "lr", "==", "SHIFT_LOOP", "||", "(", "TARGET_H8300H", "&&", "mode", "==", "SImode", "&&", "count", "==", "<NUM_LIT>", ")", ")", ";", "else", "if", "(", "type", "==", "ASHIFTRT", ")", "return", "(", "ar", "==", "SHIFT_LOOP", "||", "(", "TARGET_H8300H", "&&", "mode", "==", "SImode", "&&", "count", "==", "<NUM_LIT>", ")", ")", ";", "<FIXE>" ]

[ "}", "<BUGS>", "return", "(", "a", "==", "SHIFT_LOOP", "||", "lr", "==", "SHIFT_LOOP", "||", "ar", "==", "SHIFT_LOOP", "||", "(", "TARGET_H8300H", "&&", "mode", "==", "SImode", "&&", "count", "==", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "}" ]

[ ",", "NVTBLFrm", ",", "IIC_VTB3", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ";" ]

[ "def", "VTBL3", ":", "N3V", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "DPR", ":", "$", "Vd", ")", ",", "(", "ins", "VecListThreeD", ":", "$", "Vn", ",", "DPR", ":", "$", "Vm", ")" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_cvtepi64_epi16", "(", "_", "_", "m128i", "_", "_", "O", ",", "_", "_", "mmask8", "_", "_", "M", ",", "_", "_", "m512i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pmovqw512_mask", "(", "(", "_", "_", "v8di", ")", "_", "_", "A", ",", "(", "_", "_", "v8hi", ")", "_", "_", "O", ",", "_", "_", "M", ")", ";" ]

[ "const", "{" ]

[ "basic_block", "bb", "(", "void", ")" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "match_parallel", "<NUM_LIT>", "<STR_LIT>", "[", "(", "unspec_volatile", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPECV_VZEROUPPER", ")", "]", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ",", "LoadNOP", ",", "pattern", ">", ";" ]

[ "class", "ILAInst", "<", "dag", "OOL", ",", "dag", "IOL", ",", "list", "<", "dag", ">", "pattern", ">", ":", "RI18Form", "<", "<NUM_LIT>", ",", "OOL", ",", "IOL", ",", "<STR_LIT>" ]

[ "if", "(", "Info", "->", "getScratchWaveOffsetReg", "(", ")", "!=", "AMDGPU", "::", "SCRATCH_WAVE_OFFSET_REG", ")", "{" ]

[ "void", "SITargetLowering", "::", "finalizeLowering", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "Info", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "if", "(", "Info", "->", "isEntryFunction", "(", ")", ")", "{", "reservePrivateMemoryRegs", "(", "getTargetMachine", "(", ")", ",", "MF", ",", "*", "TRI", ",", "*", "Info", ")", ";", "}", "assert", "(", "!", "TRI", "->", "isSubRegister", "(", "Info", "->", "getScratchRSrcReg", "(", ")", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ")", ";", "if", "(", "Info", "->", "getStackPtrOffsetReg", "(", ")", "!=", "AMDGPU", "::", "SP_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "SP_REG", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ";", "if", "(", "Info", "->", "getScratchRSrcReg", "(", ")", "!=", "AMDGPU", "::", "PRIVATE_RSRC_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "PRIVATE_RSRC_REG", ",", "Info", "->", "getScratchRSrcReg", "(", ")", ")", ";", "if", "(", "Info", "->", "getFrameOffsetReg", "(", ")", "!=", "AMDGPU", "::", "FP_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "FP_REG", ",", "Info", "->", "getFrameOffsetReg", "(", ")", ")", ";" ]

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

[ "(", "define_mode_attr", "v", "\t", "[", "(", "V8HI", "<STR_LIT>", ")", "(", "V4SI", "<STR_LIT>", ")", "(", "HI", "<STR_LIT>", ")", "(", "SI", "<STR_LIT>" ]

[ "HeaderMBB", "->", "splice", "(", "HeaderMBB", "->", "end", "(", ")", ",", "MBB", ",", "MBB", "->", "begin", "(", ")", ",", "MBB", "->", "end", "(", ")", ")", ";" ]

[ "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "*", "RangeCheck", "=", "MRI", ".", "getVRegDef", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ")", ";", "assert", "(", "RangeCheck", "!=", "nullptr", ")", ";", "if", "(", "RangeCheck", "->", "getOpcode", "(", ")", "!=", "WebAssembly", "::", "GT_U_I32", ")", "return", "nullptr", ";", "MI", ".", "removeOperand", "(", "MI", ".", "getNumExplicitOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "MI", ".", "addOperand", "(", "MF", ",", "MachineOperand", "::", "CreateMBB", "(", "TBB", ")", ")", ";", "}", "TII", ".", "removeBranch", "(", "*", "HeaderMBB", ",", "nullptr", ")", ";" ]

[ "<STR_LIT>", ";" ]

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

[ ")", ";" ]

[ "static", "tree", "avr_fold_absfx", "(", "tree", "tval", ")", "{", "if", "(", "FIXED_CST", "!=", "TREE_CODE", "(", "tval", ")", ")", "return", "NULL_TREE", ";", "FIXED_VALUE_TYPE", "fval", "=", "TREE_FIXED_CST", "(", "tval", ")", ";", "unsigned", "int", "bits", "=", "GET_MODE_BITSIZE", "(", "fval", ".", "mode", ")", ";", "double_int", "ival", "=", "fval", ".", "data", ".", "sext", "(", "bits" ]

[ "]", ")" ]

[ "(", "define_peephole2", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "]", ")", ")", "]", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_op_dup", "<NUM_LIT>", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", ")", ")", "(", "clobber", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", ")" ]

[ ")", ")" ]

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

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

[ "gcc_assert", "(", "whole_jump_insn", "!=", "NULL_RTX", "&&", "LABEL_P", "(", "whole_jump_insn", ")", ")", ";", "whole_jump_insn", "=", "prev_nonnote_nondebug_insn", "(", "whole_jump_insn", ")", ";", "gcc_assert", "(", "whole_jump_insn", "!=", "NULL_RTX", "&&", "JUMP_P", "(", "whole_jump_insn", ")", ")", ";", "rtx", "whole_jump_pat", "=", "PATTERN" ]

[ "}" ]

[ "bool", "X86PassConfig", "::", "addPostFastRegAllocRewrite", "(", ")", "{", "addPass", "(", "createX86FastTileConfigPass", "(", ")", ")", ";", "return", "true", ";" ]

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

[ "if", "(", "TARGET_HARD_QUAD", ")", "emit_hard_tfmode_operation", "(", "code", "," ]

[ "<FIXS>", "if", "(", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", "==", "INVALID_REGNUM", ")", "<FIXE>", "<FIXS>", "else", "if", "(", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", "==", "INVALID_REGNUM", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "ROUND_UP", "(", "varargs_and_saved_regs_size", "+", "get_frame_size", "(", ")", ",", "<FIXE>" ]

[ "if", "(", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", "==", "SLOT_REQUIRED", ")", "{", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", "=", "offset", ";", "<BUGS>", "if", "(", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", "==", "FIRST_PSEUDO_REGISTER", ")", "<BUGE>", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", "=", "regno", ";", "<BUGS>", "else", "if", "(", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", "==", "FIRST_PSEUDO_REGISTER", "<BUGE>", "&&", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", ">=", "V0_REGNUM", ")", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", "=", "regno", ";", "offset", "+=", "UNITS_PER_WORD", ";", "}", "<BUGS>", "cfun", "->", "machine", "->", "frame", ".", "padding0", "=", "(", "ROUND_UP", "(", "offset", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", "-", "offset", ")", ";", "<BUGE>", "offset", "=", "ROUND_UP", "(", "offset", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "cfun", "->", "machine", "->", "frame", ".", "saved_regs_size", "=", "offset", ";", "cfun", "->", "machine", "->", "frame", ".", "hard_fp_offset", "<BUGS>", "ROUND_UP", "(", "cfun", "->", "machine", "->", "frame", ".", "saved_varargs_size", "+", "get_frame_size", "(", ")", "+", "cfun", "->", "machine", "->", "frame", ".", "saved_regs_size", ",", "<BUGE>", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "cfun", "->", "machine", "->", "frame", ".", "frame_size" ]

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

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

[ "<FIXS>", "int", "FIOffset", ";", "<FIXE>" ]

[ "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "<BUGS>", "int64_t", "FIOffset", ";", "<BUGE>", "Register", "BasePtr", ";", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "{", "assert", "(", "(", "!", "hasStackRealignment", "(", "MF", ")", "||" ]

[ "}" ]

[ "static", "bool", "h8300_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "mode1", "==", "mode2", "||", "(", "(", "mode1", "==", "QImode", "||", "mode1", "==", "HImode", "||", "mode1", "==", "SImode", ")", "&&", "(", "mode2", "==", "QImode", "||", "mode2", "==", "HImode", "||", "mode2", "==", "SImode", ")", ")", ")", ";" ]

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

[ "const", "size_t", "TagHeaderSize", "=", "<NUM_LIT>", "+", "<NUM_LIT>", ";", "Streamer", ".", "EmitIntValue", "(", "VendorHeaderSize", "+", "TagHeaderSize", "+", "ContentsSize", ",", "<NUM_LIT>", ")", ";", "Streamer", ".", "EmitBytes", "(", "CurrentVendor", ",", "<NUM_LIT>", ")", ";", "Streamer", ".", "EmitIntValue", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "Streamer", ".", "EmitIntValue", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ")", ";", "Streamer", ".", "EmitIntValue", "(", "TagHeaderSize", "+", "ContentsSize", ",", "<NUM_LIT>", ")", ";", "Streamer", ".", "EmitBytes", "(", "Contents", "," ]

[ "=", "FI", ";" ]

[ "InArgFIRange", ".", "second" ]

[ "(", "Regs", "[", "i", "]", ".", "second", ")", ")", ";" ]

[ "else", "{", "NewBase", "=", "Scratch", ";", "if", "(", "NewBase", "==", "<NUM_LIT>", ")", "return", "false", ";", "}", "int", "BaseOpc", "=", "!", "isThumb2", "?", "ARM", "::", "ADDri", ":", "(", "(", "Base", "==", "ARM", "::", "SP", ")", "?", "ARM", "::", "t2ADDrSPi", ":", "ARM", "::", "t2ADDri", ")", ";", "if", "(", "Offset", "<", "<NUM_LIT>", ")", "{", "BaseOpc", "=", "!", "isThumb2", "?", "ARM", "::", "SUBri", ":", "(", "(", "Base", "==", "ARM", "::", "SP", ")", "?", "ARM", "::", "t2SUBrSPi", ":", "ARM", "::", "t2SUBri", ")", ";", "Offset", "=", "-", "Offset", ";", "}", "int", "ImmedOffset", "=", "isThumb2", "?", "<STR_LIT>", "::", "<STR_LIT>", "(", "Offset", ")", ":", "<STR_LIT>", "::", "<STR_LIT>", "(", "Offset", ")", ";", "if", "(", "ImmedOffset", "==", "-", "<NUM_LIT>", ")", "return", "false", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", "->", "get", "(", "BaseOpc", ")", ",", "NewBase", ")", ".", "addReg", "(", "Base", ",", "getKillRegState", "(", "BaseKill", ")", ")", ".", "addImm", "(", "Offset", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "Base", "=", "NewBase", ";", "BaseKill", "=", "true", ";", "}", "bool", "isDPR", "=", "(", "Opcode", "==", "ARM", "::", "VLDRD", "||", "Opcode", "==", "ARM", "::", "VSTRD", ")", ";", "bool", "isDef", "=", "(", "isi32Load", "(", "Opcode", ")", "||", "Opcode", "==", "ARM", "::", "VLDRS", "||", "Opcode", "==", "ARM", "::", "VLDRD", ")", ";", "Opcode", "=", "getLoadStoreMultipleOpcode", "(", "Opcode", ")", ";", "MachineInstrBuilder", "MIB", "=", "(", "isAM4", ")", "?", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", "->", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "Base", ",", "getKillRegState", "(", "BaseKill", ")", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Mode", ")", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ":", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", "->", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "Base", ",", "getKillRegState", "(", "BaseKill", ")", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Mode", ",", "isDPR", "?", "NumRegs", "<<", "<NUM_LIT>", ":", "NumRegs", ")", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumRegs", ";", "++", "i", ")", "MIB", "=", "MIB", ".", "addReg", "(", "Regs", "[", "i", "]", ".", "first", ",", "getDefRegState", "(", "isDef", ")", "|", "getKillRegState" ]

[ "<FIXS>", "def", ":", "ProcessorModel", "<STR_LIT>", ",", "Z196Model", ",", "<FIXE>", "<FIXS>", "def", ":", "ProcessorModel", "<STR_LIT>", ",", "ZEC12Model", ",", "<FIXE>", "<FIXS>", "def", ":", "ProcessorModel", "<STR_LIT>", ",", "Z13Model", ",", "<FIXE>" ]

[ "def", ":", "Processor", "<STR_LIT>", ",", "NoItineraries", ",", "[", "]", ">", ";", "def", ":", "Processor", "<STR_LIT>", ",", "NoItineraries", ",", "[", "]", ">", ";", "<BUGS>", "def", ":", "Processor", "<STR_LIT>", ",", "NoItineraries", ",", "<BUGE>", "[", "FeatureDistinctOps", ",", "FeatureLoadStoreOnCond", ",", "FeatureHighWord", ",", "FeatureFPExtension", ",", "FeaturePopulationCount", ",", "FeatureFastSerialization", ",", "FeatureInterlockedAccess1", "]", ">", ";", "<BUGS>", "def", ":", "Processor", "<STR_LIT>", ",", "NoItineraries", ",", "<BUGE>", "[", "FeatureDistinctOps", ",", "FeatureLoadStoreOnCond", ",", "FeatureHighWord", ",", "FeatureFPExtension", ",", "FeaturePopulationCount", ",", "FeatureFastSerialization", ",", "FeatureInterlockedAccess1", ",", "FeatureMiscellaneousExtensions", ",", "FeatureTransactionalExecution", ",", "FeatureProcessorAssist", "]", ">", ";", "<BUGS>", "def", ":", "Processor", "<STR_LIT>", ",", "NoItineraries", ",", "<BUGE>", "[", "FeatureDistinctOps", ",", "FeatureLoadStoreOnCond", ",", "FeatureHighWord", ",", "FeatureFPExtension", ",", "FeaturePopulationCount", ",", "FeatureFastSerialization", ",", "FeatureInterlockedAccess1", ",", "new", "file", "mode", "<NUM_LIT>" ]

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

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

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

[ "return", "(", "_", "_", "mmask16", ")", "_", "_", "builtin_ia32_cmpb128_mask", "(", "(", "_", "_", "v16qi", ")", "_", "_", "X", ",", "(", "_", "_", "v16qi", ")", "_", "_", "Y", ",", "<NUM_LIT>", ",", "(", "_" ]

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

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "const_string" ]

[ "<NUM_LIT>", ")", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "pc", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "visium_split_cbranch", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", "," ]

[ "}" ]

[ "const", "AArch64GNULDBackend", "&", "getTarget", "(", ")", "const", "{", "return", "m_Target", ";" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "DI", "(", "not", ":", "SI", "(", "xor", ":", "SI" ]

[ "<STR_LIT>" ]

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

[ "<FIXS>", "if", "(", "cfun", "->", "machine", "->", "ra_rtx", "==", "NULL", ")", "<FIXE>", "<FIXS>", "cfun", "->", "machine", "->", "ra_rtx", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "<FIXE>", "<FIXS>", "init", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "cfun", "->", "machine", "->", "ra_rtx", ",", "init", ")", ";", "<FIXE>" ]

[ "if", "(", "count", "!=", "<NUM_LIT>", ")", "return", "const0_rtx", ";", "<BUGS>", "if", "(", "ra_rtx", "==", "NULL", ")", "<BUGE>", "{", "rtx", "init", ";", "<BUGS>", "ra_rtx", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "<BUGE>", "init", "=", "gen_rtx_REG", "(", "Pmode", ",", "LINK_POINTER_REGNUM", ")", ";", "<BUGS>", "init", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "ra_rtx", ",", "init", ")", ";", "<BUGE>", "push_topmost_sequence", "(", ")", ";" ]

[ "b", ";" ]

[ "return", "_", "_", "a", "|", "~", "_", "_" ]

[ "<STR_LIT>", ";" ]

[ "case", "X86", "::", "EAX", ":", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "<STR_LIT>", "Should not be using a 32-bit thunk!", "<STR_LIT>", ")", ";", "return", "<STR_LIT>", "__llvm_retpoline_eax", "<STR_LIT>", ";", "case", "X86", "::", "ECX", ":", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "<STR_LIT>", "Should not be using a 32-bit thunk!", "<STR_LIT>", ")", ";", "return", "<STR_LIT>", "__llvm_retpoline_ecx", "<STR_LIT>", ";", "case", "X86", "::", "EDX", ":", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "<STR_LIT>", "Should not be using a 32-bit thunk!", "<STR_LIT>", ")", ";", "return", "<STR_LIT>", "__llvm_retpoline_edx", "<STR_LIT>", ";", "case", "X86", "::", "EDI", ":", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "<STR_LIT>", "Should not be using a 32-bit thunk!", "<STR_LIT>", ")", ";", "return", "<STR_LIT>", "__llvm_retpoline_edi", "<STR_LIT>", ";", "case", "X86", "::", "R11", ":", "assert", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "<STR_LIT>", "Should not be using a 64-bit thunk!", "<STR_LIT>", ")", ";", "return", "<STR_LIT>", "__llvm_retpoline_r11", "<STR_LIT>", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "unexpected reg for retpoline", "<STR_LIT>", ")", ";", "}", "if", "(", "Subtarget", ".", "useLVIControlFlowIntegrity", "(", ")", ")", "{", "assert", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "<STR_LIT>", "Should not be using a 64-bit thunk!", "<STR_LIT>", ")", ";", "return", "<STR_LIT>", "__llvm_lvi_thunk_r11" ]

[ "}" ]

[ "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", "==", "<NUM_LIT>", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "!", "Subtarget", ".", "useSoftFloat", "(", ")", "&&", "!", "NoImplicitFloatOps", "&&", "(", "Subtarget", ".", "hasSSE1", "(", ")", "||", "Subtarget", ".", "hasX87", "(", ")", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "needsCmpXchgNb", "(", "MemType", ")", "?", "AtomicExpansionKind", "::", "Expand", ":", "AtomicExpansionKind", "::", "None", ";" ]

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

[ "bool", "hardenSlsNoComdat", "(" ]

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

[ "def", "C4_cmpneqi", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_56f114f4", ",", "TypeALU32_2op", ">", ",", "Enc_bd0b33", ",", "ImmRegRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";" ]

[ "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";" ]

[ "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tLDRspi", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", "." ]

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

[ ".", "getOpcode", "(", ")", "==", "ARM", "::", "HLT", ";" ]

[ "static", "bool", "instIsBreakpoint", "(", "const", "MCInst", "&", "Inst", ")", "{", "return", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tBKPT", "||", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "BKPT", "||", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tHLT", "||", "Inst" ]

[ "LoopPhi", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "DecReg", ")", ";" ]

[ "}", "}", "Register", "PhiReg", "=", "LoopPhi", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "DecReg", "=", "LoopDec", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "StartReg", "=", "LoopStart", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "Copies", ";", "auto", "CheckUsers", "=", "[", "&", "Copies", "]", "(", "Register", "BaseReg", ",", "ArrayRef", "<", "MachineInstr", "*", ">", "ExpectedUsers", ",", "MachineRegisterInfo", "*", "MRI", ")", "{", "SmallVector", "<", "Register", ",", "<NUM_LIT>", ">", "Worklist", ";", "Worklist", ".", "push_back", "(", "BaseReg", ")", ";", "while", "(", "!", "Worklist", ".", "empty", "(", ")", ")", "{", "Register", "Reg", "=", "Worklist", ".", "pop_back_val", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MRI", "->", "use_nodbg_instructions", "(", "Reg", ")", ")", "{", "if", "(", "llvm", "::", "is_contained", "(", "ExpectedUsers", ",", "&", "MI", ")", ")", "continue", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "TargetOpcode", "::", "COPY", "||", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ".", "isVirtual", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Extra users of register found: ", "<STR_LIT>", "<<", "MI", ")", ";", "return", "false", ";", "}", "Worklist", ".", "push_back", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "Copies", ".", "push_back", "(", "&", "MI", ")", ";", "}", "}", "return", "true", ";", "}", ";", "if", "(", "!", "CheckUsers", "(", "PhiReg", ",", "{", "LoopDec", "}", ",", "MRI", ")", "||", "!", "CheckUsers", "(", "DecReg", ",", "{", "LoopPhi", ",", "LoopEnd", "}", ",", "MRI", ")", "||", "!", "CheckUsers", "(", "StartReg", ",", "{", "LoopPhi", "}", ",", "MRI", ")", ")", "{", "if", "(", "LoopStart", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2WhileLoopStartLR", ")", "{", "RevertWhileLoopStartLR", "(", "LoopStart", ",", "TII", ")", ";", "RevertLoopDec", "(", "LoopDec", ",", "TII", ")", ";", "RevertLoopEnd", "(", "LoopEnd", ",", "TII", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "MRI", "->", "constrainRegClass", "(", "StartReg", ",", "&", "ARM", "::", "GPRlrRegClass", ")", ";", "MRI", "->", "constrainRegClass", "(", "PhiReg", ",", "&", "ARM", "::", "GPRlrRegClass", ")", ";", "MRI", "->", "constrainRegClass", "(", "DecReg", ",", "&", "ARM", "::", "GPRlrRegClass", ")", ";", "if", "(", "LoopPhi", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", "==", "ML", "->", "getLoopLatch", "(", ")", ")", "{", "LoopPhi", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setReg", "(", "StartReg", ")", ";" ]

[ "GWSResource", ";" ]

[ "static", "bool", "classof", "(", "const", "PseudoSourceValue", "*", "V", ")", "{", "return", "V", "->", "kind", "(", ")", "==" ]

[ "}" ]

[ "rtx", "c", "=", "gen_int_mode", "(", "val", ",", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "return", "gen_const_vec_duplicate", "(", "mode", ",", "c", ")", ";" ]

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

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

[ ")", ")" ]

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

[ "(", "f128", "(", "XSRQPI", "<NUM_LIT>", ",", "$", "vB", ",", "<NUM_LIT>", ")", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "f128", "(", "ftrunc", "f128", ":", "$", "vB", ")", ")", "," ]

[ "v8di", ")", "_", "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_expandloaddi512_mask", "(", "(", "const", "_", "_", "v8di", "*", ")", "_", "_", "P", ",", "(", "_", "_" ]

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

[ "(", "neg", ":", "VDF", "(", "match_operand", ":", "VDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "unsigned", "AMDGPURegisterBankInfo", "::", "copyCost", "(", "const", "RegisterBank", "&", "Dst", ",", "const", "RegisterBank", "&", "Src", ",", "unsigned", "Size", ")", "const", "{", "if", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", "&&", "isVectorRegisterBank", "(", "Src", ")", ")", "{", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "}", "if", "(", "Size", "==", "<NUM_LIT>", "&&", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", ")", "&&", "(", "isVectorRegisterBank", "(", "Src", ")", "||", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", "||", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VCCRegBankID", ")", ")", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "if", "(", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VCCRegBankID", ")", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "if", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "AGPRRegBankID", "&&", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "AGPRRegBankID", ")", "return", "<NUM_LIT>", ";", "return", "RegisterBankInfo", "::", "copyCost", "(", "Dst", ",", "Src", ",", "Size", ")", ";" ]

[ ">", ";" ]

[ "def", "SImm6Operand", ":", "SImmOperand", "<", "<NUM_LIT>" ]

[ "-", ">", "getAlignment", "(", ")", "<", "<NUM_LIT>", ";" ]

[ "}", "]", ">", ";", "def", "hword_alignedstore", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "val", ",", "node", ":", "$", "ptr", ")", ",", "(", "store", "node", ":", "$", "val", ",", "node", ":", "$", "ptr", ")", ",", "[", "{", "return", "cast", "<", "StoreSDNode", ">", "(", "N", ")", "-", ">", "getAlignment", "(", ")", "=", "=", "<NUM_LIT>", ";", "}", "]", ">", ";", "def", "byte_alignedload", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "ptr", ")", ",", "(", "load", "node", ":", "$", "ptr", ")", ",", "[", "{", "return", "cast", "<", "LoadSDNode", ">", "(", "N", ")", "-", ">", "getAlignment", "(", ")", "=", "=", "<NUM_LIT>", ";", "}", "]", ">", ";", "def", "byte_alignedstore", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "val", ",", "node", ":", "$", "ptr", ")", ",", "(", "store", "node", ":", "$", "val", ",", "node", ":", "$", "ptr", ")", ",", "[", "{", "return", "cast", "<", "StoreSDNode", ">", "(", "N", ")", "-", ">", "getAlignment", "(", ")", "=", "=", "<NUM_LIT>", ";", "}", "]", ">", ";", "def", "non_word_alignedload", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "ptr", ")", ",", "(", "load", "node", ":", "$", "ptr", ")", ",", "[", "{", "return", "cast", "<", "LoadSDNode", ">", "(", "N", ")" ]

[ "m1", ",", "$", "m2", ",", "ARMVCCThen", ",", "$", "pred", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "VTI", ".", "Vec", "(", "pred_int", "m1", ",", "(", "fneg", "m2", ")", ",", "add", ",", "pred", ")", ")", ",", "(", "Inst", "$", "add", ",", "$" ]

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

[ "bool", "isU16Imm", "(" ]

[ "<NUM_LIT>", "_", "rtx", ")", ",", "const_true_rtx", ")", ";" ]

[ "break", ";", "case", "GT", ":", "case", "GE", ":", "switch", "(", "op_mode", ")", "{", "case", "SFmode", ":", "cmp", "=", "(", "flag_finite_math_only", "&&", "!", "flag_trapping_math", ")", "?", "gen_tstsfgt_gpr", "(", "compare_result", ",", "op0", ",", "op1", ")", ":", "gen_cmpsfgt_gpr", "(", "compare_result", ",", "op0", ",", "op1", ")", ";", "break", ";", "case", "DFmode", ":", "cmp", "=", "(", "flag_finite_math_only", "&&", "!", "flag_trapping_math", ")", "?", "gen_tstdfgt_gpr", "(", "compare_result", ",", "op0", ",", "op1", ")", ":", "gen_cmpdfgt_gpr", "(", "compare_result", ",", "op0", ",", "op1", ")", ";", "break", ";", "case", "TFmode", ":", "cmp", "=", "(", "flag_finite_math_only", "&&", "!", "flag_trapping_math", ")", "?", "gen_tsttfgt_gpr", "(", "compare_result", ",", "op0", ",", "op1", ")", ":", "gen_cmptfgt_gpr", "(", "compare_result", ",", "op0", ",", "op1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "LT", ":", "case", "LE", ":", "switch", "(", "op_mode", ")", "{", "case", "SFmode", ":", "cmp", "=", "(", "flag_finite_math_only", "&&", "!", "flag_trapping_math", ")", "?", "gen_tstsflt_gpr", "(", "compare_result", ",", "op0", ",", "op1", ")", ":", "gen_cmpsflt_gpr", "(", "compare_result", ",", "op0", ",", "op1", ")", ";", "break", ";", "case", "DFmode", ":", "cmp", "=", "(", "flag_finite_math_only", "&&", "!", "flag_trapping_math", ")", "?", "gen_tstdflt_gpr", "(", "compare_result", ",", "op0", ",", "op1", ")", ":", "gen_cmpdflt_gpr", "(", "compare_result", ",", "op0", ",", "op1", ")", ";", "break", ";", "case", "TFmode", ":", "cmp", "=", "(", "flag_finite_math_only", "&&", "!", "flag_trapping_math", ")", "?", "gen_tsttflt_gpr", "(", "compare_result", ",", "op0", ",", "op1", ")", ":", "gen_cmptflt_gpr", "(", "compare_result", ",", "op0", ",", "op1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "code", "==", "LE", "||", "code", "==", "GE", ")", "{", "emit_insn", "(", "cmp", ")", ";", "compare_result2", "=", "gen_reg_rtx", "(", "CCFPmode", ")", ";", "switch", "(", "op_mode", ")", "{", "case", "SFmode", ":", "cmp", "=", "(", "flag_finite_math_only", "&&", "!", "flag_trapping_math", ")", "?", "gen_tstsfeq_gpr", "(", "compare_result2", ",", "op0", ",", "op1", ")", ":", "gen_cmpsfeq_gpr", "(", "compare_result2", ",", "op0", ",", "op1", ")", ";", "break", ";", "case", "DFmode", ":", "cmp", "=", "(", "flag_finite_math_only", "&&", "!", "flag_trapping_math", ")", "?", "gen_tstdfeq_gpr", "(", "compare_result2", ",", "op0", ",", "op1", ")", ":", "gen_cmpdfeq_gpr", "(", "compare_result2", ",", "op0", ",", "op1", ")", ";", "break", ";", "case", "TFmode", ":", "cmp", "=", "(", "flag_finite_math_only", "&&", "!", "flag_trapping_math", ")", "?", "gen_tsttfeq_gpr", "(", "compare_result2", ",", "op0", ",", "op1", ")", ":", "gen_cmptfeq_gpr", "(", "compare_result2", ",", "op0", ",", "op1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "cmp", ")", ";", "or", "_", "result", "=", "gen_reg_rtx", "(", "CCFPmode", ")", ";", "cmp", "=", "gen_e500_cr_ior_compare", "(", "or", "_", "result", ",", "compare_result", ",", "compare_result2", ")", ";", "compare_result", "=", "or", "_", "result", ";", "}", "code", "=", "reverse_p", "?", "NE", ":", "EQ", ";", "emit_insn", "(", "cmp", ")", ";", "}", "else", "{", "if", "(", "comp_mode", "==", "CCFPmode", "&&", "TARGET_XL_COMPAT", "&&", "GET_MODE", "(", "op0", ")", "==", "TFmode", "&&", "!", "TARGET_IEEEQUAD", "&&", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", "&&", "TARGET_LONG_DOUBLE_128", ")", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "compare_result", ",", "gen_rtx_COMPARE", "(", "comp_mode", ",", "op0", ",", "op1", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "DFmode", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "DFmode", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "DFmode", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "DFmode", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "DFmode", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "DFmode", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "DFmode", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "DFmode", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "Pmode", ")", ")", ")", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "op1", ")", "==", "UNSPEC", "&&", "XINT", "(", "op1", ",", "<NUM_LIT>", ")", "==", "UNSPEC_SP_TEST", ")", "{", "rtx", "op1b", "=", "XVECEXP", "(", "op1", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "comp_mode", "=", "CCEQmode", ";", "compare_result", "=", "gen_reg_rtx", "(", "CCEQmode", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_stack_protect_testdi", "(", "compare_result", ",", "op0", ",", "op1b", ")", ")", ";", "else", "emit_insn", "(", "gen_stack_protect_testsi", "(", "compare_result", ",", "op0", ",", "op1b", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "compare_result", ",", "gen_rtx_COMPARE", "(", "comp_mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "}", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", "&&", "!", "flag_finite_math_only", "&&", "!", "(", "TARGET_HARD_FLOAT", "&&", "!", "TARGET_FPRS", ")", "&&", "(", "code", "==", "LE", "||", "code", "==", "GE", "||", "code", "==", "UNEQ", "||", "code", "==", "LTGT", "||", "code", "==", "UNGT", "||", "code", "==", "UNLT", ")", ")", "{", "enum", "rtx_code", "or", "<NUM_LIT>", ",", "or", "<NUM_LIT>", ";", "rtx", "or", "<NUM_LIT>", "_", "rtx", ",", "or", "<NUM_LIT>", "_", "rtx", ",", "compare2_rtx", ";", "rtx", "or", "_", "result", "=", "gen_reg_rtx", "(", "CCEQmode", ")", ";", "switch", "(", "code", ")", "{", "case", "LE", ":", "or", "<NUM_LIT>", "=", "LT", ";", "or", "<NUM_LIT>", "=", "EQ", ";", "break", ";", "case", "GE", ":", "or", "<NUM_LIT>", "=", "GT", ";", "or", "<NUM_LIT>", "=", "EQ", ";", "break", ";", "case", "UNEQ", ":", "or", "<NUM_LIT>", "=", "UNORDERED", ";", "or", "<NUM_LIT>", "=", "EQ", ";", "break", ";", "case", "LTGT", ":", "or", "<NUM_LIT>", "=", "LT", ";", "or", "<NUM_LIT>", "=", "GT", ";", "break", ";", "case", "UNGT", ":", "or", "<NUM_LIT>", "=", "UNORDERED", ";", "or", "<NUM_LIT>", "=", "GT", ";", "break", ";", "case", "UNLT", ":", "or", "<NUM_LIT>", "=", "UNORDERED", ";", "or", "<NUM_LIT>", "=", "LT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "validate_condition_mode", "(", "or", "<NUM_LIT>", ",", "comp_mode", ")", ";", "validate_condition_mode", "(", "or", "<NUM_LIT>", ",", "comp_mode", ")", ";", "or", "<NUM_LIT>", "_", "rtx", "=", "gen_rtx_fmt_ee", "(", "or", "<NUM_LIT>", ",", "SImode", ",", "compare_result", ",", "const0_rtx", ")", ";", "or", "<NUM_LIT>", "_", "rtx", "=", "gen_rtx_fmt_ee", "(", "or", "<NUM_LIT>", ",", "SImode", ",", "compare_result", ",", "const0_rtx", ")", ";", "compare2_rtx", "=", "gen_rtx_COMPARE", "(", "CCEQmode", ",", "gen_rtx_IOR", "(", "SImode", ",", "or", "<NUM_LIT>", "_", "rtx", ",", "or" ]

[ "}" ]

[ "uint8_t", "OSABI", "=", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "TT", ".", "getOS", "(", ")", ")", ";", "return", "new", "MMIXAsmBackend", "(", "STI", ",", "OSABI", ")", ";" ]

[ ";" ]

[ "def", "J4_cmpeq_fp0_jump_t", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "GeneralSubRegs", ":", "$", "Rt16", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_56336eb0", ",", "TypeCJ", ">", ",", "Enc_6a5972", ",", "PredRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<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>" ]

[ "<FIXS>", "ARMOperand", "*", "Op", "=", "new", "ARMOperand", "(", "k_CondCode", ")", ";", "<FIXE>" ]

[ "}", "static", "ARMOperand", "*", "CreateCondCode", "(", "<STR_LIT>", "::", "<STR_LIT>", "CC", ",", "SMLoc", "S", ")", "{", "<BUGS>", "ARMOperand", "*", "Op", "=", "new", "ARMOperand", "(", "CondCode", ")", ";", "<BUGE>", "Op", "->", "CC", ".", "Val", "=", "CC", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "S", ";" ]

[ "}", "else", "if", "(", "(", "Mode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Mode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "isMatchingDecrement", "(", "NextMBBI", ",", "Base", ",", "Bytes", ",", "<NUM_LIT>", ",", "Pred", ",", "PredReg", ")", ")", "{" ]

[ "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "MI", "->", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", "==", "Base", ")", "return", "false", ";", "bool", "DoMerge", "=", "false", ";", "<STR_LIT>", "::", "<STR_LIT>", "Mode", "=", "getLoadStoreMultipleSubMode", "(", "Opcode", ")", ";", "MachineBasicBlock", "::", "iterator", "BeginMBBI", "=", "MBB", ".", "begin", "(", ")", ";", "if", "(", "MBBI", "!=", "BeginMBBI", ")", "{", "MachineBasicBlock", "::", "iterator", "PrevMBBI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "while", "(", "PrevMBBI", "!=", "BeginMBBI", "&&", "PrevMBBI", "->", "isDebugValue", "(", ")", ")", "--", "PrevMBBI", ";", "if", "(", "Mode", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "isMatchingDecrement", "(", "PrevMBBI", ",", "Base", ",", "Bytes", ",", "<NUM_LIT>", ",", "Pred", ",", "PredReg", ")", ")", "{", "Mode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "DoMerge", "=", "true", ";", "}", "else", "if", "(", "Mode", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "isMatchingDecrement", "(", "PrevMBBI", ",", "Base", ",", "Bytes", ",", "<NUM_LIT>", ",", "Pred", ",", "PredReg", ")", ")", "{", "Mode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "DoMerge", "=", "true", ";", "}", "if", "(", "DoMerge", ")", "MBB", ".", "erase", "(", "PrevMBBI", ")", ";", "}", "MachineBasicBlock", "::", "iterator", "EndMBBI", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "!", "DoMerge", "&&", "MBBI", "!=", "EndMBBI", ")", "{", "MachineBasicBlock", "::", "iterator", "NextMBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "while", "(", "NextMBBI", "!=", "EndMBBI", "&&", "NextMBBI", "->", "isDebugValue", "(", ")", ")", "++", "NextMBBI", ";", "if", "(", "(", "Mode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Mode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "isMatchingIncrement", "(", "NextMBBI", ",", "Base", ",", "Bytes", ",", "<NUM_LIT>", ",", "Pred", ",", "PredReg", ")", ")", "{", "DoMerge", "=", "true", ";" ]

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

[ "const", "TargetRegisterClass", "*", "X86InstructionSelector", "::", "getRegClass", "(", "LLT", "Ty", ",", "unsigned", "Reg", ",", "MachineRegisterInfo", "&", "MRI", ")", "const", "{", "const", "RegisterBank", "&", "RegBank", "=", "*", "RBI", ".", "getRegBank", "(", "Reg", ",", "MRI", "," ]