Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "bool", "MipsSEFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "EntryBlock", "=", "&", "MF", "->", "front", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "Mips", "::", "RA", "||", "Reg", "==", "Mips", "::", "RA_64", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", ".", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "EntryBlock", "->", "addLiveIn", "(", "Reg", ")", ";", "bool", "IsLOHI", "=", "(", "Reg", "==", "Mips", "::", "LO0", "||", "Reg", "==", "Mips", "::", "LO0_64", "||", "Reg", "==", "Mips", "::", "HI0", "||", "Reg", "==", "Mips", "::", "HI0_64", ")", ";", "const", "Function", "*", "Func", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "if", "(", "IsLOHI", "&&", "Func", "->", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Op", "=", "0", ";", "if", "(", "!", "STI", ".", "getABI", "(", ")", ".", "ArePtrs64bit", "(", ")", ")", "{", "Op", "=", "(", "Reg", "==", "Mips", "::", "HI0", ")", "?", "Mips", "::", "MFHI", ":", "Mips", "::", "MFLO", ";", "Reg", "=", "Mips", "::", "K0", ";", "}", "else", "{", "Op", "=", "(", "Reg", "==", "Mips", "::", "HI0", ")", "?", "Mips", "::", "MFHI64", ":", "Mips", "::", "MFLO64", ";", "Reg", "=", "Mips", "::", "K0_64", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Op", ")", ",", "Mips", "::", "K0", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "bool", "IsKill", "=", "!", "IsRAAndRetAddrIsTaken", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "*", "EntryBlock", ",", "MI", ",", "Reg", ",", "IsKill", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "Mips", "Mips", "0", "Mips::RA", "Mips::RA_64", "Mips::LO0", "Mips::LO0_64", "Mips::HI0", "Mips::HI0_64", "\"interrupt\"", "0", "Mips::HI0", "Mips::MFHI", "Mips::MFLO", "Mips::K0", "Mips::HI0", "Mips::MFHI64", "Mips::MFLO64", "Mips::K0_64", "Mips::K0" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "X86TargetMachine", "&", "TM", ",", "unsigned", "StackAlignOverride", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", ",", "TSInfo", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "FrameLowering", "(", "*", "this", ",", "getStackAlignment", "(", ")", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "is64Bit", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "isTargetELF", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "static", "void", "nios2_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", "mode", ",", "rtx", "op", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "CONST", ":", "case", "CONST_INT", ":", "case", "LABEL_REF", ":", "case", "CONST_DOUBLE", ":", "case", "SYMBOL_REF", ":", "if", "(", "gprel_constant_p", "(", "op", ")", ")", "{", "fprintf", "(", "file", ",", "\"%%gprel(\"", ")", ";", "output_addr_const", "(", "file", ",", "op", ")", ";", "fprintf", "(", "file", ",", "\")(%s)\"", ",", "reg_names", "[", "GP_REGNO", "]", ")", ";", "return", ";", "}", "break", ";", "case", "PLUS", ":", "{", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "REG_P", "(", "op0", ")", "&&", "CONSTANT_P", "(", "op1", ")", ")", "{", "output_addr_const", "(", "file", ",", "op1", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "op0", ")", "]", ")", ";", "return", ";", "}", "else", "if", "(", "REG_P", "(", "op1", ")", "&&", "CONSTANT_P", "(", "op0", ")", ")", "{", "output_addr_const", "(", "file", ",", "op0", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "op1", ")", "]", ")", ";", "return", ";", "}", "}", "break", ";", "case", "REG", ":", "fprintf", "(", "file", ",", "\"0(%s)\"", ",", "reg_names", "[", "REGNO", "(", "op", ")", "]", ")", ";", "return", ";", "case", "MEM", ":", "{", "rtx", "base", "=", "XEXP", "(", "op", ",", "0", ")", ";", "nios2_print_operand_address", "(", "file", ",", "mode", ",", "base", ")", ";", "return", ";", "}", "default", ":", "break", ";", "}", "fprintf", "(", "stderr", ",", "\"Missing way to print address\\n\"", ")", ";", "debug_rtx", "(", "op", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_ADDRESS", "." ]

[ "nios2", "\"%%gprel(\"", "\")(%s)\"", "0", "1", "\"(%s)\"", "\"(%s)\"", "\"0(%s)\"", "0", "\"Missing way to print address\\n\"" ]

[]

[ "<s>", "const", "char", "*", "avr_out_ashlpsi3", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "if", "(", "CONST_INT_P", "(", "op", "[", "2", "]", ")", ")", "{", "switch", "(", "INTVAL", "(", "op", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "op", "[", "2", "]", ")", "<", "24", ")", "break", ";", "return", "avr_asm_len", "(", "\"clr %A0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %C0\"", ",", "op", ",", "plen", ",", "3", ")", ";", "case", "8", ":", "{", "int", "reg0", "=", "REGNO", "(", "op", "[", "0", "]", ")", ";", "int", "reg1", "=", "REGNO", "(", "op", "[", "1", "]", ")", ";", "if", "(", "reg0", ">=", "reg1", ")", "return", "avr_asm_len", "(", "\"mov %C0,%B1\"", "CR_TAB", "\"mov %B0,%A1\"", "CR_TAB", "\"clr %A0\"", ",", "op", ",", "plen", ",", "3", ")", ";", "else", "return", "avr_asm_len", "(", "\"clr %A0\"", "CR_TAB", "\"mov %B0,%A1\"", "CR_TAB", "\"mov %C0,%B1\"", ",", "op", ",", "plen", ",", "3", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "REGNO", "(", "op", "[", "0", "]", ")", ";", "int", "reg1", "=", "REGNO", "(", "op", "[", "1", "]", ")", ";", "if", "(", "reg0", "+", "2", "!=", "reg1", ")", "avr_asm_len", "(", "\"mov %C0,%A0\"", ",", "op", ",", "plen", ",", "1", ")", ";", "return", "avr_asm_len", "(", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ",", "op", ",", "plen", ",", "2", ")", ";", "}", "case", "23", ":", "return", "avr_asm_len", "(", "\"clr %C0\"", "CR_TAB", "\"lsr %A0\"", "CR_TAB", "\"ror %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ",", "op", ",", "plen", ",", "5", ")", ";", "}", "}", "out_shift_with_cnt", "(", "\"lsl %A0\"", "CR_TAB", "\"rol %B0\"", "CR_TAB", "\"rol %C0\"", ",", "insn", ",", "op", ",", "plen", ",", "3", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "24-bit", "shift", "left" ]

[ "avr", "0", "2", "2", "2", "24", "\"clr %A0\"", "\"clr %B0\"", "\"clr %C0\"", "3", "8", "0", "1", "\"mov %C0,%B1\"", "\"mov %B0,%A1\"", "\"clr %A0\"", "3", "\"clr %A0\"", "\"mov %B0,%A1\"", "\"mov %C0,%B1\"", "3", "16", "0", "1", "2", "\"mov %C0,%A0\"", "1", "\"clr %B0\"", "\"clr %A0\"", "2", "23", "\"clr %C0\"", "\"lsr %A0\"", "\"ror %C0\"", "\"clr %B0\"", "\"clr %A0\"", "5", "\"lsl %A0\"", "\"rol %B0\"", "\"rol %C0\"", "3", "\"\"" ]

[]

[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "override", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "MSP430", "MVT::i8" ]

[]

[ "<s>", "static", "section", "*", "aarch64_select_rtx_section", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "aarch64_can_use_per_function_literal_pools_p", "(", ")", ")", "return", "function_section", "(", "current_function_decl", ")", ";", "return", "default_elf_select_rtx_section", "(", "mode", ",", "x", ",", "align", ")", ";", "}", "</s>" ]

[ "Select", "appropriate", "section", "for", "constants", "depending", "on", "where", "we", "place", "literal", "pools", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "override", "{", "assert", "(", "DirectiveID", ".", "getKind", "(", ")", "==", "AsmToken", "::", "Identifier", ")", ";", "auto", "&", "Out", "=", "getStreamer", "(", ")", ";", "auto", "&", "TOut", "=", "reinterpret_cast", "<", "WebAssemblyTargetStreamer", "&", ">", "(", "*", "Out", ".", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".type\"", ")", "{", "if", "(", "!", "(", "IsNext", "(", "AsmToken", "::", "Identifier", ")", "&&", "IsNext", "(", "AsmToken", "::", "Comma", ")", "&&", "IsNext", "(", "AsmToken", "::", "At", ")", "&&", "Lexer", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", ")", "return", "Error", "(", "\"Expected label,@type declaration, got: \"", ",", "Lexer", ".", "getTok", "(", ")", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "}", "else", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".param\"", "||", "DirectiveID", ".", "getString", "(", ")", "==", "\".local\"", ")", "{", "std", "::", "vector", "<", "MVT", ">", "Params", ";", "std", "::", "vector", "<", "MVT", ">", "Locals", ";", "while", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "Identifier", ")", ")", "{", "auto", "RegType", "=", "ParseRegType", "(", "Lexer", ".", "getTok", "(", ")", ".", "getString", "(", ")", ")", ";", "if", "(", "RegType", "==", "MVT", "::", "INVALID_SIMPLE_VALUE_TYPE", ")", "return", "true", ";", "if", "(", "DirectiveID", ".", "getString", "(", ")", "==", "\".param\"", ")", "{", "Params", ".", "push_back", "(", "RegType", ")", ";", "}", "else", "{", "Locals", ".", "push_back", "(", "RegType", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "!", "IsNext", "(", "AsmToken", "::", "Comma", ")", ")", "break", ";", "}", "assert", "(", "LastLabel", ")", ";", "TOut", ".", "emitParam", "(", "LastLabel", ",", "Params", ")", ";", "TOut", ".", "emitLocal", "(", "Locals", ")", ";", "}", "else", "{", "while", "(", "Lexer", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "}", "return", "Expect", "(", "AsmToken", "::", "EndOfStatement", ",", "\"EOL\"", ")", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "WebAssembly", "WebAssembly", "\".type\"", "\"Expected label,@type declaration, got: \"", "\".param\"", "\".local\"", "MVT::INVALID_SIMPLE_VALUE_TYPE", "\".param\"", "\"EOL\"" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "this", "->", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "GBZ80" ]

[]

[ "<s>", "bool", "AMDGPUSymbolizer", "::", "tryAddingSymbolicOperand", "(", "MCInst", "&", "Inst", ",", "raw_ostream", "&", ",", "int64_t", "Value", ",", "uint64_t", ",", "bool", "IsBranch", ",", "uint64_t", ",", "uint64_t", ")", "{", "if", "(", "!", "IsBranch", ")", "{", "return", "false", ";", "}", "auto", "*", "Symbols", "=", "static_cast", "<", "SectionSymbolsTy", "*", ">", "(", "DisInfo", ")", ";", "if", "(", "!", "Symbols", ")", "return", "false", ";", "auto", "Result", "=", "std", "::", "find_if", "(", "Symbols", "->", "begin", "(", ")", ",", "Symbols", "->", "end", "(", ")", ",", "[", "Value", "]", "(", "const", "SymbolInfoTy", "&", "Val", ")", "{", "return", "Val", ".", "Addr", "==", "static_cast", "<", "uint64_t", ">", "(", "Value", ")", "&&", "Val", ".", "Type", "==", "ELF", "::", "STT_NOTYPE", ";", "}", ")", ";", "if", "(", "Result", "!=", "Symbols", "->", "end", "(", ")", ")", "{", "auto", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Result", "->", "Name", ")", ";", "const", "auto", "*", "Add", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Ctx", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Add", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Try", "to", "add", "a", "symbolic", "operand", "instead", "of", "Value", "to", "the", "MCInst", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "iq2000_expand_epilogue", "(", "void", ")", "{", "HOST_WIDE_INT", "tsize", "=", "cfun", "->", "machine", "->", "total_size", ";", "rtx", "tsize_rtx", "=", "GEN_INT", "(", "tsize", ")", ";", "rtx", "tmp_rtx", "=", "(", "rtx", ")", "0", ";", "if", "(", "iq2000_can_use_return_insn", "(", ")", ")", "{", "emit_jump_insn", "(", "gen_return", "(", ")", ")", ";", "return", ";", "}", "if", "(", "tsize", ">", "32767", ")", "{", "tmp_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "IQ2000_TEMP1_REGNUM", ")", ";", "emit_move_insn", "(", "tmp_rtx", ",", "tsize_rtx", ")", ";", "tsize_rtx", "=", "tmp_rtx", ";", "}", "if", "(", "tsize", ">", "0", ")", "{", "if", "(", "frame_pointer_needed", ")", "{", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ")", ";", "}", "save_restore_insns", "(", "0", ")", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "rtx", "eh_ofs", "=", "EH_RETURN_STACKADJ_RTX", ";", "emit_insn", "(", "gen_addsi3", "(", "eh_ofs", ",", "eh_ofs", ",", "tsize_rtx", ")", ")", ";", "tsize_rtx", "=", "eh_ofs", ";", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "tsize", "!=", "0", "||", "crtl", "->", "calls_eh_return", ")", "{", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tsize_rtx", ")", ")", ";", "}", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "HARD_FRAME_POINTER_REGNUM", ")", ",", "stack_pointer_rtx", ")", ";", "emit_use", "(", "gen_rtx_REG", "(", "Pmode", ",", "HARD_FRAME_POINTER_REGNUM", ")", ")", ";", "emit_jump_insn", "(", "gen_eh_return_internal", "(", ")", ")", ";", "}", "else", "emit_jump_insn", "(", "gen_return_internal", "(", "gen_rtx_REG", "(", "Pmode", ",", "GP_REG_FIRST", "+", "31", ")", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "epilogue", "into", "a", "bunch", "of", "separate", "insns", "." ]

[ "iq2000", "0", "32767", "0", "0", "0", "31" ]

[]

[ "<s>", "const", "char", "*", "RISCVTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "RISCVISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "RISCVISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "RISCVISD", "::", "RET_FLAG", ":", "return", "\"RISCVISD::RET_FLAG\"", ";", "case", "RISCVISD", "::", "URET_FLAG", ":", "return", "\"RISCVISD::URET_FLAG\"", ";", "case", "RISCVISD", "::", "SRET_FLAG", ":", "return", "\"RISCVISD::SRET_FLAG\"", ";", "case", "RISCVISD", "::", "MRET_FLAG", ":", "return", "\"RISCVISD::MRET_FLAG\"", ";", "case", "RISCVISD", "::", "CALL", ":", "return", "\"RISCVISD::CALL\"", ";", "case", "RISCVISD", "::", "SELECT_CC", ":", "return", "\"RISCVISD::SELECT_CC\"", ";", "case", "RISCVISD", "::", "BuildPairF64", ":", "return", "\"RISCVISD::BuildPairF64\"", ";", "case", "RISCVISD", "::", "SplitF64", ":", "return", "\"RISCVISD::SplitF64\"", ";", "case", "RISCVISD", "::", "TAIL", ":", "return", "\"RISCVISD::TAIL\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "RISCV", "RISCV", "RISCVISD::NodeType", "RISCVISD::FIRST_NUMBER", "RISCVISD::RET_FLAG", "\"RISCVISD::RET_FLAG\"", "RISCVISD::URET_FLAG", "\"RISCVISD::URET_FLAG\"", "RISCVISD::SRET_FLAG", "\"RISCVISD::SRET_FLAG\"", "RISCVISD::MRET_FLAG", "\"RISCVISD::MRET_FLAG\"", "RISCVISD::CALL", "\"RISCVISD::CALL\"", "RISCVISD::SELECT_CC", "\"RISCVISD::SELECT_CC\"", "RISCVISD::BuildPairF64", "\"RISCVISD::BuildPairF64\"", "RISCVISD::SplitF64", "\"RISCVISD::SplitF64\"", "RISCVISD::TAIL", "\"RISCVISD::TAIL\"" ]

[]

[ "<s>", "void", "ScheduleDAGPostRA", "::", "addMutation", "(", "ScheduleDAGPostRAMutation", "*", "M", ")", "{", "Mutations", ".", "push_back", "(", "M", ")", ";", "}", "</s>" ]

[ "Add", "a", "postprocessing", "step", "to", "the", "DAG", "builder", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "void", "bpf_init_builtins", "(", "void", ")", "{", "tree", "ullt", "=", "long_long_unsigned_type_node", ";", "def_builtin", "(", "\"__builtin_bpf_load_byte\"", ",", "BPF_BUILTIN_LOAD_BYTE", ",", "build_function_type_list", "(", "ullt", ",", "ullt", ",", "0", ")", ")", ";", "def_builtin", "(", "\"__builtin_bpf_load_half\"", ",", "BPF_BUILTIN_LOAD_HALF", ",", "build_function_type_list", "(", "ullt", ",", "ullt", ",", "0", ")", ")", ";", "def_builtin", "(", "\"__builtin_bpf_load_word\"", ",", "BPF_BUILTIN_LOAD_WORD", ",", "build_function_type_list", "(", "ullt", ",", "ullt", ",", "0", ")", ")", ";", "def_builtin", "(", "\"__builtin_preserve_access_index\"", ",", "BPF_BUILTIN_PRESERVE_ACCESS_INDEX", ",", "build_function_type_list", "(", "ptr_type_node", ",", "ptr_type_node", ",", "0", ")", ")", ";", "def_builtin", "(", "\"__builtin_preserve_field_info\"", ",", "BPF_BUILTIN_PRESERVE_FIELD_INFO", ",", "build_function_type_list", "(", "unsigned_type_node", ",", "ptr_type_node", ",", "unsigned_type_node", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Define", "machine-specific", "built-in", "functions", "." ]

[ "bpf", "\"__builtin_bpf_load_byte\"", "0", "\"__builtin_bpf_load_half\"", "0", "\"__builtin_bpf_load_word\"", "0", "\"__builtin_preserve_access_index\"", "0", "\"__builtin_preserve_field_info\"", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "!", "VT1", ".", "isScalarInteger", "(", ")", "||", "!", "VT2", ".", "isScalarInteger", "(", ")", ")", "return", "false", ";", "unsigned", "NumBits1", "=", "VT1", ".", "getSizeInBits", "(", ")", ";", "unsigned", "NumBits2", "=", "VT2", ".", "getSizeInBits", "(", ")", ";", "return", "NumBits1", ">", "NumBits2", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "const", "char", "*", "frv_asm_output_opcode", "(", "FILE", "*", "f", ",", "const", "char", "*", "ptr", ")", "{", "int", "c", ";", "if", "(", "frv_insn_packing_flag", "<=", "0", ")", "return", "ptr", ";", "for", "(", ";", "*", "ptr", "&&", "*", "ptr", "!=", "' '", "&&", "*", "ptr", "!=", "'\\t'", ";", ")", "{", "c", "=", "*", "ptr", "++", ";", "if", "(", "c", "==", "'%'", "&&", "(", "(", "*", "ptr", ">=", "'a'", "&&", "*", "ptr", "<=", "'z'", ")", "||", "(", "*", "ptr", ">=", "'A'", "&&", "*", "ptr", "<=", "'Z'", ")", ")", ")", "{", "int", "letter", "=", "*", "ptr", "++", ";", "c", "=", "atoi", "(", "ptr", ")", ";", "frv_print_operand", "(", "f", ",", "frv_insn_operands", "[", "c", "]", ",", "letter", ")", ";", "while", "(", "(", "c", "=", "*", "ptr", ")", ">=", "'0'", "&&", "c", "<=", "'9'", ")", "ptr", "++", ";", "}", "else", "fputc", "(", "c", ",", "f", ")", ";", "}", "fprintf", "(", "f", ",", "\".p\"", ")", ";", "return", "ptr", ";", "}", "</s>" ]

[ "The", "following", "function", "is", "used", "to", "add", "assembler", "insn", "code", "suffix", ".p", "if", "it", "is", "necessary", "." ]

[ "frv", "0", "\".p\"" ]

[]

[ "<s>", "void", "NVPTXTargetStreamer", "::", "changeSection", "(", "const", "MCSection", "*", "CurSection", ",", "MCSection", "*", "Section", ",", "const", "MCExpr", "*", "SubSection", ",", "raw_ostream", "&", "OS", ")", "{", "assert", "(", "!", "SubSection", "&&", "\"SubSection is not null!\"", ")", ";", "const", "MCObjectFileInfo", "*", "FI", "=", "getStreamer", "(", ")", ".", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", ";", "if", "(", "isDwarfSection", "(", "FI", ",", "CurSection", ")", ")", "OS", "<<", "\"\\t}\\n\"", ";", "if", "(", "isDwarfSection", "(", "FI", ",", "Section", ")", ")", "{", "outputDwarfFileDirectives", "(", ")", ";", "OS", "<<", "\"\\t.section\"", ";", "Section", "->", "PrintSwitchToSection", "(", "*", "getStreamer", "(", ")", ".", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", ",", "FI", "->", "getTargetTriple", "(", ")", ",", "OS", ",", "SubSection", ")", ";", "OS", "<<", "\"\\t{\\n\"", ";", "HasSections", "=", "true", ";", "}", "}", "</s>" ]

[ "Update", "streamer", "for", "a", "new", "active", "section", "." ]

[ "NVPTX", "NVPTX", "\"SubSection is not null!\"", "\"\\t}\\n\"", "\"\\t.section\"", "\"\\t{\\n\"" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "FORMAL_ARGUMENTS", ":", "return", "LowerFORMAL_ARGUMENTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "return", "LowerShifts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RET", ":", "return", "LowerRET", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CALL", ":", "return", "LowerCALL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSIGN_EXTEND", "(", "Op", ",", "DAG", ")", ";", "default", ":", "assert", "(", "0", "&&", "\"unimplemented operand\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "MSP430", "MSP430", "ISD::FORMAL_ARGUMENTS", "ISD::SHL", "ISD::SRL", "ISD::SRA", "ISD::RET", "ISD::CALL", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::SIGN_EXTEND", "0", "\"unimplemented operand\"" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "useHVXOps", "(", ")", ")", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Hexagon_HVX", ")", ";", "else", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Hexagon", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Val", "=", "DAG", ".", "getBitcast", "(", "VA", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "break", ";", "}", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "HexagonISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Hexagon", "Hexagon", "ISD::OutputArg", "16", "Hexagon", "Hexagon", "4", "1", "0", "\"Unknown loc info!\"", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "1", "0", "HexagonISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "bool", "AArch64AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", "->", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "!", "ExtraCode", "||", "!", "ExtraCode", "[", "0", "]", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected operand for inline assembly\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "printModifiedFPRAsmOperand", "(", "MO", ",", "TRI", ",", "AArch64", "::", "VPR128RegClass", ",", "O", ")", ")", "O", "<<", "AArch64InstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "O", "<<", "'#'", "<<", "MO", ".", "getImm", "(", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "assert", "(", "MO", ".", "getFPImm", "(", ")", "->", "isExactlyValue", "(", "0.0", ")", "&&", "\"Only FP 0.0 expected\"", ")", ";", "O", "<<", "\"#0.0\"", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "return", "printSymbolicAddress", "(", "MO", ",", "false", ",", "\"\"", ",", "O", ")", ";", "}", "return", "false", ";", "}", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "case", "'c'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isImm", "(", ")", ")", "return", "true", ";", "O", "<<", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "'w'", ":", "return", "printModifiedGPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "AArch64", "::", "GPR32RegClass", ",", "O", ")", ";", "case", "'x'", ":", "return", "printModifiedGPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "AArch64", "::", "GPR64RegClass", ",", "O", ")", ";", "case", "'H'", ":", "case", "'Q'", ":", "case", "'R'", ":", "llvm_unreachable", "(", "\"FIXME: Unimplemented register pairs\"", ")", ";", "case", "'b'", ":", "return", "printModifiedFPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "AArch64", "::", "FPR8RegClass", ",", "O", ")", ";", "case", "'h'", ":", "return", "printModifiedFPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "AArch64", "::", "FPR16RegClass", ",", "O", ")", ";", "case", "'s'", ":", "return", "printModifiedFPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "AArch64", "::", "FPR32RegClass", ",", "O", ")", ";", "case", "'d'", ":", "return", "printModifiedFPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "AArch64", "::", "FPR64RegClass", ",", "O", ")", ";", "case", "'q'", ":", "return", "printModifiedFPRAsmOperand", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "TRI", ",", "AArch64", "::", "FPR128RegClass", ",", "O", ")", ";", "case", "'A'", ":", "return", "printSymbolicAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "false", ",", "\"\"", ",", "O", ")", ";", "case", "'L'", ":", "return", "printSymbolicAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "true", ",", "\"lo12\"", ",", "O", ")", ";", "case", "'G'", ":", "return", "printSymbolicAddress", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ",", "true", ",", "\"hi12\"", ",", "O", ")", ";", "}", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "AArch64", "AArch64", "0", "\"Unexpected operand for inline assembly\"", "AArch64::VPR128RegClass", "AArch64", "0.0", "\"Only FP 0.0 expected\"", "\"#0.0\"", "\"\"", "0", "AArch64::GPR32RegClass", "AArch64::GPR64RegClass", "\"FIXME: Unimplemented register pairs\"", "AArch64::FPR8RegClass", "AArch64::FPR16RegClass", "AArch64::FPR32RegClass", "AArch64::FPR64RegClass", "AArch64::FPR128RegClass", "\"\"", "\"lo12\"", "\"hi12\"" ]

[]

[ "<s>", "static", "int", "aarch64_sched_issue_rate", "(", "void", ")", "{", "return", "aarch64_tune_params", ".", "issue_rate", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "that", "can", "be", "issued", "per", "cycle", "." ]

[ "aarch64" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerCall", "(", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "return", "lowerUnhandledCall", "(", "CLI", ",", "InVals", ",", "\"unsupported call to function \"", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "AMDGPU", "AMDGPU", "\"unsupported call to function \"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "initialize", "(", "MF", ")", ";", "return", "eliminateTruncSeq", "(", ")", ";", "}", "</s>" ]

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

[ "BPF" ]

[]

[ "<s>", "bool", "Thumb1FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "FFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "CFSize", "=", "FFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "CFSize", ">=", "(", "(", "1", "<<", "8", ")", "-", "1", ")", "*", "4", "/", "2", ")", "return", "false", ";", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "ARM", "1", "8", "1", "4", "2" ]

[]

[ "<s>", "bool", "DLXAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "if", "(", "(", "Count", "%", "4", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "4", ")", "OS", ".", "write", "(", "\"\\x15\\0\\0\\0\"", ",", "4", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "DLX", "DLX", "4", "0", "0", "4", "\"\\x15\\0\\0\\0\"", "4" ]

[]

[ "<s>", "char", "*", "aarch64_output_sve_cnt_immediate", "(", "const", "char", "*", "prefix", ",", "const", "char", "*", "operands", ",", "rtx", "x", ")", "{", "poly_int64", "value", "=", "rtx_to_poly_int64", "(", "x", ")", ";", "gcc_assert", "(", "aarch64_sve_cnt_immediate_p", "(", "value", ")", ")", ";", "return", "aarch64_output_sve_cnt_immediate", "(", "prefix", ",", "operands", ",", "AARCH64_SV_ALL", ",", "value", ".", "coeffs", "[", "1", "]", ",", "0", ")", ";", "}", "</s>" ]

[ "Return", "the", "asm", "string", "for", "an", "instruction", "with", "a", "CNT-like", "vector", "size", "operand", "(", "a", "vector", "pattern", "followed", "by", "a", "multiplier", "in", "the", "range", "[", "1", ",", "16", "]", ")", ".", "PREFIX", "is", "the", "mnemonic", "without", "the", "size", "suffix", "and", "OPERANDS", "is", "the", "first", "part", "of", "the", "operands", "template", "(", "the", "part", "that", "comes", "before", "the", "vector", "size", "itself", ")", ".", "X", "is", "the", "value", "of", "the", "vector", "size", "operand", ",", "as", "a", "polynomial", "integer", "rtx", "." ]

[ "aarch64", "1", "0" ]

[]

[ "<s>", "FusionKind", "getKind", "(", ")", "const", "{", "return", "Kd", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "FISCPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createFISCISelDag", "(", "getFISCTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "FISC", "FISC", "FISC", "FISC" ]

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "StartLoc", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "CAHP" ]

[]

[ "<s>", "void", "TPCInstrCompress", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "static", "rtx", "arm_function_arg", "(", "cumulative_args_t", "pcum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "int", "nregs", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "const0_rtx", ";", "if", "(", "pcum", "->", "pcs_variant", "<=", "ARM_PCS_AAPCS_LOCAL", ")", "{", "aapcs_layout_arg", "(", "pcum", ",", "mode", ",", "type", ",", "named", ")", ";", "return", "pcum", "->", "aapcs_reg", ";", "}", "if", "(", "TARGET_IWMMXT_ABI", "&&", "arm_vector_mode_supported_p", "(", "mode", ")", "&&", "pcum", "->", "named_count", ">", "pcum", "->", "nargs", "+", "1", ")", "{", "if", "(", "pcum", "->", "iwmmxt_nregs", "<=", "9", ")", "return", "gen_rtx_REG", "(", "mode", ",", "pcum", "->", "iwmmxt_nregs", "+", "FIRST_IWMMXT_REGNUM", ")", ";", "else", "{", "pcum", "->", "can_split", "=", "false", ";", "return", "NULL_RTX", ";", "}", "}", "if", "(", "(", "pcum", "->", "nregs", "&", "1", ")", "&&", "ARM_DOUBLEWORD_ALIGN", ")", "{", "int", "res", "=", "arm_needs_doubleword_align", "(", "mode", ",", "type", ")", ";", "if", "(", "res", "<", "0", "&&", "warn_psabi", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 7.1\"", ",", "type", ")", ";", "else", "if", "(", "res", ">", "0", ")", "{", "pcum", "->", "nregs", "++", ";", "if", "(", "res", ">", "1", "&&", "warn_psabi", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 9.1\"", ",", "type", ")", ";", "}", "}", "if", "(", "pcum", "->", "can_split", ")", "nregs", "=", "1", ";", "else", "nregs", "=", "ARM_NUM_REGS2", "(", "mode", ",", "type", ")", ";", "if", "(", "!", "named", "||", "pcum", "->", "nregs", "+", "nregs", ">", "NUM_ARG_REGS", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_REG", "(", "mode", ",", "pcum", "->", "nregs", ")", ";", "}", "</s>" ]

[ "Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "the", "ARM", ",", "normally", "the", "first", "16", "bytes", "are", "passed", "in", "registers", "r0-r3", ";", "all", "other", "arguments", "are", "passed", "on", "the", "stack", ".", "If", "(", "NAMED", "==", "0", ")", "(", "which", "happens", "only", "in", "assign_parms", ",", "since", "TARGET_SETUP_INCOMING_VARARGS", "is", "defined", ")", ",", "say", "it", "is", "passed", "in", "the", "stack", "(", "function_prologue", "will", "indeed", "make", "it", "pass", "in", "the", "stack", "if", "necessary", ")", "." ]

[ "arm", "1", "9", "1", "0", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 7.1\"", "0", "1", "\"parameter passing for argument of type \"", "\"%qT changed in GCC 9.1\"", "1" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_function_arg_alignment", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "int", "alignment", ";", "if", "(", "type", ")", "{", "if", "(", "!", "integer_zerop", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "mode", ")", "alignment", "=", "TYPE_ALIGN", "(", "type", ")", ";", "else", "alignment", "=", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "}", "else", "alignment", "=", "0", ";", "}", "else", "alignment", "=", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "return", "alignment", ";", "}", "</s>" ]

[ "Given", "MODE", "and", "TYPE", "of", "a", "function", "argument", ",", "return", "the", "alignment", "in", "bits", ".", "The", "idea", "is", "to", "suppress", "any", "stronger", "alignment", "requested", "by", "the", "user", "and", "opt", "for", "the", "natural", "alignment", "(", "specified", "in", "AAPCS64", "\\S", "4.1", ")", ".", "This", "is", "a", "helper", "function", "for", "local", "use", "only", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "const", "Z80oldRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "getInstrInfo", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "Z80old", "Z80old" ]

[]

[ "<s>", "unsigned", "AlphaInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "Alpha", "::", "STL", ":", "case", "Alpha", "::", "STQ", ":", "case", "Alpha", "::", "STB", ":", "case", "Alpha", "::", "STW", ":", "case", "Alpha", "::", "STS", ":", "case", "Alpha", "::", "STT", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Alpha", "Alpha", "Alpha::STL", "Alpha::STQ", "Alpha::STB", "Alpha::STW", "Alpha::STS", "Alpha::STT", "1", "1", "0", "0" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "PPCInstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "PPCII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_PLT", ",", "\"ppc-plt\"", "}", ",", "{", "MO_PIC_FLAG", ",", "\"ppc-pic\"", "}", ",", "{", "MO_PCREL_FLAG", ",", "\"ppc-pcrel\"", "}", ",", "{", "MO_GOT_FLAG", ",", "\"ppc-got\"", "}", ",", "{", "MO_PCREL_OPT_FLAG", ",", "\"ppc-opt-pcrel\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "bitmask", "target", "flag", "values", "and", "their", "names", "." ]

[ "PowerPC", "PPC", "PPC", "\"ppc-plt\"", "\"ppc-pic\"", "\"ppc-pcrel\"", "\"ppc-got\"", "\"ppc-opt-pcrel\"" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "k_Register", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "Cpu0" ]

[]

[ "<s>", "bool", "ARCInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", ")", "&&", "\"Invalid ARC branch condition!\"", ")", ";", "Cond", "[", "2", "]", ".", "setImm", "(", "GetOppositeBranchCondition", "(", "(", "ARCCC", "::", "CondCode", ")", "Cond", "[", "2", "]", ".", "getImm", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "ARC", "ARC", "3", "\"Invalid ARC branch condition!\"", "2", "ARCCC::CondCode", "2" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vtbl", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "rtx", "rperm", "[", "MAX_VECT_LEN", "]", ",", "sel", ";", "machine_mode", "vmode", "=", "d", "->", "vmode", ";", "unsigned", "int", "i", ",", "nelt", "=", "d", "->", "nelt", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "if", "(", "vmode", "!=", "V8QImode", "&&", "vmode", "!=", "V16QImode", ")", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "rperm", "[", "i", "]", "=", "GEN_INT", "(", "d", "->", "perm", "[", "i", "]", ")", ";", "sel", "=", "gen_rtx_CONST_VECTOR", "(", "vmode", ",", "gen_rtvec_v", "(", "nelt", ",", "rperm", ")", ")", ";", "sel", "=", "force_reg", "(", "vmode", ",", "sel", ")", ";", "arm_expand_vec_perm_1", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "d", "->", "op1", ",", "sel", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "NEON", "VTBL", "instruction", "is", "a", "fully", "variable", "permuation", "that", "'s", "even", "stronger", "than", "what", "we", "expose", "via", "VEC_PERM_EXPR", ".", "What", "it", "does", "n't", "do", "is", "mask", "the", "index", "operand", "as", "VEC_PERM_EXPR", "requires", ".", "Therefore", "we", "can", "do", "slightly", "better", "by", "expanding", "this", "as", "a", "constant", "where", "we", "do", "n't", "have", "to", "apply", "a", "mask", "." ]

[ "arm", "0" ]

[]

[ "<s>", "bool", "Z80oldTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "Scale", ")", "{", "return", "false", ";", "}", "if", "(", "AM", ".", "BaseGV", "&&", "AM", ".", "HasBaseReg", ")", "{", "return", "false", ";", "}", "if", "(", "AM", ".", "BaseGV", ")", "{", "return", "AM", ".", "BaseOffs", "==", "0", ";", "}", "if", "(", "AM", ".", "HasBaseReg", ")", "{", "return", "isInt", "<", "8", ">", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "Z80old", "Z80old", "0", "8" ]

[]

[ "<s>", "static", "unsigned", "getSubRegIndex", "(", "const", "TargetRegisterClass", "*", "RC", ")", "{", "unsigned", "SubIdx", "=", "X86", "::", "NoSubRegister", ";", "if", "(", "RC", "==", "&", "X86", "::", "GR32RegClass", ")", "{", "SubIdx", "=", "X86", "::", "sub_32bit", ";", "}", "else", "if", "(", "RC", "==", "&", "X86", "::", "GR16RegClass", ")", "{", "SubIdx", "=", "X86", "::", "sub_16bit", ";", "}", "else", "if", "(", "RC", "==", "&", "X86", "::", "GR8RegClass", ")", "{", "SubIdx", "=", "X86", "::", "sub_8bit", ";", "}", "return", "SubIdx", ";", "}", "</s>" ]

[ "Check", "if", "the", "given", "identifier", "is", "a", "name", "of", "a", "subregister", "index", "." ]

[ "X86", "X86::NoSubRegister", "X86::GR32RegClass", "X86::sub_32bit", "X86::GR16RegClass", "X86::sub_16bit", "X86::GR8RegClass", "X86::sub_8bit" ]

[]

[ "<s>", "bool", "BPFFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "BPF", "BPF" ]

[]

[ "<s>", "bool", "Nios2AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "O", "<<", "\"($\"", "<<", "Nios2InstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "Nios2", "Nios2", "0", "\"unexpected inline asm memory operand\"", "\"($\"", "Nios2", "\")\"" ]

[]

[ "<s>", "static", "int", "ix86_mode_after", "(", "int", "entity", ",", "int", "mode", ",", "rtx_insn", "*", "insn", ")", "{", "switch", "(", "entity", ")", "{", "case", "X86_DIRFLAG", ":", "return", "mode", ";", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_after", "(", "mode", ",", "insn", ")", ";", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "return", "mode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "mode", "that", "an", "insn", "results", "in", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "arm_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_NEON", "&&", "(", "mode", "==", "V2SFmode", "||", "mode", "==", "V4SImode", "||", "mode", "==", "V8HImode", "||", "mode", "==", "V4HFmode", "||", "mode", "==", "V16QImode", "||", "mode", "==", "V4SFmode", "||", "mode", "==", "V2DImode", ")", ")", "return", "true", ";", "if", "(", "(", "TARGET_NEON", "||", "TARGET_IWMMXT", ")", "&&", "(", "(", "mode", "==", "V2SImode", ")", "||", "(", "mode", "==", "V4HImode", ")", "||", "(", "mode", "==", "V8QImode", ")", ")", ")", "return", "true", ";", "if", "(", "TARGET_INT_SIMD", "&&", "(", "mode", "==", "V4UQQmode", "||", "mode", "==", "V4QQmode", "||", "mode", "==", "V2UHQmode", "||", "mode", "==", "V2HQmode", "||", "mode", "==", "V2UHAmode", "||", "mode", "==", "V2HAmode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "arm" ]

[]

[ "<s>", "void", "addPreEmitPass", "(", ")", "override", "{", "if", "(", "!", "getPatmosSubtarget", "(", ")", ".", "usePatmosPostRAScheduler", "(", "getOptLevel", "(", ")", ")", ")", "{", "addPass", "(", "createPatmosDelaySlotFillerPass", "(", "getPatmosTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ")", ";", "}", "if", "(", "getPatmosSubtarget", "(", ")", ".", "hasMethodCache", "(", ")", ")", "{", "addPass", "(", "createPatmosFunctionSplitterPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "}", "addPass", "(", "createPatmosDelaySlotKillerPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createPatmosEnsureAlignmentPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isDesirableToCommuteWithShift", "(", "const", "SDNode", "*", "N", ",", "CombineLevel", "Level", ")", "const", "{", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "EVT", "Ty", "=", "N0", ".", "getValueType", "(", ")", ";", "if", "(", "Ty", ".", "isScalarInteger", "(", ")", "&&", "(", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "||", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", ")", "{", "auto", "*", "C1", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N0", "->", "getOperand", "(", "1", ")", ")", ";", "auto", "*", "C2", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", ";", "if", "(", "C1", "&&", "C2", ")", "{", "const", "APInt", "&", "C1Int", "=", "C1", "->", "getAPIntValue", "(", ")", ";", "APInt", "ShiftedC1Int", "=", "C1Int", "<<", "C2", "->", "getAPIntValue", "(", ")", ";", "if", "(", "ShiftedC1Int", ".", "getMinSignedBits", "(", ")", "<=", "64", "&&", "isLegalAddImmediate", "(", "ShiftedC1Int", ".", "getSExtValue", "(", ")", ")", ")", "return", "true", ";", "if", "(", "C1Int", ".", "getMinSignedBits", "(", ")", "<=", "64", "&&", "isLegalAddImmediate", "(", "C1Int", ".", "getSExtValue", "(", ")", ")", ")", "return", "false", ";", "int", "C1Cost", "=", "RISCVMatInt", "::", "getIntMatCost", "(", "C1Int", ",", "Ty", ".", "getSizeInBits", "(", ")", ",", "Subtarget", ".", "is64Bit", "(", ")", ")", ";", "int", "ShiftedC1Cost", "=", "RISCVMatInt", "::", "getIntMatCost", "(", "ShiftedC1Int", ",", "Ty", ".", "getSizeInBits", "(", ")", ",", "Subtarget", ".", "is64Bit", "(", ")", ")", ";", "if", "(", "C1Cost", "<", "ShiftedC1Cost", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "move", "this", "shift", "by", "a", "constant", "amount", "through", "its", "operand", ",", "adjusting", "any", "immediate", "operands", "as", "necessary", "to", "preserve", "semantics", "." ]

[ "RISCV", "RISCV", "0", "ISD::ADD", "ISD::OR", "1", "1", "64", "64", "RISCVMatInt::getIntMatCost", "RISCVMatInt::getIntMatCost" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "hasReservedSpillSlot", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Reg", ",", "int", "&", "FrameIdx", ")", "const", "{", "if", "(", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", "{", "FrameIdx", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "getCRSpillFrameIndex", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "has", "reserved", "a", "spill", "slot", "in", "the", "stack", "frame", "of", "the", "given", "function", "for", "the", "specified", "register", "." ]

[ "PowerPC", "PPC", "PPC::CR2", "PPC::CR4", "PPC" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addInstSelector", "(", ")", "{", "AMDGPUPassConfig", "::", "addInstSelector", "(", ")", ";", "addPass", "(", "&", "SIFixSGPRCopiesID", ")", ";", "addPass", "(", "createSILowerI1CopiesPass", "(", ")", ")", ";", "addPass", "(", "createSIFixupVectorISelPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "SI" ]

[]

[ "<s>", "MipsSubtarget", "&", "MipsSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "&", "TM", ")", "{", "StringRef", "CPUName", "=", "MIPS_MC", "::", "selectMipsCPU", "(", "TM", ".", "getTargetTriple", "(", ")", ",", "CPU", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "InMips16Mode", "&&", "!", "IsSoftFloat", ")", "InMips16HardFloat", "=", "true", ";", "if", "(", "StackAlignOverride", ")", "stackAlignment", "=", "*", "StackAlignOverride", ";", "else", "if", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", "stackAlignment", "=", "Align", "(", "16", ")", ";", "else", "{", "assert", "(", "isABI_O32", "(", ")", "&&", "\"Unknown ABI for stack alignment!\"", ")", ";", "stackAlignment", "=", "Align", "(", "8", ")", ";", "}", "if", "(", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", "&&", "!", "isGP64bit", "(", ")", ")", "report_fatal_error", "(", "\"64-bit code requested on a subtarget that doesn't \"", "\"support it!\"", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "Mips", "Mips", "Mips", "MIPS_MC::selectMipsCPU", "Mips", "Mips", "16", "\"Unknown ABI for stack alignment!\"", "8", "\"64-bit code requested on a subtarget that doesn't \"", "\"support it!\"" ]

[]

[ "<s>", "PPCTargetLowering", "::", "ConstraintType", "PPCTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'b'", ":", "case", "'r'", ":", "case", "'f'", ":", "case", "'v'", ":", "case", "'y'", ":", "return", "C_RegisterClass", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "PowerPC", "PPC", "PPC", "1", "0" ]

[]

[ "<s>", "size_t", "MipsLA25Stub", "::", "size", "(", ")", "const", "{", "return", "m_Size", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "SUnit", "*", "GCNMaxOccupancySchedStrategy", "::", "pickNodeBidirectional", "(", "bool", "&", "IsTopNode", ")", "{", "if", "(", "SUnit", "*", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ")", "{", "IsTopNode", "=", "false", ";", "return", "SU", ";", "}", "if", "(", "SUnit", "*", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ")", "{", "IsTopNode", "=", "true", ";", "return", "SU", ";", "}", "CandPolicy", "BotPolicy", ";", "setPolicy", "(", "BotPolicy", ",", "false", ",", "Bot", ",", "&", "Top", ")", ";", "CandPolicy", "TopPolicy", ";", "setPolicy", "(", "TopPolicy", ",", "false", ",", "Top", ",", "&", "Bot", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Picking from Bot:\\n\"", ")", ";", "if", "(", "!", "BotCand", ".", "isValid", "(", ")", "||", "BotCand", ".", "SU", "->", "isScheduled", "||", "BotCand", ".", "Policy", "!=", "BotPolicy", ")", "{", "BotCand", ".", "reset", "(", "CandPolicy", "(", ")", ")", ";", "pickNodeFromQueue", "(", "Bot", ",", "BotPolicy", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotCand", ".", "Reason", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "}", "else", "{", "DEBUG", "(", "traceCandidate", "(", "BotCand", ")", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Picking from Top:\\n\"", ")", ";", "if", "(", "!", "TopCand", ".", "isValid", "(", ")", "||", "TopCand", ".", "SU", "->", "isScheduled", "||", "TopCand", ".", "Policy", "!=", "TopPolicy", ")", "{", "TopCand", ".", "reset", "(", "CandPolicy", "(", ")", ")", ";", "pickNodeFromQueue", "(", "Top", ",", "TopPolicy", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopCand", ".", "Reason", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "}", "else", "{", "DEBUG", "(", "traceCandidate", "(", "TopCand", ")", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Top Cand: \"", ";", "traceCandidate", "(", "TopCand", ")", ";", "dbgs", "(", ")", "<<", "\"Bot Cand: \"", ";", "traceCandidate", "(", "BotCand", ")", ";", ")", ";", "SchedCandidate", "Cand", ";", "if", "(", "TopCand", ".", "Reason", "==", "BotCand", ".", "Reason", ")", "{", "Cand", "=", "BotCand", ";", "GenericSchedulerBase", "::", "CandReason", "TopReason", "=", "TopCand", ".", "Reason", ";", "TopCand", ".", "Reason", "=", "NoCand", ";", "GenericScheduler", "::", "tryCandidate", "(", "Cand", ",", "TopCand", ",", "nullptr", ")", ";", "if", "(", "TopCand", ".", "Reason", "!=", "NoCand", ")", "{", "Cand", ".", "setBest", "(", "TopCand", ")", ";", "}", "else", "{", "TopCand", ".", "Reason", "=", "TopReason", ";", "}", "}", "else", "{", "if", "(", "TopCand", ".", "Reason", "==", "RegExcess", "&&", "TopCand", ".", "RPDelta", ".", "Excess", ".", "getUnitInc", "(", ")", "<=", "0", ")", "{", "Cand", "=", "TopCand", ";", "}", "else", "if", "(", "BotCand", ".", "Reason", "==", "RegExcess", "&&", "BotCand", ".", "RPDelta", ".", "Excess", ".", "getUnitInc", "(", ")", "<=", "0", ")", "{", "Cand", "=", "BotCand", ";", "}", "else", "if", "(", "TopCand", ".", "Reason", "==", "RegCritical", "&&", "TopCand", ".", "RPDelta", ".", "CriticalMax", ".", "getUnitInc", "(", ")", "<=", "0", ")", "{", "Cand", "=", "TopCand", ";", "}", "else", "if", "(", "BotCand", ".", "Reason", "==", "RegCritical", "&&", "BotCand", ".", "RPDelta", ".", "CriticalMax", ".", "getUnitInc", "(", ")", "<=", "0", ")", "{", "Cand", "=", "BotCand", ";", "}", "else", "{", "if", "(", "BotCand", ".", "Reason", ">", "TopCand", ".", "Reason", ")", "{", "Cand", "=", "TopCand", ";", "}", "else", "{", "Cand", "=", "BotCand", ";", "}", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Picking: \"", ";", "traceCandidate", "(", "Cand", ")", ";", ")", ";", "IsTopNode", "=", "Cand", ".", "AtTop", ";", "return", "Cand", ".", "SU", ";", "}", "</s>" ]

[ "Pick", "the", "best", "candidate", "node", "from", "either", "the", "top", "or", "bottom", "queue", "." ]

[ "AMDGPU", "\"Picking from Bot:\\n\"", "\"failed to find the first candidate\"", "\"Picking from Top:\\n\"", "\"failed to find the first candidate\"", "\"Top Cand: \"", "\"Bot Cand: \"", "0", "0", "0", "0", "\"Picking: \"" ]

[]

[ "<s>", "Register", "SparcTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "LLT", "VT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "Register", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"i0\"", ",", "SP", "::", "I0", ")", ".", "Case", "(", "\"i1\"", ",", "SP", "::", "I1", ")", ".", "Case", "(", "\"i2\"", ",", "SP", "::", "I2", ")", ".", "Case", "(", "\"i3\"", ",", "SP", "::", "I3", ")", ".", "Case", "(", "\"i4\"", ",", "SP", "::", "I4", ")", ".", "Case", "(", "\"i5\"", ",", "SP", "::", "I5", ")", ".", "Case", "(", "\"i6\"", ",", "SP", "::", "I6", ")", ".", "Case", "(", "\"i7\"", ",", "SP", "::", "I7", ")", ".", "Case", "(", "\"o0\"", ",", "SP", "::", "O0", ")", ".", "Case", "(", "\"o1\"", ",", "SP", "::", "O1", ")", ".", "Case", "(", "\"o2\"", ",", "SP", "::", "O2", ")", ".", "Case", "(", "\"o3\"", ",", "SP", "::", "O3", ")", ".", "Case", "(", "\"o4\"", ",", "SP", "::", "O4", ")", ".", "Case", "(", "\"o5\"", ",", "SP", "::", "O5", ")", ".", "Case", "(", "\"o6\"", ",", "SP", "::", "O6", ")", ".", "Case", "(", "\"o7\"", ",", "SP", "::", "O7", ")", ".", "Case", "(", "\"l0\"", ",", "SP", "::", "L0", ")", ".", "Case", "(", "\"l1\"", ",", "SP", "::", "L1", ")", ".", "Case", "(", "\"l2\"", ",", "SP", "::", "L2", ")", ".", "Case", "(", "\"l3\"", ",", "SP", "::", "L3", ")", ".", "Case", "(", "\"l4\"", ",", "SP", "::", "L4", ")", ".", "Case", "(", "\"l5\"", ",", "SP", "::", "L5", ")", ".", "Case", "(", "\"l6\"", ",", "SP", "::", "L6", ")", ".", "Case", "(", "\"l7\"", ",", "SP", "::", "L7", ")", ".", "Case", "(", "\"g0\"", ",", "SP", "::", "G0", ")", ".", "Case", "(", "\"g1\"", ",", "SP", "::", "G1", ")", ".", "Case", "(", "\"g2\"", ",", "SP", "::", "G2", ")", ".", "Case", "(", "\"g3\"", ",", "SP", "::", "G3", ")", ".", "Case", "(", "\"g4\"", ",", "SP", "::", "G4", ")", ".", "Case", "(", "\"g5\"", ",", "SP", "::", "G5", ")", ".", "Case", "(", "\"g6\"", ",", "SP", "::", "G6", ")", ".", "Case", "(", "\"g7\"", ",", "SP", "::", "G7", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "Sparc", "Sparc", "\"i0\"", "SP::I0", "\"i1\"", "SP::I1", "\"i2\"", "SP::I2", "\"i3\"", "SP::I3", "\"i4\"", "SP::I4", "\"i5\"", "SP::I5", "\"i6\"", "SP::I6", "\"i7\"", "SP::I7", "\"o0\"", "SP::O0", "\"o1\"", "SP::O1", "\"o2\"", "SP::O2", "\"o3\"", "SP::O3", "\"o4\"", "SP::O4", "\"o5\"", "SP::O5", "\"o6\"", "SP::O6", "\"o7\"", "SP::O7", "\"l0\"", "SP::L0", "\"l1\"", "SP::L1", "\"l2\"", "SP::L2", "\"l3\"", "SP::L3", "\"l4\"", "SP::L4", "\"l5\"", "SP::L5", "\"l6\"", "SP::L6", "\"l7\"", "SP::L7", "\"g0\"", "SP::G0", "\"g1\"", "SP::G1", "\"g2\"", "SP::G2", "\"g3\"", "SP::G3", "\"g4\"", "SP::G4", "\"g5\"", "SP::G5", "\"g6\"", "SP::G6", "\"g7\"", "SP::G7", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "bool", "BlackfinAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'r'", ":", "break", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "Blackfin", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "AMDGPUMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "Opcode", "=", "AMDGPU", "::", "S_SETPC_B64", ";", "int", "MCOpcode", "=", "ST", ".", "getInstrInfo", "(", ")", "->", "pseudoToMCOpcode", "(", "Opcode", ")", ";", "if", "(", "MCOpcode", "==", "-", "1", ")", "{", "LLVMContext", "&", "C", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "C", ".", "emitError", "(", "\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"", "\"a target-specific version: \"", "+", "Twine", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ";", "}", "OutMI", ".", "setOpcode", "(", "MCOpcode", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "explicit_operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "lowerOperand", "(", "MO", ",", "MCOp", ")", ";", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::S_SETPC_B64_return", "AMDGPU::S_SETPC_B64", "1", "\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"", "\"a target-specific version: \"" ]

[]

[ "<s>", "bool", "AMDGPUMCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "return", "true", ";", "case", "MachineOperand", "::", "MO_Register", ":", "MCOp", "=", "MCOperand", "::", "createReg", "(", "AMDGPU", "::", "getMCReg", "(", "MO", ".", "getReg", "(", ")", ",", "ST", ")", ")", ";", "return", "true", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "{", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "!=", "0", ")", "{", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "getLongBranchBlockExpr", "(", "*", "MO", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MO", ")", ")", ";", "}", "else", "{", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "}", "return", "true", ";", "}", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "SmallString", "<", "128", ">", "SymbolName", ";", "AP", ".", "getNameWithPrefix", "(", "SymbolName", ",", "GV", ")", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "SymbolName", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "getVariantKind", "(", "MO", ".", "getTargetFlags", "(", ")", ")", ",", "Ctx", ")", ";", "int64_t", "Offset", "=", "MO", ".", "getOffset", "(", ")", ";", "if", "(", "Offset", "!=", "0", ")", "{", "Expr", "=", "MCBinaryExpr", "::", "createAdd", "(", "Expr", ",", "MCConstantExpr", "::", "create", "(", "Offset", ",", "Ctx", ")", ",", "Ctx", ")", ";", "}", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "Expr", ")", ";", "return", "true", ";", "}", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "{", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "StringRef", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "Sym", "->", "setExternal", "(", "true", ")", ";", "const", "MCSymbolRefExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Ctx", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "Expr", ")", ";", "return", "true", ";", "}", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "AMDGPU", "AMDGPU", "\"unknown operand type\"", "AMDGPU::getMCReg", "0", "128", "0" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isHighLatencyDef", "(", "int", "opc", ")", "const", "{", "switch", "(", "opc", ")", "{", "default", ":", "return", "false", ";", "case", "X86", "::", "DIVSDrm", ":", "case", "X86", "::", "DIVSDrm_Int", ":", "case", "X86", "::", "DIVSDrr", ":", "case", "X86", "::", "DIVSDrr_Int", ":", "case", "X86", "::", "DIVSSrm", ":", "case", "X86", "::", "DIVSSrm_Int", ":", "case", "X86", "::", "DIVSSrr", ":", "case", "X86", "::", "DIVSSrr_Int", ":", "case", "X86", "::", "SQRTPDm", ":", "case", "X86", "::", "SQRTPDm_Int", ":", "case", "X86", "::", "SQRTPDr", ":", "case", "X86", "::", "SQRTPDr_Int", ":", "case", "X86", "::", "SQRTPSm", ":", "case", "X86", "::", "SQRTPSm_Int", ":", "case", "X86", "::", "SQRTPSr", ":", "case", "X86", "::", "SQRTPSr_Int", ":", "case", "X86", "::", "SQRTSDm", ":", "case", "X86", "::", "SQRTSDm_Int", ":", "case", "X86", "::", "SQRTSDr", ":", "case", "X86", "::", "SQRTSDr_Int", ":", "case", "X86", "::", "SQRTSSm", ":", "case", "X86", "::", "SQRTSSm_Int", ":", "case", "X86", "::", "SQRTSSr", ":", "case", "X86", "::", "SQRTSSr_Int", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "this", "opcode", "has", "high", "latency", "to", "its", "result", "." ]

[ "X86", "X86", "X86::DIVSDrm", "X86::DIVSDrm_Int", "X86::DIVSDrr", "X86::DIVSDrr_Int", "X86::DIVSSrm", "X86::DIVSSrm_Int", "X86::DIVSSrr", "X86::DIVSSrr_Int", "X86::SQRTPDm", "X86::SQRTPDm_Int", "X86::SQRTPDr", "X86::SQRTPDr_Int", "X86::SQRTPSm", "X86::SQRTPSm_Int", "X86::SQRTPSr", "X86::SQRTPSr_Int", "X86::SQRTSDm", "X86::SQRTSDm_Int", "X86::SQRTSDr", "X86::SQRTSDr_Int", "X86::SQRTSSm", "X86::SQRTSSm_Int", "X86::SQRTSSr", "X86::SQRTSSr_Int" ]

[]

[ "<s>", "bool", "ARMExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "STI", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "Modified", "|=", "ExpandMBB", "(", "*", "MFI", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "reg_class_t", "microblaze_secondary_reload", "(", "bool", "in_p", "ATTRIBUTE_UNUSED", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "rclass", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "secondary_reload_info", "*", "sri", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "rclass", "==", "ST_REGS", ")", "return", "GR_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "TARGET_SECONDARY_RELOAD", "." ]

[ "microblaze" ]

[]

[ "<s>", "const", "char", "*", "emit_fusion_p9_load", "(", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "tmp_reg", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "rtx", "hi", ";", "rtx", "lo", ";", "rtx", "addr", ";", "const", "char", "*", "load_string", ";", "int", "r", ";", "if", "(", "GET_CODE", "(", "mem", ")", "==", "FLOAT_EXTEND", "||", "GET_CODE", "(", "mem", ")", "==", "ZERO_EXTEND", ")", "{", "mem", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "}", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "{", "gcc_assert", "(", "SUBREG_BYTE", "(", "reg", ")", "==", "0", ")", ";", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "}", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_load, bad reg #1\"", ",", "reg", ")", ";", "r", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "FP_REGNO_P", "(", "r", ")", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "load_string", "=", "\"lfs\"", ";", "else", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "DImode", ")", "load_string", "=", "\"lfd\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "ALTIVEC_REGNO_P", "(", "r", ")", "&&", "TARGET_P9_DFORM_SCALAR", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "load_string", "=", "\"lxssp\"", ";", "else", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "DImode", ")", "load_string", "=", "\"lxsd\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "INT_REGNO_P", "(", "r", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "load_string", "=", "\"lbz\"", ";", "break", ";", "case", "E_HImode", ":", "load_string", "=", "\"lhz\"", ";", "break", ";", "case", "E_SImode", ":", "case", "E_SFmode", ":", "load_string", "=", "\"lwz\"", ";", "break", ";", "case", "E_DImode", ":", "case", "E_DFmode", ":", "if", "(", "!", "TARGET_POWERPC64", ")", "gcc_unreachable", "(", ")", ";", "load_string", "=", "\"ld\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "fatal_insn", "(", "\"emit_fusion_p9_load, bad reg #2\"", ",", "reg", ")", ";", "if", "(", "!", "MEM_P", "(", "mem", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_load not MEM\"", ",", "mem", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "fusion_split_address", "(", "addr", ",", "&", "hi", ",", "&", "lo", ")", ";", "emit_fusion_addis", "(", "tmp_reg", ",", "hi", ",", "\"power9 load fusion\"", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "emit_fusion_load_store", "(", "reg", ",", "tmp_reg", ",", "lo", ",", "load_string", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "a", "string", "to", "fuse", "an", "addis", "instruction", "with", "a", "load", "using", "extended", "fusion", ".", "The", "address", "that", "is", "used", "is", "the", "logical", "address", "that", "was", "formed", "during", "peephole2", ":", "(", "lo_sum", "(", "high", ")", "(", "low-part", ")", ")", "The", "code", "is", "complicated", ",", "so", "we", "call", "output_asm_insn", "directly", ",", "and", "just", "return", "``", "''", "." ]

[ "powerpcspe", "0", "0", "\"emit_fusion_p9_load, bad reg #1\"", "\"lfs\"", "\"lfd\"", "\"lxssp\"", "\"lxsd\"", "\"lbz\"", "\"lhz\"", "\"lwz\"", "\"ld\"", "\"emit_fusion_p9_load, bad reg #2\"", "\"emit_fusion_p9_load not MEM\"", "0", "\"power9 load fusion\"", "\"\"" ]

[]

[ "<s>", "bool", "PPCLoopInstrFormPrep", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ".", "getSE", "(", ")", ";", "auto", "*", "DTWP", "=", "getAnalysisIfAvailable", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "DT", "=", "DTWP", "?", "&", "DTWP", "->", "getDomTree", "(", ")", ":", "nullptr", ";", "PreserveLCSSA", "=", "mustPreserveAnalysisID", "(", "LCSSAID", ")", ";", "ST", "=", "TM", "?", "TM", "->", "getSubtargetImpl", "(", "F", ")", ":", "nullptr", ";", "SuccPrepCount", "=", "0", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "auto", "I", "=", "LI", "->", "begin", "(", ")", ",", "IE", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "L", "=", "df_begin", "(", "*", "I", ")", ",", "LE", "=", "df_end", "(", "*", "I", ")", ";", "L", "!=", "LE", ";", "++", "L", ")", "MadeChange", "|=", "runOnLoop", "(", "*", "L", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "PowerPC", "PPC", "0" ]

[]

[ "<s>", "static", "bool", "tilepro_legitimate_address_p", "(", "machine_mode", "ARG_UNUSED", "(", "mode", ")", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "POST_INC", ":", "case", "POST_DEC", ":", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "UNITS_PER_WORD", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "break", ";", "case", "POST_MODIFY", ":", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "UNITS_PER_WORD", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "PLUS", ")", "return", "false", ";", "if", "(", "!", "rtx_equal_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ")", ")", "return", "false", ";", "if", "(", "!", "satisfies_constraint_I", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "1", ")", ")", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "break", ";", "case", "REG", ":", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "!", "REG_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "strict", ")", "return", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "x", ")", ")", ";", "else", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "rtx", "X", "can", "be", "used", "as", "an", "address", "operand", "." ]

[ "tilepro", "0", "1", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "bool", "supportsEfficientVectorElementLoadStore", "(", ")", "{", "return", "ST", "->", "getProcFamily", "(", ")", "==", "AArch64Subtarget", "::", "ThunderX2T99", ";", "}", "</s>" ]

[ "If", "target", "has", "efficient", "vector", "element", "load/store", "instructions", ",", "it", "can", "return", "true", "here", "so", "that", "insertion/extraction", "costs", "are", "not", "added", "to", "the", "scalarization", "cost", "of", "a", "load/store", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "bool", "arm_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "unsigned", "long", "func_type", ";", "if", "(", "cfun", "->", "machine", "->", "sibcall_blocked", ")", "return", "false", ";", "if", "(", "TARGET_FDPIC", ")", "{", "if", "(", "decl", "==", "NULL", ")", "return", "false", ";", "}", "if", "(", "TARGET_THUMB1", ")", "return", "false", ";", "if", "(", "TARGET_VXWORKS_RTP", "&&", "flag_pic", "&&", "decl", "&&", "!", "targetm", ".", "binds_local_p", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TARGET_APCS_FRAME", "&&", "TARGET_ARM", "&&", "TARGET_HARD_FLOAT", "&&", "decl", "&&", "arm_is_long_call_p", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TARGET_INTERWORK", "&&", "decl", "&&", "TREE_PUBLIC", "(", "decl", ")", "&&", "!", "TREE_ASM_WRITTEN", "(", "decl", ")", ")", "return", "false", ";", "func_type", "=", "arm_current_func_type", "(", ")", ";", "if", "(", "IS_INTERRUPT", "(", "func_type", ")", ")", "return", "false", ";", "if", "(", "IS_CMSE_ENTRY", "(", "arm_current_func_type", "(", ")", ")", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "CALL_EXPR", ")", "{", "tree", "fntype", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp", ")", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"cmse_nonsecure_call\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ")", "return", "false", ";", "}", "if", "(", "!", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ")", ")", "{", "rtx", "a", ",", "b", ";", "tree", "decl_or_type", "=", "decl", ";", "if", "(", "!", "decl", ")", "decl_or_type", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp", ")", ")", ")", ";", "a", "=", "arm_function_value", "(", "TREE_TYPE", "(", "exp", ")", ",", "decl_or_type", ",", "false", ")", ";", "b", "=", "arm_function_value", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ",", "cfun", "->", "decl", ",", "false", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "a", ",", "b", ")", ")", "return", "false", ";", "}", "if", "(", "IS_STACKALIGN", "(", "func_type", ")", ")", "return", "false", ";", "if", "(", "TARGET_AAPCS_BASED", "&&", "arm_abi", "==", "ARM_ABI_AAPCS", "&&", "decl", "&&", "DECL_WEAK", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "!", "decl", "&&", "CALL_EXPR_BY_DESCRIPTOR", "(", "exp", ")", "&&", "!", "flag_trampolines", ")", "{", "tree", "fntype", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp", ")", ")", ")", ";", "CUMULATIVE_ARGS", "cum", ";", "cumulative_args_t", "cum_v", ";", "arm_init_cumulative_args", "(", "&", "cum", ",", "fntype", ",", "NULL_RTX", ",", "NULL_TREE", ")", ";", "cum_v", "=", "pack_cumulative_args", "(", "&", "cum", ")", ";", "for", "(", "tree", "t", "=", "TYPE_ARG_TYPES", "(", "fntype", ")", ";", "t", ";", "t", "=", "TREE_CHAIN", "(", "t", ")", ")", "{", "tree", "type", "=", "TREE_VALUE", "(", "t", ")", ";", "if", "(", "!", "VOID_TYPE_P", "(", "type", ")", ")", "{", "function_arg_info", "arg", "(", "type", ",", "true", ")", ";", "arm_function_arg_advance", "(", "cum_v", ",", "arg", ")", ";", "}", "}", "function_arg_info", "arg", "(", "integer_type_node", ",", "true", ")", ";", "if", "(", "!", "arm_function_arg", "(", "cum_v", ",", "arg", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "it", "is", "ok", "to", "make", "a", "tail-call", "to", "DECL", "." ]

[ "arm", "\"cmse_nonsecure_call\"" ]

[]

[ "<s>", "bool", "isMachineVerifierClean", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "is", "expected", "to", "pass", "all", "machine", "verifier", "checks", "." ]

[ "AVR" ]

[]

[ "<s>", "int", "msp430_hard_regno_nregs", "(", "int", "regno", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "PSImode", "&&", "msp430x", ")", "return", "1", ";", "return", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implements", "HARD_REGNO_NREGS", ".", "MSP430X", "registers", "can", "hold", "a", "single", "PSImode", "value", ",", "but", "not", "an", "SImode", "value", "." ]

[ "msp430", "1", "1" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "isAlwaysUniform", "(", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "{", "switch", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "amdgcn_readfirstlane", ":", "case", "Intrinsic", "::", "amdgcn_readlane", ":", "case", "Intrinsic", "::", "amdgcn_icmp", ":", "case", "Intrinsic", "::", "amdgcn_fcmp", ":", "case", "Intrinsic", "::", "amdgcn_ballot", ":", "case", "Intrinsic", "::", "amdgcn_if_break", ":", "return", "true", ";", "}", "}", "if", "(", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "V", ")", ")", "{", "if", "(", "CI", "->", "isInlineAsm", "(", ")", ")", "return", "!", "isInlineAsmSourceOfDivergence", "(", "CI", ")", ";", "return", "false", ";", "}", "const", "ExtractValueInst", "*", "ExtValue", "=", "dyn_cast", "<", "ExtractValueInst", ">", "(", "V", ")", ";", "if", "(", "!", "ExtValue", ")", "return", "false", ";", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "ExtValue", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "!", "CI", ")", "return", "false", ";", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "CI", ")", ")", "{", "switch", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "amdgcn_if", ":", "case", "Intrinsic", "::", "amdgcn_else", ":", "{", "ArrayRef", "<", "unsigned", ">", "Indices", "=", "ExtValue", "->", "getIndices", "(", ")", ";", "return", "Indices", ".", "size", "(", ")", "==", "1", "&&", "Indices", "[", "0", "]", "==", "1", ";", "}", "}", "}", "if", "(", "CI", "->", "isInlineAsm", "(", ")", ")", "return", "!", "isInlineAsmSourceOfDivergence", "(", "CI", ",", "ExtValue", "->", "getIndices", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Whether", "Val", "will", "always", "return", "a", "uniform", "value", "regardless", "of", "its", "operands", "." ]

[ "AMDGPU", "Intrinsic::amdgcn_readfirstlane", "Intrinsic::amdgcn_readlane", "Intrinsic::amdgcn_icmp", "Intrinsic::amdgcn_fcmp", "Intrinsic::amdgcn_ballot", "Intrinsic::amdgcn_if_break", "0", "Intrinsic::amdgcn_if", "Intrinsic::amdgcn_else", "1", "0", "1" ]

[]

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRBuilder", "<", ">", "&", "IRB", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "isTargetAndroid", "(", ")", ")", "return", "TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRB", ")", ";", "const", "unsigned", "TlsOffset", "=", "0x48", ";", "Module", "*", "M", "=", "IRB", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Function", "*", "ThreadPointerFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Intrinsic", "::", "aarch64_thread_pointer", ")", ";", "return", "IRB", ".", "CreatePointerCast", "(", "IRB", ".", "CreateConstGEP1_32", "(", "IRB", ".", "CreateCall", "(", "ThreadPointerFunc", ")", ",", "TlsOffset", ")", ",", "Type", "::", "getInt8PtrTy", "(", "IRB", ".", "getContext", "(", ")", ")", "->", "getPointerTo", "(", "0", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "stores", "SafeStack", "pointer", "at", "a", "fixed", "offset", "in", "some", "non-standard", "address", "space", ",", "and", "populates", "the", "address", "space", "and", "offset", "as", "appropriate", "." ]

[ "AArch64", "AArch64", "0x48", "Intrinsic::getDeclaration", "Intrinsic::aarch64_thread_pointer", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "PPCTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRCRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F4RCRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F8RCRegClass", ")", ";", "break", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VRRCRegClass", ")", ";", "case", "'y'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRRCRegClass", ")", ";", "}", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "R", "=", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "R", ".", "first", "&&", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", "&&", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "R", ".", "first", ")", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "std", "::", "make_pair", "(", "TRI", "->", "getMatchingSuperReg", "(", "R", ".", "first", ",", "PPC", "::", "sub_32", ",", "&", "PPC", "::", "GPRCRegClass", ")", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "}", "return", "R", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "PowerPC", "PPC", "1", "0", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RC_NOX0RegClass", "0U", "PPC::GPRC_NOR0RegClass", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RCRegClass", "0U", "PPC::GPRCRegClass", "MVT::f32", "MVT::i32", "0U", "PPC::F4RCRegClass", "MVT::f64", "MVT::i64", "0U", "PPC::F8RCRegClass", "0U", "PPC::VRRCRegClass", "0U", "PPC::CRRCRegClass", "MVT::i64", "PPC", "PPC", "PPC::GPRCRegClass", "PPC::sub_32", "PPC::GPRCRegClass", "PPC::G8RCRegClass" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "FindSwizzleForVectorSlot", "(", "const", "std", "::", "vector", "<", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">>", ">", "&", "IGSrcs", ",", "std", "::", "vector", "<", "R600InstrInfo", "::", "BankSwizzle", ">", "&", "SwzCandidate", ",", "const", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">>", "&", "TransSrcs", ",", "R600InstrInfo", "::", "BankSwizzle", "TransSwz", ")", "const", "{", "unsigned", "ValidUpTo", "=", "0", ";", "do", "{", "ValidUpTo", "=", "isLegalUpTo", "(", "IGSrcs", ",", "SwzCandidate", ",", "TransSrcs", ",", "TransSwz", ")", ";", "if", "(", "ValidUpTo", "==", "IGSrcs", ".", "size", "(", ")", ")", "return", "true", ";", "}", "while", "(", "NextPossibleSolution", "(", "SwzCandidate", ",", "ValidUpTo", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Enumerate", "all", "possible", "Swizzle", "sequence", "to", "find", "one", "that", "can", "meet", "all", "read", "port", "requirements", "." ]

[ "AMDGPU", "R600", "R600", "R600", "0" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "override", "{", "return", "Kind", "==", "Token", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "WebAssembly" ]

[]

[ "<s>", "void", "s390_expand_tbegin", "(", "rtx", "dest", ",", "rtx", "tdb", ",", "rtx", "retry", ",", "bool", "clobber_fprs_p", ")", "{", "rtx", "retry_plus_two", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "retry_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx_code_label", "*", "retry_label", "=", "NULL", ";", "if", "(", "retry", "!=", "NULL_RTX", ")", "{", "emit_move_insn", "(", "retry_reg", ",", "retry", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "retry_plus_two", ",", "retry_reg", ",", "const2_rtx", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "retry_reg", ",", "retry_reg", ",", "const1_rtx", ")", ")", ";", "retry_label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "retry_label", ")", ";", "}", "if", "(", "clobber_fprs_p", ")", "emit_insn", "(", "gen_tbegin_1", "(", "gen_rtx_CONST_INT", "(", "VOIDmode", ",", "TBEGIN_MASK", ")", ",", "tdb", ")", ")", ";", "else", "emit_insn", "(", "gen_tbegin_nofloat_1", "(", "gen_rtx_CONST_INT", "(", "VOIDmode", ",", "TBEGIN_MASK", ")", ",", "tdb", ")", ")", ";", "emit_move_insn", "(", "dest", ",", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "gen_rtx_REG", "(", "CCRAWmode", ",", "CC_REGNUM", ")", ")", ",", "UNSPEC_CC_TO_INT", ")", ")", ";", "if", "(", "retry", "!=", "NULL_RTX", ")", "{", "const", "int", "CC0", "=", "1", "<<", "3", ";", "const", "int", "CC1", "=", "1", "<<", "2", ";", "const", "int", "CC3", "=", "1", "<<", "0", ";", "rtx", "jump", ";", "rtx", "count", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx_code_label", "*", "leave_label", "=", "gen_label_rtx", "(", ")", ";", "jump", "=", "s390_emit_jump", "(", "leave_label", ",", "gen_rtx_EQ", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCRAWmode", ",", "CC_REGNUM", ")", ",", "gen_rtx_CONST_INT", "(", "VOIDmode", ",", "CC0", "|", "CC1", "|", "CC3", ")", ")", ")", ";", "LABEL_NUSES", "(", "leave_label", ")", "=", "1", ";", "emit_move_insn", "(", "count", ",", "retry_plus_two", ")", ";", "emit_insn", "(", "gen_subsi3", "(", "count", ",", "count", ",", "retry_reg", ")", ")", ";", "emit_insn", "(", "gen_tx_assist", "(", "count", ")", ")", ";", "jump", "=", "emit_jump_insn", "(", "gen_doloop_si64", "(", "retry_label", ",", "retry_reg", ",", "retry_reg", ")", ")", ";", "JUMP_LABEL", "(", "jump", ")", "=", "retry_label", ";", "LABEL_NUSES", "(", "retry_label", ")", "=", "1", ";", "emit_label", "(", "leave_label", ")", ";", "}", "}", "</s>" ]

[ "Emit", "rtl", "for", "the", "tbegin", "or", "tbegin_retry", "(", "RETRY", "!", "=", "NULL_RTX", ")", "expanders", ".", "DEST", "-", "Register", "location", "where", "CC", "will", "be", "stored", ".", "TDB", "-", "Pointer", "to", "a", "256", "byte", "area", "where", "to", "store", "the", "transaction", ".", "diagnostic", "block", ".", "NULL", "if", "TDB", "is", "not", "needed", ".", "RETRY", "-", "Retry", "count", "value", ".", "If", "non-NULL", "a", "retry", "loop", "for", "CC2", "is", "emitted", "CLOBBER_FPRS_P", "-", "If", "true", "clobbers", "for", "all", "FPRs", "are", "emitted", "as", "part", "of", "the", "tbegin", "instruction", "pattern", "." ]

[ "s390", "1", "1", "3", "1", "2", "1", "0", "1", "1" ]

[]

[ "<s>", "static", "hsa_status_t", "get_kernarg_region", "(", "hsa_region_t", "region", ",", "void", "*", "data", "__attribute__", "(", "(", "unused", ")", ")", ")", "{", "hsa_region_segment_t", "segment", ";", "hsa_fns", ".", "hsa_region_get_info_fn", "(", "region", ",", "HSA_REGION_INFO_SEGMENT", ",", "&", "segment", ")", ";", "if", "(", "HSA_REGION_SEGMENT_GLOBAL", "!=", "segment", ")", "return", "HSA_STATUS_SUCCESS", ";", "hsa_region_global_flag_t", "flags", ";", "hsa_fns", ".", "hsa_region_get_info_fn", "(", "region", ",", "HSA_REGION_INFO_GLOBAL_FLAGS", ",", "&", "flags", ")", ";", "if", "(", "flags", "&", "HSA_REGION_GLOBAL_FLAG_KERNARG", ")", "{", "kernargs_region", "=", "region", ";", "return", "HSA_STATUS_INFO_BREAK", ";", "}", "return", "HSA_STATUS_SUCCESS", ";", "}", "</s>" ]

[ "Callback", "of", "hsa_iterate_regions", ".", "Called", "once", "for", "each", "available", "memory", "region", ",", "and", "returns", "``", "break", "''", "when", "a", "suitable", "one", "has", "been", "found", "." ]

[ "gcn" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isOperandLegal", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpIdx", ",", "const", "MachineOperand", "*", "MO", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "InstDesc", "=", "MI", ".", "getDesc", "(", ")", ";", "const", "MCOperandInfo", "&", "OpInfo", "=", "InstDesc", ".", "OpInfo", "[", "OpIdx", "]", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "TargetRegisterClass", "*", "DefinedRC", "=", "OpInfo", ".", "RegClass", "!=", "-", "1", "?", "RI", ".", "getRegClass", "(", "OpInfo", ".", "RegClass", ")", ":", "nullptr", ";", "if", "(", "!", "MO", ")", "MO", "=", "&", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "int", "ConstantBusLimit", "=", "ST", ".", "getConstantBusLimit", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "int", "VOP3LiteralLimit", "=", "ST", ".", "hasVOP3Literal", "(", ")", "?", "1", ":", "0", ";", "if", "(", "isVALU", "(", "MI", ")", "&&", "usesConstantBus", "(", "MRI", ",", "*", "MO", ",", "OpInfo", ")", ")", "{", "if", "(", "isVOP3", "(", "MI", ")", "&&", "isLiteralConstantLike", "(", "*", "MO", ",", "OpInfo", ")", "&&", "!", "VOP3LiteralLimit", "--", ")", "return", "false", ";", "SmallDenseSet", "<", "RegSubRegPair", ">", "SGPRsUsed", ";", "if", "(", "MO", "->", "isReg", "(", ")", ")", "SGPRsUsed", ".", "insert", "(", "RegSubRegPair", "(", "MO", "->", "getReg", "(", ")", ",", "MO", "->", "getSubReg", "(", ")", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "i", "==", "OpIdx", ")", "continue", ";", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "RegSubRegPair", "SGPR", "(", "Op", ".", "getReg", "(", ")", ",", "Op", ".", "getSubReg", "(", ")", ")", ";", "if", "(", "!", "SGPRsUsed", ".", "count", "(", "SGPR", ")", "&&", "usesConstantBus", "(", "MRI", ",", "Op", ",", "InstDesc", ".", "OpInfo", "[", "i", "]", ")", ")", "{", "if", "(", "--", "ConstantBusLimit", "<=", "0", ")", "return", "false", ";", "SGPRsUsed", ".", "insert", "(", "SGPR", ")", ";", "}", "}", "else", "if", "(", "InstDesc", ".", "OpInfo", "[", "i", "]", ".", "OperandType", "==", "AMDGPU", "::", "OPERAND_KIMM32", ")", "{", "if", "(", "--", "ConstantBusLimit", "<=", "0", ")", "return", "false", ";", "}", "else", "if", "(", "isVOP3", "(", "MI", ")", "&&", "AMDGPU", "::", "isSISrcOperand", "(", "InstDesc", ",", "i", ")", "&&", "isLiteralConstantLike", "(", "Op", ",", "InstDesc", ".", "OpInfo", "[", "i", "]", ")", ")", "{", "if", "(", "!", "VOP3LiteralLimit", "--", ")", "return", "false", ";", "if", "(", "--", "ConstantBusLimit", "<=", "0", ")", "return", "false", ";", "}", "}", "}", "if", "(", "MO", "->", "isReg", "(", ")", ")", "{", "assert", "(", "DefinedRC", ")", ";", "return", "isLegalRegOperand", "(", "MRI", ",", "OpInfo", ",", "*", "MO", ")", ";", "}", "assert", "(", "MO", "->", "isImm", "(", ")", "||", "MO", "->", "isTargetIndex", "(", ")", "||", "MO", "->", "isFI", "(", ")", "||", "MO", "->", "isGlobal", "(", ")", ")", ";", "if", "(", "!", "DefinedRC", ")", "{", "return", "true", ";", "}", "return", "isImmOperandLegal", "(", "MI", ",", "OpIdx", ",", "*", "MO", ")", ";", "}", "</s>" ]

[ "Check", "if", "MO", "is", "a", "legal", "operand", "if", "it", "was", "the", "OpIdx", "Operand", "for", "MI", "." ]

[ "AMDGPU", "SI", "1", "1", "0", "0", "0", "AMDGPU::OPERAND_KIMM32", "0", "AMDGPU::isSISrcOperand", "0" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", "true", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getARMSubtarget", "(", ")", ".", "isCortexA9", "(", ")", ")", "addPass", "(", "createMLxExpansionPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getARMSubtarget", "(", ")", ".", "isCortexA15", "(", ")", "&&", "getARMSubtarget", "(", ")", ".", "hasNEON", "(", ")", "&&", "!", "DisableA15SDOptimization", ")", "{", "addPass", "(", "createA15SDOptimizerPass", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "bool", "HexagonAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".falign\"", ")", "return", "ParseDirectiveFalign", "(", "256", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "(", "IDVal", ".", "lower", "(", ")", "==", "\".lcomm\"", ")", "||", "(", "IDVal", ".", "lower", "(", ")", "==", "\".lcommon\"", ")", ")", "return", "ParseDirectiveComm", "(", "true", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "(", "IDVal", ".", "lower", "(", ")", "==", "\".comm\"", ")", "||", "(", "IDVal", ".", "lower", "(", ")", "==", "\".common\"", ")", ")", "return", "ParseDirectiveComm", "(", "false", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".subsection\"", ")", "return", "ParseDirectiveSubsection", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "Hexagon", "Hexagon", "\".falign\"", "256", "\".lcomm\"", "\".lcommon\"", "\".comm\"", "\".common\"", "\".subsection\"" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_MSP430", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::InputArg", "16", "MSP430", "0", "1", "2", "0" ]

[]

[ "<s>", "static", "bool", "flexible_array_member_type_p", "(", "const_tree", "type", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "!=", "RECORD_TYPE", ")", "return", "false", ";", "const_tree", "last_field", "=", "NULL_TREE", ";", "for", "(", "const_tree", "f", "=", "TYPE_FIELDS", "(", "type", ")", ";", "f", ";", "f", "=", "TREE_CHAIN", "(", "f", ")", ")", "last_field", "=", "f", ";", "if", "(", "!", "last_field", ")", "return", "false", ";", "const_tree", "last_field_type", "=", "TREE_TYPE", "(", "last_field", ")", ";", "if", "(", "TREE_CODE", "(", "last_field_type", ")", "!=", "ARRAY_TYPE", ")", "return", "false", ";", "return", "(", "!", "TYPE_DOMAIN", "(", "last_field_type", ")", "||", "!", "TYPE_MAX_VALUE", "(", "TYPE_DOMAIN", "(", "last_field_type", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "TYPE", "is", "a", "record", "type", "where", "the", "last", "field", "is", "an", "array", "without", "given", "dimension", "." ]

[ "nvptx" ]

[]

[ "<s>", "void", "scalar_chain", "::", "convert_op", "(", "rtx", "*", "op", ",", "rtx_insn", "*", "insn", ")", "{", "*", "op", "=", "copy_rtx_if_shared", "(", "*", "op", ")", ";", "if", "(", "GET_CODE", "(", "*", "op", ")", "==", "NOT", ")", "{", "convert_op", "(", "&", "XEXP", "(", "*", "op", ",", "0", ")", ",", "insn", ")", ";", "PUT_MODE", "(", "*", "op", ",", "V2DImode", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "*", "op", ")", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "emit_insn_before", "(", "gen_move_insn", "(", "tmp", ",", "*", "op", ")", ",", "insn", ")", ";", "*", "op", "=", "gen_rtx_SUBREG", "(", "V2DImode", ",", "tmp", ",", "0", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Preloading operand for insn %d into r%d\\n\"", ",", "INSN_UID", "(", "insn", ")", ",", "REGNO", "(", "tmp", ")", ")", ";", "}", "else", "if", "(", "REG_P", "(", "*", "op", ")", ")", "{", "df_ref", "ref", ";", "FOR_EACH_INSN_USE", "(", "ref", ",", "insn", ")", "if", "(", "DF_REF_REGNO", "(", "ref", ")", "==", "REGNO", "(", "*", "op", ")", ")", "{", "gcc_assert", "(", "!", "DF_REF_CHAIN", "(", "ref", ")", ")", ";", "break", ";", "}", "*", "op", "=", "gen_rtx_SUBREG", "(", "V2DImode", ",", "*", "op", ",", "0", ")", ";", "}", "else", "{", "gcc_assert", "(", "SUBREG_P", "(", "*", "op", ")", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "*", "op", ")", "==", "V2DImode", ")", ";", "}", "}", "</s>" ]

[ "Convert", "operand", "OP", "in", "INSN", ".", "We", "should", "handle", "memory", "operands", "and", "uninitialized", "registers", ".", "All", "other", "register", "uses", "are", "converted", "during", "registers", "conversion", "." ]

[ "i386", "0", "0", "\" Preloading operand for insn %d into r%d\\n\"", "0" ]

[]

[ "<s>", "void", "HexagonShuffler", "::", "append", "(", "MCInst", "const", "&", "ID", ",", "MCInst", "const", "*", "Extender", ",", "unsigned", "S", ")", "{", "HexagonInstr", "PI", "(", "&", "TUL", ",", "MCII", ",", "&", "ID", ",", "Extender", ",", "S", ")", ";", "Packet", ".", "push_back", "(", "PI", ")", ";", "}", "</s>" ]

[ "Append", "from", "a", "list", "of", "StringRefs", "." ]

[ "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "AVRRelaxMem", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "Block", "&", "MBB", ":", "MF", ")", "{", "bool", "BlockModified", "=", "runOnBasicBlock", "(", "MBB", ")", ";", "Modified", "|=", "BlockModified", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreLegalizeMachineIR", "(", ")", "{", "bool", "IsOptNone", "=", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "addPass", "(", "createAArch64PreLegalizerCombiner", "(", "IsOptNone", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "legalization", "." ]

[ "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "RISCVTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "RISCV", "::", "GPRRegClass", ")", ";", "case", "'f'", ":", "if", "(", "Subtarget", ".", "hasStdExtF", "(", ")", "&&", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "RISCV", "::", "FPR32RegClass", ")", ";", "if", "(", "Subtarget", ".", "hasStdExtD", "(", ")", "&&", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "RISCV", "::", "FPR64RegClass", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "RISCV", "RISCV", "1", "0", "0U", "RISCV::GPRRegClass", "MVT::f32", "0U", "RISCV::FPR32RegClass", "MVT::f64", "0U", "RISCV::FPR64RegClass" ]

[]

[ "<s>", "bool", "AVRAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "(", "void", ")", "MO", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"Unexpected inline asm memory operand\"", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "AVR", "::", "R31R30", ")", "{", "O", "<<", "\"Z\"", ";", "}", "else", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "AVR", "::", "R29R28", "&&", "\"Wrong register class for memory operand.\"", ")", ";", "O", "<<", "\"Y\"", ";", "}", "unsigned", "OpFlags", "=", "MI", "->", "getOperand", "(", "OpNum", "-", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumOpRegs", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "OpFlags", ")", ";", "if", "(", "NumOpRegs", "==", "2", ")", "{", "O", "<<", "'+'", "<<", "MI", "->", "getOperand", "(", "OpNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "AVR", "AVR", "0", "\"Unexpected inline asm memory operand\"", "AVR::R31R30", "\"Z\"", "AVR::R29R28", "\"Wrong register class for memory operand.\"", "\"Y\"", "1", "2", "1" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARCOMPACT DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "ARCompact", "\"ARCOMPACT DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown rematerializable operation!\"", ")", ";", "break", ";", "case", "PPC", "::", "LI", ":", "case", "PPC", "::", "LI8", ":", "case", "PPC", "::", "LIS", ":", "case", "PPC", "::", "LIS8", ":", "case", "PPC", "::", "QVGPCI", ":", "case", "PPC", "::", "ADDIStocHA", ":", "case", "PPC", "::", "ADDIStocHA8", ":", "case", "PPC", "::", "ADDItocL", ":", "case", "PPC", "::", "LOAD_STACK_GUARD", ":", "case", "PPC", "::", "XXLXORz", ":", "case", "PPC", "::", "XXLXORspz", ":", "case", "PPC", "::", "XXLXORdpz", ":", "case", "PPC", "::", "XXLEQVOnes", ":", "case", "PPC", "::", "V_SET0B", ":", "case", "PPC", "::", "V_SET0H", ":", "case", "PPC", "::", "V_SET0", ":", "case", "PPC", "::", "V_SETALLONESB", ":", "case", "PPC", "::", "V_SETALLONESH", ":", "case", "PPC", "::", "V_SETALLONES", ":", "case", "PPC", "::", "CRSET", ":", "case", "PPC", "::", "CRUNSET", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "PowerPC", "PPC", "\"Unknown rematerializable operation!\"", "PPC::LI", "PPC::LI8", "PPC::LIS", "PPC::LIS8", "PPC::QVGPCI", "PPC::ADDIStocHA", "PPC::ADDIStocHA8", "PPC::ADDItocL", "PPC::LOAD_STACK_GUARD", "PPC::XXLXORz", "PPC::XXLXORspz", "PPC::XXLXORdpz", "PPC::XXLEQVOnes", "PPC::V_SET0B", "PPC::V_SET0H", "PPC::V_SET0", "PPC::V_SETALLONESB", "PPC::V_SETALLONESH", "PPC::V_SETALLONES", "PPC::CRSET", "PPC::CRUNSET" ]

[]

[ "<s>", "static", "rtx", "m68k_struct_value_rtx", "(", "tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "incoming", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "Pmode", ",", "M68K_STRUCT_VALUE_REGNUM", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_STRUCT_VALUE_RTX", "." ]

[ "m68k" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldExtendGSIndex", "(", "EVT", "VT", ",", "EVT", "&", "EltTy", ")", "const", "{", "if", "(", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i8", "||", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i16", ")", "{", "EltTy", "=", "MVT", "::", "i32", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "index", "type", "for", "a", "masked", "gather/scatter", "requires", "extending", "." ]

[ "AArch64", "AArch64", "MVT::i8", "MVT::i16", "MVT::i32" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "MOSPassConfig", "::", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "{", "return", "new", "ScheduleDAGMILive", "(", "C", ",", "std", "::", "make_unique", "<", "MOSSchedStrategy", ">", "(", "C", ")", ")", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

[ "MOS", "MOS", "MOS" ]

[]

[ "<s>", "void", "SPURegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "MachineOperand", "&", "SPOp", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "int", "FrameIndex", "=", "SPOp", ".", "getIndex", "(", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "unsigned", "OpNo", "=", "1", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SPU", "::", "AIr32", "||", "MI", ".", "getOpcode", "(", ")", "==", "SPU", "::", "ILAr32", ")", "OpNo", "=", "2", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "Offset", "+=", "MO", ".", "getImm", "(", ")", "+", "MFI", "->", "getStackSize", "(", ")", "+", "SPUFrameInfo", "::", "minStackSize", "(", ")", ";", "assert", "(", "(", "Offset", "&", "0xf", ")", "==", "0", "&&", "\"16-byte alignment violated in eliminateFrameIndex\"", ")", ";", "SPOp", ".", "ChangeToRegister", "(", "SPU", "::", "R1", ",", "false", ")", ";", "if", "(", "Offset", ">", "SPUFrameInfo", "::", "maxFrameOffset", "(", ")", "||", "Offset", "<", "SPUFrameInfo", "::", "minFrameOffset", "(", ")", ")", "{", "cerr", "<<", "\"Large stack adjustment (\"", "<<", "Offset", "<<", "\") in SPURegisterInfo::eliminateFrameIndex.\"", ";", "}", "else", "{", "MO", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "CellSPU", "SPU", "0", "\"Instr doesn't have FrameIndex operand!\"", "1", "SPU::AIr32", "SPU::ILAr32", "2", "SPU", "0xf", "0", "\"16-byte alignment violated in eliminateFrameIndex\"", "SPU::R1", "SPU", "SPU", "\"Large stack adjustment (\"", "\") in SPURegisterInfo::eliminateFrameIndex.\"" ]

[]

[ "<s>", "virtual", "EVT", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i1", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "NVPTX", "MVT::i1" ]

[]

[ "<s>", "Register", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "Hexagon", "::", "R0", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "." ]

[ "Hexagon", "Hexagon::R0" ]

[]

[ "<s>", "static", "bool", "pru_repeat_loop_p", "(", "struct", "pru_doloop", "*", "loop", ")", "{", "struct", "pru_doloop_end", "*", "end", ";", "rtx_insn", "*", "fallthrough", ";", "if", "(", "loop", "->", "begin", "==", "0", "||", "loop", "->", "end", "==", "0", "||", "loop", "->", "begin", "->", "next", "!=", "0", ")", "return", "false", ";", "if", "(", "prev_real_insn", "(", "as_a", "<", "rtx_insn", "*", ">", "(", "loop", "->", "end", "->", "label", ")", ")", "!=", "loop", "->", "begin", "->", "insn", ")", "return", "false", ";", "if", "(", "get_attr_length", "(", "loop", "->", "end", "->", "insn", ")", "!=", "4", ")", "return", "false", ";", "fallthrough", "=", "loop", "->", "end", "->", "fallthrough", ";", "for", "(", "end", "=", "loop", "->", "end", "->", "next", ";", "end", "!=", "0", ";", "end", "=", "end", "->", "next", ")", "if", "(", "end", "->", "label", "!=", "loop", "->", "end", "->", "label", "||", "!", "simplejump_p", "(", "end", "->", "fallthrough", ")", "||", "fallthrough", "!=", "next_real_insn", "(", "JUMP_LABEL_AS_INSN", "(", "end", "->", "fallthrough", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "LOOP", "can", "be", "converted", "into", "LOOP", "form", "(", "that", "is", ",", "if", "it", "matches", "cases", "(", "1", ")", "or", "(", "2", ")", "above", ")", "." ]

[ "pru", "0", "0", "0", "4", "0" ]

[]

[ "<s>", "static", "void", "write_fn_proto_1", "(", "std", "::", "stringstream", "&", "s", ",", "bool", "is_defn", ",", "const", "char", "*", "name", ",", "const_tree", "decl", ")", "{", "if", "(", "lookup_attribute", "(", "\"alias\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "==", "NULL", ")", "write_fn_marker", "(", "s", ",", "is_defn", ",", "TREE_PUBLIC", "(", "decl", ")", ",", "name", ")", ";", "if", "(", "DECL_EXTERNAL", "(", "decl", ")", ")", "s", "<<", "\".extern \"", ";", "else", "if", "(", "TREE_PUBLIC", "(", "decl", ")", ")", "s", "<<", "(", "DECL_WEAK", "(", "decl", ")", "?", "\".weak \"", ":", "\".visible \"", ")", ";", "s", "<<", "(", "write_as_kernel", "(", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "?", "\".entry \"", ":", "\".func \"", ")", ";", "tree", "fntype", "=", "TREE_TYPE", "(", "decl", ")", ";", "tree", "result_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "int", "not_atomic_weak_arg", "=", "-", "1", ";", "if", "(", "DECL_BUILT_IN_CLASS", "(", "decl", ")", "==", "BUILT_IN_NORMAL", ")", "switch", "(", "DECL_FUNCTION_CODE", "(", "decl", ")", ")", "{", "case", "BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1", ":", "case", "BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2", ":", "case", "BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4", ":", "case", "BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8", ":", "case", "BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16", ":", "not_atomic_weak_arg", "=", "3", ";", "break", ";", "default", ":", "break", ";", "}", "bool", "return_in_mem", "=", "write_return_type", "(", "s", ",", "true", ",", "result_type", ")", ";", "s", "<<", "name", ";", "int", "argno", "=", "0", ";", "if", "(", "return_in_mem", ")", "argno", "=", "write_arg_type", "(", "s", ",", "-", "1", ",", "argno", ",", "ptr_type_node", ",", "true", ")", ";", "tree", "args", "=", "TYPE_ARG_TYPES", "(", "fntype", ")", ";", "bool", "prototyped", "=", "true", ";", "if", "(", "!", "args", ")", "{", "args", "=", "DECL_ARGUMENTS", "(", "decl", ")", ";", "prototyped", "=", "false", ";", "}", "for", "(", ";", "args", ";", "args", "=", "TREE_CHAIN", "(", "args", ")", ",", "not_atomic_weak_arg", "--", ")", "{", "tree", "type", "=", "prototyped", "?", "TREE_VALUE", "(", "args", ")", ":", "TREE_TYPE", "(", "args", ")", ";", "if", "(", "not_atomic_weak_arg", ")", "argno", "=", "write_arg_type", "(", "s", ",", "-", "1", ",", "argno", ",", "type", ",", "prototyped", ")", ";", "else", "gcc_assert", "(", "TREE_CODE", "(", "type", ")", "==", "BOOLEAN_TYPE", ")", ";", "}", "if", "(", "stdarg_p", "(", "fntype", ")", ")", "argno", "=", "write_arg_type", "(", "s", ",", "-", "1", ",", "argno", ",", "ptr_type_node", ",", "true", ")", ";", "if", "(", "DECL_STATIC_CHAIN", "(", "decl", ")", ")", "argno", "=", "write_arg_type", "(", "s", ",", "-", "1", ",", "argno", ",", "ptr_type_node", ",", "true", ")", ";", "if", "(", "argno", "<", "2", "&&", "strcmp", "(", "name", ",", "\"main\"", ")", "==", "0", ")", "{", "if", "(", "argno", "==", "0", ")", "argno", "=", "write_arg_type", "(", "s", ",", "-", "1", ",", "argno", ",", "integer_type_node", ",", "true", ")", ";", "if", "(", "argno", "==", "1", ")", "argno", "=", "write_arg_type", "(", "s", ",", "-", "1", ",", "argno", ",", "ptr_type_node", ",", "true", ")", ";", "}", "if", "(", "argno", ")", "s", "<<", "\")\"", ";", "s", "<<", "(", "is_defn", "?", "\"\\n\"", ":", "\";\\n\"", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "write_fn_proto", "." ]

[ "nvptx", "\"alias\"", "\".extern \"", "\".weak \"", "\".visible \"", "\".entry \"", "\".func \"", "1", "3", "0", "1", "1", "1", "1", "2", "\"main\"", "0", "0", "1", "1", "1", "\")\"", "\"\\n\"", "\";\\n\"" ]

[]

[ "<s>", "const", "char", "*", "HexagonTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "HexagonISD", "::", "CONST32", ":", "return", "\"HexagonISD::CONST32\"", ";", "case", "HexagonISD", "::", "CONST32_GP", ":", "return", "\"HexagonISD::CONST32_GP\"", ";", "case", "HexagonISD", "::", "CONST32_Int_Real", ":", "return", "\"HexagonISD::CONST32_Int_Real\"", ";", "case", "HexagonISD", "::", "ADJDYNALLOC", ":", "return", "\"HexagonISD::ADJDYNALLOC\"", ";", "case", "HexagonISD", "::", "CMPICC", ":", "return", "\"HexagonISD::CMPICC\"", ";", "case", "HexagonISD", "::", "CMPFCC", ":", "return", "\"HexagonISD::CMPFCC\"", ";", "case", "HexagonISD", "::", "BRICC", ":", "return", "\"HexagonISD::BRICC\"", ";", "case", "HexagonISD", "::", "BRFCC", ":", "return", "\"HexagonISD::BRFCC\"", ";", "case", "HexagonISD", "::", "SELECT_ICC", ":", "return", "\"HexagonISD::SELECT_ICC\"", ";", "case", "HexagonISD", "::", "SELECT_FCC", ":", "return", "\"HexagonISD::SELECT_FCC\"", ";", "case", "HexagonISD", "::", "Hi", ":", "return", "\"HexagonISD::Hi\"", ";", "case", "HexagonISD", "::", "Lo", ":", "return", "\"HexagonISD::Lo\"", ";", "case", "HexagonISD", "::", "FTOI", ":", "return", "\"HexagonISD::FTOI\"", ";", "case", "HexagonISD", "::", "ITOF", ":", "return", "\"HexagonISD::ITOF\"", ";", "case", "HexagonISD", "::", "CALL", ":", "return", "\"HexagonISD::CALL\"", ";", "case", "HexagonISD", "::", "RET_FLAG", ":", "return", "\"HexagonISD::RET_FLAG\"", ";", "case", "HexagonISD", "::", "BR_JT", ":", "return", "\"HexagonISD::BR_JT\"", ";", "case", "HexagonISD", "::", "TC_RETURN", ":", "return", "\"HexagonISD::TC_RETURN\"", ";", "case", "HexagonISD", "::", "EH_RETURN", ":", "return", "\"HexagonISD::EH_RETURN\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "Hexagon", "Hexagon", "0", "HexagonISD::CONST32", "\"HexagonISD::CONST32\"", "HexagonISD::CONST32_GP", "\"HexagonISD::CONST32_GP\"", "HexagonISD::CONST32_Int_Real", "\"HexagonISD::CONST32_Int_Real\"", "HexagonISD::ADJDYNALLOC", "\"HexagonISD::ADJDYNALLOC\"", "HexagonISD::CMPICC", "\"HexagonISD::CMPICC\"", "HexagonISD::CMPFCC", "\"HexagonISD::CMPFCC\"", "HexagonISD::BRICC", "\"HexagonISD::BRICC\"", "HexagonISD::BRFCC", "\"HexagonISD::BRFCC\"", "HexagonISD::SELECT_ICC", "\"HexagonISD::SELECT_ICC\"", "HexagonISD::SELECT_FCC", "\"HexagonISD::SELECT_FCC\"", "HexagonISD::Hi", "\"HexagonISD::Hi\"", "HexagonISD::Lo", "\"HexagonISD::Lo\"", "HexagonISD::FTOI", "\"HexagonISD::FTOI\"", "HexagonISD::ITOF", "\"HexagonISD::ITOF\"", "HexagonISD::CALL", "\"HexagonISD::CALL\"", "HexagonISD::RET_FLAG", "\"HexagonISD::RET_FLAG\"", "HexagonISD::BR_JT", "\"HexagonISD::BR_JT\"", "HexagonISD::TC_RETURN", "\"HexagonISD::TC_RETURN\"", "HexagonISD::EH_RETURN", "\"HexagonISD::EH_RETURN\"" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_PPC", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "else", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "PowerPC", "PPC", "ISD::OutputArg", "16", "PPC", "0", "0", "\"Can only return in registers!\"", "\"Unknown loc info!\"", "ISD::ANY_EXTEND", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "1", "PPCISD::RET_FLAG", "MVT::Other", "PPCISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "uint32_t", "insert", "(", "T", "Val", ")", "{", "auto", "F", "=", "llvm", "::", "find", "(", "Map", ",", "Val", ")", ";", "if", "(", "F", "!=", "Map", ".", "end", "(", ")", ")", "return", "F", "-", "Map", ".", "begin", "(", ")", "+", "1", ";", "Map", ".", "push_back", "(", "Val", ")", ";", "return", "Map", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "insert", "-", "Append", "entry", "to", "the", "vector", "if", "it", "does", "n't", "already", "exist", "." ]

[ "Hexagon", "1" ]

[]

[ "<s>", "virtual", "StringRef", "getPassName", "(", ")", "const", "{", "return", "StringRef", "(", "\"CJG Assembly Printer\"", ")", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "CJG", "\"CJG Assembly Printer\"" ]

[]

[ "<s>", "static", "int", "cris_initial_frame_pointer_offset", "(", ")", "{", "int", "regno", ";", "int", "offs", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "(", "(", "(", "regs_ever_live", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "||", "(", "regno", "==", "(", "int", ")", "PIC_OFFSET_TABLE_REGNUM", "&&", "(", "current_function_uses_pic_offset_table", "||", "(", "flag_pic", "&&", "regs_ever_live", "[", "regno", "+", "1", "]", "&&", "!", "call_used_regs", "[", "regno", "+", "1", "]", ")", ")", ")", ")", "&&", "(", "regno", "!=", "FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", "&&", "regno", "!=", "CRIS_SRP_REGNUM", ")", "||", "(", "current_function_calls_eh_return", "&&", "(", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "0", ")", "||", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "1", ")", "||", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "2", ")", "||", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "3", ")", ")", ")", ")", "offs", "+=", "4", ";", "offs", "+=", "get_frame_size", "(", ")", ";", "offs", "+=", "current_function_outgoing_args_size", ";", "if", "(", "TARGET_STACK_ALIGN", ")", "offs", "=", "TARGET_ALIGN_BY_32", "?", "(", "offs", "+", "3", ")", "&", "~", "3", ":", "(", "offs", "+", "1", ")", "&", "~", "1", ";", "return", "offs", ";", "}", "</s>" ]

[ "This", "used", "to", "be", "the", "INITIAL_FRAME_POINTER_OFFSET", "worker", ";", "now", "only", "handles", "FP", "-", ">", "SP", "elimination", "offset", "." ]

[ "cris", "0", "0", "1", "1", "0", "1", "2", "3", "4", "3", "3", "1", "1" ]

[]