Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "OS", "<<", "markup", "(", "<STR_LIT>", "<reg:", "<STR_LIT>", ")", "<<", "getRegName", "(", "RegNo", ")", "<<", "markup", "(" ]

[ "<NUM_LIT>", ";" ]

[ "def", "A2_svadduhs", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_61830035", ",", "TypeALU32_3op", ">", ",", "Enc_5ab2be", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ "return", "Entry", "=", "MCSectionPIC16", "::", "Create", "(", "Name", ",", "Kind", ",", "getContext", "(", ")", ")", ";" ]

[ "getPIC16Section", "(", "const", "char", "*", "Name", ",", "SectionKind", "Kind", ")", "const", "{", "MCSectionPIC16", "*", "&", "Entry", "=", "SectionsByName", "[", "Name", "]", ";", "if", "(", "Entry", ")", "return", "Entry", ";" ]

[ "case", "ARM", "::", "tADDrSPi", ":" ]

[ "default", ":", "MI", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported opcode for unwinding information", "<STR_LIT>", ")", ";", "case", "ARM", "::", "tPUSH", ":", "StartOp", "=", "<NUM_LIT>", ";", "NumOffset", "=", "<NUM_LIT>", ";", "case", "ARM", "::", "STMDB_UPD", ":", "case", "ARM", "::", "t2STMDB_UPD", ":", "case", "ARM", "::", "VSTMDDB_UPD", ":", "assert", "(", "SrcReg", "==", "ARM", "::", "SP", "&&", "<STR_LIT>", "Only stack pointer as a source reg is supported", "<STR_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "StartOp", ",", "NumOps", "=", "MI", "->", "getNumOperands", "(", ")", "-", "NumOffset", ";", "i", "!=", "NumOps", ";", "++", "i", ")", "RegList", ".", "push_back", "(", "MI", "->", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "ARM", "::", "STR_PRE_IMM", ":", "case", "ARM", "::", "STR_PRE_REG", ":", "case", "ARM", "::", "t2STR_PRE", ":", "assert", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", "&&", "<STR_LIT>", "Only stack pointer as a source reg is supported", "<STR_LIT>", ")", ";", "RegList", ".", "push_back", "(", "SrcReg", ")", ";", "break", ";", "}", "OutStreamer", ".", "EmitRegSave", "(", "RegList", ",", "Opc", "==", "ARM", "::", "VSTMDDB_UPD", ")", ";", "}", "else", "{", "if", "(", "SrcReg", "==", "ARM", "::", "SP", ")", "{", "int64_t", "Offset", "=", "<NUM_LIT>", ";", "switch", "(", "Opc", ")", "{", "default", ":", "MI", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported opcode for unwinding information", "<STR_LIT>", ")", ";", "case", "ARM", "::", "MOVr", ":", "case", "ARM", "::", "tMOVr", ":", "Offset", "=", "<NUM_LIT>", ";", "break", ";", "case", "ARM", "::", "ADDri", ":", "Offset", "=", "-", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "break", ";", "case", "ARM", "::", "SUBri", ":", "case", "ARM", "::", "t2SUBri", ":", "Offset", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "break", ";", "case", "ARM", "::", "tSUBspi", ":", "Offset", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "*", "<NUM_LIT>", ";", "break", ";", "case", "ARM", "::", "tADDspi", ":" ]

[ "(", "insn", ")", ")", ",", "<NUM_LIT>", ")", "==", "UNSPEC_MOVA", "&&", "GET_CODE", "(", "XVECEXP", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "==", "LABEL_REF", ")", ";" ]

[ "return", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "SET_SRC", "(", "PATTERN" ]

[ "b", ",", "_", "_", "lane", ")", ";" ]

[ "return", "_", "_", "a", "*", "_", "_", "aarch64_vget_lane_any", "(", "_", "_" ]

[ "]", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_MHSETLOH", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "bool", "isABI_EABI", "(", ")", "const", ";", "bool", "isABI_N64", "(", ")", "const", ";", "bool", "isABI_N32", "(", ")", "const", ";", "bool", "isABI_O32", "(", ")", "const", ";", "const", "MipsABIInfo", "&", "getABI", "(", ")", "const", ";", "<FIXE>" ]

[ "CodeGenOpt", "::", "Level", "getOptLevelToEnablePostRAScheduler", "(", ")", "const", "override", ";", "<BUGS>", "bool", "isABI_EABI", "(", ")", "const", "{", "return", "ABI", ".", "IsEABI", "(", ")", ";", "}", "bool", "isABI_N64", "(", ")", "const", "{", "return", "ABI", ".", "IsN64", "(", ")", ";", "}", "bool", "isABI_N32", "(", ")", "const", "{", "return", "ABI", ".", "IsN32", "(", ")", ";", "}", "bool", "isABI_O32", "(", ")", "const", "{", "return", "ABI", ".", "IsO32", "(", ")", ";", "}", "<BUGE>", "bool", "isABI_FPXX", "(", ")", "const", "{", "return", "isABI_O32", "(", ")", "&&", "IsFPXX", ";", "}", "<BUGS>", "const", "MipsABIInfo", "&", "getABI", "(", ")", "const", "{", "return", "ABI", ";", "}", "<BUGE>" ]

[ "}" ]

[ "unsigned", "getMaxInlineSizeThreshold", "(", ")", "const", "{", "return", "<NUM_LIT>", ";" ]

[ "X", "(", "TheDCPU16Target", ")", ";" ]

[ "void", "LLVMInitializeDCPU16AsmPrinter", "(", ")", "{", "RegisterAsmPrinter", "<", "DCPU16AsmPrinter", ">" ]

[ "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";" ]

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

[ "let", "opExtendable", "=", "<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", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "Subtarget", "(", "TT", ",", "FS", ",", "is64Bit", ")", ",", "DataLayout", "(", "Subtarget", ".", "getDataLayout", "(", ")", ")", ",", "FrameInfo", "(", "TargetFrameInfo", "::", "StackGrowsDown", ",", "Subtarget", ".", "getStackAlignment", "(", ")", ",", "(", "Subtarget", ".", "isTargetWin64", "(", ")", "?", "-", "<NUM_LIT>", ":", "(", "Subtarget", ".", "is64Bit", "(", ")", "?", "-", "<NUM_LIT>", ":", "-", "<NUM_LIT>", ")", ")", ")", ",", "InstrInfo", "(", "*", "this", ")", ",", "JITInfo", "(", "*", "this", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "ELFWriterInfo", "(", "*", "this", ")", "{", "DefRelocModel", "=", "getRelocationModel", "(", ")", ";", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Default", ")", "{", "if", "(", "!", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "setRelocationModel", "(", "Reloc", "::", "Static", ")", ";", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "else", "setRelocationModel", "(", "Reloc", "::", "DynamicNoPIC", ")", ";", "}", "assert", "(", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "&&", "<STR_LIT>", "Relocation mode not picked", "<STR_LIT>", ")", ";", "if", "(", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Default", ")", "setCodeModel", "(", "CodeModel", "::", "Small", ")", ";", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", "{", "if", "(", "is64Bit", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "else", "if", "(", "!", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "setRelocationModel", "(", "Reloc", "::", "Static", ")", ";", "}", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", "&&", "Subtarget", ".", "isTargetDarwin", "(", ")", "&&", "is64Bit", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetCygMing", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "else", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";" ]

[ "OutStreamer", ".", "EmitLabel", "(", "CurrentFnSym", ")", ";" ]

[ "void", "MipsAsmPrinter", "::", "EmitFunctionEntryLabel", "(", ")", "{", "O", "<<", "<STR_LIT>", "\\t.ent\\t", "<STR_LIT>", "<<", "*", "CurrentFnSym", "<<", "'", "\\n", "'", ";" ]

[ "emit_insn", "(", "gen_cstore", "<", "mode", ">", "<NUM_LIT>", "(", "o", ",", "operands", "[", "<NUM_LIT>", "]", "," ]

[ "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operator", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "QHPSI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QHPSI", "<NUM_LIT>", "<STR_LIT>", ")", "]", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "TARGET_A24", ")", "{", "rtx", "o", "=", "gen_reg_rtx", "(", "HImode", ")" ]

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

[ "fixELFSymbolsInTLSFixupsImpl", "(", "getSubExpr", "(", ")" ]

[ "}" ]

[ "vreinterpretq_p16_bf16", "(", "bfloat16x8_t", "_", "_", "a", ")", "{", "return", "(", "poly16x8_t", ")", "_", "_", "a", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_bypass", "<NUM_LIT>", "<STR_LIT>" ]

[ "static", "bool", "rs6000_valid_attribute_p", "(", "tree", "fndecl", ",", "tree", "ARG_UNUSED", "(", "name", ")", ",", "tree", "args", ",", "int", "flags", ")", "{", "struct", "cl_target_option", "cur_target", ";", "bool", "ret", ";", "tree", "old_optimize", "=", "build_optimization_node", "(", "&", "global_options", ")", ";", "tree", "new", "_", "target", ",", "new", "_", "optimize", ";", "tree", "func_optimize", "=", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", ";", "gcc_assert", "(", "(", "fndecl", "!=", "NULL_TREE", ")", "&&", "(", "args", "!=", "NULL_TREE", ")", ")", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "{", "tree", "tname", "=", "DECL_NAME", "(", "fndecl", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "\\n==================== rs6000_valid_attribute_p:\\n", "<STR_LIT>", ")", ";", "if", "(", "tname", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "function: %.*s\\n", "<STR_LIT>", ",", "(", "int", ")", "IDENTIFIER_LENGTH", "(", "tname", ")", ",", "IDENTIFIER_POINTER", "(", "tname", ")", ")", ";", "else", "fprintf", "(", "stderr", ",", "<STR_LIT>", "function: unknown\\n", "<STR_LIT>", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "args:", "<STR_LIT>", ")", ";", "rs6000_debug_target_options", "(", "args", ",", "<STR_LIT>", "<STR_LIT>", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "if", "(", "flags", ")", "fprintf", "(", "stderr", ",", "<STR_LIT>", "flags: 0x%x\\n", "<STR_LIT>", ",", "flags", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "--------------------\\n", "<STR_LIT>", ")", ";", "}", "old_optimize", "=", "build_optimization_node", "(", "&", "global_options", ")", ";", "func_optimize", "=", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", ";", "if", "(", "func_optimize", "&&", "func_optimize", "!=", "old_optimize", ")", "cl_optimization_restore", "(", "&", "global_options", ",", "TREE_OPTIMIZATION", "(", "func_optimize", ")", ")", ";", "cl_target_option_save", "(", "&", "cur_target", ",", "&", "global_options", ")", ";", "rs6000_cpu_index", "=", "rs6000_tune_index", "=", "-", "<NUM_LIT>", ";", "ret", "=", "rs6000_inner_target_options", "(", "args", ",", "true", ")", ";", "if", "(", "ret", ")", "{", "ret", "=", "rs6000_option_override_internal", "(", "false", ")", ";", "new", "_", "target", "=", "build_target_option_node", "(", "&", "global_options", ")", ";", "}", "else", "new", "_", "target", "=", "NULL", ";", "new", "_", "optimize", "=", "build_optimization_node", "(", "&", "global_options", ")", ";", "if", "(", "!", "new", "_", "target", ")", "ret", "=", "false", ";", "else", "if", "(", "fndecl", ")", "{", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "=", "new", "_", "target", ";", "if", "(", "old_optimize", "!=", "new", "_", "optimize", ")", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", "=", "new", "_", "optimize", ";", "}", "cl_target_option_restore", "(", "&", "global_options", ",", "&", "cur_target", ")", ";", "if", "(", "old_optimize", "!=", "new", "_", "optimize", ")", "cl_optimization_restore", "(", "&", "global_options", ",", "TREE_OPTIMIZATION", "(", "old_optimize", ")", ")", ";", "return", "ret", ";", "}" ]

[ "Hook", "to", "validate", "attribute", "(", "(", "target", "(", "``", "...", "''", ")", ")", ")", "." ]

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

[ "O", "<<", "(", "unsigned", "int", ")", "MO", ".", "getImm", "(", ")", ";", "}", "else", "{", "printOperand", "(", "MI", ",", "opNum", "," ]

[ ";" ]

[ "case", "ISD", "::", "SETNE", ":", "std", "::", "swap", "(", "TV", ",", "FV", ")", ";", "case", "ISD", "::", "SETEQ", ":", "if", "(", "LHS", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "LHS", ")", ";", "Sel1", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "LHS", ",", "TV", ",", "FV", ")", ";", "if", "(", "Sel1", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "Sel1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "Sel1", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "FNEG", ",", "dl", ",", "MVT", "::", "f64", ",", "LHS", ")", ",", "Sel1", ",", "FV", ")", ";", "case", "ISD", "::", "SETULT", ":", "case", "ISD", "::", "SETLT", ":", "std", "::", "swap", "(", "TV", ",", "FV", ")", ";", "case", "ISD", "::", "SETOGE", ":", "case", "ISD", "::", "SETGE", ":", "if", "(", "LHS", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "LHS", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "LHS", ",", "TV", ",", "FV", ")", ";", "case", "ISD", "::", "SETUGT", ":", "case", "ISD", "::", "SETGT", ":", "std", "::", "swap", "(", "TV", ",", "FV", ")", ";", "case", "ISD", "::", "SETOLE", ":", "case", "ISD", "::", "SETLE", ":", "if", "(", "LHS", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "LHS", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "LHS", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "FNEG", ",", "dl", ",", "MVT", "::", "f64", ",", "LHS", ")", ",", "TV", ",", "FV", ")", ";", "}", "SDValue", "Cmp", ";", "switch", "(", "CC", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SETNE", ":", "std", "::", "swap", "(", "TV", ",", "FV", ")", ";", "case", "ISD", "::", "SETEQ", ":", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FSUB", ",", "dl", ",", "CmpVT", ",", "LHS", ",", "RHS", ",", "Flags", ")", ";", "if", "(", "Cmp", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "Cmp", ")", ";", "Sel1", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "Cmp", ",", "TV", ",", "FV", ")", ";", "if", "(", "Sel1", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "Sel1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "Sel1", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "DAG", ".", "getNode", "(", "ISD", "::", "FNEG", ",", "dl", ",", "MVT", "::", "f64", ",", "Cmp", ")", ",", "Sel1", ",", "FV", ")", ";", "case", "ISD", "::", "SETULT", ":", "case", "ISD", "::", "SETLT", ":", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FSUB", ",", "dl", ",", "CmpVT", ",", "LHS", ",", "RHS", ",", "Flags", ")", ";", "if", "(", "Cmp", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "Cmp", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "Cmp", ",", "FV", ",", "TV", ")", ";", "case", "ISD", "::", "SETOGE", ":", "case", "ISD", "::", "SETGE", ":", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FSUB", ",", "dl", ",", "CmpVT", ",", "LHS", ",", "RHS", ",", "Flags", ")", ";", "if", "(", "Cmp", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "Cmp", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "Cmp", ",", "TV", ",", "FV", ")", ";", "case", "ISD", "::", "SETUGT", ":", "case", "ISD", "::", "SETGT", ":", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FSUB", ",", "dl", ",", "CmpVT", ",", "RHS", ",", "LHS", ",", "Flags", ")", ";", "if", "(", "Cmp", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "Cmp", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "Cmp", ",", "FV", ",", "TV", ")", ";", "case", "ISD", "::", "SETOLE", ":", "case", "ISD", "::", "SETLE", ":", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FSUB", ",", "dl", ",", "CmpVT", ",", "RHS", ",", "LHS", ",", "Flags", ")", ";", "if", "(", "Cmp", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", ")", "Cmp", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "MVT", "::", "f64", ",", "Cmp", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "ResVT", ",", "Cmp", ",", "TV", ",", "FV", ")", ";", "}", "return", "Op" ]

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

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

[ "static", "bool", "arm_vectorize_vec_perm_const", "(", "machine_mode", "vmode", ",", "machine_mode", "op_mode", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "vec_perm_indices", "&", "sel", ")", "{", "if", "(", "vmode", "!=", "op_mode", ")", "return", "false", ";", "struct", "expand_vec_perm_d", "d", ";", "int", "i", ",", "nelt", ",", "which", ";", "if", "(", "!", "VALID_NEON_DREG_MODE", "(", "vmode", ")", "&&", "!", "VALID_NEON_QREG_MODE", "(", "vmode", ")", ")", "return", "false", ";", "d", ".", "target", "=", "target", ";", "if", "(", "op0", ")", "{", "rtx", "nop0", "=", "force_reg", "(", "vmode", ",", "op0", ")", ";", "if", "(", "op0", "==", "op1", ")", "op1", "=", "nop0", ";", "op0", "=", "nop0", ";", "}", "if", "(", "op1", ")", "op1", "=", "force_reg", "(", "vmode", ",", "op1", ")", ";", "d", ".", "op0", "=", "op0", ";", "d", ".", "op1", "=", "op1", ";", "d", ".", "vmode", "=", "vmode", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "d", ".", "vmode", ")", ")", ";", "d", ".", "testing_p", "=", "!", "target", ";", "nelt", "=", "GET_MODE_NUNITS", "(", "d", ".", "vmode", ")", ";", "for", "(", "i", "=", "which", "=", "<NUM_LIT>", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "int", "ei", "=", "sel", "[", "i", "]", "&", "(", "<NUM_LIT>", "*", "nelt", "-", "<NUM_LIT>", ")", ";", "which", "|=", "(", "ei", "<", "nelt", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "}", "switch", "(", "which", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "<NUM_LIT>", ":", "d", ".", "one_vector_p", "=", "false", ";", "if", "(", "d", ".", "testing_p", "||", "!", "rtx_equal_p", "(", "op0", ",", "op1", ")", ")", "break", ";", "case", "<NUM_LIT>", ":", "d", ".", "op0", "=", "op1", ";", "d", ".", "one_vector_p", "=", "true", ";", "break", ";", "case", "<NUM_LIT>", ":", "d", ".", "op1", "=", "op0", ";", "d", ".", "one_vector_p", "=", "true", ";", "break", ";", "}", "d", ".", "perm", ".", "new", "_", "vector", "(", "sel", ".", "encoding", "(", ")", ",", "d", ".", "one_vector_p", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "nelt", ")", ";", "if", "(", "!", "d", ".", "testing_p", ")", "return", "arm_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "d", ".", "target", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "<NUM_LIT>", ")", ";", "d", ".", "op1", "=", "d", ".", "op0", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "<NUM_LIT>", ")", ";", "if", "(", "!", "d", ".", "one_vector_p", ")", "d", ".", "op1", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "<NUM_LIT>", ")", ";", "start_sequence", "(", ")", ";", "bool", "ret", "=", "arm_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "end_sequence", "(", ")", ";", "return", "ret", ";", "}" ]

[ "Implement", "TARGET_VECTORIZE_VEC_PERM_CONST", "." ]

[ ")", ";" ]

[ "void", "MipsMCCodeEmitter", "::", "EncodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "MCInst", "TmpInst", "=", "MI", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "DSLL", ":", "case", "Mips", "::", "DSRL", ":", "case", "Mips", "::", "DSRA", ":", "Mips", "::", "LowerLargeShift", "(", "TmpInst", ")", ";", "break", ";", "case", "Mips", "::", "DEXT", ":", "case", "Mips", "::", "DINS", ":", "Mips", "::", "LowerDextDins", "(", "TmpInst" ]

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

[ "[", "(", "set", "(", "reg", "FLAGS_REG", ")", "(", "compare", "(", "lshiftrt", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "lshiftrt", ":", "DI", "(", "zero_extend", ":", "DI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]" ]

[ "*", "this", ",", "*", "RBI", ")", ")", ";" ]

[ "else", "if", "(", "isTargetDarwin", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "Style", "::", "StubPIC", ")", ";", "else", "if", "(", "isTargetELF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "Style", "::", "GOT", ")", ";", "CallLoweringInfo", ".", "reset", "(", "new", "X86CallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "X86LegalizerInfo", "(", "*", "this", ",", "TM", ")", ")", ";", "auto", "*", "RBI", "=", "new", "X86RegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "InstSelector", ".", "reset", "(", "createX86InstructionSelector", "(", "TM", "," ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "eq", "(", "saturate", ",", "<NUM_LIT>", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "saturate", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "negate", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "def", ":", "InstRW", "<", "[", "A64FXWrite_6Cyc_GI0", "]", ",", "(", "instregex", "<STR_LIT>", ",", "<STR_LIT>" ]

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

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

[ "bool", "mem_operand_gpr", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "offset", ";", "int", "extra", ";", "rtx", "addr", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "if", "(", "TARGET_UPDATE", "&&", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", ")", "&&", "mode_supports_pre_incdec_p", "(", "mode", ")", "&&", "legitimate_indirect_address_p", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ",", "false", ")", ")", "return", "true", ";", "if", "(", "!", "rs6000_offsettable_memref_p", "(", "op", ",", "mode", ",", "false", ")", ")", "return", "false", ";", "op", "=", "address_offset", "(", "addr", ")", ";", "if", "(", "op", "==", "NULL_RTX", ")", "return", "true", ";", "offset", "=", "INTVAL", "(", "op", ")", ";", "if", "(", "TARGET_POWERPC64", "&&", "(", "offset", "&", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "extra", "=", "GET_MODE_SIZE", "(", "mode", ")", "-", "UNITS_PER_WORD", ";", "if", "(", "extra", "<", "<NUM_LIT>", ")", "extra", "=", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "offset", "=", "(", "(", "offset", "&", "<NUM_LIT>", ")", "^", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "return", "offset", "+", "<NUM_LIT>", "<", "<NUM_LIT>", "u", "-", "extra", ";", "}" ]

[ "Return", "true", "if", "the", "MEM", "operand", "is", "a", "memory", "operand", "suitable", "for", "use", "with", "a", "(", "full", "width", ",", "possibly", "multiple", ")", "gpr", "load/store", ".", "On", "powerpc64", "this", "means", "the", "offset", "must", "be", "divisible", "by", "4", ".", "Implements", "'", "Y", "'", "constraint", ".", "Accept", "direct", ",", "indexed", ",", "offset", ",", "lo_sum", "and", "tocref", ".", "Since", "this", "is", "a", "constraint", "function", "we", "know", "the", "operand", "has", "satisfied", "a", "suitable", "memory", "predicate", ".", "Offsetting", "a", "lo_sum", "should", "not", "be", "allowed", ",", "except", "where", "we", "know", "by", "alignment", "that", "a", "32k", "boundary", "is", "not", "crossed", ".", "Note", "that", "by", "``", "offsetting", "''", "here", "we", "mean", "a", "further", "offset", "to", "access", "parts", "of", "the", "MEM", ".", "It", "'s", "fine", "to", "have", "a", "lo_sum", "where", "the", "inner", "address", "is", "offset", "from", "a", "sym", ",", "since", "the", "same", "sym+offset", "will", "appear", "in", "the", "high", "part", "of", "the", "address", "calculation", "." ]

[ "int", "Index", ",", "Type", "*", "SubTp", ")", "{" ]

[ "int", "FPGATTIImpl", "::", "getShuffleCost", "(", "TTI", "::", "ShuffleKind", "Kind", ",", "Type", "*", "Tp", "," ]

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

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

[ "->", "fp_div_sf", ";" ]

[ "return", "mode", "==", "DFmode", "?", "mips_cost", "->", "fp_div_df", ":", "mips_cost" ]

[ "Changed", ";" ]

[ "Loops", "=", "getAnalysisIfAvailable", "<", "MachineLoopInfo", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "DomNode", ":", "post_order", "(", "DomTree", ")", ")", "if", "(", "tryConvertIf", "(", "DomNode", "->", "getBlock", "(", ")", ")", ")", "Changed", "=", "true", ";", "return" ]

[ "op", ")", "=", "=", "CONST_INT" ]

[ "(", "GET_CODE", "(", "op", ")", "=", "=", "REG", "|", "|", "(", "GET_CODE", "(" ]

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

[ "def", "C4_or_and", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps4", ",", "PredRegs", ":", "$", "Pt4", ",", "PredRegs", ":", "$", "Pu4", ")", ",", "<STR_LIT>", ",", "tc_b31c2e97", ",", "TypeCR", ">", ",", "Enc_9ac432", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "auto", "&", "Map", "=", "LibcallNameMap", ".", "Map", ";", "auto", "Val", "=", "Map", ".", "find", "(", "Name", ")", ";", "if", "(", "Val", "==", "Map", ".", "end", "(", ")", ")", "{", "auto", "Message", "=", "std", "::", "string", "(", "<STR_LIT>", "unexpected runtime library name: ", "<STR_LIT>", ")", "+", "std", "::", "string", "(", "Name", ")", ";", "llvm_unreachable", "(", "Message", ".", "c_str", "(", ")", ")", ";" ]

[ ">", ",", "Enc_b9c5fb", "{" ]

[ "def", "F2_conv_df2ud_chop", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_3a867367", ",", "TypeS_2op" ]

[ "<NUM_LIT>", ";" ]

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

[ "}" ]

[ "SDValue", "Src2", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "&&", "(", "Src0", "==", "Src1", "||", "Src0", "==", "Src2", ")", ")", "break", ";", "MVT", "VT", "=", "Src0", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "getRegClassFor", "(", "VT", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "SDValue", "UndefReg", "=", "DAG", ".", "getRegister", "(", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ",", "VT", ")", ";", "SDValue", "ImpDef", "=", "DAG", ".", "getCopyToReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "SDLoc", "(", "Node", ")", ",", "UndefReg", ",", "Src0", ",", "SDValue", "(", ")", ")", ";", "if", "(", "Src0", ".", "isMachineOpcode", "(", ")", "&&", "Src0", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", "{", "if", "(", "Src1", ".", "isMachineOpcode", "(", ")", "&&", "Src1", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src1", ";", "else", "if", "(", "Src2", ".", "isMachineOpcode", "(", ")", "&&", "Src2", ".", "getMachineOpcode", "(", ")", "!=", "AMDGPU", "::", "IMPLICIT_DEF", ")", "Src0", "=", "Src2", ";", "else", "{", "assert", "(", "Src1", ".", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", ";", "Src0", "=", "UndefReg", ";", "Src1", "=", "UndefReg", ";", "}", "}", "else", "break", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", "=", "{", "Src0", ",", "Src1", ",", "Src2", "}", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "N", "=", "Node", "->", "getNumOperands", "(", ")", ";", "I", "!=", "N", ";", "++", "I", ")", "Ops", ".", "push_back", "(", "Node", "->", "getOperand", "(", "I", ")", ")", ";", "Ops", ".", "push_back", "(", "ImpDef", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "return", "DAG", ".", "getMachineNode", "(", "Opcode", ",", "SDLoc", "(", "Node", ")", ",", "Node", "->", "getVTList", "(", ")", ",", "Ops", ")", ";" ]

[ "<FIXS>", "(", "bc_v4i64", "(", "v8i32", "(", "X86SubVBroadcast", "(", "loadv4i32", "addr", ":", "$", "src", ")", ")", ")", ")", ",", "<FIXE>", "<FIXS>", "(", "bc_v4i64", "(", "v8i32", "(", "X86SubVBroadcast", "(", "loadv4i32", "addr", ":", "$", "src", ")", ")", ")", ")", ",", "<FIXE>" ]

[ "VR256X", ":", "$", "src0", ")", ",", "(", "VBROADCASTF64X2Z128rmk", "VR256X", ":", "$", "src0", ",", "VK4WM", ":", "$", "mask", ",", "addr", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "vselect", "VK4WM", ":", "$", "mask", ",", "<BUGS>", "(", "bc_v4i64", "(", "v8i32", "(", "X86SubVBroadcast", "(", "bc_v4i32", "(", "loadv2i64", "addr", ":", "$", "src", ")", ")", ")", ")", ")", ",", "<BUGE>", "(", "bc_v4i64", "(", "v8i32", "immAllZerosV", ")", ")", ")", ",", "(", "VBROADCASTI64X2Z128rmkz", "VK4WM", ":", "$", "mask", ",", "addr", ":", "$", "src", ")", ">", ";", "def", ":", "Pat", "(", "vselect", "VK4WM", ":", "$", "mask", ",", "<BUGS>", "(", "bc_v4i64", "(", "v8i32", "(", "X86SubVBroadcast", "(", "bc_v4i32", "(", "loadv2i64", "addr", ":", "$", "src", ")", ")", ")", ")", ")", ",", "<BUGE>", "VR256X", ":", "$", "src0", ")", ",", "(", "VBROADCASTI64X2Z128rmk", "VR256X", ":", "$", "src0", ",", "VK4WM", ":", "$", "mask", ",", "addr", ":", "$", "src", ")", ">", ";", "}" ]

[ "<NUM_LIT>", ")" ]

[ "(", "SP_REG", "<NUM_LIT>", ")", "(", "MDR_REG", "<NUM_LIT>", ")", "(", "CC_REG" ]

[ "Ty", "(", "OpNode", "QPR", ":", "$", "src1", ",", "(", "Ty", "(", "MulOp", "QPR", ":", "$", "Vn", ",", "QPR", ":", "$", "Vm", ")", ")", ")", ")", ")", "]", ">", ";" ]

[ "class", "N3VQMulOp", "<", "bit", "op24", ",", "bit", "op23", ",", "bits", "<", "<NUM_LIT>", ">", "op21_20", ",", "bits", "<", "<NUM_LIT>", ">", "op11_8", ",", "bit", "op4", ",", "InstrItinClass", "itin", ",", "string", "OpcodeStr", ",", "string", "Dt", ",", "ValueType", "Ty", ",", "SDPatternOperator", "MulOp", ",", "SDPatternOperator", "OpNode", ">", ":", "N3V", "<", "op24", ",", "op23", ",", "op21_20", ",", "op11_8", ",", "<NUM_LIT>", ",", "op4", ",", "(", "outs", "QPR", ":", "$", "Vd", ")", ",", "(", "ins", "QPR", ":", "$", "src1", ",", "QPR", ":", "$", "Vn", ",", "QPR", ":", "$", "Vm", ")", ",", "N3RegFrm", ",", "itin", ",", "OpcodeStr", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "QPR", ":", "$", "Vd", ",", "(" ]

[ "<FIXS>", "[", "(", "match_operand", ":", "V_widen", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V_widen", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VMDI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V_elem", ">", "<NUM_LIT>", "<STR_LIT>", ")", "]", "<FIXE>" ]

[ "}", ")", "(", "define_expand", "<STR_LIT>", "<BUGS>", "[", "(", "match_operand", ":", "V_widen", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V_widen", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VMDI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V_elem", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<BUGE>", "<STR_LIT>", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "MODE", ">", "mode", ")" ]

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

[ "MF", "=", "ML", ".", "getHeader", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "auto", "*", "MBB", "=", "ML", ".", "getLoopPreheader", "(", ")", ")", "Preheader", "=", "MBB", ";", "else", "if", "(", "auto", "*", "MBB", "=", "MLI", ".", "findLoopPreheader", "(", "&", "ML", ",", "true", ",", "true", ")", ")", "Preheader", "=", "MBB", ";", "VPTState", "::", "reset" ]

[ "if", "(", "instr", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "RETURN", ")", "return", "instr", ";" ]

[ "if", "(", "It", "!=", "MBB", "->", "rend", "(", ")", ")", "{", "MachineInstr", "*", "instr", "=", "&", "(", "*", "It", ")", ";" ]

[ "return", "nds32_output_32bit_load", "(", "operands", ",", "<", "byte", ">", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "SI", "(", "match_operand", ":", "QIHI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "switch", "(", "which_alternative", ")", "{", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "case", "<NUM_LIT>", ":", "return", "<STR_LIT>", "case", "<NUM_LIT>", ":", "return", "nds32_output_16bit_load", "(", "operands", ",", "<", "byte", ">", ")", "case", "<NUM_LIT>", ":" ]

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

[ "gcc_assert", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "<NUM_LIT>", ")", ";", "lowpart", "=", "gen_lowpart", "(", "SImode", ",", "val", ")", ";", "highpart", "=", "gen_highpart_mode", "(", "SImode", ",", "mode", ",", "val", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "lowpart", ")", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "highpart" ]

[ "EFLAGS", ")", "]", ">", ",", "XS", ";" ]

[ "def", "LZCNT64rr", ":", "RI", "<", "<NUM_LIT>", ",", "MRMSrcReg", ",", "(", "outs", "GR64", ":", "$", "dst", ")", ",", "(", "ins", "GR64", ":", "$", "src", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "GR64", ":", "$", "dst", ",", "(", "ctlz", "GR64", ":", "$", "src", ")", ")", ",", "(", "implicit" ]

[ ")", ")" ]

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

[ "return", "NULL", ";" ]

[ "if", "(", "!", "Node1", "&&", "MBB1", "->", "succ_size", "(", ")", "==", "<NUM_LIT>", ")", "return", "findNearestCommonPostDom", "(", "*", "MBB1", "->", "succ_begin", "(", ")", ",", "MBB2", ")", ";", "if", "(", "!", "Node2", "&&", "MBB2", "->", "succ_size", "(", ")", "==", "<NUM_LIT>", ")", "return", "findNearestCommonPostDom", "(", "MBB1", ",", "*", "MBB2", "->", "succ_begin", "(", ")", ")", ";", "if", "(", "!", "Node1", "||", "!", "Node2", ")" ]

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

[ "def", "SM3SS1", ":", "CryptoRRRR_4S", "<", "<NUM_LIT>", "," ]

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

[ "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_FCHKSM16", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", ")", "<BUGE>", "(", "define_code_iterator", "vis3_shift", "[", "ashift", "ss_ashift", "lshiftrt", "ashiftrt", "]", ")", "(", "define_code_attr", "vis3_shift_insn" ]

[ "}" ]

[ "}", "if", "(", "!", "flag_non_call_exceptions", "||", "!", "instance", ".", "could_trap_p", "(", ")", ")", "attrs", "=", "add_attribute", "(", "<STR_LIT>", "nothrow", "<STR_LIT>", ",", "attrs", ")", ";", "return", "add_attribute", "(", "<STR_LIT>", "leaf", "<STR_LIT>", ",", "attrs", ")", ";" ]

[ "}" ]

[ "vneg_s8", "(", "int8x8_t", "_", "_", "a", ")", "{", "return", "(", "int8x8_t", ")", "_", "_", "builtin_neon_vnegv8qi", "(", "_", "_", "a", ")", ";" ]

[ "if", "(", "Asm", ".", "isThumbFunc", "(", "Sym", ")", "&&", "(", "FixupKind", "==", "ARM", "::", "fixup_arm_uncondbranch", ")", ")", "IsResolved", "=", "false", ";" ]

[ "void", "ARMAsmBackend", "::", "processFixupValue", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCFragment", "*", "DF", ",", "const", "MCValue", "&", "Target", ",", "uint64_t", "&", "Value", ",", "bool", "&", "IsResolved", ")", "{", "const", "MCSymbolRefExpr", "*", "A", "=", "Target", ".", "getSymA", "(", ")", ";", "const", "MCSymbol", "*", "Sym", "=", "A", "?", "&", "A", "->", "getSymbol", "(", ")", ":", "nullptr", ";", "const", "unsigned", "FixupKind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "FixupKind", "==", "FK_Data_4", "||", "FixupKind", "==", "ARM", "::", "fixup_arm_movw_lo16", "||", "FixupKind", "==", "ARM", "::", "fixup_arm_movt_hi16", "||", "FixupKind", "==", "ARM", "::", "fixup_t2_movw_lo16", "||", "FixupKind", "==", "ARM", "::", "fixup_t2_movt_hi16", ")", "{", "if", "(", "Sym", ")", "{", "if", "(", "Asm", ".", "isThumbFunc", "(", "Sym", ")", ")", "Value", "|=", "<NUM_LIT>", ";", "}", "}", "if", "(", "IsResolved", "&&", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", "==", "ARM", "::", "fixup_arm_thumb_bl", ")", "{", "assert", "(", "Sym", "&&", "<STR_LIT>", "How did we resolve this?", "<STR_LIT>", ")", ";", "if", "(", "Sym", "->", "isExternal", "(", ")", "||", "Value", ">=", "<NUM_LIT>", ")", "IsResolved", "=", "false", ";", "}", "if", "(", "Sym", "&&", "Sym", "->", "isELF", "(", ")", ")", "{", "unsigned", "Type", "=", "dyn_cast", "<", "MCSymbolELF", ">", "(", "Sym", ")", "->", "getType", "(", ")", ";", "if", "(", "(", "Type", "==", "ELF", "::", "STT_FUNC", "||", "Type", "==", "ELF", "::", "STT_GNU_IFUNC", ")", ")", "{" ]

[ ";" ]

[ "break", ";", "}", "}", "if", "(", "!", "FoundPreScan", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Have not found candidates for pmpy\\n", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "if", "(", "!", "PV", ".", "Left", ")", "{", "if", "(", "!", "promoteTypes", "(", "LoopB", ",", "ExitB", ")", ")", "return", "false", ";", "if", "(", "!", "convertShiftsToLeft", "(", "LoopB", ",", "ExitB", ",", "IterCount", ")", ")", "return", "false", ";", "cleanupLoopBody", "(", "LoopB", ")", ";", "}", "bool", "FoundScan", "=", "false", ";", "for", "(", "Instruction", "&", "In", ":", "*", "LoopB", ")", "{", "SelectInst", "*", "SelI", "=", "dyn_cast", "<", "SelectInst", ">", "(", "&", "In", ")", ";", "if", "(", "!", "SelI", ")", "continue", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "scanSelect: ", "<STR_LIT>", "<<", "*", "SelI", "<<", "'", "\\n", "'", ")", ";", "FoundScan", "=", "scanSelect", "(", "SelI", ",", "LoopB", ",", "EntryB", ",", "CIV", ",", "PV", ",", "false", ")", ";", "if", "(", "FoundScan", ")", "break", ";", "}", "assert", "(", "FoundScan", ")", ";", "DEBUG", "(", "{", "StringRef", "PP", "=", "(", "PV", ".", "M", "?", "<STR_LIT>", "(P+M)", "<STR_LIT>", ":", "<STR_LIT>", "P", "<STR_LIT>", ")", ";", "if", "(", "!", "PV", ".", "Inv", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", "Found pmpy idiom: R = ", "<STR_LIT>", "<<", "PP", "<<", "<STR_LIT>", ".Q\\n", "<STR_LIT>", ";", "else", "dbgs", "(", ")", "<<", "<STR_LIT>", "Found inverse pmpy idiom: R = (", "<STR_LIT>", "<<", "PP", "<<", "<STR_LIT>", "/Q).Q) + ", "<STR_LIT>", "<<", "PP", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", " Res:", "<STR_LIT>", "<<", "*", "PV", ".", "Res", "<<", "<STR_LIT>", "\\n P:", "<STR_LIT>", "<<", "*", "PV", ".", "P", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "if", "(", "PV", ".", "M", ")", "dbgs", "(", ")", "<<", "<STR_LIT>", " M:", "<STR_LIT>", "<<", "*", "PV", ".", "M", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", " Q:", "<STR_LIT>", "<<", "*", "PV", ".", "Q", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", " Iteration count:", "<STR_LIT>", "<<", "PV", ".", "IterCount", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "}", ")", ";", "BasicBlock", "::", "iterator", "At", "(", "EntryB", "->", "getTerminator", "(", ")", ")", ";", "Value", "*", "PM", "=", "generate", "(", "At", ",", "PV", ")", ";", "if", "(", "PM", "==", "nullptr", ")", "return", "false", ";", "if", "(", "PM", "->", "getType", "(", ")", "!=", "PV", ".", "Res", "->", "getType", "(", ")", ")", "PM", "=", "IRBuilder", "<", ">", "(", "&", "*", "At", ")", ".", "CreateIntCast", "(", "PM", ",", "PV", ".", "Res", "->", "getType", "(", ")", ",", "false", ")", ";", "PV", ".", "Res", "->", "replaceAllUsesWith", "(", "PM", ")", ";", "PV", ".", "Res", "->", "eraseFromParent", "(", ")", ";", "return", "true" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

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

[ "let", "Defs", "=", "[", "LC1", ",", "SA1", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", "||", "I", "->", "isPseudo", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", "||", "I", "->", "isIndirectBranch", "(", ")", ")", "return", "true", ";", "if", "(", "!", "isPredicated", "(", "I", ")", ")", "{", "if", "(", "!", "I", "->", "isUnconditionalBranch", "(", ")", ")", "fixOpcodeForGuard", "(", "I", ")", ";", "TBB", "=", "getBranchTarget", "(", "I", ")", ";", "if", "(", "AllowModify", ")", "{", "while", "(", "llvm", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "llvm", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";" ]

[ ";" ]

[ "bool", "isLWE", "(", ")", "const", "{", "return", "isImmTy", "(", "ImmTyLWE", ")" ]

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

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

[ "return", "<NUM_LIT>", "}", ")", "<BUGS>", "<BUGE>", "(", "define_predicate", "<STR_LIT>", "<BUGS>", "(", "match_code", "<STR_LIT>", ")", "<BUGE>", "{" ]

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

[ "enum", "ShiftType", "ShiftType", "=", "Lsl", ";", "const", "MCExpr", "*", "ShiftAmount", "=", "<NUM_LIT>", ";", "const", "MCExpr", "*", "Offset", "=", "<NUM_LIT>", ";", "if", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Preindexed", "=", "true", ";", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseMemoryOffsetReg", "(", "Negative", ",", "OffsetRegShifted", ",", "ShiftType", ",", "ShiftAmount", ",", "Offset", ",", "OffsetIsReg", ",", "OffsetRegNum", ",", "E", ")", ")", "return", "true", ";", "const", "AsmToken", "&", "RBracTok", "=", "Parser", ".", "getTok", "(", ")", ";", "if", "(", "RBracTok", ".", "isNot", "(", "AsmToken", "::", "RBrac", ")", ")", "{", "Error", "(", "RBracTok", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "']' expected", "<STR_LIT>", ")", ";", "return", "true", ";", "}", "E", "=", "RBracTok", ".", "getLoc", "(", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "const", "AsmToken", "&", "ExclaimTok", "=", "Parser", ".", "getTok", "(", ")", ";", "if", "(", "ExclaimTok", ".", "is", "(", "AsmToken", "::", "Exclaim", ")", ")", "{", "WBOp", "=", "ARMOperand", "::", "CreateToken", "(", "ExclaimTok", ".", "getString", "(", ")", ",", "ExclaimTok", ".", "getLoc", "(", ")", ")", ";", "Writeback", "=", "true", ";", "Parser", ".", "Lex", "(", ")", ";", "}", "}", "else", "{", "E", "=", "Tok", ".", "getLoc", "(", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "const", "AsmToken", "&", "NextTok", "=", "Parser", ".", "getTok", "(", ")", ";", "if", "(", "NextTok", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement" ]

[ "if", "(", "!", "IsVMEMClause", "&&", "!", "isSMEMClauseInst", "(", "MI", ")", ")", "return", "false", ";" ]

[ "if", "(", "MI", ".", "isDebugValue", "(", ")", "||", "MI", ".", "isBundled", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MI", ".", "mayLoad", "(", ")", "||", "MI", ".", "mayStore", "(", ")", ")", "return", "false", ";", "if", "(", "AMDGPU", "::", "getAtomicNoRetOp", "(", "MI", ".", "getOpcode", "(", ")", ")", "!=", "-", "<NUM_LIT>", "||", "AMDGPU", "::", "getAtomicRetOp", "(", "MI", ".", "getOpcode", "(", ")", ")", "!=", "-", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "IsVMEMClause", "&&", "!", "isVMEMClauseInst", "(", "MI", ")", ")", "return", "false", ";" ]

[ "}" ]

[ "assert", "(", "MBB", ".", "getParent", "(", ")", "&&", "<STR_LIT>", "Block is not attached to a function!", "<STR_LIT>", ")", ";", "if", "(", "STI", ".", "isTargetWin64", "(", ")", "&&", "!", "MBB", ".", "succ_empty", "(", ")", "&&", "!", "MBB", ".", "isReturnBlock", "(", ")", ")", "return", "false", ";", "if", "(", "canUseLEAForSPInEpilogue", "(", "*", "MBB", ".", "getParent", "(", ")", ")", ")", "return", "true", ";", "return", "!", "flagsNeedToBePreservedBeforeTheTerminators", "(", "MBB", ")", ";" ]

[ ";" ]

[ "field", "bits", "<", "<NUM_LIT>", ">", "Unpredictable", "=", "<NUM_LIT>", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "Unpredictable", ";", "let", "Namespace", "=", "<STR_LIT>", ";", "Format", "F", "=", "f", ";", "bits", "<", "<NUM_LIT>", ">", "Form", "=", "F", ".", "Value", ";", "let", "Pattern", "=", "[", "]", ";", "let", "Constraints", "=", "cstr" ]

[ "static", "void", "rs6000_emit_move_from_cr", "(", "rtx", "reg", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "TARGET_MFCRF", ")", "{", "int", "i", ",", "cr_reg", "[", "<NUM_LIT>", "]", ",", "count", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "cr_reg", "[", "count", "++", "]", "=", "i", ";", "if", "(", "count", "==", "<NUM_LIT>", ")", "{", "rtvec", "p", "=", "rtvec_alloc", "(", "<NUM_LIT>", ")", ";", "rtvec", "r", "=", "rtvec_alloc", "(", "<NUM_LIT>", ")", ";", "RTVEC_ELT", "(", "r", ",", "<NUM_LIT>", ")", "=", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", "+", "cr_reg", "[", "<NUM_LIT>", "]", ")", ";", "RTVEC_ELT", "(", "r", ",", "<NUM_LIT>", ")", "=", "GEN_INT", "(", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "cr_reg", "[", "<NUM_LIT>", "]", ")", ")", ";", "RTVEC_ELT", "(", "p", ",", "<NUM_LIT>", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "gen_rtx_UNSPEC", "(", "SImode", ",", "r", ",", "UNSPEC_MOVESI_FROM_CR", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ")", ";", "return", ";", "}", "}", "emit_insn", "(", "gen_movesi_from_cr", "(", "reg", ")", ")", ";", "}" ]

[ "Emit", "code", "to", "store", "CR", "fields", "that", "need", "to", "be", "saved", "into", "REG", "." ]

[ "<FIXS>", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "reg", ")", ")", ";", "<FIXE>" ]

[ "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "DFmode", ",", "plus_constant", "(", "base", ",", "offset", ")", ")", ";", "<BUGS>", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "reg", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "<BUGE>", "}", "else", "{" ]

[ "FeatureBitset", "RealCalleeBits", "=", "CalleeBits", "&", "~", "InlineFeatureIgnoreList", ";" ]

[ "const", "FeatureBitset", "&", "CallerBits", "=", "TM", ".", "getSubtargetImpl", "(", "*", "Caller", ")", "->", "getFeatureBits", "(", ")", ";", "const", "FeatureBitset", "&", "CalleeBits", "=", "TM", ".", "getSubtargetImpl", "(", "*", "Callee", ")", "->", "getFeatureBits", "(", ")", ";", "FeatureBitset", "RealCallerBits", "=", "CallerBits", "&", "~", "InlineFeatureIgnoreList", ";" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "call", "(", "mem", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "return", "xtensa_emit_sibcall", "(", "<NUM_LIT>", ",", "operands", ")", "}", "[", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "\t" ]

[ "const", "MCExpr", "*", "Res", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_GOT", ",", "getContext", "(", ")", ")", ";" ]

[ "const", "MCExpr", "*", "AArch64_MachoTargetObjectFile", "::", "getIndirectSymViaGOTPCRel", "(", "const", "GlobalValue", "*", "GV", ",", "const", "MCSymbol", "*", "Sym", ",", "const", "MCValue", "&", "MV", ",", "int64_t", "Offset", ",", "MachineModuleInfo", "*", "MMI", ",", "MCStreamer", "&", "Streamer", ")", "const", "{", "assert", "(", "(", "Offset", "+", "MV", ".", "getConstant", "(", ")", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Arch64 does not support GOT PC rel with extra offset", "<STR_LIT>", ")", ";" ]

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

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{", "rtx", "dest", "=", "XEXP", "(", "operands", "[" ]

[ ",", "unsigned", "long", "long", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cvtu64_sh", "(", "_", "_", "m128h", "_", "_", "A" ]

[ "<", "[", "WriteVLD2", "]", ">", ";" ]

[ "def", "VLD3DUPq8OddPseudo", ":", "VLDQQQQPseudo", "<", "IIC_VLD3dup", ">", ",", "Sched" ]

[ ",", "&", "X86", "::", "FR32XRegClass", ")", ";" ]

[ "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VK16RegClass", ")", ";", "case", "MVT", "::", "i8", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VK8RegClass", ")", ";", "case", "MVT", "::", "i1", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VK1RegClass", ")", ";", "case", "MVT", "::", "i64", ":", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VK64RegClass", ")", ";", "}", "}", "break", ";", "case", "'", "q", "'", ":", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR32RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR16RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i1", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR8RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "||", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR64RegClass", ")", ";", "break", ";", "}", "case", "'", "Q", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR32_ABCDRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR16_ABCDRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i1", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR8_ABCD_LRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR64_ABCDRegClass", ")", ";", "break", ";", "case", "'", "r", "'", ":", "case", "'", "l", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i1", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR8RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR16RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "f32", "||", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR32RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR64RegClass", ")", ";", "case", "'", "R", "'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i1", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR8_NOREXRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR16_NOREXRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR32_NOREXRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "GR64_NOREXRegClass", ")", ";", "case", "'", "f", "'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "!", "isScalarFPTypeInSSEReg", "(", "VT", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "RFP32RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "&&", "!", "isScalarFPTypeInSSEReg", "(", "VT", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "RFP64RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "RFP80RegClass", ")", ";", "case", "'", "y", "'", ":", "if", "(", "!", "Subtarget", ".", "hasMMX", "(", ")", ")", "break", ";", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U", ",", "&", "X86", "::", "VR64RegClass", ")", ";", "case", "'", "Y", "'", ":", "if", "(", "!", "Subtarget", ".", "hasSSE2", "(", ")", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "case", "'", "v", "'", ":", "case", "'", "x", "'", ":", "if", "(", "!", "Subtarget", ".", "hasSSE1", "(", ")", ")", "break", ";", "bool", "VConstraint", "=", "(", "Constraint", "[", "<NUM_LIT>", "]", "==", "'", "v", "'", ")", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "i32", ":", "if", "(", "VConstraint", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "Subtarget", ".", "hasVLX", "(", ")", ")", "return", "std", "::", "make_pair", "(", "<NUM_LIT>", "U" ]

[ ")" ]

[ "(", "define_code_attr", "atomic_op_operand", "[", "(", "ior", "<STR_LIT>" ]

[ "false", ";" ]

[ "bool", "MipsDAGToDAGISel", "::", "selectVSplatUimmPow2", "(", "SDValue", "N", ",", "SDValue", "&", "Imm", ")", "const", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unimplemented function.", "<STR_LIT>", ")", ";", "return" ]

[ "if", "(", "!", "GV", "->", "hasLocalLinkage", "(", ")", "||", "isa", "<", "Function", ">", "(", "GV", ")", ")", "return", "ResNode", ";" ]

[ "return", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "GOT", ",", "GPRelNode", ")", ";", "}", "SDValue", "HiPart", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VTs", ",", "<NUM_LIT>", ",", "Ops", ",", "<NUM_LIT>", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "GA", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "MVT", "::", "i32", ",", "HiPart", ",", "Lo", ")", ";", "}", "else", "{", "SDValue", "ResNode", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "GA", ",", "NULL", ",", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "f_2", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "<STR_LIT>", "count", "<STR_LIT>", ")", ",", "<FIXE>" ]

[ "f_1", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "<STR_LIT>", "base", "<STR_LIT>", ")", ",", "ptr_type_node", ")", ";", "<BUGS>", "f_2", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "<STR_LIT>", "count", "<STR_LIT>", ")", ",", "<BUGE>", "unsigned_type_node", ")", ";", "DECL_FIELD_CONTEXT", "(", "f_1", ")", "=", "record", ";" ]

[ "arg", ")", "{" ]

[ "static", "void", "or", "<NUM_LIT>", "k_tls_call", "(", "rtx", "dest", ",", "rtx" ]

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

[ "return", "decodeSrcOp", "(", "OPW64", "," ]

[ "}" ]

[ "FunctionPass", "*", "createGBZ80FrameAnalyzerPass", "(", ")", "{", "return", "new", "GBZ80FrameAnalyzer", "(", ")", ";" ]

[ "void", "XCoreFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineModuleInfo", "*", "MMI", "=", "&", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", "->", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "XCoreInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "DebugLoc", "dl", ";", "if", "(", "MFI", "->", "getMaxAlignment", "(", ")", ">", "getStackAlignment", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "emitPrologue unsupported alignment: ", "<STR_LIT>", "+", "Twine", "(", "MFI", "->", "getMaxAlignment", "(", ")", ")", ")", ";", "const", "AttributeSet", "&", "PAL", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "if", "(", "PAL", ".", "hasAttrSomewhere", "(", "Attribute", "::", "Nest", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "assert", "(", "MFI", "->", "getStackSize", "(", ")", "%", "<NUM_LIT>", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Misaligned frame size", "<STR_LIT>", ")", ";", "const", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", "/", "<NUM_LIT>", ";", "int", "Adjusted", "=", "<NUM_LIT>", ";", "bool", "saveLR", "=", "XFI", "->", "hasLRSpillSlot", "(", ")", ";", "bool", "UseENTSP", "=", "saveLR", "&&", "FrameSize", "&&", "(", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", "==", "<NUM_LIT>", ")", ";", "if", "(", "UseENTSP", ")", "saveLR", "=", "false", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "bool", "emitFrameMoves", "=", "XCoreRegisterInfo", "::", "needsFrameMoves", "(", "MF", ")", ";", "if", "(", "UseENTSP", ")", "{", "Adjusted", "=", "(", "FrameSize", ">", "MaxImmU16", ")", "?", "MaxImmU16", ":", "FrameSize", ";", "int", "Opcode", "=", "isImmU6", "(", "Adjusted", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "MBB", ".", "addLiveIn", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ";", "MIB", ".", "addImm", "(", "Adjusted", ")", ";", "MIB", "->", "addRegisterKilled", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "true", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "EmitDefCfaOffset", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "MMI", ",", "Adjusted", "*", "<NUM_LIT>", ")", ";", "unsigned", "DRegNum", "=", "MRI", "->", "getDwarfRegNum", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ")", ";", "EmitCfiOffset", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "MMI", ",", "DRegNum", ",", "<NUM_LIT>", ")", ";", "}", "}", "SmallVector", "<", "StackSlotInfo", ",", "<NUM_LIT>", ">", "SpillList", ";", "GetSpillList", "(", "SpillList", ",", "MFI", ",", "XFI", ",", "saveLR", ",", "FP", ")", ";", "std", "::", "reverse", "(", "SpillList", ".", "begin", "(", ")", ",", "SpillList", ".", "end", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "SpillList", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "assert", "(", "SpillList", "[", "i", "]", ".", "Offset", "%", "<NUM_LIT>", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Misaligned stack offset", "<STR_LIT>", ")", ";", "assert", "(", "SpillList", "[", "i", "]", ".", "Offset", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected positive stack offset", "<STR_LIT>", ")", ";", "int", "OffsetFromTop", "=", "-", "SpillList", "[", "i", "]", ".", "Offset", "/", "<NUM_LIT>", ";", "IfNeededExtSP", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "MMI", ",", "OffsetFromTop", ",", "Adjusted", ",", "FrameSize", ",", "emitFrameMoves", ")", ";", "int", "Offset", "=", "Adjusted", "-", "OffsetFromTop", ";", "int", "Opcode", "=", "isImmU6", "(", "Offset", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "MBB", ".", "addLiveIn", "(", "SpillList", "[", "i", "]", ".", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SpillList", "[", "i", "]", ".", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Offset", ")", ".", "addMemOperand", "(", "getFrameIndexMMO", "(", "MBB", ",", "SpillList", "[", "i", "]", ".", "FI", ",", "MachineMemOperand", "::", "MOStore", ")", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "unsigned", "DRegNum", "=", "MRI", "->", "getDwarfRegNum", "(", "SpillList", "[", "i", "]", ".", "Reg", ",", "true", ")", ";", "EmitCfiOffset", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "MMI", ",", "DRegNum", ",", "SpillList", "[", "i", "]", ".", "Offset", ")", ";", "}", "}", "IfNeededExtSP", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "MMI", ",", "FrameSize", ",", "Adjusted", ",", "FrameSize", ",", "emitFrameMoves", ")", ";", "assert", "(", "Adjusted", "==", "FrameSize", "&&", "<STR_LIT>", "IfNeededExtSP has not completed adjustment", "<STR_LIT>", ")", ";", "if", "(", "FP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "FramePtr", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "emitFrameMoves", ")", "EmitDefCfaRegister", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "MMI", ",", "MRI", "->", "getDwarfRegNum", "(", "FramePtr", ",", "true", ")", ")", ";", "}", "if", "(", "emitFrameMoves", ")", "{", "auto", "SpillLabels", "=", "XFI", "->", "getSpillLabels", "(", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "SpillLabels", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineBasicBlock", "::", "iterator", "Pos", "=", "SpillLabels", "[", "I", "]", ".", "first", ";", "++", "Pos", ";", "CalleeSavedInfo", "&", "CSI", "=", "SpillLabels", "[", "I", "]", ".", "second", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "CSI", ".", "getFrameIdx", "(", ")", ")", ";", "unsigned", "DRegNum", "=", "MRI", "->", "getDwarfRegNum", "(", "CSI", ".", "getReg", "(", ")", ",", "true", ")", ";", "EmitCfiOffset", "(", "MBB", ",", "Pos", ",", "dl", ",", "TII", ",", "MMI", ",", "DRegNum", ",", "Offset", ")", ";", "}", "if", "(", "XFI", "->", "hasEHSpillSlot", "(", ")", ")", "{", "SmallVector", "<", "StackSlotInfo", ",", "<NUM_LIT>", ">", "SpillList", ";", "GetEHSpillList", "(", "SpillList", ",", "MFI", ",", "XFI", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", ")", ";", "assert", "(", "SpillList", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected SpillList size", "<STR_LIT>", ")", ";", "EmitCfiOffset", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "MMI", ",", "MRI", "->", "getDwarfRegNum", "(", "SpillList", "[", "<NUM_LIT>", "]", ".", "Reg", ",", "true", ")", ",", "SpillList", "[", "<NUM_LIT>", "]", ".", "Offset", ")", ";", "EmitCfiOffset", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ",", "MMI", ",", "MRI", "->", "getDwarfRegNum", "(", "SpillList", "[", "<NUM_LIT>", "]", ".", "Reg", ",", "true", ")", ",", "SpillList", "[", "<NUM_LIT>", "]", ".", "Offset", ")", ";", "}", "}", "}" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "<FIXS>", "||", "SYMBOL_REF_P", "(", "XEXP", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ")", "<FIXE>" ]

[ "&&", "GET_CODE", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "add_operand", "(", "XEXP", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "mode", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "LABEL_REF", "<BUGS>", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "SYMBOL_REF", ")", "<BUGE>", "&&", "!", "side_effects_p", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "rtx", "sym", "=" ]

[ "<FIXS>", "&&", "TARGET_HARD_FLOAT", "&&", "TARGET_FUSED_MADD", ")", "<FIXE>" ]

[ "if", "(", "(", "GET_MODE", "(", "x", ")", "==", "DFmode", "||", "GET_MODE", "(", "x", ")", "==", "SFmode", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "MULT", "<BUGS>", "&&", "TARGET_HARD_FLOAT", "&&", "TARGET_IEEE_FLOAT", "&&", "TARGET_FUSED_MADD", ")", "<BUGE>", "{", "if", "(", "GET_MODE", "(", "x", ")", "==", "DFmode", ")" ]

[ "artificial__", ")", ")", "_", "writegsbase_u64", "(", "unsigned", "long", "long", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_" ]

[ "}" ]

[ "SDValue", "Shift", "=", "DAG", ".", "getConstant", "(", "BitsDiff", ",", "VT", ")", ";", "SDValue", "Shl", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "VT", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Shift", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "DL", ",", "VT", ",", "Shl", ",", "Shift", ")", ";" ]

[ "}" ]

[ "void", "aarch64_cpu_cpp_builtins", "(", "cpp_reader", "*", "pfile", ")", "{", "aarch64_define_unconditional_macros", "(", "pfile", ")", ";", "aarch64_update_cpp_builtins", "(", "pfile", ")", ";" ]

[ "VAR1", "(", "LOAD1_P", ",", "ld1", ",", "<NUM_LIT>", ",", "LOAD", ",", "v4hi", ")", "VAR1", "(", "STORE1_P", ",", "st1", ",", "<NUM_LIT>", ",", "STORE", ",", "v4hi", ")", "return", "Poly16x4_t", ";" ]

[ "VAR1", "(", "LOAD1", ",", "ld1", ",", "<NUM_LIT>", ",", "LOAD", ",", "v2di", ")", "VAR1", "(", "STORE1", ",", "st1", ",", "<NUM_LIT>", ",", "STORE", ",", "v2di", ")", "return", "Int64x2_t", ";", "VAR1", "(", "LOAD1_U", ",", "ld1", ",", "<NUM_LIT>", ",", "LOAD", ",", "v8qi", ")", "VAR1", "(", "STORE1_U", ",", "st1", ",", "<NUM_LIT>", ",", "STORE", ",", "v8qi", ")", "return", "Uint8x8_t", ";", "VAR1", "(", "LOAD1_U", ",", "ld1", ",", "<NUM_LIT>", ",", "LOAD", ",", "v16qi", ")", "VAR1", "(", "STORE1_U", ",", "st1", ",", "<NUM_LIT>", ",", "STORE", ",", "v16qi", ")", "return", "Uint8x16_t", ";", "VAR1", "(", "LOAD1_U", ",", "ld1", ",", "<NUM_LIT>", ",", "LOAD", ",", "v4hi", ")", "VAR1", "(", "STORE1_U", ",", "st1", ",", "<NUM_LIT>", ",", "STORE", ",", "v4hi", ")", "return", "Uint16x4_t", ";", "VAR1", "(", "LOAD1_U", ",", "ld1", ",", "<NUM_LIT>", ",", "LOAD", ",", "v8hi", ")", "VAR1", "(", "STORE1_U", ",", "st1", ",", "<NUM_LIT>", ",", "STORE", ",", "v8hi", ")", "return", "Uint16x8_t", ";", "VAR1", "(", "LOAD1_U", ",", "ld1", ",", "<NUM_LIT>", ",", "LOAD", ",", "v2si", ")", "VAR1", "(", "STORE1_U", ",", "st1", ",", "<NUM_LIT>", ",", "STORE", ",", "v2si", ")", "return", "Uint32x2_t", ";", "VAR1", "(", "LOAD1_U", ",", "ld1", ",", "<NUM_LIT>", ",", "LOAD", ",", "v4si", ")", "VAR1", "(", "STORE1_U", ",", "st1", ",", "<NUM_LIT>", ",", "STORE", ",", "v4si", ")", "return", "Uint32x4_t", ";", "VAR1", "(", "LOAD1_U", ",", "ld1", ",", "<NUM_LIT>", ",", "LOAD", ",", "v2di", ")", "VAR1", "(", "STORE1_U", ",", "st1", ",", "<NUM_LIT>", ",", "STORE", ",", "v2di", ")", "return", "Uint64x2_t", ";", "VAR1", "(", "LOAD1_P", ",", "ld1", ",", "<NUM_LIT>", ",", "LOAD", ",", "v8qi", ")", "VAR1", "(", "STORE1_P", ",", "st1", ",", "<NUM_LIT>", ",", "STORE", ",", "v8qi", ")", "return", "Poly8x8_t", ";", "VAR1", "(", "LOAD1_P", ",", "ld1", ",", "<NUM_LIT>", ",", "LOAD", ",", "v16qi", ")", "VAR1", "(", "STORE1_P", ",", "st1", ",", "<NUM_LIT>", ",", "STORE", ",", "v16qi", ")", "return", "Poly8x16_t", ";" ]

[ "return", "(", "ashl_lshr_seq", "[", "shift_amount_i", "]", ".", "clobbers_t", "&", "ASHL_CLOBBERS_T", ")", "!=", "<NUM_LIT>", ";" ]

[ "bool", "sh_ashlsi_clobbers_t_reg_p", "(", "rtx", "shift_amount", ")", "{", "gcc_assert", "(", "CONST_INT_P", "(", "shift_amount", ")", ")", ";", "const", "int", "shift_amount_i", "=", "INTVAL", "(", "shift_amount", ")", "&", "<NUM_LIT>", ";", "if", "(", "shift_amount_i", "==", "<NUM_LIT>", ")", "return", "true", ";" ]

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

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

[ "}" ]

[ "if", "(", "isI32Insn", "(", "User", ",", "N", ")", ")", "continue", ";", "return", "SDValue", "(", ")", ";", "}", "SDValue", "SubI32", "=", "DAG", ".", "getTargetConstant", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "TargetOpcode", "::", "EXTRACT_SUBREG", ",", "DL", ",", "VT", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "SubI32", ")", ",", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "!", "IsInlineConstant", "(", "NegSplatValue", ")", ")", "return", "false", ";" ]

[ "SDValue", "C", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "auto", "*", "BVN", "=", "dyn_cast", "<", "BuildVectorSDNode", ">", "(", "C", ")", ";", "if", "(", "!", "BVN", ")", "return", "false", ";", "APInt", "SplatValue", ",", "SplatUndef", ";", "unsigned", "SplatBitSize", ";", "bool", "HasAnyUndefs", ";", "if", "(", "!", "BVN", "->", "isConstantSplat", "(", "SplatValue", ",", "SplatUndef", ",", "SplatBitSize", ",", "HasAnyUndefs", ",", "<NUM_LIT>", ",", "!", "Subtarget", "->", "isLittle", "(", ")", ")", ")", "return", "false", ";", "auto", "IsInlineConstant", "=", "[", "]", "(", "const", "APInt", "&", "Imm", ")", "{", "return", "Imm", ".", "isIntN", "(", "<NUM_LIT>", ")", ";", "}", ";", "if", "(", "IsInlineConstant", "(", "SplatValue", ")", ")", "return", "false", ";", "APInt", "NegSplatValue", "=", "<NUM_LIT>", "-", "SplatValue", ";" ]

[ "<STR_LIT>" ]

[ "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "QI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>" ]

[ "<NUM_LIT>", ";" ]

[ "def", "L2_loadbzw2_pbr", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "ModRegs", ":", "$", "Mu2", ")", ",", "<STR_LIT>", ",", "tc_44d3da28", ",", "TypeLD", ">", ",", "Enc_74d4e5", "{", "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", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=" ]

[ "}" ]

[ "ThumbTargetMachine", "::", "ThumbTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "ARMBaseTargetMachine", "(", "T", ",", "TT", ",", "FS", ",", "true", ")", ",", "InstrInfo", "(", "Subtarget", ".", "hasThumb2", "(", ")", "?", "(", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb2InstrInfo", "(", "Subtarget", ")", ")", ":", "(", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb1InstrInfo", "(", "Subtarget", ")", ")", ")", ",", "DataLayout", "(", "Subtarget", ".", "isAPCS_ABI", "(", ")", "?", "std", "::", "string", "(", "<STR_LIT>", "e-p:32:32-f64:32:32-i64:32:32-", "<STR_LIT>", "<STR_LIT>", "i16:16:32-i8:8:32-i1:8:32-", "<STR_LIT>", "<STR_LIT>", "v128:32:128-v64:32:64-a:0:32-n32", "<STR_LIT>", ")", ":", "std", "::", "string", "(", "<STR_LIT>", "e-p:32:32-f64:64:64-i64:64:64-", "<STR_LIT>", "<STR_LIT>", "i16:16:32-i8:8:32-i1:8:32-", "<STR_LIT>", "<STR_LIT>", "v128:64:128-v64:64:64-a:0:32-n32", "<STR_LIT>", ")", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", "{" ]

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

[ "<STR_LIT>", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "<", "MODE", ">", "mode", ")", "emit_insn", "(", "gen_neon_vset_lane", "<", "mode", ">", "(", "tmp", ",", "operands", "[", "<NUM_LIT>", "]", ",", "tmp", ",", "const0_rtx", ")", ")", "emit_insn", "(", "gen_neon_vmls_lane", "<", "mode", ">", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[" ]

[ "<FIXS>", "ParamValue", ")", ";", "<FIXE>" ]

[ "unsigned", "ParamSize", "=", "Ins", "[", "i", "]", ".", "VT", ".", "getStoreSizeInBits", "(", ")", ";", "unsigned", "Param", "=", "PM", ".", "addArgumentParam", "(", "ParamSize", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Ins", "[", "i", "]", ".", "VT", ",", "Chain", ",", "<BUGS>", "DAG", ".", "getTargetConstant", "(", "Param", ",", "MVT", "::", "i32", ")", ")", ";", "<BUGE>", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "}" ]

[ "return", "loadImmediate", "(", "Offset", ".", "getImm", "(", ")", ",", "DstReg", ",", "BaseReg", ",", "Is32BitAddress", ",", "true", ",", "IDLoc", ",", "Out", ",", "STI", ")", ";" ]

[ "if", "(", "!", "Offset", ".", "isImm", "(", ")", ")", "return", "loadAndAddSymbolAddress", "(", "Offset", ".", "getExpr", "(", ")", ",", "DstReg", ",", "BaseReg", ",", "Is32BitAddress", ",", "IDLoc", ",", "Out", ",", "STI", ")", ";", "if", "(", "!", "ABI", ".", "ArePtrs64bit", "(", ")", ")", "{", "Is32BitAddress", "=", "true", ";", "}" ]