Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "int", "NewFPIdx", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateFixedObject", "(", "SlotSize", ",", "NewFPLoc", ",", "true", ",", "false", ")", ";", "<FIXE>" ]

[ "if", "(", "isDarwinABI", ")", "{", "int", "NewFPLoc", "=", "SPDiff", "+", "PPCFrameInfo", "::", "getFramePointerSaveOffset", "(", "isPPC64", ",", "isDarwinABI", ")", ";", "<BUGS>", "int", "NewFPIdx", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateFixedObject", "(", "SlotSize", ",", "NewFPLoc", ")", ";", "<BUGE>", "SDValue", "NewFramePtrIdx", "=", "DAG", ".", "getFrameIndex", "(", "NewFPIdx", ",", "VT", ")", ";", "Chain", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "OldFP", ",", "NewFramePtrIdx", ",", "PseudoSourceValue", "::", "getFixedStack", "(", "NewFPIdx", ")", ",", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "GET_SSE_REGNO", "(", "sse_regno", ")", ")", ";", "<FIXE>" ]

[ "case", "X86_64_SSEDF_CLASS", ":", "if", "(", "mode", "!=", "BLKmode", ")", "return", "gen_reg_or_parallel", "(", "mode", ",", "or", "ig_mode", ",", "<BUGS>", "SSE_REGNO", "(", "sse_regno", ")", ")", ";", "<BUGE>", "break", ";", "case", "X86_64_X87_CLASS", ":", "case", "X86_64_COMPLEX_X87_CLASS", ":" ]

[ "unsigned", "getFramePred", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "assert", "(", "isFrameInstr", "(", "MI", ")", ")", ";", "return", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}" ]

[ "Returns", "predicate", "register", "associated", "with", "the", "given", "frame", "instruction", "." ]

[ "}" ]

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

[ "void", "build", "(", "function_builder", "&", "b", ",", "const", "function_group_info", "&", "group", ")", "const", "override", "{", "b", ".", "add_overloaded_functions", "(", "group", ",", "MODE_none", ")", ";", "build_all", "(", "b", ",", "<STR_LIT>", "v0,vu0", "<STR_LIT>", ",", "group", ",", "MODE_none", ")", ";", "}" ]

[ "Build", "new", "chain", "starting", "from", "insn", "INSN_UID", "recursively", "adding", "all", "dependent", "uses", "and", "definitions", ".", "Return", "true", "if", "OK", ",", "false", "if", "the", "chain", "discovery", "was", "aborted", "." ]

[ "<FIXS>", "if", "(", "(", "TM", "->", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "||", "MF", ".", "getFunction", "(", ")", ".", "hasAddressTaken", "(", ")", "||", "<FIXE>" ]

[ "TII", "=", "SubTarget", ".", "getInstrInfo", "(", ")", ";", "EndbrOpcode", "=", "SubTarget", ".", "is64Bit", "(", ")", "?", "X86", "::", "ENDBR64", ":", "X86", "::", "ENDBR32", ";", "<BUGS>", "if", "(", "(", "MF", ".", "getFunction", "(", ")", ".", "hasAddressTaken", "(", ")", "||", "<BUGE>", "!", "MF", ".", "getFunction", "(", ")", ".", "hasLocalLinkage", "(", ")", ")", "&&", "!", "MF", ".", "getFunction", "(", ")", ".", "doesNoCfCheck", "(", ")", ")", "{", "auto", "MBB", "=", "MF", ".", "begin", "(", ")", ";" ]

[ "case", "ARM", "::", "VST2b16wb_register", ":" ]

[ "case", "ARM", "::", "VST2b32wb_register", ":", "if", "(", "Rm", "==", "<NUM_LIT>", ")", "return", "MCDisassembler", "::", "Fail", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "<NUM_LIT>", ")", ")", ";", "break", ";", "case", "ARM", "::", "VST3d8_UPD", ":", "case", "ARM", "::", "VST3d16_UPD", ":", "case", "ARM", "::", "VST3d32_UPD", ":", "case", "ARM", "::", "VST3q8_UPD", ":", "case", "ARM", "::", "VST3q16_UPD", ":", "case", "ARM", "::", "VST3q32_UPD", ":", "case", "ARM", "::", "VST4d8_UPD", ":", "case", "ARM", "::", "VST4d16_UPD", ":", "case", "ARM", "::", "VST4d32_UPD", ":", "case", "ARM", "::", "VST4q8_UPD", ":", "case", "ARM", "::", "VST4q16_UPD", ":", "case", "ARM", "::", "VST4q32_UPD", ":", "if", "(", "!", "Check", "(", "S", ",", "DecodeGPRRegisterClass", "(", "Inst", ",", "wb", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "!", "Check", "(", "S", ",", "DecodeAddrMode6Operand", "(", "Inst", ",", "Rn", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "if", "(", "Rm", "==", "<NUM_LIT>", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "<NUM_LIT>", ")", ")", ";", "else", "if", "(", "Rm", "!=", "<NUM_LIT>", ")", "{", "if", "(", "!", "Check", "(", "S", ",", "DecodeGPRRegisterClass", "(", "Inst", ",", "Rm", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "}", "break", ";", "case", "ARM", "::", "VST1d8wb_fixed", ":", "case", "ARM", "::", "VST1d16wb_fixed", ":", "case", "ARM", "::", "VST1d32wb_fixed", ":", "case", "ARM", "::", "VST1d64wb_fixed", ":", "case", "ARM", "::", "VST1q8wb_fixed", ":", "case", "ARM", "::", "VST1q16wb_fixed", ":", "case", "ARM", "::", "VST1q32wb_fixed", ":", "case", "ARM", "::", "VST1q64wb_fixed", ":", "case", "ARM", "::", "VST1d8Twb_fixed", ":", "case", "ARM", "::", "VST1d16Twb_fixed", ":", "case", "ARM", "::", "VST1d32Twb_fixed", ":", "case", "ARM", "::", "VST1d64Twb_fixed", ":", "case", "ARM", "::", "VST1d8Qwb_fixed", ":", "case", "ARM", "::", "VST1d16Qwb_fixed", ":", "case", "ARM", "::", "VST1d32Qwb_fixed", ":", "case", "ARM", "::", "VST1d64Qwb_fixed", ":", "case", "ARM", "::", "VST2d8wb_fixed", ":", "case", "ARM", "::", "VST2d16wb_fixed", ":", "case", "ARM", "::", "VST2d32wb_fixed", ":", "case", "ARM", "::", "VST2q8wb_fixed", ":", "case", "ARM", "::", "VST2q16wb_fixed", ":", "case", "ARM", "::", "VST2q32wb_fixed", ":", "case", "ARM", "::", "VST2b8wb_fixed", ":", "case", "ARM", "::", "VST2b16wb_fixed", ":", "case", "ARM", "::", "VST2b32wb_fixed", ":", "break", ";", "}", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VST1q16", ":", "case", "ARM", "::", "VST1q32", ":", "case", "ARM", "::", "VST1q64", ":", "case", "ARM", "::", "VST1q8", ":", "case", "ARM", "::", "VST1q16wb_fixed", ":", "case", "ARM", "::", "VST1q16wb_register", ":", "case", "ARM", "::", "VST1q32wb_fixed", ":", "case", "ARM", "::", "VST1q32wb_register", ":", "case", "ARM", "::", "VST1q64wb_fixed", ":", "case", "ARM", "::", "VST1q64wb_register", ":", "case", "ARM", "::", "VST1q8wb_fixed", ":", "case", "ARM", "::", "VST1q8wb_register", ":", "case", "ARM", "::", "VST2d16", ":", "case", "ARM", "::", "VST2d32", ":", "case", "ARM", "::", "VST2d8", ":", "case", "ARM", "::", "VST2d16wb_fixed", ":", "case", "ARM", "::", "VST2d16wb_register", ":", "case", "ARM", "::", "VST2d32wb_fixed", ":", "case", "ARM", "::", "VST2d32wb_register", ":", "case", "ARM", "::", "VST2d8wb_fixed", ":", "case", "ARM", "::", "VST2d8wb_register", ":", "if", "(", "!", "Check", "(", "S", ",", "DecodeDPairRegisterClass", "(", "Inst", ",", "Rd", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "break", ";", "case", "ARM", "::", "VST2b16", ":", "case", "ARM", "::", "VST2b32", ":", "case", "ARM", "::", "VST2b8", ":", "case", "ARM", "::", "VST2b16wb_fixed", ":" ]

[ ")", ")" ]

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

[ "(", "AVX512BoolReduction", ",", "ISD", ",", "MTy", ")", ")", "return", "LT", ".", "first", "*", "Entry", "->", "Cost", ";" ]

[ "if", "(", "ST", "->", "isSLM", "(", ")", ")", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "SLMCostTblPairWise", ",", "ISD", ",", "MTy", ")", ")", "return", "LT", ".", "first", "*", "Entry", "->", "Cost", ";", "if", "(", "ST", "->", "hasAVX", "(", ")", ")", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "AVX1CostTblPairWise", ",", "ISD", ",", "MTy", ")", ")", "return", "LT", ".", "first", "*", "Entry", "->", "Cost", ";", "if", "(", "ST", "->", "hasSSE2", "(", ")", ")", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "SSE2CostTblPairWise", ",", "ISD", ",", "MTy", ")", ")", "return", "LT", ".", "first", "*", "Entry", "->", "Cost", ";", "}", "else", "{", "if", "(", "ST", "->", "isSLM", "(", ")", ")", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "SLMCostTblNoPairWise", ",", "ISD", ",", "MTy", ")", ")", "return", "LT", ".", "first", "*", "Entry", "->", "Cost", ";", "if", "(", "ST", "->", "hasAVX", "(", ")", ")", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "AVX1CostTblNoPairWise", ",", "ISD", ",", "MTy", ")", ")", "return", "LT", ".", "first", "*", "Entry", "->", "Cost", ";", "if", "(", "ST", "->", "hasSSE2", "(", ")", ")", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "SSE2CostTblNoPairWise", ",", "ISD", ",", "MTy", ")", ")", "return", "LT", ".", "first", "*", "Entry", "->", "Cost", ";", "}", "static", "const", "CostTblEntry", "AVX512BoolReduction", "[", "]", "=", "{", "{", "ISD", "::", "AND", ",", "MVT", "::", "v2i1", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "AND", ",", "MVT", "::", "v4i1", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "AND", ",", "MVT", "::", "v8i1", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "AND", ",", "MVT", "::", "v16i1", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "AND", ",", "MVT", "::", "v32i1", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "AND", ",", "MVT", "::", "v64i1", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v2i1", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v4i1", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v8i1", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v16i1", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v32i1", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v64i1", ",", "<NUM_LIT>", "}", ",", "}", ";", "static", "const", "CostTblEntry", "AVX2BoolReduction", "[", "]", "=", "{", "{", "ISD", "::", "AND", ",", "MVT", "::", "v16i16", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "AND", ",", "MVT", "::", "v32i8", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v16i16", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v32i8", ",", "<NUM_LIT>", "}", ",", "}", ";", "static", "const", "CostTblEntry", "AVX1BoolReduction", "[", "]", "=", "{", "{", "ISD", "::", "AND", ",", "MVT", "::", "v4i64", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "AND", ",", "MVT", "::", "v8i32", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "AND", ",", "MVT", "::", "v16i16", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "AND", ",", "MVT", "::", "v32i8", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v4i64", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v8i32", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v16i16", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v32i8", ",", "<NUM_LIT>", "}", ",", "}", ";", "static", "const", "CostTblEntry", "SSE2BoolReduction", "[", "]", "=", "{", "{", "ISD", "::", "AND", ",", "MVT", "::", "v2i64", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "AND", ",", "MVT", "::", "v4i32", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "AND", ",", "MVT", "::", "v8i16", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "AND", ",", "MVT", "::", "v16i8", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v2i64", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v4i32", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v8i16", ",", "<NUM_LIT>", "}", ",", "{", "ISD", "::", "OR", ",", "MVT", "::", "v16i8", ",", "<NUM_LIT>", "}", ",", "}", ";", "if", "(", "!", "IsPairwise", "&&", "ValTy", "->", "getVectorElementType", "(", ")", "->", "isIntegerTy", "(", "<NUM_LIT>", ")", ")", "{", "if", "(", "ST", "->", "hasAVX512", "(", ")", ")", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_automaton" ]

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

[ "O", "<<", "<STR_LIT>", "\\tcall\\t.LLGETPC", "<STR_LIT>", "<<", "mfNum", "<<", "'", "_", "'", "<<", "bbNum", "<<", "'", "\\n", "'", ";", "O", "<<", "<STR_LIT>", "\\t sethi\\t", "<STR_LIT>", "<<", "<STR_LIT>", "%hi(_GLOBAL_OFFSET_TABLE_+(.-.LLGETPCH", "<STR_LIT>", "<<", "mfNum", "<<", "'", "_", "'", "<<", "bbNum", "<<", "<STR_LIT>", ")), ", "<STR_LIT>", "<<", "operand", "<<", "'", "\\n", "'", ";", "O", "<<", "<STR_LIT>", ".LLGETPC", "<STR_LIT>", "<<", "mfNum", "<<", "'", "_", "'", "<<", "bbNum", "<<", "<STR_LIT>", ":\\n", "<STR_LIT>", ";", "O", "<<", "<STR_LIT>", "\\tor\\t", "<STR_LIT>", "<<", "operand", "<<", "<STR_LIT>", ", %lo(_GLOBAL_OFFSET_TABLE_+(.-.LLGETPCH", "<STR_LIT>", "<<", "mfNum", "<<", "'", "_", "'", "<<", "bbNum", "<<", "<STR_LIT>", ")), ", "<STR_LIT>", "<<", "operand", "<<", "'", "\\n", "'", ";", "O", "<<", "<STR_LIT>", "\\tadd\\t", "<STR_LIT>", "<<", "operand", "<<", "<STR_LIT>", ", %o7, ", "<STR_LIT>", "<<", "operand", "<<", "'", "\\n", "'", ";" ]

[ ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "eq", "(", "zero_extract", ":", "HI", "(", "match_operand", ":", "QHI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "pc", ")", ")", ")", "(", "clobber", "(", "reg", ":", "BI", "CARRY", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "case", "X86", "::", "SUB64mi8", ":", "return", "X86", "::", "SUB64mi32", ";" ]

[ "case", "X86", "::", "IMUL32rri8", ":", "return", "X86", "::", "IMUL32rri", ";", "case", "X86", "::", "IMUL32rmi8", ":", "return", "X86", "::", "IMUL32rmi", ";", "case", "X86", "::", "IMUL64rri8", ":", "return", "X86", "::", "IMUL64rri32", ";", "case", "X86", "::", "IMUL64rmi8", ":", "return", "X86", "::", "IMUL64rmi32", ";", "case", "X86", "::", "AND16ri8", ":", "return", "X86", "::", "AND16ri", ";", "case", "X86", "::", "AND16mi8", ":", "return", "X86", "::", "AND16mi", ";", "case", "X86", "::", "AND32ri8", ":", "return", "X86", "::", "AND32ri", ";", "case", "X86", "::", "AND32mi8", ":", "return", "X86", "::", "AND32mi", ";", "case", "X86", "::", "AND64ri8", ":", "return", "X86", "::", "AND64ri32", ";", "case", "X86", "::", "AND64mi8", ":", "return", "X86", "::", "AND64mi32", ";", "case", "X86", "::", "OR16ri8", ":", "return", "X86", "::", "OR16ri", ";", "case", "X86", "::", "OR16mi8", ":", "return", "X86", "::", "OR16mi", ";", "case", "X86", "::", "OR32ri8", ":", "return", "X86", "::", "OR32ri", ";", "case", "X86", "::", "OR32mi8", ":", "return", "X86", "::", "OR32mi", ";", "case", "X86", "::", "OR64ri8", ":", "return", "X86", "::", "OR64ri32", ";", "case", "X86", "::", "OR64mi8", ":", "return", "X86", "::", "OR64mi32", ";", "case", "X86", "::", "XOR16ri8", ":", "return", "X86", "::", "XOR16ri", ";", "case", "X86", "::", "XOR16mi8", ":", "return", "X86", "::", "XOR16mi", ";", "case", "X86", "::", "XOR32ri8", ":", "return", "X86", "::", "XOR32ri", ";", "case", "X86", "::", "XOR32mi8", ":", "return", "X86", "::", "XOR32mi", ";", "case", "X86", "::", "XOR64ri8", ":", "return", "X86", "::", "XOR64ri32", ";", "case", "X86", "::", "XOR64mi8", ":", "return", "X86", "::", "XOR64mi32", ";", "case", "X86", "::", "ADD16ri8", ":", "return", "X86", "::", "ADD16ri", ";", "case", "X86", "::", "ADD16mi8", ":", "return", "X86", "::", "ADD16mi", ";", "case", "X86", "::", "ADD32ri8", ":", "return", "X86", "::", "ADD32ri", ";", "case", "X86", "::", "ADD32mi8", ":", "return", "X86", "::", "ADD32mi", ";", "case", "X86", "::", "ADD64ri8", ":", "return", "X86", "::", "ADD64ri32", ";", "case", "X86", "::", "ADD64mi8", ":", "return", "X86", "::", "ADD64mi32", ";", "case", "X86", "::", "SUB16ri8", ":", "return", "X86", "::", "SUB16ri", ";", "case", "X86", "::", "SUB16mi8", ":", "return", "X86", "::", "SUB16mi", ";", "case", "X86", "::", "SUB32ri8", ":", "return", "X86", "::", "SUB32ri", ";", "case", "X86", "::", "SUB32mi8", ":", "return", "X86", "::", "SUB32mi", ";", "case", "X86", "::", "SUB64ri8", ":", "return", "X86", "::", "SUB64ri32", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "match_operand", "<NUM_LIT>" ]

[ "void", "MipsFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "const", "MipsRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "MipsRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "const", "MipsInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "bool", "isPIC", "=", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", ";", "unsigned", "NewReg", "=", "<NUM_LIT>", ";", "int", "NewImm", "=", "<NUM_LIT>", ";", "bool", "ATUsed", ";", "unsigned", "RegSize", "=", "STI", ".", "isGP32bit", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "LocalVarAreaOffset", "=", "MipsFI", "->", "needGPSaveRestore", "(", ")", "?", "(", "MFI", "->", "getObjectOffset", "(", "MipsFI", "->", "getGPFI", "(", ")", ")", "+", "RegSize", ")", ":", "MipsFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "StackSize", "=", "AlignOffset", "(", "LocalVarAreaOffset", ",", "StackAlign", ")", "+", "AlignOffset", "(", "MFI", "->", "getStackSize", "(", ")", ",", "StackAlign", ")", ";", "MFI", "->", "setStackSize", "(", "StackSize", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "NOREORDER", ")", ")", ";", "if", "(", "isPIC", "&&", "STI", ".", "isABI_O32", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "CPLOAD", ")", ")", ".", "addReg", "(", "RegInfo", "->", "getPICCallReg", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "NOMACRO", ")", ")", ";", "if", "(", "StackSize", "==", "<NUM_LIT>", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", ")", "return", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "std", "::", "vector", "<", "MachineMove", ">", "&", "Moves", "=", "MMI", ".", "getFrameMoves", "(", ")", ";", "MachineLocation", "DstML", ",", "SrcML", ";", "ATUsed", "=", "expandRegLargeImmPair", "(", "Mips", "::", "SP", ",", "-", "StackSize", ",", "NewReg", ",", "NewImm", ",", "MBB", ",", "MBBI", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDiu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "NewReg", ")", ".", "addImm", "(", "NewImm", ")", ";", "if", "(", "ATUsed", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ATMACRO", ")", ")", ";", "MCSymbol", "*", "AdjustSPLabel", "=", "MMI", ".", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "PROLOG_LABEL", ")", ")", ".", "addSym", "(", "AdjustSPLabel", ")", ";", "DstML", "=", "MachineLocation", "(", "MachineLocation", "::", "VirtualFP", ")", ";", "SrcML", "=", "MachineLocation", "(", "MachineLocation", "::", "VirtualFP", ",", "-", "StackSize", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "AdjustSPLabel", ",", "DstML", ",", "SrcML", ")", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", "->", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "++", "MBBI", ";", "MCSymbol", "*", "CSLabel", "=", "MMI", ".", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "PROLOG_LABEL", ")", ")", ".", "addSym", "(", "CSLabel", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "I", "=", "CSI", ".", "begin", "(", ")", ",", "E", "=", "CSI", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "int64_t", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "I", "->", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "I", "->", "getReg", "(", ")", ";", "if", "(", "Mips", "::", "AFGR64RegisterClass", "->", "contains", "(", "Reg", ")", ")", "{", "const", "unsigned", "*", "SubRegs", "=", "RegInfo", "->", "getSubRegisters", "(", "Reg", ")", ";", "MachineLocation", "DstML0", "(", "MachineLocation", "::", "VirtualFP", ",", "Offset", ")", ";", "MachineLocation", "DstML1", "(", "MachineLocation", "::", "VirtualFP", ",", "Offset", "+", "<NUM_LIT>", ")", ";", "MachineLocation", "SrcML0", "(", "*", "SubRegs", ")", ";", "MachineLocation", "SrcML1", "(", "*", "(", "SubRegs", "+", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "STI", ".", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "SrcML0", ",", "SrcML1", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "CSLabel", ",", "DstML0", ",", "SrcML0", ")", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "CSLabel", ",", "DstML1", ",", "SrcML1", ")", ")", ";", "}", "else", "{", "DstML", "=", "MachineLocation", "(", "MachineLocation", "::", "VirtualFP", ",", "Offset", ")", ";", "SrcML", "=", "MachineLocation", "(", "Reg", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "CSLabel", ",", "DstML", ",", "SrcML", ")", ")", ";", "}", "}", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDu", ")", ",", "Mips", "::", "FP", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ";", "MCSymbol", "*", "SetFPLabel", "=", "MMI", ".", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "PROLOG_LABEL", ")", ")", ".", "addSym", "(", "SetFPLabel", ")", ";", "DstML", "=", "MachineLocation", "(", "Mips", "::", "FP", ")", ";", "SrcML", "=", "MachineLocation", "(", "MachineLocation", "::", "VirtualFP", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "SetFPLabel", ",", "DstML", ",", "SrcML", ")", ")", ";", "}", "if", "(", "MipsFI", "->", "needGPSaveRestore", "(", ")", ")", "{", "unsigned", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "MipsFI", "->", "getGPFI", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "CPRESTORE", ")", ")", ".", "addImm", "(", "Offset", ")", ";", "if", "(", "Offset", ">=", "<NUM_LIT>", ")", "{", "BuildMI", "(", "MBB", ",", "llvm", "::", "prior", "(", "MBBI", ")", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "MACRO", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "NOMACRO", ")", ")", ";", "}", "}", "}" ]

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

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

[ "def", "VJCVT", ":", "AVConv1IsD_Encode", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "SPR", ":", "$", "Sd", ")", ",", "(", "ins", "DPR", ":", "$", "Dm", ")", ",", "IIC_fpCVTDI", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Requires", "<", "[", "HasFPARMv8", ",", "HasV8_3a", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>" ]

[ "<FIXS>", "bit", "HasMods", ",", "bit", "DefExec", ",", "string", "revOp", ">", "{", "<FIXE>", "<FIXS>", "opName", ",", "HasMods", ",", "DefExec", ",", "revOp", ">", ",", "<FIXE>" ]

[ "multiclass", "VOPC_Class_Helper", "vopc", "op", ",", "string", "opName", ",", "dag", "ins32", ",", "string", "asm32", ",", "list", "dag", ">", "pat32", ",", "dag", "out64", ",", "dag", "ins64", ",", "string", "asm64", ",", "list", "dag", ">", "pat64", ",", "<BUGS>", "bit", "HasMods", ",", "bit", "DefExec", ">", "{", "<BUGE>", "defm", "_e32", ":", "VOPC_m", "op", ",", "(", "outs", ")", ",", "ins32", ",", "opName", "#", "asm32", ",", "pat32", ",", "opName", ",", "DefExec", ">", ";", "defm", "_e64", ":", "VOP3_C_m", "op", ",", "out64", ",", "ins64", ",", "opName", "#", "asm64", ",", "pat64", ",", "<BUGS>", "opName", ",", "HasMods", ",", "DefExec", ">", ",", "<BUGE>", "VOP3DisableModFields", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ">", ";", "}", "multiclass", "VOPCInst", "vopc", "op", ",", "string", "opName", ",", "VOPProfile", "P", ",", "PatLeaf", "cond", "=", "COND_NULL", ",", "bit", "DefExec", "=", "<NUM_LIT>", ">", ":", "VOPC_Helper", "op", ",", "opName", ",", "P", ".", "Ins32", ",", "P", ".", "Asm32", ",", "[", "]", "," ]

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

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

[ "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "STW8", ":", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ",", "FrameIndex", ")", ";" ]

[ "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC", "::", "GPRCRegClass", ";", "unsigned", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "LP64", "?", "G8RC", ":", "GPRC", ")", ";", "unsigned", "SrcReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "MFOCRF8", ":", "PPC", "::", "MFOCRF", ")", ",", "Reg", ")", ".", "addReg", "(", "getCRFromCRBit", "(", "SrcReg", ")", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Implicit", "|", "getKillRegState", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isKill", "(", ")", ")", ")", ";", "unsigned", "Reg1", "=", "Reg", ";", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "LP64", "?", "G8RC", ":", "GPRC", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "LP64", "?", "PPC", "::", "RLWINM8", ":", "PPC", "::", "RLWINM", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg1", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "getEncodingValue", "(", "SrcReg", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";" ]

[ "int64_t", "Val", "=", "DefInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";" ]

[ "bool", "SILowerI1Copies", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "std", "::", "vector", "<", "unsigned", ">", "I1Defs", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "IMPLICIT_DEF", ")", "{", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "Reg", ")", ";", "if", "(", "RC", "==", "&", "AMDGPU", "::", "VReg_1RegClass", ")", "MRI", ".", "setRegClass", "(", "Reg", ",", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "continue", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "COPY", ")", "continue", ";", "const", "MachineOperand", "&", "Dst", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "const", "MachineOperand", "&", "Src", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Src", ".", "getReg", "(", ")", ")", "||", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Dst", ".", "getReg", "(", ")", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "MRI", ".", "getRegClass", "(", "Dst", ".", "getReg", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "MRI", ".", "getRegClass", "(", "Src", ".", "getReg", "(", ")", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineInstr", "*", "DefInst", "=", "MRI", ".", "getUniqueVRegDef", "(", "Src", ".", "getReg", "(", ")", ")", ";", "if", "(", "DstRC", "==", "&", "AMDGPU", "::", "VReg_1RegClass", "&&", "TRI", "->", "getCommonSubClass", "(", "SrcRC", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ")", "{", "I1Defs", ".", "push_back", "(", "Dst", ".", "getReg", "(", ")", ")", ";", "if", "(", "DefInst", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_MOV_B64", ")", "{", "if", "(", "DefInst", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", ")", "{", "I1Defs", ".", "push_back", "(", "Dst", ".", "getReg", "(", ")", ")", ";" ]

[ "else", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";" ]

[ "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "<NUM_LIT>", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "else", "Offset", "+=", "<NUM_LIT>", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "<NUM_LIT>", ")", "return", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "<NUM_LIT>", ")", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";" ]

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

[ "cpu_type", "=", "(", "int", ")", "CPU_H8300", ";", "h8_reg_names", "=", "names_big", ";", "}", "else", "{", "cpu_type", "=", "(", "int", ")", "CPU_H8300H", ";", "h8_reg_names", "=", "names_extended", ";", "}", "h8_push_op", "=", "h8_push_ops", "[", "cpu_type", "]", ";", "h8_pop_op", "=", "h8_pop_ops", "[", "cpu_type", "]", ";", "h8_mov_op", "=", "h8_mov_ops", "[", "cpu_type", "]", ";", "if", "(", "!", "TARGET_H8300S", "&&", "TARGET_MAC", ")", "{", "error", "(", "<STR_LIT>", "-ms2600 is used without -ms", "<STR_LIT>", ")", ";" ]

[ "<STR_LIT>" ]

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

[ "<STR_LIT>", ",", "[", "(", "set", "(", "v1i16", "FPR16", ":", "$", "Rd", ")", ",", "(", "v1i16", "(", "opnode", "(", "v4i16", "VPR64", ":", "$", "Rn", ")", ")", ")", ")", "]", ",", "NoItinerary", ">", ";" ]

[ "def", "_1h4h", ":", "NeonI_2VAcross", "<", "<NUM_LIT>", ",", "u", ",", "<NUM_LIT>", ",", "opcode", ",", "(", "outs", "FPR16", ":", "$", "Rd", ")", ",", "(", "ins", "VPR64", ":", "$", "Rn", ")", ",", "asmop", "#" ]

[ "}" ]

[ "UseHVXOps", "=", "false", ";", "UseHVXDblOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "EnableHexagonHVX", ".", "getPosition", "(", ")", ")", "UseHVXOps", "=", "EnableHexagonHVX", ";", "if", "(", "EnableHexagonHVXDouble", ".", "getPosition", "(", ")", ")", "UseHVXDblOps", "=", "EnableHexagonHVXDouble", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "return", "*", "this", ";" ]

[ "addImm", "(", "imm", ">>", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "SI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isGlobal", "(", ")", ")", "{", "BuildMI", "(", "*", "SI", ".", "getParent", "(", ")", ",", "SI", ",", "SI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "SI", ".", "getParent", "(", ")", ",", "SI", ",", "SI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "SI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addGlobalAddress", "(", "SI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getGlobal", "(", ")", ")", ";", "}", "else", "if", "(", "SI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isJTI", "(", ")", ")", "{", "BuildMI", "(", "*", "SI", ".", "getParent", "(", ")", ",", "SI", ",", "SI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "SI", ".", "getParent", "(", ")", ",", "SI", ",", "SI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "SI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addJumpTableIndex", "(", "SI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ")", ";", "}", "else", "{", "uint32_t", "imm", "=", "SI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "BuildMI", "(", "*", "SI", ".", "getParent", "(", ")", ",", "SI", ",", "SI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "." ]

[ "bool", "X86FrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "X86RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "X86RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "unsigned", "SlotSize", "=", "RegInfo", "->", "getSlotSize", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeSavedFrameSize", "=", "<NUM_LIT>", ";", "int", "SpillSlotOffset", "=", "getOffsetOfLocalArea", "(", ")", "+", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "MF", ".", "protectReturnPtr", "(", ")", "&&", "!", "MF", ".", "getName", "(", ")", ".", "equals", "(", "<STR_LIT>", "main", "<STR_LIT>", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "if", "(", "MF", ".", "protectFramePtr", "(", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "}", "unsigned", "FPReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", "==", "FPReg", ")", "{", "CSI", ".", "erase", "(", "CSI", ".", "begin", "(", ")", "+", "i", ")", ";", "break", ";", "}", "}", "}", "bool", "hasGPR", "=", "false", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "<NUM_LIT>", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "hasGPR", "=", "true", ";", "SpillSlotOffset", "-=", "SlotSize", ";", "CalleeSavedFrameSize", "+=", "SlotSize", ";", "int", "SlotIndex", "=", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "}", "if", "(", "MF", ".", "protectCSRs", "(", ")", "&&", "hasGPR", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "CalleeSavedFrameSize", "+=", "SlotSize", ";", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeSavedFrameSize", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "<NUM_LIT>", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RegInfo", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "SpillSlotOffset", "-=", "abs", "(", "SpillSlotOffset", ")", "%", "RC", "->", "getAlignment", "(", ")", ";", "SpillSlotOffset", "-=", "RC", "->", "getSize", "(", ")", ";", "int", "SlotIndex", "=", "MFI", "->", "CreateFixedSpillStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "MFI", "->", "ensureMaxAlignment", "(", "RC", "->", "getAlignment", "(", ")", ")", ";", "}", "return", "true", ";", "}" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "static", "int", "ia64_first_cycle_multipass_dfa_lookahead_guard", "(", "rtx_insn", "*", "insn", ",", "int", "ready_index", ")", "{", "gcc_assert", "(", "insn", "&&", "INSN_P", "(", "insn", ")", ")", ";", "if", "(", "pending_data_specs", ">=", "<NUM_LIT>", "&&", "(", "TODO_SPEC", "(", "insn", ")", "&", "BEGIN_DATA", ")", ")", "return", "ready_index", "==", "<NUM_LIT>", "?", "-", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "if", "(", "ready_index", "==", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "(", "!", "reload_completed", "||", "!", "safe_group_barrier_needed", "(", "insn", ")", ")", "&&", "(", "!", "mflag_sched_mem_insns_hard_limit", "||", "!", "is_load_p", "(", "insn", ")", "||", "mem_ops_in_group", "[", "current_cycle", "%", "<NUM_LIT>", "]", "<", "ia64_max_memory_insns", ")", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "We", "are", "choosing", "insn", "from", "the", "ready", "queue", ".", "Return", "nonzero", "if", "INSN", "can", "be", "chosen", "." ]

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

[ "(", "vec_concat", ":", "V16QI", "(", "match_operand", ":", "V8QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V8QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "v8i16", ",", "MSA128HOpnd", ">", ";" ]

[ "class", "ST_H_DESC", ":", "ST_DESC_BASE", "<", "<STR_LIT>", ",", "store", "," ]

[ "<", "<NUM_LIT>", ">", ",", "SDTCisVT", "<", "<NUM_LIT>", ",", "i64", ">", ",", "SDTCisVT", "<", "<NUM_LIT>", ",", "i64", ">", "]", ">", ";" ]

[ "def", "SDT_ZMemMemLoopCC", ":", "SDTypeProfile", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisVT", "<", "<NUM_LIT>", ",", "i32", ">", ",", "SDTCisPtrTy", "<", "<NUM_LIT>", ">", ",", "SDTCisPtrTy" ]

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

[ "reportError", "(", "llvm", "::", "Twine", "(", "<STR_LIT>", "invalid instruction packet: out of slots", "<STR_LIT>", ")", ")", ";", "return", "false", ";", "}", "}", "bool", "validateSlots", "=", "true", ";", "if", "(", "jumps", ">", "<NUM_LIT>", ")", "{", "if", "(", "foundBranches", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "{", "reportError", "(", "llvm", "::", "Twine", "(", "<STR_LIT>", "too many branches in packet", "<STR_LIT>", ")", ")", ";", "return", "false", ";", "}", "for", "(", "unsigned", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "MAX_JUMP_SLOTS", ";", "++", "i", ")", "{", "if", "(", "!", "(", "jumpSlots", "[", "i", "]", ".", "first", "&", "foundBranches", "[", "<NUM_LIT>", "]", "->", "Core", ".", "getUnits", "(", ")", ")", ")", "continue", ";", "if", "(", "!", "(", "jumpSlots", "[", "i", "]", ".", "second", "&", "foundBranches", "[", "<NUM_LIT>", "]", "->", "Core", ".", "getUnits", "(", ")", ")", ")", "continue", ";", "PacketSave", "=", "Packet", ";", "foundBranches", "[", "<NUM_LIT>", "]", "->", "Core", ".", "setUnits", "(", "jumpSlots", "[", "i", "]", ".", "first", ")", ";", "foundBranches", "[", "<NUM_LIT>", "]", "->", "Core", ".", "setUnits", "(", "jumpSlots", "[", "i", "]", ".", "second", ")", ";", "HexagonUnitAuction", "AuctionCore", "(", "reservedSlots", ")", ";", "std", "::", "sort", "(", "begin", "(", ")", ",", "end", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "bool", "bFail", "=", "false", ";", "for", "(", "iterator", "I", "=", "begin", "(", ")", ";", "I", "!=", "end", "(", ")", "&&", "bFail", "!=", "true", ";", "++", "I", ")", "if", "(", "!", "AuctionCore", ".", "bid", "(", "I", "->", "Core", ".", "getUnits", "(", ")", ")", ")", "bFail", "=", "true", ";", "if", "(", "!", "bFail", ")", "{", "validateSlots", "=", "false", ";", "break", ";", "}", "else", "Packet", "=", "PacketSave", ";", "}", "if", "(", "validateSlots", "==", "true", ")", "{", "reportError", "(", "llvm", "::", "Twine", "(", "<STR_LIT>", "invalid instruction packet: out of slots", "<STR_LIT>", ")", ")", ";", "return", "false", ";", "}", "}", "if", "(", "jumps", "<=", "<NUM_LIT>", "&&", "bOnlySlot3", "==", "false", "&&", "pSlot3Cnt", "==", "<NUM_LIT>", "&&", "slot3ISJ", "!=", "end", "(", ")", ")", "{", "validateSlots", "=", "true", ";", "unsigned", "saveUnits", "=", "slot3ISJ", "->", "Core", ".", "getUnits", "(", ")", ";", "slot3ISJ", "->", "Core", ".", "setUnits", "(", "saveUnits", "&", "slotThree", ")", ";", "HexagonUnitAuction", "AuctionCore", "(", "reservedSlots", ")", ";", "std", "::", "sort", "(", "begin", "(", ")", ",", "end", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "bool", "bFail", "=", "false", ";", "for", "(", "iterator", "I", "=", "begin", "(", ")", ";", "I", "!=", "end", "(", ")", "&&", "bFail", "!=", "true", ";", "++", "I", ")", "if", "(", "!", "AuctionCore", ".", "bid", "(", "I", "->", "Core", ".", "getUnits", "(", ")", ")", ")", "bFail", "=", "true", ";", "if", "(", "!", "bFail", ")", "validateSlots", "=", "false", ";", "else", "for", "(", "iterator", "ISJ", "=", "begin", "(", ")", ";", "ISJ", "!=", "end", "(", ")", ";", "++", "ISJ", ")", "{", "MCInst", "const", "&", "ID", "=", "ISJ", "->", "getDesc", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "prefersSlot3", "(", "MCII", ",", "ID", ")", ")", "ISJ", "->", "Core", ".", "setUnits", "(", "saveUnits", ")", ";", "}", "}", "if", "(", "validateSlots", ")", "{", "HexagonUnitAuction", "AuctionCore", "(", "reservedSlots", ")", ";", "std", "::", "sort", "(", "begin", "(", ")", ",", "end", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "for", "(", "iterator", "I", "=", "begin", "(", ")", ";", "I", "!=", "end", "(", ")", ";", "++", "I", ")", "if", "(", "!", "AuctionCore", ".", "bid", "(", "I", "->", "Core", ".", "getUnits", "(", ")", ")", ")", "{", "reportError", "(", "llvm", "::", "Twine", "(", "<STR_LIT>", "invalid instruction packet: slot error", "<STR_LIT>", ")", ")", ";", "return", "false", ";", "}", "}", "std", "::", "sort", "(", "begin", "(", ")", ",", "end", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "HVXInstsT", "hvxInsts", ";", "hvxInsts", ".", "clear", "(", ")", ";", "for", "(", "iterator", "I", "=", "begin", "(", ")", ";", "I", "!=", "end", "(", ")", ";", "++", "I", ")", "{", "struct", "CVIUnits", "inst", ";", "inst", ".", "Units", "=", "I", "->", "CVI", ".", "getUnits", "(", ")", ";", "inst", ".", "Lanes", "=", "I", "->", "CVI", ".", "getLanes", "(", ")", ";", "if", "(", "inst", ".", "Units", "==", "<NUM_LIT>", ")", "continue", ";", "hvxInsts", ".", "push_back", "(", "inst", ")", ";", "}", "if", "(", "hvxInsts", ".", "size", "(", ")" ]

[ "<FIXS>", "fpu_name", "=", "<STR_LIT>", "softvfp", "<STR_LIT>", ";", "<FIXE>" ]

[ "if", "(", "TARGET_SOFT_FLOAT", ")", "{", "<BUGS>", "if", "(", "TARGET_VFP", ")", "fpu_name", "=", "<STR_LIT>", "softvfp", "<STR_LIT>", ";", "elsefpu_name", "=", "<STR_LIT>", "softfpa", "<STR_LIT>", ";", "<BUGE>", "}", "else", "{" ]

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

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

[ "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "AMDIC: ", "<STR_LIT>", "<<", "*", "CI", "<<", "<STR_LIT>", " ---> ", "<STR_LIT>", ")", ";" ]

[ "AMDGPULibFunc", "nf", "=", "FInfo", ";", "nf", ".", "setPrefix", "(", "AMDGPULibFunc", "::", "NATIVE", ")", ";", "if", "(", "Constant", "*", "FPExpr", "=", "getFunction", "(", "M", ",", "nf", ")", ")", "{" ]

[ "}" ]

[ "static", "bool", "str_prefix_p", "(", "const", "char", "*", "str", ",", "const", "char", "*", "prefix", ")", "{", "return", "<NUM_LIT>", "==", "strncmp", "(", "str", ",", "prefix", ",", "strlen", "(", "prefix", ")", ")", ";" ]

[ "}" ]

[ "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "assert", "(", "MI", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "<NUM_LIT>", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "invalid MOVZi operands", "<STR_LIT>", ")", ";", "return", "true", ";", "}", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "TargetOpcode", "::", "COPY", ":", "return", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "return", "false", ";" ]

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

[ "return", "isSImmScaled", "<", "Width", ",", "<NUM_LIT>" ]

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

[ "enum", "machine_mode", "val_mode", "=", "(", "mode", "==", "V4QImode", ")", "?", "QImode", ":", "HImode", ";", "int", "shift_acc", "=", "(", "val_mode", "==", "QImode", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "int", "mask", "=", "(", "val_mode", "==", "QImode", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "int", "tmp_val", "=", "val", ";", "if", "(", "TARGET_BIG_ENDIAN", ")", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nunits", ";", "i", "++", ")", "{", "tmp_val", "=", "(", "val", ">>", "shift", ")", "&", "mask", ";", "RTVEC_ELT", "(", "v", ",", "nunits", "-", "i", "-", "<NUM_LIT>", ")", "=", "gen_int_mode", "(", "tmp_val", ",", "val_mode", ")", ";", "shift", "+=", "shift_acc", ";", "}", "else", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nunits", ";", "i", "++", ")", "{", "tmp_val", "=", "(", "val", ">>", "shift", ")", "&", "mask", ";", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "gen_int_mode", "(", "tmp_val", ",", "val_mode", ")", ";", "shift", "+=", "shift_acc", ";", "}", "return", "copy_to_mode_reg", "(", "mode", ",", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "v", ")", ")", ";", "}", "else", "{", "rtx", "tmp_rtx", "=", "gen_reg_rtx", "(", "mode", ")", ";", "convert_move", "(", "tmp_rtx", ",", "arg", "," ]

[ "_", "A", ",", "_", "_", "A", ",", "_", "_", "A", ",", "_", "_", "A", ",", "_", "_", "A", ",", "_", "_", "A", ",", "_", "_", "A", ")", ";" ]

[ "return", "_", "mm256_set_ph", "(", "_", "_", "A", ",", "_", "_", "A", ",", "_", "_", "A", ",", "_", "_", "A", ",", "_", "_", "A", ",", "_", "_", "A", ",", "_", "_", "A", ",", "_", "_", "A", ",", "_", "_", "A", ",", "_" ]

[ "if", "(", "isVectorSuperClass", "(", "&", "RC", ")", ")", "return", "RC", ".", "hasSuperClassEq", "(", "getVectorSuperClassForBitWidth", "(", "getRegSizeInBits", "(", "RC", ")", ")", ")", ";" ]

[ "bool", "SIRegisterInfo", "::", "isProperlyAlignedRC", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "if", "(", "!", "ST", ".", "needsAlignedVGPRs", "(", ")", ")", "return", "true", ";", "if", "(", "isVGPRClass", "(", "&", "RC", ")", ")", "return", "RC", ".", "hasSuperClassEq", "(", "getVGPRClassForBitWidth", "(", "getRegSizeInBits", "(", "RC", ")", ")", ")", ";", "if", "(", "isAGPRClass", "(", "&", "RC", ")", ")", "return", "RC", ".", "hasSuperClassEq", "(", "getAGPRClassForBitWidth", "(", "getRegSizeInBits", "(", "RC", ")", ")", ")", ";" ]

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

[ "unsigned", "Reg", "=", "getFPReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "bool", "KillsSrc", "=", "MI", "->", "killsRegister", "(", "X86", "::", "FP0", "+", "Reg", ")", ";", "if", "(", "KillsSrc", ")", "{", "moveToTop", "(", "Reg", ",", "I", ")", ";", "assert", "(", "StackTop", ">", "<NUM_LIT>", "&&", "<STR_LIT>", "Stack cannot be empty!", "<STR_LIT>", ")", ";", "--", "StackTop", ";", "pushReg", "(", "getFPReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", ";", "}", "else", "{", "duplicateToTop", "(", "Reg", ",", "getFPReg", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ",", "I", ")", ";", "}", "MI", "->", "RemoveOperand", "(", "<NUM_LIT>", ")", ";", "MI", "->", "RemoveOperand" ]

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

[ "return", "getLexer", "(", ")", "->" ]

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

[ "return", "(", "int32x4_t", ")", "_" ]

[ ")" ]

[ "(", "div", ":", "DF", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "<STR_LIT>", ")" ]

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

[ "t", "=", "fold_build1", "(", "NEGATE_EXPR", ",", "TREE_TYPE", "(", "t", ")", ",", "t", ")", ";" ]

[ "static", "tree", "xstormy16_gimplify_va_arg_expr", "(", "tree", "valist", ",", "tree", "type", ",", "gimple_seq", "*", "pre_p", ",", "gimple_seq", "*", "post_p", "ATTRIBUTE_UNUSED", ")", "{", "tree", "f_base", ",", "f_count", ";", "tree", "base", ",", "count", ";", "tree", "count_tmp", ",", "addr", ",", "t", ";", "tree", "lab_gotaddr", ",", "lab_fromstack", ";", "int", "size", ",", "size_of_reg_args", ",", "must_stack", ";", "tree", "size_tree", ";", "f_base", "=", "TYPE_FIELDS", "(", "va_list_type_node", ")", ";", "f_count", "=", "DECL_CHAIN", "(", "f_base", ")", ";", "base", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_base", ")", ",", "valist", ",", "f_base", ",", "NULL_TREE", ")", ";", "count", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_count", ")", ",", "valist", ",", "f_count", ",", "NULL_TREE", ")", ";", "must_stack", "=", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "TYPE_MODE", "(", "type", ")", ",", "type", ")", ";", "size_tree", "=", "round_up", "(", "size_in_bytes", "(", "type", ")", ",", "UNITS_PER_WORD", ")", ";", "gimplify_expr", "(", "&", "size_tree", ",", "pre_p", ",", "NULL", ",", "is_gimple_val", ",", "fb_rvalue", ")", ";", "size_of_reg_args", "=", "NUM_ARGUMENT_REGISTERS", "*", "UNITS_PER_WORD", ";", "count_tmp", "=", "get_initialized_tmp_var", "(", "count", ",", "pre_p", ",", "NULL", ")", ";", "lab_gotaddr", "=", "create_artificial_label", "(", "UNKNOWN_LOCATION", ")", ";", "lab_fromstack", "=", "create_artificial_label", "(", "UNKNOWN_LOCATION", ")", ";", "addr", "=", "create_tmp_var", "(", "ptr_type_node", ")", ";", "if", "(", "!", "must_stack", ")", "{", "tree", "r", ";", "t", "=", "fold_convert", "(", "TREE_TYPE", "(", "count", ")", ",", "size_tree", ")", ";", "t", "=", "build2", "(", "PLUS_EXPR", ",", "TREE_TYPE", "(", "count", ")", ",", "count_tmp", ",", "t", ")", ";", "r", "=", "fold_convert", "(", "TREE_TYPE", "(", "count", ")", ",", "size_int", "(", "size_of_reg_args", ")", ")", ";", "t", "=", "build2", "(", "GT_EXPR", ",", "boolean_type_node", ",", "t", ",", "r", ")", ";", "t", "=", "build3", "(", "COND_EXPR", ",", "void_type_node", ",", "t", ",", "build1", "(", "GOTO_EXPR", ",", "void_type_node", ",", "lab_fromstack", ")", ",", "NULL_TREE", ")", ";", "gimplify_and_add", "(", "t", ",", "pre_p", ")", ";", "t", "=", "fold_build_pointer_plus", "(", "base", ",", "count_tmp", ")", ";", "gimplify_assign", "(", "addr", ",", "t", ",", "pre_p", ")", ";", "t", "=", "build1", "(", "GOTO_EXPR", ",", "void_type_node", ",", "lab_gotaddr", ")", ";", "gimplify_and_add", "(", "t", ",", "pre_p", ")", ";", "t", "=", "build1", "(", "LABEL_EXPR", ",", "void_type_node", ",", "lab_fromstack", ")", ";", "gimplify_and_add", "(", "t", ",", "pre_p", ")", ";", "}", "size", "=", "PUSH_ROUNDING", "(", "int_size_in_bytes", "(", "type", ")", ")", ";", "if", "(", "size", ">", "<NUM_LIT>", "||", "size", "<", "<NUM_LIT>", "||", "must_stack", ")", "{", "tree", "r", ",", "u", ";", "r", "=", "size_int", "(", "NUM_ARGUMENT_REGISTERS", "*", "UNITS_PER_WORD", ")", ";", "u", "=", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "count_tmp", ")", ",", "count_tmp", ",", "r", ")", ";", "t", "=", "fold_convert", "(", "TREE_TYPE", "(", "count", ")", ",", "r", ")", ";", "t", "=", "build2", "(", "GE_EXPR", ",", "boolean_type_node", ",", "count_tmp", ",", "t", ")", ";", "t", "=", "build3", "(", "COND_EXPR", ",", "void_type_node", ",", "t", ",", "NULL_TREE", ",", "u", ")", ";", "gimplify_and_add", "(", "t", ",", "pre_p", ")", ";", "}", "t", "=", "size_int", "(", "NUM_ARGUMENT_REGISTERS", "*", "UNITS_PER_WORD", "+", "INCOMING_FRAME_SP_OFFSET", ")", ";", "t", "=", "fold_convert", "(", "TREE_TYPE", "(", "count", ")", ",", "t", ")", ";", "t", "=", "build2", "(", "MINUS_EXPR", ",", "TREE_TYPE", "(", "count", ")", ",", "count_tmp", ",", "t", ")", ";", "t", "=", "build2", "(", "PLUS_EXPR", ",", "TREE_TYPE", "(", "count", ")", ",", "t", ",", "fold_convert", "(", "TREE_TYPE", "(", "count", ")", ",", "size_tree", ")", ")", ";", "t", "=", "fold_convert", "(", "TREE_TYPE", "(", "t", ")", ",", "fold", "(", "t", ")", ")", ";" ]

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

[ "bool", "ARMBaseRegisterInfo", "::", "requiresFrameIndexScavenging", "(", "const", "MachineFunction", "&" ]

[ "std", "::", "string", "getNodeLabel", "(", "const", "MCGNode", "*", "N", ",", "const", "MCallSubGraph", "&", "G", ")", "{", "if", "(", "N", "->", "isUnknown", "(", ")", ")", "{", "std", "::", "string", "tmp", ";", "raw_string_ostream", "s", "(", "tmp", ")", ";", "s", "<<", "<STR_LIT>", "<UNKNOWN-", "<STR_LIT>", "<<", "*", "N", "->", "getType", "(", ")", "<<", "<STR_LIT>", ">", "<STR_LIT>", ";", "return", "s", ".", "str", "(", ")", ";", "}", "else", "return", "N", "->", "getMF", "(", ")", "->", "getFunction", "(", ")", "->", "getName", "(", ")", ";", "}" ]

[ "Print", "a", "DDG", "node", "either", "in", "concise", "form", "(", "-ddg-dot-only", ")", "or", "verbose", "mode", "(", "-ddg-dot", ")", "." ]

[ "<FIXS>", "OpSizeFixed", "=", "<NUM_LIT>", "<<", "OpSizeShift", ",", "OpSize16", "=", "<NUM_LIT>", "<<", "OpSizeShift", ",", "OpSize32", "=", "<NUM_LIT>", "<<", "OpSizeShift", ",", "<FIXE>", "<FIXS>", "AdSizeMask", "=", "<NUM_LIT>", "<<", "AdSizeShift", ",", "AdSizeX", "=", "<NUM_LIT>", "<<", "AdSizeShift", ",", "AdSize16", "=", "<NUM_LIT>", "<<", "AdSizeShift", ",", "AdSize32", "=", "<NUM_LIT>", "<<", "AdSizeShift", ",", "AdSize64", "=", "<NUM_LIT>", "<<", "AdSizeShift", ",", "<FIXE>", "<FIXS>", "OpPrefixShift", "=", "AdSizeShift", "+", "<NUM_LIT>", ",", "<FIXE>" ]

[ "OpSizeShift", "=", "<NUM_LIT>", ",", "OpSizeMask", "=", "<NUM_LIT>", "<<", "OpSizeShift", ",", "<BUGS>", "OpSize16", "=", "<NUM_LIT>", "<<", "OpSizeShift", ",", "OpSize32", "=", "<NUM_LIT>", "<<", "OpSizeShift", ",", "<BUGE>", "AdSizeShift", "=", "OpSizeShift", "+", "<NUM_LIT>", ",", "<BUGS>", "AdSize", "=", "<NUM_LIT>", "<<", "AdSizeShift", ",", "<BUGE>", "<BUGS>", "OpPrefixShift", "=", "AdSizeShift", "+", "<NUM_LIT>", ",", "<BUGE>", "OpPrefixMask", "=", "<NUM_LIT>", "<<", "OpPrefixShift", "," ]

[ ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "VF1_AVX512VL", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unsigned_float", ":", "VF1_AVX512VL", "(", "match_operand", ":", "<", "sseintvecmode", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "SDValue", "SITargetLowering", "::", "handleD16VData", "(", "SDValue", "VData", ",", "SelectionDAG", "&", "DAG", ",", "bool", "ImageStore", ")", "const", "{", "EVT", "StoreVT", "=", "VData", ".", "getValueType", "(", ")", ";", "if", "(", "!", "StoreVT", ".", "isVector", "(", ")", ")", "return", "VData", ";", "SDLoc", "DL", "(", "VData", ")", ";", "unsigned", "NumElements", "=", "StoreVT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "Subtarget", "->", "hasUnpackedD16VMem", "(", ")", ")", "{", "EVT", "IntStoreVT", "=", "StoreVT", ".", "changeTypeToInteger", "(", ")", ";", "SDValue", "IntVData", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "IntStoreVT", ",", "VData", ")", ";", "EVT", "EquivStoreVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "i32", ",", "NumElements", ")", ";", "SDValue", "ZExt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "EquivStoreVT", ",", "IntVData", ")", ";", "return", "DAG", ".", "UnrollVectorOp", "(", "ZExt", ".", "getNode", "(", ")", ")", ";", "}", "if", "(", "ImageStore", "&&", "Subtarget", "->", "hasImageStoreD16Bug", "(", ")", ")", "{", "EVT", "IntStoreVT", "=", "StoreVT", ".", "changeTypeToInteger", "(", ")", ";", "SDValue", "IntVData", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "IntStoreVT", ",", "VData", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Elts", ";", "DAG", ".", "ExtractVectorElements", "(", "IntVData", ",", "Elts", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "PackedElts", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "<", "Elts", ".", "size", "(", ")", "/", "<NUM_LIT>", ";", "I", "+=", "<NUM_LIT>", ")", "{", "SDValue", "Pair", "=", "DAG", ".", "getBuildVector", "(", "MVT", "::", "v2i16", ",", "DL", ",", "{", "Elts", "[", "I", "*", "<NUM_LIT>", "]", ",", "Elts", "[", "I", "*", "<NUM_LIT>", "+", "<NUM_LIT>", "]", "}", ")", ";", "SDValue", "IntPair", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "i32", ",", "Pair", ")", ";", "PackedElts", ".", "push_back", "(", "IntPair", ")", ";", "}", "if", "(", "(", "NumElements", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "unsigned", "I", "=", "Elts", ".", "size", "(", ")", "/", "<NUM_LIT>", ";", "SDValue", "Pair", "=", "DAG", ".", "getBuildVector", "(", "MVT", "::", "v2i16", ",", "DL", ",", "{", "Elts", "[", "I", "*", "<NUM_LIT>", "]", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i16", ")", "}", ")", ";", "SDValue", "IntPair", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "i32", ",", "Pair", ")", ";", "PackedElts", ".", "push_back", "(", "IntPair", ")", ";", "}", "PackedElts", ".", "resize", "(", "Elts", ".", "size", "(", ")", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ")", ";", "EVT", "VecVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "i32", ",", "PackedElts", ".", "size", "(", ")", ")", ";", "return", "DAG", ".", "getBuildVector", "(", "VecVT", ",", "DL", ",", "PackedElts", ")", ";", "}", "if", "(", "NumElements", "==", "<NUM_LIT>", ")", "{", "EVT", "IntStoreVT", "=", "EVT", "::", "getIntegerVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "StoreVT", ".", "getStoreSizeInBits", "(", ")", ")", ";", "SDValue", "IntVData", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "IntStoreVT", ",", "VData", ")", ";", "EVT", "WidenedStoreVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "StoreVT", ".", "getVectorElementType", "(", ")", ",", "NumElements", "+", "<NUM_LIT>", ")", ";", "EVT", "WidenedIntVT", "=", "EVT", "::", "getIntegerVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "WidenedStoreVT", ".", "getStoreSizeInBits", "(", ")", ")", ";", "SDValue", "ZExt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "WidenedIntVT", ",", "IntVData", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "WidenedStoreVT", ",", "ZExt", ")", ";", "}", "assert", "(", "isTypeLegal", "(", "StoreVT", ")", ")", ";", "return", "VData", ";", "}" ]

[ "Handle", "register", "layout", "difference", "for", "f16", "images", "for", "some", "subtargets", "." ]

[ "}" ]

[ "bool", "InlineHint", "=", "Callee", "&&", "!", "Callee", "->", "isDeclaration", "(", ")", "&&", "Callee", "->", "hasFnAttribute", "(", "Attribute", "::", "InlineHint", ")", ";", "if", "(", "InlineHint", "&&", "Params", ".", "HintThreshold", "&&", "Params", ".", "HintThreshold", ">", "Thres", "&&", "!", "Caller", "->", "hasFnAttribute", "(", "Attribute", "::", "MinSize", ")", ")", "Thres", "=", "Params", ".", "HintThreshold", ".", "getValue", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "Caller", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "if", "(", "!", "Callee", ")", "return", "(", "unsigned", ")", "Thres", ";", "const", "AMDGPUAS", "AS", "=", "AMDGPU", "::", "getAMDGPUAS", "(", "*", "Caller", "->", "getParent", "(", ")", ")", ";", "uint64_t", "AllocaSize", "=", "<NUM_LIT>", ";", "SmallPtrSet", "<", "const", "AllocaInst", "*", ",", "<NUM_LIT>", ">", "AIVisited", ";", "for", "(", "Value", "*", "PtrArg", ":", "CS", ".", "args", "(", ")", ")", "{", "Type", "*", "Ty", "=", "PtrArg", "->", "getType", "(", ")", ";", "if", "(", "!", "Ty", "->", "isPointerTy", "(", ")", "||", "Ty", "->", "getPointerAddressSpace", "(", ")", "!=", "AS", ".", "PRIVATE_ADDRESS", ")", "continue", ";", "PtrArg", "=", "GetUnderlyingObject", "(", "PtrArg", ",", "DL", ")", ";", "if", "(", "const", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "PtrArg", ")", ")", "{", "if", "(", "!", "AI", "->", "isStaticAlloca", "(", ")", "||", "!", "AIVisited", ".", "insert", "(", "AI", ")", ".", "second", ")", "continue", ";", "AllocaSize", "+=", "DL", ".", "getTypeAllocSize", "(", "AI", "->", "getAllocatedType", "(", ")", ")", ";", "if", "(", "AllocaSize", ">", "ArgAllocaCutoff", ")", "{", "AllocaSize", "=", "<NUM_LIT>", ";", "break", ";", "}" ]

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

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

[ ")" ]

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

[ "SDValue", "MergedValues", "[", "<NUM_LIT>", "]", "=", "{" ]

[ "if", "(", "Load", "->", "getAddressSpace", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "SDValue", "(", ")", ";", "SDValue", "TruncPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_ELEMENT", ",", "DL", ",", "MVT", "::", "i32", ",", "Load", "->", "getBasePtr", "(", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "Ptr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i32", ",", "TruncPtr", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SDValue", "Ret", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Op", ".", "getValueType", "(", ")", ",", "Load", "->", "getChain", "(", ")", ",", "Ptr", ",", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "[", "CSI", ".", "size", "(", ")", "-", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";" ]

[ "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "<NUM_LIT>", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "MSP430X", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "if", "(", "MSP430X", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "CSI", ".", "size", "(", ")", ")", ".", "addReg", "(", "CSI" ]

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

[ "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">" ]

[ "}" ]

[ "const", "MCPhysReg", "*", "M88kRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_M88k_SaveList", ";" ]

[ "]", ")" ]

[ "(", "define_mode_iterator", "VF1_128_256VL", "[", "(", "V8SF", "<STR_LIT>", ")", "(", "V4SF", "<STR_LIT>", ")" ]

[ "<FIXS>", "symtab", "->", "call_cgraph_insertion_hooks", "(", "cgraph_node", "::", "get_create", "(", "decl", ")", ")", ";", "<FIXE>" ]

[ "*", "empty_bb", "=", "init_lowered_empty_function", "(", "decl", ",", "false", ")", ";", "cgraph_node", "::", "add_new_function", "(", "decl", ",", "true", ")", ";", "<BUGS>", "cgraph_node", "::", "get_create", "(", "decl", ")", "->", "call_function_insertion_hooks", "(", ")", ";", "<BUGE>", "pop_cfun", "(", ")", ";" ]

[ ";" ]

[ "static", "bool", "nios2_ldstwm_regset_p", "(", "unsigned", "int", "regno", ",", "unsigned", "int", "*", "regset", ")", "{", "if", "(", "*", "regset", "==", "<NUM_LIT>", ")", "{", "if", "(", "CDX_LDSTWM_VALID_REGS_0", "&", "(", "<NUM_LIT>", "<<", "regno", ")", ")", "*", "regset", "=", "CDX_LDSTWM_VALID_REGS_0", ";", "else", "if", "(", "CDX_LDSTWM_VALID_REGS_1", "&", "(", "<NUM_LIT>", "<<", "regno", ")", ")", "*", "regset", "=", "CDX_LDSTWM_VALID_REGS_1", ";", "else", "return", "false" ]

[ "unsigned", "ARMConstantIslands", "::", "getOffsetOf", "(", "MachineInstr", "*", "MI", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "unsigned", "Offset", "=", "BBInfo", "[", "MBB", "->", "getNumber", "(", ")", "]", ".", "Offset", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ";", "&", "*", "I", "!=", "MI", ";", "++", "I", ")", "{", "assert", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "<STR_LIT>", "Didn't find MI in its own basic block?", "<STR_LIT>", ")", ";", "Offset", "+=", "TII", "->", "getInstSizeInBytes", "(", "*", "I", ")", ";", "}", "return", "Offset", ";", "}" ]

[ "getOffsetOf", "-", "Return", "the", "current", "offset", "of", "the", "specified", "machine", "instruction", "from", "the", "start", "of", "the", "function", "." ]

[ "asmvariantin", ";" ]

[ "class", "CondVariant", "<", "bits", "<", "<NUM_LIT>", ">", "ccmaskin", ",", "string", "suffixin", ",", "bit", "alternatein", ",", "string", "asmvariantin", "=", "<STR_LIT>", ">", "{", "bits", "<", "<NUM_LIT>", ">", "ccmask", "=", "ccmaskin", ";", "string", "suffix", "=", "suffixin", ";", "bit", "alternate", "=", "alternatein", ";", "string", "asmvariant", "=" ]

[ "}" ]

[ "}", "switch", "(", "MOTy", ")", "{", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "Symbol", "=", "AsmPrinter", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "Offset", "+=", "MO", ".", "getOffset", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "Symbol", "=", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "Symbol", "=", "AsmPrinter", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "Offset", "+=", "MO", ".", "getOffset", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "Symbol", "=", "AsmPrinter", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "Offset", "+=", "MO", ".", "getOffset", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "Symbol", "=", "AsmPrinter", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "<unknown operand type>", "<STR_LIT>", ")", ";" ]

[ "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";" ]

[ "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "BB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "Mips", "::", "MSA128DRegClass", ";", "unsigned", "Ws1", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";", "unsigned", "Ws2", "=", "RegInfo", ".", "createVirtualRegister", "(", "RC", ")", ";" ]

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

[ "rtx", "t_1", ",", "t_2", ",", "t_3", ";", "sel", "=", "gen_lowpart", "(", "DImode", ",", "sel", ")", ";", "switch", "(", "vmode", ")", "{", "case", "E_V2SImode", ":", "t_1", "=", "expand_simple_binop", "(", "DImode", ",", "LSHIFTRT", ",", "sel", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "sel", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "gen_lowpart", "(", "SImode", ",", "sel", ")", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "t_1", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "gen_lowpart", "(", "SImode", ",", "t_1", ")", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "sel", "=", "expand_simple_binop", "(", "SImode", ",", "IOR", ",", "sel", ",", "t_1", ",", "sel", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "sel", "=", "expand_mult", "(", "SImode", ",", "sel", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "sel", ",", "<NUM_LIT>", ")", ";", "t_1", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ";", "break", ";", "case", "E_V4HImode", ":", "t_1", "=", "expand_simple_binop", "(", "DImode", ",", "LSHIFTRT", ",", "sel", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "t_2", "=", "expand_simple_binop", "(", "DImode", ",", "LSHIFTRT", ",", "sel", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "t_3", "=", "expand_simple_binop", "(", "DImode", ",", "LSHIFTRT", ",", "sel", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "sel", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "gen_lowpart", "(", "SImode", ",", "sel", ")", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "NULL_RTX", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "t_1", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "gen_lowpart", "(", "SImode", ",", "t_1", ")", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "NULL_RTX", "," ]

[ "<FIXS>", "else", "<FIXE>", "<FIXS>", "t", "=", "build2", "(", "POINTER_PLUS_EXPR", ",", "TREE_TYPE", "(", "ovf", ")", ",", "ovf", ",", "size_int", "(", "align", "-", "<NUM_LIT>", ")", ")", ";", "t", "=", "fold_convert", "(", "sizetype", ",", "t", ")", ";", "<FIXE>", "<FIXS>", "size_int", "(", "-", "align", ")", ")", ";", "t", "=", "fold_convert", "(", "TREE_TYPE", "(", "ovf", ")", ",", "t", ")", ";", "<FIXE>", "<FIXS>", "t", "=", "build2", "(", "POINTER_PLUS_EXPR", ",", "TREE_TYPE", "(", "t", ")", ",", "t", ",", "size_int", "(", "rsize", "*", "UNITS_PER_WORD", ")", ")", ";", "<FIXE>" ]

[ "if", "(", "FUNCTION_ARG_BOUNDARY", "(", "VOIDmode", ",", "type", ")", "<=", "<NUM_LIT>", "||", "integer_zerop", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", "t", "=", "ovf", ";", "<BUGS>", "else", "<BUGE>", "{", "HOST_WIDE_INT", "align", "=", "FUNCTION_ARG_BOUNDARY", "(", "VOIDmode", ",", "type", ")", "/", "<NUM_LIT>", ";", "<BUGS>", "t", "=", "build2", "(", "PLUS_EXPR", ",", "TREE_TYPE", "(", "ovf", ")", ",", "ovf", ",", "build_int_cst", "(", "TREE_TYPE", "(", "ovf", ")", ",", "align", "-", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "t", "=", "build2", "(", "BIT_AND_EXPR", ",", "TREE_TYPE", "(", "t", ")", ",", "t", ",", "<BUGS>", "build_int_cst", "(", "TREE_TYPE", "(", "t", ")", ",", "-", "align", ")", ")", ";", "<BUGE>", "}", "gimplify_expr", "(", "&", "t", ",", "pre_p", ",", "NULL", ",", "is_gimple_val", ",", "fb_rvalue", ")", ";", "t2", "=", "build2", "(", "GIMPLE_MODIFY_STMT", ",", "void_type_node", ",", "addr", ",", "t", ")", ";", "gimplify_and_add", "(", "t2", ",", "pre_p", ")", ";", "<BUGS>", "t", "=", "build2", "(", "PLUS_EXPR", ",", "TREE_TYPE", "(", "t", ")", ",", "t", ",", "build_int_cst", "(", "TREE_TYPE", "(", "t", ")", ",", "rsize", "*", "UNITS_PER_WORD", ")", ")", ";", "<BUGE>", "t", "=", "build2", "(", "GIMPLE_MODIFY_STMT", ",", "TREE_TYPE", "(", "ovf", ")", ",", "ovf", ",", "t", ")", ";", "gimplify_and_add", "(", "t", ",", "pre_p", ")", ";" ]

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

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_max_pd", "(", "_", "_" ]

[ "VOIDmode", ",", "scratch", ")", ";" ]

[ "static", "void", "rs6000_secondary_reload_trace", "(", "int", "line", ",", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "scratch", ",", "bool", "store_p", ")", "{", "rtx", "set", ",", "clobber", ";", "gcc_assert", "(", "reg", "!=", "NULL_RTX", "&&", "mem", "!=", "NULL_RTX", "&&", "scratch", "!=", "NULL_RTX", ")", ";", "fprintf", "(", "stderr", ",", "<STR_LIT>", "rs6000_secondary_reload_inner:%d, type = %s\\n", "<STR_LIT>", ",", "line", ",", "store_p", "?", "<STR_LIT>", "store", "<STR_LIT>", ":", "<STR_LIT>", "load", "<STR_LIT>", ")", ";", "if", "(", "store_p", ")", "set", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "else", "set", "=", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "clobber", "=", "gen_rtx_CLOBBER", "(" ]

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

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

[ "DONE" ]

[ "<STR_LIT>", "{", "rs6000_emit_popcount", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "void", "MSP430FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "<NUM_LIT>", ")", "{", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "<NUM_LIT>", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "nullptr", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "uint64_t", "CalleeAmt", "=", "Old", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "V2DI", "[", "(", "match_operand", ":", "V2DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<BUGE>", "UNSPEC_EXTRQI", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "static", "bool", "canGuaranteeTCO", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "GuaranteeTailCalls", ")", "{", "return", "(", "CC", "==", "CallingConv", "::", "Fast", "&&", "GuaranteeTailCalls", ")", "||", "CC", "==", "CallingConv", "::", "Tail", "||", "CC", "==", "CallingConv", "::", "SwiftTail", ";" ]

[ "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")" ]

[ "(", "clobber", "(", "match_scratch", ":", "DI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "DI", "<NUM_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>", "{" ]

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

[ "return", "(", "int16x8_t", ")", "_", "_", "builtin_neon_vqaddsv8hi", "(", "_", "_", "a", ",", "_" ]

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

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

[ "SDValue", "AArch64TargetLowering", "::", "getGOT", "(", "NodeTy", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flags", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "AArch64TargetLowering::getGOT\\n", "<STR_LIT>", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "GotAddr", "=", "getTargetNode", "(", "N", ",", "Ty", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", "|", "Flags", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Ty", ",", "GotAddr", ")", ";", "}" ]

[ "Return", "a", "pseudo", "source", "value", "referencing", "the", "global", "offset", "table", "(", "or", "something", "the", "like", ")", "." ]

[ ";" ]

[ "bool", "PPCPassConfig", "::", "addIRTranslator", "(", ")", "{", "addPass", "(", "new", "IRTranslator", "(", ")", ")", ";", "return", "false" ]

[ ")", ")" ]

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

[ "<FIXS>", "if", "(", "TARGET_DIRECT_MOVE_64BIT", "&&", "!", "lra_in_progress", "&&", "!", "reload_completed", "<FIXE>" ]

[ "static", "boolrs6000_emit_move_si_sf_subreg", "(", "rtx", "dest", ",", "rtx", "source", ",", "machine_mode", "mode", ")", "{", "<BUGS>", "if", "(", "TARGET_DIRECT_MOVE_64BIT", "&&", "!", "reload_in_progress", "&&", "!", "reload_completed", "&&", "!", "lra_in_progress", "<BUGE>", "&&", "(", "!", "SUBREG_P", "(", "dest", ")", "||", "!", "sf_subreg_operand", "(", "dest", ",", "mode", ")", ")", "&&", "SUBREG_P", "(", "source", ")", "&&", "sf_subreg_operand", "(", "source", ",", "mode", ")", ")", "{" ]

[ "return", "getGPRsForTailCall", "(", "MF", ")", ";" ]

[ "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOSPRegClass", ";", "case", "<NUM_LIT>", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOREXRegClass", ";", "return", "&", "X86", "::", "GR32_NOREXRegClass", ";", "case", "<NUM_LIT>", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOREX_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOREX_NOSPRegClass", ";", "case", "<NUM_LIT>", ":" ]

[ "<", "v2f64", ">", ";" ]

[ "def", "v2f64", ":", "SHLQBYIVecInst" ]

[ "VNx8HI", "VNx4SI", "VNx2DI", "]", ")" ]

[ "(", "define_mode_iterator", "SVE_FULL_I", "[", "VNx16QI" ]

[ "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "op", ",", "clob", ")", ")", ")", ";" ]

[ "else", "dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "}", "if", "(", "!", "use_ndd", "&&", "MEM_P", "(", "src", ")", "&&", "!", "matching_memory", ")", "src", "=", "force_reg", "(", "mode", ",", "src", ")", ";", "op", "=", "gen_rtx_SET", "(", "dst", ",", "gen_rtx_fmt_e", "(", "code", ",", "mode", ",", "src", ")", ")", ";", "if", "(", "code", "==", "NOT", ")", "emit_insn", "(", "op", ")", ";", "else", "{", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";" ]

[ "void", "Cpu0TargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "<STR_LIT>", ".sdata", "<STR_LIT>", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "<STR_LIT>", ".sbss", "<STR_LIT>", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "}" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

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

[ ")", ";" ]

[ "switch", "(", "code", "&", "AARCH64_BUILTIN_CLASS", ")", "{", "case", "AARCH64_BUILTIN_GENERAL", ":", "return", "true", ";", "case", "AARCH64_BUILTIN_SVE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", "(", "loc", ",", "arg_loc", ",", "subcode", ",", "or", "ig_fndecl", ",", "nargs", ",", "args", ")", ";", "}", "gcc_unreachable", "(" ]

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

[ "def", "NEONvcge", ":", "SDNode", "<", "<STR_LIT>" ]

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

[ "SDValue", "VETargetLowering", "::", "lowerBlockAddress", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "makeAddress", "(", "Op", "," ]

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

[ "if", "(", "TARGET_FPU", "&&", "named", ")", "{", "if", "(", "slotno", ">=", "SPARC_FP_ARG_MAX", ")", "<BUGS>", "return", "<NUM_LIT>", ";", "<BUGE>", "regno", "=", "SPARC_FP_ARG_FIRST", "+", "slotno", "*", "<NUM_LIT>", ";", "if", "(", "mode", "==", "SFmode", ")", "regno", "++", ";" ]

[ ")", "{" ]

[ "if", "(", "Eval", ")", "{", "dbgs", "(", ")", "<<", "<STR_LIT>", " outputs:", "<STR_LIT>", ";", "for", "(", "auto", "&", "I", ":", "Outputs", ")", "dbgs", "(", ")", "<<", "'", "'", "<<", "I", ".", "second", ";", "dbgs", "(", ")", "<<", "'", "\\n", "'", ";", "}", "}", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "DefR", "(", "MO", ")", ";", "if", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DefR", ".", "Reg", ")", ")", "continue", ";", "bool", "Changed", "=", "false", ";", "if", "(", "!", "Eval" ]

[ "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i64", ",", "Hi", ")", ";" ]

[ "SDValue", "Src2Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src2", ")", ";", "SDValue", "Src2Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "dl", ",", "MVT", "::", "i64", ",", "Src2", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i64", ")", ")", ";", "Src2Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src2Hi", ")", ";", "bool", "hasChain", "=", "false", ";", "unsigned", "hiOpc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Invalid opcode", "<STR_LIT>", ")", ";", "case", "ISD", "::", "ADDC", ":", "hiOpc", "=", "ISD", "::", "ADDE", ";", "break", ";", "case", "ISD", "::", "ADDE", ":", "hasChain", "=", "true", ";", "break", ";", "case", "ISD", "::", "SUBC", ":", "hiOpc", "=", "ISD", "::", "SUBE", ";", "break", ";", "case", "ISD", "::", "SUBE", ":", "hasChain", "=", "true", ";", "break", ";", "}", "SDValue", "Lo", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "Glue", ")", ";", "if", "(", "hasChain", ")", "{", "Lo", "=", "DAG", ".", "getNode", "(", "Op", ".", "getOpcode", "(", ")", ",", "dl", ",", "VTs", ",", "Src1Lo", ",", "Src2Lo", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "Lo", "=", "DAG", ".", "getNode", "(", "Op", ".", "getOpcode", "(", ")", ",", "dl", ",", "VTs", ",", "Src1Lo", ",", "Src2Lo", ")", ";", "}", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "hiOpc", ",", "dl", ",", "VTs", ",", "Src1Hi", ",", "Src2Hi", ",", "Lo", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "Carry", "=", "Hi", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i64", ",", "Lo", ")", ";" ]

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

[ "static", "rtx", "loongarch_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", ",", "bool", "outgoing" ]

[ ")", "*", "Sign", ";" ]

[ "else", "if", "(", "Opcode", "!=", "ARM", "::", "ADDri", ")", "return", "std", "::", "nullopt", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", ")", "return", "std", "::", "nullopt", ";", "Offset", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(" ]

[ "MachineInstr", "*", "NewMI", "=", "BuildMI", "(", "*", "MFI", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "LEAOpcode", ")", ")", ".", "add", "(", "Dst", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "add", "(", "Scale", ")", ".", "add", "(", "Index", ")", ".", "add", "(", "Offset", ")", ".", "add", "(", "Segment", ")", ";" ]

[ "if", "(", "!", "IsInefficientBase", "||", "(", "!", "IsInefficientIndex", "&&", "IsScale1", ")", ")", "{", "MachineInstr", "*", "NewMI", "=", "BuildMI", "(", "*", "MFI", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "LEAOpcode", ")", ")", ".", "add", "(", "Dst", ")", ".", "add", "(", "IsInefficientBase", "?", "Index", ":", "Base", ")", ".", "add", "(", "Scale", ")", ".", "add", "(", "IsInefficientBase", "?", "Base", ":", "Index", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "add", "(", "Segment", ")", ";", "LLVM_DEBUG", "(", "NewMI", "->", "dump", "(", ")", ";", ")", ";", "if", "(", "hasLEAOffset", "(", "Offset", ")", ")", "{", "NewMI", "=", "BuildMI", "(", "*", "MFI", ",", "MI", ",", "DL", ",", "ADDri", ",", "DstR", ")", ".", "addReg", "(", "DstR", ")", ".", "add", "(", "Offset", ")", ";", "LLVM_DEBUG", "(", "NewMI", "->", "dump", "(", ")", ";", ")", ";", "}", "return", "NewMI", ";", "}", "assert", "(", "SSDstR", "!=", "BaseR", "&&", "<STR_LIT>", "SSDstR == BaseR should be handled already!", "<STR_LIT>", ")", ";", "assert", "(", "IsInefficientBase", "&&", "<STR_LIT>", "efficient base should be handled already!", "<STR_LIT>", ")", ";", "if", "(", "IsScale1", "&&", "!", "hasLEAOffset", "(", "Offset", ")", ")", "{", "bool", "BIK", "=", "Base", ".", "isKill", "(", ")", "&&", "BaseR", "!=", "IndexR", ";", "TII", "->", "copyPhysReg", "(", "*", "MFI", ",", "MI", ",", "DL", ",", "DstR", ",", "BaseR", ",", "BIK", ")", ";", "LLVM_DEBUG", "(", "MI", ".", "getPrevNode", "(", ")", "->", "dump", "(", ")", ";", ")", ";", "MachineInstr", "*", "NewMI", "=", "BuildMI", "(", "*", "MFI", ",", "MI", ",", "DL", ",", "ADDrr", ",", "DstR", ")", ".", "addReg", "(", "DstR", ")", ".", "add", "(", "Index", ")", ";", "LLVM_DEBUG", "(", "NewMI", "->", "dump", "(", ")", ";", ")", ";", "return", "NewMI", ";", "}" ]

[ "OpNum", ")", ".", "getReg", "(", ")", "+", "<NUM_LIT>", ")", "<<", "<STR_LIT>", "[]}", "<STR_LIT>", ";" ]

[ "O", "<<", "<STR_LIT>", "{", "<STR_LIT>", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ")", "<<", "<STR_LIT>", "[], ", "<STR_LIT>", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(" ]

[ "static", "bool", "aarch64_hard_regno_call_part_clobbered", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "FP_REGNUM_P", "(", "regno", ")", "&&", "maybe_gt", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "<NUM_LIT>", ")", ";", "}" ]

[ "Implement", "TARGET_HARD_REGNO_CALL_PART_CLOBBERED", ".", "The", "callee", "only", "saves", "the", "lower", "64", "bits", "of", "a", "128-bit", "register", ".", "Tell", "the", "compiler", "the", "callee", "clobbers", "the", "top", "64", "bits", "when", "restoring", "the", "bottom", "64", "bits", "." ]

[ "CurDAG", "->", "getConstant", "(", "ShlAmt", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";" ]

[ "SDValue", "Result", "=", "CurDAG", "->", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ",", "Glue", ")", ";", "if", "(", "IPM", ".", "XORValue", ")", "Result", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "XOR", ",", "DL", ",", "MVT", "::", "i32", ",", "Result", ",", "CurDAG", "->", "getConstant", "(", "IPM", ".", "XORValue", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "if", "(", "IPM", ".", "AddValue", ")", "Result", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "MVT", "::", "i32", ",", "Result", ",", "CurDAG", "->", "getConstant", "(", "IPM", ".", "AddValue", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i32", "&&", "IPM", ".", "Bit", "==", "<NUM_LIT>", ")", "{", "unsigned", "ShiftOp", "=", "TrueOp", "->", "getSExtValue", "(", ")", "==", "<NUM_LIT>", "?", "ISD", "::", "SRL", ":", "ISD", "::", "SRA", ";", "Result", "=", "CurDAG", "->", "getNode", "(", "ShiftOp", ",", "DL", ",", "MVT", "::", "i32", ",", "Result", ",", "CurDAG", "->", "getConstant", "(", "IPM", ".", "Bit", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "}", "else", "{", "if", "(", "VT", "!=", "MVT", "::", "i32", ")", "Result", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "VT", ",", "Result", ")", ";", "if", "(", "TrueOp", "->", "getSExtValue", "(", ")", "==", "<NUM_LIT>", ")", "{", "Result", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "VT", ",", "Result", ",", "CurDAG", "->", "getConstant", "(", "IPM", ".", "Bit", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "Result", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "VT", ",", "Result", ",", "CurDAG", "->", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "VT", ")", ")", ";", "}", "else", "{", "int", "ShlAmt", "=", "VT", ".", "getSizeInBits", "(", ")", "-", "<NUM_LIT>", "-", "IPM", ".", "Bit", ";", "int", "SraAmt", "=", "VT", ".", "getSizeInBits", "(", ")", "-", "<NUM_LIT>", ";", "Result", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "VT", ",", "Result", "," ]