Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "int", "ix86_address_cost", "(", "rtx", "x", ",", "machine_mode", ",", "addr_space_t", ",", "bool", ")", "{", "struct", "ix86_address", "parts", ";", "int", "cost", "=", "1", ";", "int", "ok", "=", "ix86_decompose_address", "(", "x", ",", "&", "parts", ")", ";", "gcc_assert", "(", "ok", ")", ";", "if", "(", "parts", ".", "base", "&&", "SUBREG_P", "(", "parts", ".", "base", ")", ")", "parts", ".", "base", "=", "SUBREG_REG", "(", "parts", ".", "base", ")", ";", "if", "(", "parts", ".", "index", "&&", "SUBREG_P", "(", "parts", ".", "index", ")", ")", "parts", ".", "index", "=", "SUBREG_REG", "(", "parts", ".", "index", ")", ";", "if", "(", "parts", ".", "base", "&&", "(", "!", "REG_P", "(", "parts", ".", "base", ")", "||", "REGNO", "(", "parts", ".", "base", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "&&", "(", "current_pass", "->", "type", "==", "GIMPLE_PASS", "||", "!", "pic_offset_table_rtx", "||", "!", "REG_P", "(", "parts", ".", "base", ")", "||", "REGNO", "(", "pic_offset_table_rtx", ")", "!=", "REGNO", "(", "parts", ".", "base", ")", ")", ")", "cost", "++", ";", "if", "(", "parts", ".", "index", "&&", "(", "!", "REG_P", "(", "parts", ".", "index", ")", "||", "REGNO", "(", "parts", ".", "index", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "&&", "(", "current_pass", "->", "type", "==", "GIMPLE_PASS", "||", "!", "pic_offset_table_rtx", "||", "!", "REG_P", "(", "parts", ".", "index", ")", "||", "REGNO", "(", "pic_offset_table_rtx", ")", "!=", "REGNO", "(", "parts", ".", "index", ")", ")", ")", "cost", "++", ";", "if", "(", "TARGET_CPU_P", "(", "K6", ")", "&&", "(", "(", "!", "parts", ".", "disp", "&&", "parts", ".", "base", "&&", "parts", ".", "index", "&&", "parts", ".", "scale", "!=", "1", ")", "||", "(", "parts", ".", "disp", "&&", "!", "parts", ".", "base", "&&", "parts", ".", "index", "&&", "parts", ".", "scale", "!=", "1", ")", "||", "(", "!", "parts", ".", "disp", "&&", "parts", ".", "base", "&&", "parts", ".", "index", "&&", "parts", ".", "scale", "==", "1", ")", ")", ")", "cost", "+=", "10", ";", "return", "cost", ";", "}", "</s>" ]

[ "Return", "cost", "of", "the", "memory", "address", "x", ".", "For", "i386", ",", "it", "is", "better", "to", "use", "a", "complex", "address", "than", "let", "gcc", "copy", "the", "address", "into", "a", "reg", "and", "make", "a", "new", "pseudo", ".", "But", "not", "if", "the", "address", "requires", "to", "two", "regs", "-", "that", "would", "mean", "more", "pseudos", "with", "longer", "lifetimes", "." ]

[ "i386", "1", "1", "1", "1", "10" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Fix SGPR copies\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI Fix SGPR copies\"" ]

[]

[ "<s>", "static", "int", "s390_issue_rate", "(", "void", ")", "{", "switch", "(", "s390_tune", ")", "{", "case", "PROCESSOR_2084_Z990", ":", "case", "PROCESSOR_2094_Z9_109", ":", "case", "PROCESSOR_2817_Z196", ":", "return", "3", ";", "case", "PROCESSOR_2097_Z10", ":", "case", "PROCESSOR_2827_ZEC12", ":", "return", "2", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createRISCVMergeBaseOffsetOptPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createRISCVRemoveRedundancyVSETVLPass", "(", ")", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "static", "rtx_insn", "*", "find_load", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "return", "NULL", ";", "if", "(", "get_attr_type", "(", "insn", ")", "==", "TYPE_MCLD", ")", "return", "insn", ";", "if", "(", "GET_MODE", "(", "insn", ")", "!=", "SImode", ")", "return", "NULL", ";", "do", "{", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "(", "GET_MODE", "(", "insn", ")", "==", "SImode", "||", "GET_MODE", "(", "insn", ")", "==", "QImode", ")", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_MCLD", ")", "return", "insn", ";", "}", "while", "(", "GET_MODE", "(", "insn", ")", "!=", "QImode", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Return", "INSN", "if", "it", "is", "of", "TYPE_MCLD", ".", "Alternatively", ",", "if", "INSN", "is", "the", "start", "of", "a", "three-insn", "bundle", ",", "see", "if", "one", "of", "them", "is", "a", "load", "and", "return", "that", "if", "so", ".", "Return", "NULL", "if", "the", "insn", "does", "not", "contain", "loads", "." ]

[ "bfin" ]

[]

[ "<s>", "bool", "LanaiAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "StringRef", "Mnemonic", "=", "splitMnemonic", "(", "Name", ",", "NameLoc", ",", "&", "Operands", ")", ";", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "&", "Operands", ",", "Mnemonic", ")", "!=", "MatchOperand_Success", ")", "return", "true", ";", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "Name", "==", "\"st\"", "&&", "Operands", ".", "size", "(", ")", "==", "2", ")", "{", "Operands", ".", "erase", "(", "Operands", ".", "begin", "(", ")", ",", "Operands", ".", "begin", "(", ")", "+", "1", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", ",", "LanaiOperand", "::", "CreateToken", "(", "\"s\"", ",", "NameLoc", ")", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", "+", "1", ",", "LanaiOperand", "::", "createImm", "(", "MCConstantExpr", "::", "create", "(", "LPCC", "::", "ICC_T", ",", "getContext", "(", ")", ")", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "}", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "Name", ".", "startswith", "(", "\"bt\"", ")", "&&", "Operands", ".", "size", "(", ")", "==", "3", ")", "{", "Operands", ".", "erase", "(", "Operands", ".", "begin", "(", ")", ",", "Operands", ".", "begin", "(", ")", "+", "2", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", ",", "LanaiOperand", "::", "CreateToken", "(", "\"bt\"", ",", "NameLoc", ")", ")", ";", "}", "while", "(", "Lexer", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "Lexer", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Lexer", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "&", "Operands", ",", "Mnemonic", ")", "!=", "MatchOperand_Success", ")", "return", "true", ";", "}", "if", "(", "IsMemoryAssignmentError", "(", "Operands", ")", ")", "{", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "\"the destination register can't equal the base register in an \"", "\"instruction that modifies the base register.\"", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "Lanai", "Lanai", "\"st\"", "2", "1", "LanaiOperand::CreateToken", "\"s\"", "1", "LanaiOperand::createImm", "\"bt\"", "3", "2", "LanaiOperand::CreateToken", "\"bt\"", "\"the destination register can't equal the base register in an \"", "\"instruction that modifies the base register.\"" ]

[]

[ "<s>", "bool", "R600ClauseMergePass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "BB_E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "BB_E", ";", "++", "BB", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BB", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "LatestCFAlu", "=", "E", ";", "while", "(", "I", "!=", "E", ")", "{", "MachineInstr", "*", "MI", "=", "I", "++", ";", "if", "(", "(", "!", "TII", "->", "canBeConsideredALU", "(", "MI", ")", "&&", "!", "isCFAlu", "(", "MI", ")", ")", "||", "TII", "->", "mustBeLastInClause", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "LatestCFAlu", "=", "E", ";", "if", "(", "!", "isCFAlu", "(", "MI", ")", ")", "continue", ";", "cleanPotentialDisabledCFAlu", "(", "MI", ")", ";", "if", "(", "LatestCFAlu", "!=", "E", "&&", "mergeIfPossible", "(", "LatestCFAlu", ",", "MI", ")", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "assert", "(", "MI", "->", "getOperand", "(", "8", ")", ".", "getImm", "(", ")", "&&", "\"CF ALU instruction disabled\"", ")", ";", "LatestCFAlu", "=", "MI", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "8", "\"CF ALU instruction disabled\"" ]

[]

[ "<s>", "void", "machopic_output_stub", "(", "FILE", "*", "file", ",", "const", "char", "*", "symb", ",", "const", "char", "*", "stub", ")", "{", "unsigned", "int", "length", ";", "char", "*", "binder_name", ",", "*", "symbol_name", ",", "lazy_ptr_name", "[", "32", "]", ";", "int", "label", "=", "++", "current_machopic_label_num", ";", "symb", "=", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "symb", ")", ";", "length", "=", "strlen", "(", "stub", ")", ";", "binder_name", "=", "alloca", "(", "length", "+", "32", ")", ";", "GEN_BINDER_NAME_FOR_STUB", "(", "binder_name", ",", "stub", ",", "length", ")", ";", "length", "=", "strlen", "(", "symb", ")", ";", "symbol_name", "=", "alloca", "(", "length", "+", "32", ")", ";", "GEN_SYMBOL_NAME_FOR_SYMBOL", "(", "symbol_name", ",", "symb", ",", "length", ")", ";", "sprintf", "(", "lazy_ptr_name", ",", "\"L%d$lz\"", ",", "label", ")", ";", "if", "(", "MACHOPIC_PURE", ")", "machopic_picsymbol_stub_section", "(", ")", ";", "else", "machopic_symbol_stub_section", "(", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\"", ",", "stub", ")", ";", "fprintf", "(", "file", ",", "\"\\t.indirect_symbol %s\\n\"", ",", "symbol_name", ")", ";", "if", "(", "MACHOPIC_PURE", ")", "{", "fprintf", "(", "file", ",", "\"\\tcall LPC$%d\\nLPC$%d:\\tpopl %%eax\\n\"", ",", "label", ",", "label", ")", ";", "fprintf", "(", "file", ",", "\"\\tmovl %s-LPC$%d(%%eax),%%edx\\n\"", ",", "lazy_ptr_name", ",", "label", ")", ";", "fprintf", "(", "file", ",", "\"\\tjmp %%edx\\n\"", ")", ";", "}", "else", "fprintf", "(", "file", ",", "\"\\tjmp *%s\\n\"", ",", "lazy_ptr_name", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\"", ",", "binder_name", ")", ";", "if", "(", "MACHOPIC_PURE", ")", "{", "fprintf", "(", "file", ",", "\"\\tlea %s-LPC$%d(%%eax),%%eax\\n\"", ",", "lazy_ptr_name", ",", "label", ")", ";", "fprintf", "(", "file", ",", "\"\\tpushl %%eax\\n\"", ")", ";", "}", "else", "fprintf", "(", "file", ",", "\"\\t pushl $%s\\n\"", ",", "lazy_ptr_name", ")", ";", "fprintf", "(", "file", ",", "\"\\tjmp dyld_stub_binding_helper\\n\"", ")", ";", "machopic_lazy_symbol_ptr_section", "(", ")", ";", "fprintf", "(", "file", ",", "\"%s:\\n\"", ",", "lazy_ptr_name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.indirect_symbol %s\\n\"", ",", "symbol_name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.long %s\\n\"", ",", "binder_name", ")", ";", "}", "</s>" ]

[ "Generate", "external", "symbol", "indirection", "stubs", "(", "PIC", "and", "non-PIC", ")", "." ]

[ "i386", "32", "32", "32", "\"L%d$lz\"", "\"%s:\\n\"", "\"\\t.indirect_symbol %s\\n\"", "\"\\tcall LPC$%d\\nLPC$%d:\\tpopl %%eax\\n\"", "\"\\tmovl %s-LPC$%d(%%eax),%%edx\\n\"", "\"\\tjmp %%edx\\n\"", "\"\\tjmp *%s\\n\"", "\"%s:\\n\"", "\"\\tlea %s-LPC$%d(%%eax),%%eax\\n\"", "\"\\tpushl %%eax\\n\"", "\"\\t pushl $%s\\n\"", "\"\\tjmp dyld_stub_binding_helper\\n\"", "\"%s:\\n\"", "\"\\t.indirect_symbol %s\\n\"", "\"\\t.long %s\\n\"" ]

[]

[ "<s>", "static", "void", "print_addrstyle_operand", "(", "FILE", "*", "file", ",", "rtx", "op", ")", "{", "HOST_WIDE_INT", "offset", ";", "rtx", "base", ";", "if", "(", "!", "s390_decompose_addrstyle_without_index", "(", "op", ",", "&", "base", ",", "&", "offset", ")", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "base", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "base", ")", "==", "REG", ")", ";", "gcc_assert", "(", "REGNO", "(", "base", ")", "<", "FIRST_PSEUDO_REGISTER", ")", ";", "gcc_assert", "(", "REGNO_REG_CLASS", "(", "REGNO", "(", "base", ")", ")", "==", "ADDR_REGS", ")", ";", "}", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "offset", "&", "(", "(", "1", "<<", "12", ")", "-", "1", ")", ")", ";", "if", "(", "base", ")", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "base", ")", "]", ")", ";", "}", "</s>" ]

[ "Output", "operand", "OP", "to", "stdio", "stream", "FILE", ".", "OP", "is", "an", "address", "(", "register", "+", "offset", ")", "which", "is", "not", "used", "to", "address", "data", ";", "instead", "the", "rightmost", "bits", "are", "interpreted", "as", "the", "value", "." ]

[ "s390", "1", "12", "1", "\"(%s)\"" ]

[]

[ "<s>", "static", "int", "advance_line", "(", "FILE", "*", "file", ")", "{", "while", "(", "1", ")", "{", "if", "(", "!", "fgets", "(", "linebuf", ",", "sizeof", "linebuf", ",", "file", ")", ")", "return", "0", ";", "line", "++", ";", "size_t", "len", "=", "strlen", "(", "linebuf", ")", ";", "lastline", "=", "0", ";", "if", "(", "len", ">", "1", ")", "{", "strcpy", "(", "lines", "[", "0", "]", ",", "linebuf", ")", ";", "while", "(", "linebuf", "[", "len", "-", "2", "]", "==", "'\\\\'", "&&", "linebuf", "[", "len", "-", "1", "]", "==", "'\\n'", ")", "{", "lastline", "++", ";", "if", "(", "lastline", "==", "MAXLINES", ")", "fatal", "(", "\"number of supported overflow lines exceeded\"", ")", ";", "line", "++", ";", "if", "(", "!", "fgets", "(", "lines", "[", "lastline", "]", ",", "LINELEN", ",", "file", ")", ")", "fatal", "(", "\"unexpected end of file\"", ")", ";", "strcpy", "(", "&", "linebuf", "[", "len", "-", "2", "]", ",", "lines", "[", "lastline", "]", ")", ";", "len", "+=", "strlen", "(", "lines", "[", "lastline", "]", ")", "-", "2", ";", "}", "}", "if", "(", "linebuf", "[", "len", "-", "1", "]", "!=", "'\\n'", ")", "fatal", "(", "\"line doesn't terminate with newline\"", ")", ";", "pos", "=", "0", ";", "consume_whitespace", "(", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "!=", "'\\n'", "&&", "linebuf", "[", "pos", "]", "!=", "';'", ")", "return", "1", ";", "}", "}", "</s>" ]

[ "Get", "the", "next", "nonblank", ",", "noncomment", "line", ",", "returning", "0", "on", "EOF", ",", "1", "otherwise", "." ]

[ "rs6000", "1", "0", "0", "1", "0", "2", "1", "\"number of supported overflow lines exceeded\"", "\"unexpected end of file\"", "2", "2", "1", "\"line doesn't terminate with newline\"", "0", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SystemZTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'d'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GR64BitRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "i128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GR128BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GR32BitRegClass", ")", ";", "case", "'a'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "ADDR64BitRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "i128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "ADDR128BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "ADDR32BitRegClass", ")", ";", "case", "'h'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "GRH32BitRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "FP64BitRegClass", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "FP128BitRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "SystemZ", "::", "FP32BitRegClass", ")", ";", "}", "}", "if", "(", "Constraint", ".", "size", "(", ")", ">", "0", "&&", "Constraint", "[", "0", "]", "==", "'{'", ")", "{", "if", "(", "Constraint", "[", "1", "]", "==", "'r'", ")", "{", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "GR32BitRegClass", ",", "SystemZMC", "::", "GR32Regs", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i128", ")", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "GR128BitRegClass", ",", "SystemZMC", "::", "GR128Regs", ")", ";", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "GR64BitRegClass", ",", "SystemZMC", "::", "GR64Regs", ")", ";", "}", "if", "(", "Constraint", "[", "1", "]", "==", "'f'", ")", "{", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "FP32BitRegClass", ",", "SystemZMC", "::", "FP32Regs", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f128", ")", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "FP128BitRegClass", ",", "SystemZMC", "::", "FP128Regs", ")", ";", "return", "parseRegisterNumber", "(", "Constraint", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "SystemZMC", "::", "FP64Regs", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "1", "0", "MVT::i64", "0U", "SystemZ::GR64BitRegClass", "MVT::i128", "0U", "SystemZ::GR128BitRegClass", "0U", "SystemZ::GR32BitRegClass", "MVT::i64", "0U", "SystemZ::ADDR64BitRegClass", "MVT::i128", "0U", "SystemZ::ADDR128BitRegClass", "0U", "SystemZ::ADDR32BitRegClass", "0U", "SystemZ::GRH32BitRegClass", "MVT::f64", "0U", "SystemZ::FP64BitRegClass", "MVT::f128", "0U", "SystemZ::FP128BitRegClass", "0U", "SystemZ::FP32BitRegClass", "0", "0", "1", "MVT::i32", "SystemZ::GR32BitRegClass", "SystemZMC::GR32Regs", "MVT::i128", "SystemZ::GR128BitRegClass", "SystemZMC::GR128Regs", "SystemZ::GR64BitRegClass", "SystemZMC::GR64Regs", "1", "MVT::f32", "SystemZ::FP32BitRegClass", "SystemZMC::FP32Regs", "MVT::f128", "SystemZ::FP128BitRegClass", "SystemZMC::FP128Regs", "SystemZ::FP64BitRegClass", "SystemZMC::FP64Regs" ]

[]

[ "<s>", "unsigned", "MipsTargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ",", "EVT", "&", "IntermediateVT", ",", "unsigned", "&", "NumIntermediates", ",", "MVT", "&", "RegisterVT", ")", "const", "{", "RegisterVT", "=", "getRegisterTypeForCallingConv", "(", "Context", ",", "VT", ")", ";", "IntermediateVT", "=", "RegisterVT", ";", "NumIntermediates", "=", "VT", ".", "getSizeInBits", "(", ")", "<", "RegisterVT", ".", "getSizeInBits", "(", ")", "?", "VT", ".", "getVectorNumElements", "(", ")", ":", "VT", ".", "getSizeInBits", "(", ")", "/", "RegisterVT", ".", "getSizeInBits", "(", ")", ";", "return", "NumIntermediates", ";", "}", "</s>" ]

[ "Certain", "targets", "such", "as", "MIPS", "require", "that", "some", "types", "such", "as", "vectors", "are", "always", "broken", "down", "into", "scalars", "in", "some", "contexts", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "aarch64_init_bf16_types", "(", "void", ")", "{", "lang_hooks", ".", "types", ".", "register_builtin_type", "(", "bfloat16_type_node", ",", "\"__bf16\"", ")", ";", "aarch64_bf16_ptr_type_node", "=", "build_pointer_type", "(", "bfloat16_type_node", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "backend", "REAL_TYPE", "type", "supporting", "bfloat", "types", "." ]

[ "aarch64", "\"__bf16\"" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "bool", "IsLegal", "=", "false", ";", "const", "APInt", "ImmInt", "=", "Imm", ".", "bitcastToAPInt", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "IsLegal", "=", "AArch64_AM", "::", "getFP64Imm", "(", "ImmInt", ")", "!=", "-", "1", "||", "Imm", ".", "isPosZero", "(", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "IsLegal", "=", "AArch64_AM", "::", "getFP32Imm", "(", "ImmInt", ")", "!=", "-", "1", "||", "Imm", ".", "isPosZero", "(", ")", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f16", "&&", "Subtarget", "->", "hasFullFP16", "(", ")", ")", "IsLegal", "=", "AArch64_AM", "::", "getFP16Imm", "(", "ImmInt", ")", "!=", "-", "1", "||", "Imm", ".", "isPosZero", "(", ")", ";", "if", "(", "!", "IsLegal", "&&", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "f32", ")", ")", "IsLegal", "=", "AArch64_AM", "::", "isAnyMOVWMovAlias", "(", "ImmInt", ".", "getZExtValue", "(", ")", ",", "VT", ".", "getSizeInBits", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "(", "IsLegal", "?", "\"Legal \"", ":", "\"Illegal \"", ")", "<<", "VT", ".", "getEVTString", "(", ")", "<<", "\" imm value: \"", ";", "Imm", ".", "dump", "(", ")", ";", ")", ";", "return", "IsLegal", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "AArch64", "AArch64", "MVT::f64", "AArch64_AM::getFP64Imm", "1", "MVT::f32", "AArch64_AM::getFP32Imm", "1", "MVT::f16", "AArch64_AM::getFP16Imm", "1", "MVT::f64", "MVT::f32", "AArch64_AM::isAnyMOVWMovAlias", "\"Legal \"", "\"Illegal \"", "\" imm value: \"" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "int", "mips_adjust_insn_length", "(", "rtx", "insn", ",", "int", "length", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", "||", "(", "TARGET_MIPS16", "?", "simplejump_p", "(", "insn", ")", ":", "JUMP_P", "(", "insn", ")", ")", ")", "length", "+=", "4", ";", "if", "(", "!", "cfun", "->", "machine", "->", "ignore_hazard_length_p", "&&", "INSN_CODE", "(", "insn", ")", ">=", "0", ")", "switch", "(", "get_attr_hazard", "(", "insn", ")", ")", "{", "case", "HAZARD_NONE", ":", "break", ";", "case", "HAZARD_DELAY", ":", "length", "+=", "4", ";", "break", ";", "case", "HAZARD_HILO", ":", "length", "+=", "8", ";", "break", ";", "}", "if", "(", "TARGET_MIPS16", ")", "length", "/=", "2", ";", "return", "length", ";", "}", "</s>" ]

[ "Return", "the", "length", "of", "INSN", ".", "LENGTH", "is", "the", "initial", "length", "computed", "by", "attributes", "in", "the", "machine-description", "file", "." ]

[ "mips", "4", "0", "4", "8", "2" ]

[]

[ "<s>", "bool", "NVPTXPrologEpilogPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getFrameLowering", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "calculateFrameObjectOffsets", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "BB", "->", "begin", "(", ")", ";", "I", "!=", "BB", "->", "end", "(", ")", ";", "++", "I", ")", "{", "MachineInstr", "*", "MI", "=", "I", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "continue", ";", "TRI", ".", "eliminateFrameIndex", "(", "MI", ",", "0", ",", "i", ",", "nullptr", ")", ";", "Modified", "=", "true", ";", "}", "}", "}", "TFI", ".", "emitPrologue", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "empty", "(", ")", "&&", "I", "->", "back", "(", ")", ".", "isReturn", "(", ")", ")", "TFI", ".", "emitEpilogue", "(", "MF", ",", "*", "I", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "0" ]

[]

[ "<s>", "void", "SIMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "verifyInstructionPredicates", "(", "MI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "uint64_t", "Encoding", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "bytes", "=", "Desc", ".", "getSize", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "bytes", ";", "i", "++", ")", "{", "OS", ".", "write", "(", "(", "uint8_t", ")", "(", "(", "Encoding", ">>", "(", "8", "*", "i", ")", ")", "&", "0xff", ")", ")", ";", "}", "if", "(", "bytes", ">", "4", ")", "return", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Desc", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "if", "(", "!", "AMDGPU", "::", "isSISrcOperand", "(", "Desc", ",", "i", ")", ")", "continue", ";", "const", "MCOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "getLitEncoding", "(", "Op", ",", "Desc", ".", "OpInfo", "[", "i", "]", ",", "STI", ")", "!=", "255", ")", "continue", ";", "int64_t", "Imm", "=", "0", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "Imm", "=", "Op", ".", "getImm", "(", ")", ";", "else", "if", "(", "Op", ".", "isExpr", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "C", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ")", "Imm", "=", "C", "->", "getValue", "(", ")", ";", "}", "else", "if", "(", "!", "Op", ".", "isExpr", "(", ")", ")", "llvm_unreachable", "(", "\"Must be immediate or expr\"", ")", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "4", ";", "j", "++", ")", "{", "OS", ".", "write", "(", "(", "uint8_t", ")", "(", "(", "Imm", ">>", "(", "8", "*", "j", ")", ")", "&", "0xff", ")", ")", ";", "}", "break", ";", "}", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "AMDGPU", "SI", "0", "8", "0xff", "4", "0", "AMDGPU::isSISrcOperand", "255", "0", "\"Must be immediate or expr\"", "0", "4", "8", "0xff" ]

[]

[ "<s>", "bool", "canMergeStoresTo", "(", "unsigned", "AddressSpace", ",", "EVT", "MemVT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "bool", "NoFloat", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "NoFloat", ")", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "64", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "if", "it", "'s", "reasonable", "to", "merge", "stores", "to", "MemVT", "size", "." ]

[ "AArch64", "64" ]

[]

[ "<s>", "void", "xtensa_emit_loop_end", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ")", "{", "char", "done", "=", "0", ";", "for", "(", "insn", "=", "PREV_INSN", "(", "insn", ")", ";", "insn", "&&", "!", "done", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "{", "switch", "(", "GET_CODE", "(", "insn", ")", ")", "{", "case", "NOTE", ":", "case", "BARRIER", ":", "break", ";", "case", "CODE_LABEL", ":", "output_asm_insn", "(", "TARGET_DENSITY", "?", "\"nop.n\"", ":", "\"nop\"", ",", "operands", ")", ";", "done", "=", "1", ";", "break", ";", "default", ":", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "JUMP_P", "(", "body", ")", ")", "{", "output_asm_insn", "(", "TARGET_DENSITY", "?", "\"nop.n\"", ":", "\"nop\"", ",", "operands", ")", ";", "done", "=", "1", ";", "}", "else", "if", "(", "(", "GET_CODE", "(", "body", ")", "!=", "USE", ")", "&&", "(", "GET_CODE", "(", "body", ")", "!=", "CLOBBER", ")", ")", "done", "=", "1", ";", "}", "break", ";", "}", "}", "output_asm_insn", "(", "\"%1_LEND:\"", ",", "operands", ")", ";", "}", "</s>" ]

[ "Emit", "the", "assembly", "for", "the", "end", "of", "a", "zero-cost", "loop", ".", "Normally", "we", "just", "emit", "a", "comment", "showing", "where", "the", "end", "of", "the", "loop", "is", ".", "However", ",", "if", "there", "is", "a", "label", "or", "a", "branch", "at", "the", "end", "of", "the", "loop", "then", "we", "need", "to", "place", "a", "nop", "there", ".", "If", "the", "loop", "ends", "with", "a", "label", "we", "need", "the", "nop", "so", "that", "branches", "targetting", "that", "label", "will", "target", "the", "nop", "(", "and", "thus", "remain", "in", "the", "loop", ")", ",", "instead", "of", "targetting", "the", "instruction", "after", "the", "loop", "(", "and", "thus", "exiting", "the", "loop", ")", ".", "If", "the", "loop", "ends", "with", "a", "branch", ",", "we", "need", "the", "nop", "in", "case", "the", "branch", "is", "targetting", "a", "location", "inside", "the", "loop", ".", "When", "the", "branch", "executes", "it", "will", "cause", "the", "loop", "count", "to", "be", "decremented", "even", "if", "it", "is", "taken", "(", "because", "it", "is", "the", "last", "instruction", "in", "the", "loop", ")", ",", "so", "we", "need", "to", "nop", "after", "the", "branch", "to", "prevent", "the", "loop", "count", "from", "being", "decremented", "when", "the", "branch", "is", "taken", "." ]

[ "xtensa", "0", "\"nop.n\"", "\"nop\"", "1", "\"nop.n\"", "\"nop\"", "1", "1", "\"%1_LEND:\"" ]

[]

[ "<s>", "void", "ARMOperand", "::", "dump", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "CondCode", ":", "OS", "<<", "ARMCondCodeToString", "(", "getCondCode", "(", ")", ")", ";", "break", ";", "case", "Immediate", ":", "getImm", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "case", "Memory", ":", "OS", "<<", "\"<memory>\"", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "}", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "ARM", "ARM", "ARM", "\"<memory>\"", "\"<register \"", "\">\"", "\"'\"", "\"'\"" ]

[]

[ "<s>", "static", "bool", "get_memref_parts", "(", "rtx", "mem", ",", "rtx", "*", "base", ",", "HOST_WIDE_INT", "*", "offset", ",", "HOST_WIDE_INT", "*", "size", ")", "{", "rtx", "addr_rtx", ";", "if", "MEM_SIZE_KNOWN_P", "(", "mem", ")", "*", "size", "=", "MEM_SIZE", "(", "mem", ")", ";", "else", "return", "false", ";", "addr_rtx", "=", "(", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "if", "(", "GET_CODE", "(", "addr_rtx", ")", "==", "PRE_MODIFY", ")", "addr_rtx", "=", "XEXP", "(", "addr_rtx", ",", "1", ")", ";", "*", "offset", "=", "0", ";", "while", "(", "GET_CODE", "(", "addr_rtx", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr_rtx", ",", "1", ")", ")", ")", "{", "*", "offset", "+=", "INTVAL", "(", "XEXP", "(", "addr_rtx", ",", "1", ")", ")", ";", "addr_rtx", "=", "XEXP", "(", "addr_rtx", ",", "0", ")", ";", "}", "if", "(", "!", "REG_P", "(", "addr_rtx", ")", ")", "return", "false", ";", "*", "base", "=", "addr_rtx", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "determine", "base/offset/size", "parts", "of", "the", "given", "MEM", ".", "Return", "true", "if", "successful", ",", "false", "if", "all", "the", "values", "could", "n't", "be", "determined", ".", "This", "function", "only", "looks", "for", "REG", "or", "REG+CONST", "address", "forms", ".", "REG+REG", "address", "form", "will", "return", "false", "." ]

[ "rs6000", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "unsigned", "AVRAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "ExpectedKind", ")", "{", "AVROperand", "&", "Op", "=", "static_cast", "<", "AVROperand", "&", ">", "(", "AsmOp", ")", ";", "MatchClassKind", "Expected", "=", "static_cast", "<", "MatchClassKind", ">", "(", "ExpectedKind", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "if", "(", "MCConstantExpr", "const", "*", "Const", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "{", "int64_t", "RegNum", "=", "Const", "->", "getValue", "(", ")", ";", "if", "(", "0", "<=", "RegNum", "&&", "RegNum", "<=", "15", "&&", "STI", ".", "hasFeature", "(", "AVR", "::", "FeatureTinyEncoding", ")", ")", "return", "Match_InvalidRegisterOnTiny", ";", "std", "::", "ostringstream", "RegName", ";", "RegName", "<<", "\"r\"", "<<", "RegNum", ";", "RegNum", "=", "MatchRegisterName", "(", "RegName", ".", "str", "(", ")", ")", ";", "if", "(", "RegNum", "!=", "AVR", "::", "NoRegister", ")", "{", "Op", ".", "makeReg", "(", "RegNum", ")", ";", "if", "(", "validateOperandClass", "(", "Op", ",", "Expected", ")", "==", "Match_Success", ")", "{", "return", "Match_Success", ";", "}", "}", "}", "}", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "if", "(", "isSubclass", "(", "Expected", ",", "MCK_DREGS", ")", ")", "{", "unsigned", "correspondingDREG", "=", "toDREG", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "correspondingDREG", "!=", "AVR", "::", "NoRegister", ")", "{", "Op", ".", "makeReg", "(", "correspondingDREG", ")", ";", "return", "validateOperandClass", "(", "Op", ",", "Expected", ")", ";", "}", "}", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "AVR", "AVR", "AVR", "AVR", "0", "15", "AVR::FeatureTinyEncoding", "\"r\"", "AVR::NoRegister", "AVR::NoRegister" ]

[]

[ "<s>", "bool", "ARMInstrInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", "||", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "bool", "isVarArg", "=", "AFI", "->", "getVarArgsRegSaveSize", "(", ")", ">", "0", ";", "MachineInstr", "*", "PopMI", "=", "MF", ".", "CreateMachineInstr", "(", "get", "(", "ARM", "::", "tPOP", ")", ",", "MI", "->", "getDebugLoc", "(", ")", ")", ";", "MBB", ".", "insert", "(", "MI", ",", "PopMI", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "if", "(", "isVarArg", ")", "continue", ";", "Reg", "=", "ARM", "::", "PC", ";", "PopMI", "->", "setDesc", "(", "get", "(", "ARM", "::", "tPOP_RET", ")", ")", ";", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "PopMI", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "Reg", ",", "true", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "0", "ARM::tPOP", "0", "1", "ARM::LR", "ARM::PC", "ARM::tPOP_RET" ]

[]

[ "<s>", "static", "rtx", "get_branch_target", "(", "rtx", "branch", ")", "{", "if", "(", "CALL_P", "(", "branch", ")", ")", "{", "rtx", "call", ";", "call", "=", "XVECEXP", "(", "PATTERN", "(", "branch", ")", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "call", ")", "==", "SET", ")", "call", "=", "SET_SRC", "(", "call", ")", ";", "if", "(", "GET_CODE", "(", "call", ")", "!=", "CALL", ")", "abort", "(", ")", ";", "return", "XEXP", "(", "XEXP", "(", "call", ",", "0", ")", ",", "0", ")", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Returns", "0", "if", "we", "do", "n't", "want", "a", "hint", "for", "this", "branch", ".", "Otherwise", "return", "the", "rtx", "for", "the", "branch", "target", "." ]

[ "microblaze", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AtomicCmpXchgInst", "*", "AI", ")", "const", "{", "const", "DataLayout", "&", "DL", "=", "AI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "Size", "=", "DL", ".", "getTypeStoreSize", "(", "AI", "->", "getCompareOperand", "(", ")", "->", "getType", "(", ")", ")", ";", "return", "Size", ">=", "4", "&&", "Size", "<=", "8", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "atomic", "cmpxchg", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

[ "Hexagon", "Hexagon", "4", "8" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "performVECTOR_SHUFFLECombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "performVectorExtendCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "performVectorConvertLowCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "performVectorTruncSatLowCombine", "(", "N", ",", "DCI", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "WebAssembly", "WebAssembly", "ISD::VECTOR_SHUFFLE", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::EXTRACT_SUBVECTOR", "ISD::CONCAT_VECTORS" ]

[]

[ "<s>", "void", "P2InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i32", ")", ")", "{", "Opcode", "=", "P2", "::", "RDLONGri", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot load this register from a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\">> load reg \"", "<<", "DestReg", "<<", "\" from stack \"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "P2", "P2", "0", "MVT::i32", "P2::RDLONGri", "\"Cannot load this register from a stack slot!\"", "\">> load reg \"", "\" from stack \"", "\"\\n\"" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "const", "HexagonRegisterInfo", "*", "QRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "determineFrameLayout", "(", "MF", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "InsertPt", "=", "MBB", ".", "begin", "(", ")", ";", "HexagonMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", ";", "const", "std", "::", "vector", "<", "MachineInstr", "*", ">", "&", "AdjustRegs", "=", "FuncInfo", "->", "getAllocaAdjustInsts", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "MachineInstr", "*", ">", "::", "const_iterator", "i", "=", "AdjustRegs", ".", "begin", "(", ")", ",", "e", "=", "AdjustRegs", ".", "end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineInstr", "*", "MI", "=", "*", "i", ";", "assert", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "ADJDYNALLOC", ")", "&&", "\"Expected adjust alloca node\"", ")", ";", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "2", ")", ";", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"Expected immediate\"", ")", ";", "MO", ".", "setImm", "(", "MFI", "->", "getMaxCallFrameSize", "(", ")", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "const", "int", "ALLOCFRAME_MAX", "=", "16384", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "NumBytes", ">=", "ALLOCFRAME_MAX", ")", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "S2_allocframe", ")", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "CONST32_Int_Real", ")", ",", "HEXAGON_RESERVED_REG_1", ")", ".", "addImm", "(", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "A2_sub", ")", ",", "QRI", "->", "getStackRegister", "(", ")", ")", ".", "addReg", "(", "QRI", "->", "getStackRegister", "(", ")", ")", ".", "addReg", "(", "HEXAGON_RESERVED_REG_1", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "S2_allocframe", ")", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon::ADJDYNALLOC", "\"Expected adjust alloca node\"", "2", "\"Expected immediate\"", "16384", "Hexagon::S2_allocframe", "0", "Hexagon::CONST32_Int_Real", "Hexagon::A2_sub", "Hexagon::S2_allocframe" ]

[]

[ "<s>", "unsigned", "HexagonMCInstrInfo", "::", "getUnits", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCSubtargetInfo", "const", "&", "STI", ",", "MCInst", "const", "&", "MCI", ")", "{", "const", "InstrItinerary", "*", "II", "=", "STI", ".", "getSchedModel", "(", ")", ".", "InstrItineraries", ";", "int", "SchedClass", "=", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "MCI", ")", ".", "getSchedClass", "(", ")", ";", "return", "(", "(", "II", "[", "SchedClass", "]", ".", "FirstStage", "+", "HexagonStages", ")", "->", "getUnits", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "choice", "of", "FUs", "." ]

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

[]

[ "<s>", "static", "int", "mn10300_address_cost", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", ")", "{", "HOST_WIDE_INT", "i", ";", "rtx", "base", ",", "index", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "speed", "?", "1", ":", "4", ";", "case", "REG", ":", "case", "SUBREG", ":", "case", "POST_INC", ":", "return", "0", ";", "case", "POST_MODIFY", ":", "i", "=", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "?", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ":", "0x12345678", ")", ";", "if", "(", "IN_RANGE", "(", "i", ",", "-", "128", ",", "127", ")", ")", "return", "speed", "?", "0", ":", "1", ";", "if", "(", "speed", ")", "return", "1", ";", "if", "(", "IN_RANGE", "(", "i", ",", "-", "0x800000", ",", "0x7fffff", ")", ")", "return", "3", ";", "return", "4", ";", "case", "PLUS", ":", "base", "=", "XEXP", "(", "x", ",", "0", ")", ";", "index", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "register_operand", "(", "index", ",", "SImode", ")", ")", "{", "if", "(", "register_operand", "(", "base", ",", "SImode", ")", ")", "return", "1", ";", "base", "=", "XEXP", "(", "x", ",", "1", ")", ";", "index", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "i", "=", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "?", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ":", "0x12345678", ")", ";", "if", "(", "IN_RANGE", "(", "i", ",", "-", "128", ",", "127", ")", ")", "return", "speed", "?", "0", ":", "1", ";", "if", "(", "IN_RANGE", "(", "i", ",", "-", "32768", ",", "32767", ")", ")", "return", "speed", "?", "0", ":", "2", ";", "return", "speed", "?", "2", ":", "6", ";", "default", ":", "return", "rtx_cost", "(", "x", ",", "MEM", ",", "0", ",", "speed", ")", ";", "}", "}", "</s>" ]

[ "For", "addresses", ",", "costs", "are", "relative", "to", "``", "MOV", "(", "Rm", ")", ",", "Rn", "''", ".", "For", "AM33", "this", "is", "the", "3-byte", "fully", "general", "instruction", ";", "for", "MN103", "this", "is", "the", "2-byte", "form", "with", "an", "address", "register", "." ]

[ "mn10300", "1", "4", "0", "1", "1", "0x12345678", "128", "127", "0", "1", "1", "0x800000", "0x7fffff", "3", "4", "0", "1", "1", "1", "0", "1", "1", "0x12345678", "128", "127", "0", "1", "32768", "32767", "0", "2", "2", "6", "0" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "LEG" ]

[]

[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "DL", "(", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"", ")", ",", "InstrInfo", "(", ")", ",", "FrameLowering", "(", "Subtarget", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", ",", "STTI", "(", "&", "TLInfo", ")", ",", "VTTI", "(", "&", "TLInfo", ")", "{", "}", "</s>" ]

[ "Create", "an", "ILP32", "architecture", "model", "." ]

[ "XCore", "XCore", "XCore", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "SITargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "RMW", ")", "const", "{", "switch", "(", "RMW", "->", "getOperation", "(", ")", ")", "{", "case", "AtomicRMWInst", "::", "FAdd", ":", "{", "Type", "*", "Ty", "=", "RMW", "->", "getType", "(", ")", ";", "if", "(", "Ty", "->", "isHalfTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "!", "Ty", "->", "isFloatTy", "(", ")", "&&", "(", "!", "Subtarget", "->", "hasGFX90AInsts", "(", ")", "||", "!", "Ty", "->", "isDoubleTy", "(", ")", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "unsigned", "AS", "=", "RMW", "->", "getPointerAddressSpace", "(", ")", ";", "if", "(", "(", "AS", "==", "AMDGPUAS", "::", "GLOBAL_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "&&", "Subtarget", "->", "hasAtomicFaddInsts", "(", ")", ")", "{", "if", "(", "RMW", "->", "getFunction", "(", ")", "->", "getFnAttribute", "(", "\"amdgpu-unsafe-fp-atomics\"", ")", ".", "getValueAsString", "(", ")", "!=", "\"true\"", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "if", "(", "Subtarget", "->", "hasGFX90AInsts", "(", ")", ")", "{", "if", "(", "Ty", "->", "isFloatTy", "(", ")", "&&", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "auto", "SSID", "=", "RMW", "->", "getSyncScopeID", "(", ")", ";", "if", "(", "SSID", "==", "SyncScope", "::", "System", "||", "SSID", "==", "RMW", "->", "getContext", "(", ")", ".", "getOrInsertSyncScopeID", "(", "\"one-as\"", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "return", "AtomicExpansionKind", "::", "None", ";", "}", "if", "(", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "return", "RMW", "->", "use_empty", "(", ")", "?", "AtomicExpansionKind", "::", "None", ":", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "if", "(", "AS", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "&&", "Subtarget", "->", "hasLDSFPAtomics", "(", ")", ")", "{", "if", "(", "!", "Ty", "->", "isDoubleTy", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "(", "fpModeMatchesGlobalFPAtomicMode", "(", "RMW", ")", "||", "RMW", "->", "getFunction", "(", ")", "->", "getFnAttribute", "(", "\"amdgpu-unsafe-fp-atomics\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "?", "AtomicExpansionKind", "::", "None", ":", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "}", "default", ":", "break", ";", "}", "return", "AMDGPUTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "RMW", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "\"amdgpu-unsafe-fp-atomics\"", "\"true\"", "AMDGPU", "SI", "SI", "SI", "\"one-as\"", "AMDGPU", "AMDGPU", "\"amdgpu-unsafe-fp-atomics\"", "\"true\"", "AMDGPU" ]

[]

[ "<s>", "bool", "WebAssemblyFastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "}", "return", "selectOperator", "(", "I", ",", "I", "->", "getOpcode", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "const", "PPCSubtarget", "&", "ST", "=", "C", "->", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "usePPCPostRASchedStrategy", "(", ")", ")", "return", "createPPCPostMachineScheduler", "(", "C", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Similar", "to", "createMachineScheduler", "but", "used", "when", "postRA", "machine", "scheduling", "is", "enabled", "." ]

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Patmos Single-Path Prepare\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Single-Path Prepare\"" ]

[]

[ "<s>", "void", "AVRInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "RC", "->", "hasType", "(", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "AVR", "::", "LDDRdPtrQ", ";", "}", "else", "if", "(", "RC", "->", "hasType", "(", "MVT", "::", "i16", ")", ")", "{", "Opcode", "=", "AVR", "::", "LDDWRdYQ", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot load this register from a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "AVR", "AVR", "0", "MVT::i8", "AVR::LDDRdPtrQ", "MVT::i16", "AVR::LDDWRdYQ", "\"Cannot load this register from a stack slot!\"", "0" ]

[]

[ "<s>", "MCInst", "HexagonInstrInfo", "::", "getNop", "(", ")", "const", "{", "static", "const", "MCInst", "Nop", "=", "MCInstBuilder", "(", "Hexagon", "::", "A2_nop", ")", ";", "return", "MCInstBuilder", "(", "Hexagon", "::", "BUNDLE", ")", ".", "addImm", "(", "0", ")", ".", "addInst", "(", "&", "Nop", ")", ";", "}", "</s>" ]

[ "Return", "the", "noop", "instruction", "to", "use", "for", "a", "noop", "." ]

[ "Hexagon", "Hexagon", "Hexagon::A2_nop", "Hexagon::BUNDLE", "0" ]

[]

[ "<s>", "static", "unsigned", "ix86_loop_unroll_adjust", "(", "unsigned", "nunroll", ",", "class", "loop", "*", "loop", ")", "{", "basic_block", "*", "bbs", ";", "rtx_insn", "*", "insn", ";", "unsigned", "i", ";", "unsigned", "mem_count", "=", "0", ";", "if", "(", "ix86_unroll_only_small_loops", "&&", "!", "loop", "->", "unroll", ")", "{", "if", "(", "loop", "->", "ninsns", "<=", "ix86_cost", "->", "small_unroll_ninsns", ")", "return", "MIN", "(", "nunroll", ",", "ix86_cost", "->", "small_unroll_factor", ")", ";", "else", "return", "1", ";", "}", "if", "(", "!", "TARGET_ADJUST_UNROLL", ")", "return", "nunroll", ";", "subrtx_iterator", "::", "array_type", "array", ";", "bbs", "=", "get_loop_body", "(", "loop", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "loop", "->", "num_nodes", ";", "i", "++", ")", "FOR_BB_INSNS", "(", "bbs", "[", "i", "]", ",", "insn", ")", "if", "(", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "if", "(", "const_rtx", "x", "=", "*", "iter", ")", "if", "(", "MEM_P", "(", "x", ")", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "unsigned", "int", "n_words", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "n_words", ">", "4", ")", "mem_count", "+=", "2", ";", "else", "mem_count", "+=", "1", ";", "}", "free", "(", "bbs", ")", ";", "if", "(", "mem_count", "&&", "mem_count", "<=", "32", ")", "return", "MIN", "(", "nunroll", ",", "32", "/", "mem_count", ")", ";", "return", "nunroll", ";", "}", "</s>" ]

[ "This", "function", "adjusts", "the", "unroll", "factor", "based", "on", "the", "hardware", "capabilities", ".", "For", "ex", ",", "bdver3", "has", "a", "loop", "buffer", "which", "makes", "unrolling", "of", "smaller", "loops", "less", "important", ".", "This", "function", "decides", "the", "unroll", "factor", "using", "number", "of", "memory", "references", "(", "value", "32", "is", "used", ")", "as", "a", "heuristic", "." ]

[ "i386", "0", "1", "0", "4", "2", "1", "32", "32" ]

[]

[ "<s>", "void", "mprocFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "mproc", "mproc" ]

[]

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

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "R600RegisterInfo", "::", "getCFGStructurizerRegClass", "(", "MVT", "VT", ")", "const", "{", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "case", "MVT", "::", "i32", ":", "return", "&", "AMDGPU", "::", "R600_TReg32RegClass", ";", "}", "}", "</s>" ]

[ "get", "the", "register", "class", "of", "the", "specified", "type", "to", "use", "in", "the", "CFGStructurizer" ]

[ "R600", "MVT::i32" ]

[]

[ "<s>", "TargetTransformInfo", "::", "PopcntSupportKind", "FPGATTIImpl", "::", "getPopcntSupport", "(", "unsigned", "IntTyWidthInBit", ")", "{", "return", "TTI", "::", "PSK_FastHardware", ";", "}", "</s>" ]

[ "Return", "hardware", "support", "for", "population", "count", "." ]

[ "FPGA", "FPGA" ]

[]

[ "<s>", "void", "tilegx_init_expanders", "(", "void", ")", "{", "init_machine_status", "=", "tilegx_init_machine_status", ";", "if", "(", "cfun", "&&", "cfun", "->", "machine", "&&", "flag_pic", ")", "{", "static", "int", "label_num", "=", "0", ";", "char", "text_label_name", "[", "32", "]", ";", "struct", "machine_function", "*", "machine", "=", "cfun", "->", "machine", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "text_label_name", ",", "\"L_PICLNK\"", ",", "label_num", "++", ")", ";", "machine", "->", "text_label_symbol", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "text_label_name", ")", ")", ";", "machine", "->", "text_label_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "TILEGX_PIC_TEXT_LABEL_REGNUM", ")", ";", "machine", "->", "got_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_OFFSET_TABLE_REGNUM", ")", ";", "machine", "->", "calls_tls_get_addr", "=", "false", ";", "}", "}", "</s>" ]

[ "Do", "anything", "needed", "before", "RTL", "is", "emitted", "for", "each", "function", "." ]

[ "tilegx", "0", "32", "\"L_PICLNK\"" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "GV", ")", "{", "if", "(", "Optional", "<", "ConstantRange", ">", "CR", "=", "GV", "->", "getAbsoluteSymbolRange", "(", ")", ")", "{", "if", "(", "CR", "->", "getUnsignedMax", "(", ")", ".", "ult", "(", "128", ")", ")", "return", "X86II", "::", "MO_ABS8", ";", "else", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "}", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "classifyLocalReference", "(", "GV", ")", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "if", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "return", "X86II", "::", "MO_COFFSTUB", ";", "}", "if", "(", "is64Bit", "(", ")", ")", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "return", "isTargetELF", "(", ")", "?", "X86II", "::", "MO_GOT", ":", "X86II", "::", "MO_NO_FLAG", ";", "return", "X86II", "::", "MO_GOTPCREL", ";", "}", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY", ";", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "}", "return", "X86II", "::", "MO_GOT", ";", "}", "</s>" ]

[ "Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "128", "X86II::MO_ABS8", "X86II::MO_NO_FLAG", "X86II::MO_DLLIMPORT", "X86II::MO_COFFSTUB", "X86II::MO_GOT", "X86II::MO_NO_FLAG", "X86II::MO_GOTPCREL", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_GOT" ]

[]

[ "<s>", "void", "frv_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", ",", "tree", "fndecl", ",", "int", "incoming", ")", "{", "*", "cum", "=", "FIRST_ARG_REGNUM", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "{", "fprintf", "(", "stderr", ",", "\"\\ninit_cumulative_args:\"", ")", ";", "if", "(", "!", "fndecl", "&&", "fntype", ")", "fputs", "(", "\" indirect\"", ",", "stderr", ")", ";", "if", "(", "incoming", ")", "fputs", "(", "\" incoming\"", ",", "stderr", ")", ";", "if", "(", "fntype", ")", "{", "tree", "ret_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "fprintf", "(", "stderr", ",", "\" return=%s,\"", ",", "tree_code_name", "[", "(", "int", ")", "TREE_CODE", "(", "ret_type", ")", "]", ")", ";", "}", "if", "(", "libname", "&&", "GET_CODE", "(", "libname", ")", "==", "SYMBOL_REF", ")", "fprintf", "(", "stderr", ",", "\" libname=%s\"", ",", "XSTR", "(", "libname", ",", "0", ")", ")", ";", "if", "(", "cfun", "->", "returns_struct", ")", "fprintf", "(", "stderr", ",", "\" return-struct\"", ")", ";", "putc", "(", "'\\n'", ",", "stderr", ")", ";", "}", "}", "</s>" ]

[ "A", "C", "statement", "(", "sans", "semicolon", ")", "for", "initializing", "the", "variable", "CUM", "for", "the", "state", "at", "the", "beginning", "of", "the", "argument", "list", ".", "The", "variable", "has", "type", "`", "CUMULATIVE_ARGS", "'", ".", "The", "value", "of", "FNTYPE", "is", "the", "tree", "node", "for", "the", "data", "type", "of", "the", "function", "which", "will", "receive", "the", "args", ",", "or", "0", "if", "the", "args", "are", "to", "a", "compiler", "support", "library", "function", ".", "The", "value", "of", "INDIRECT", "is", "nonzero", "when", "processing", "an", "indirect", "call", ",", "for", "example", "a", "call", "through", "a", "function", "pointer", ".", "The", "value", "of", "INDIRECT", "is", "zero", "for", "a", "call", "to", "an", "explicitly", "named", "function", ",", "a", "library", "function", "call", ",", "or", "when", "`", "INIT_CUMULATIVE_ARGS", "'", "is", "used", "to", "find", "arguments", "for", "the", "function", "being", "compiled", ".", "When", "processing", "a", "call", "to", "a", "compiler", "support", "library", "function", ",", "LIBNAME", "identifies", "which", "one", ".", "It", "is", "a", "`", "symbol_ref", "'", "rtx", "which", "contains", "the", "name", "of", "the", "function", ",", "as", "a", "string", ".", "LIBNAME", "is", "0", "when", "an", "ordinary", "C", "function", "call", "is", "being", "processed", ".", "Thus", ",", "each", "time", "this", "macro", "is", "called", ",", "either", "LIBNAME", "or", "FNTYPE", "is", "nonzero", ",", "but", "never", "both", "of", "them", "at", "once", "." ]

[ "frv", "\"\\ninit_cumulative_args:\"", "\" indirect\"", "\" incoming\"", "\" return=%s,\"", "\" libname=%s\"", "0", "\" return-struct\"" ]

[]

[ "<s>", "static", "const", "char", "*", "fp_const_from_val", "(", "REAL_VALUE_TYPE", "*", "r", ")", "{", "int", "i", ";", "if", "(", "!", "fp_consts_inited", ")", "init_fp_table", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "REAL_VALUES_EQUAL", "(", "*", "r", ",", "values_fp", "[", "i", "]", ")", ")", "return", "strings_fp", "[", "i", "]", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "As", "for", "fp_immediate_constant", ",", "but", "value", "is", "passed", "directly", ",", "not", "in", "rtx", "." ]

[ "arm", "0", "8" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isOperandLegal", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpIdx", ",", "const", "MachineOperand", "*", "MO", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "InstDesc", "=", "MI", ".", "getDesc", "(", ")", ";", "const", "MCOperandInfo", "&", "OpInfo", "=", "InstDesc", ".", "OpInfo", "[", "OpIdx", "]", ";", "const", "TargetRegisterClass", "*", "DefinedRC", "=", "OpInfo", ".", "RegClass", "!=", "-", "1", "?", "RI", ".", "getRegClass", "(", "OpInfo", ".", "RegClass", ")", ":", "nullptr", ";", "if", "(", "!", "MO", ")", "MO", "=", "&", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "isVALU", "(", "MI", ")", "&&", "usesConstantBus", "(", "MRI", ",", "*", "MO", ",", "OpInfo", ")", ")", "{", "RegSubRegPair", "SGPRUsed", ";", "if", "(", "MO", "->", "isReg", "(", ")", ")", "SGPRUsed", "=", "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", "(", ")", ")", "{", "if", "(", "(", "Op", ".", "getReg", "(", ")", "!=", "SGPRUsed", ".", "Reg", "||", "Op", ".", "getSubReg", "(", ")", "!=", "SGPRUsed", ".", "SubReg", ")", "&&", "usesConstantBus", "(", "MRI", ",", "Op", ",", "InstDesc", ".", "OpInfo", "[", "i", "]", ")", ")", "{", "return", "false", ";", "}", "}", "else", "if", "(", "InstDesc", ".", "OpInfo", "[", "i", "]", ".", "OperandType", "==", "AMDGPU", "::", "OPERAND_KIMM32", ")", "{", "return", "false", ";", "}", "}", "}", "if", "(", "MO", "->", "isReg", "(", ")", ")", "{", "assert", "(", "DefinedRC", ")", ";", "return", "isLegalRegOperand", "(", "MRI", ",", "OpInfo", ",", "*", "MO", ")", ";", "}", "assert", "(", "MO", "->", "isImm", "(", ")", "||", "MO", "->", "isTargetIndex", "(", ")", "||", "MO", "->", "isFI", "(", ")", ")", ";", "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", "0", "AMDGPU::OPERAND_KIMM32" ]

[]

[ "<s>", "void", "BT", "::", "run", "(", ")", "{", "reset", "(", ")", ";", "assert", "(", "FlowQ", ".", "empty", "(", ")", ")", ";", "typedef", "GraphTraits", "<", "const", "MachineFunction", "*", ">", "MachineFlowGraphTraits", ";", "const", "MachineBasicBlock", "*", "Entry", "=", "MachineFlowGraphTraits", "::", "getEntryNode", "(", "&", "MF", ")", ";", "unsigned", "MaxBN", "=", "0", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "assert", "(", "I", "->", "getNumber", "(", ")", ">=", "0", "&&", "\"Disconnected block\"", ")", ";", "unsigned", "BN", "=", "I", "->", "getNumber", "(", ")", ";", "if", "(", "BN", ">", "MaxBN", ")", "MaxBN", "=", "BN", ";", "}", "BitVector", "BlockScanned", "(", "MaxBN", "+", "1", ")", ";", "int", "EntryN", "=", "Entry", "->", "getNumber", "(", ")", ";", "FlowQ", ".", "push", "(", "CFGEdge", "(", "-", "1", ",", "EntryN", ")", ")", ";", "while", "(", "!", "FlowQ", ".", "empty", "(", ")", ")", "{", "CFGEdge", "Edge", "=", "FlowQ", ".", "front", "(", ")", ";", "FlowQ", ".", "pop", "(", ")", ";", "if", "(", "EdgeExec", ".", "count", "(", "Edge", ")", ")", "continue", ";", "EdgeExec", ".", "insert", "(", "Edge", ")", ";", "const", "MachineBasicBlock", "&", "B", "=", "*", "MF", ".", "getBlockNumbered", "(", "Edge", ".", "second", ")", ";", "MachineBasicBlock", "::", "const_iterator", "It", "=", "B", ".", "begin", "(", ")", ",", "End", "=", "B", ".", "end", "(", ")", ";", "while", "(", "It", "!=", "End", "&&", "It", "->", "isPHI", "(", ")", ")", "{", "const", "MachineInstr", "*", "PI", "=", "&", "*", "It", "++", ";", "InstrExec", ".", "insert", "(", "PI", ")", ";", "visitPHI", "(", "PI", ")", ";", "}", "if", "(", "BlockScanned", "[", "Edge", ".", "second", "]", ")", "continue", ";", "BlockScanned", "[", "Edge", ".", "second", "]", "=", "true", ";", "while", "(", "It", "!=", "End", "&&", "!", "It", "->", "isBranch", "(", ")", ")", "{", "const", "MachineInstr", "*", "MI", "=", "&", "*", "It", "++", ";", "InstrExec", ".", "insert", "(", "MI", ")", ";", "visitNonBranch", "(", "MI", ")", ";", "}", "if", "(", "It", "==", "End", ")", "{", "MachineFunction", "::", "const_iterator", "BIt", "=", "B", ".", "getIterator", "(", ")", ";", "MachineFunction", "::", "const_iterator", "Next", "=", "std", "::", "next", "(", "BIt", ")", ";", "if", "(", "Next", "!=", "MF", ".", "end", "(", ")", "&&", "B", ".", "isSuccessor", "(", "Next", ")", ")", "{", "int", "ThisN", "=", "B", ".", "getNumber", "(", ")", ";", "int", "NextN", "=", "Next", "->", "getNumber", "(", ")", ";", "FlowQ", ".", "push", "(", "CFGEdge", "(", "ThisN", ",", "NextN", ")", ")", ";", "}", "}", "else", "{", "visitBranchesFrom", "(", "It", ")", ";", "}", "}", "if", "(", "Trace", ")", "{", "dbgs", "(", ")", "<<", "\"Cells after propagation:\\n\"", ";", "for", "(", "CellMapType", "::", "iterator", "I", "=", "Map", ".", "begin", "(", ")", ",", "E", "=", "Map", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "dbgs", "(", ")", "<<", "PrintReg", "(", "I", "->", "first", ",", "&", "ME", ".", "TRI", ")", "<<", "\" -> \"", "<<", "I", "->", "second", "<<", "\"\\n\"", ";", "}", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "Hexagon", "0", "0", "\"Disconnected block\"", "1", "1", "\"Cells after propagation:\\n\"", "\" -> \"", "\"\\n\"" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "FrameInfo", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "assert", "(", "DestReg", "!=", "AMDGPU", "::", "M0", "&&", "\"m0 should not be reloaded into\"", ")", ";", "assert", "(", "DestReg", "!=", "AMDGPU", "::", "EXEC_LO", "&&", "DestReg", "!=", "AMDGPU", "::", "EXEC_HI", "&&", "DestReg", "!=", "AMDGPU", "::", "EXEC", "&&", "\"exec should not be spilled\"", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillRestoreOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "DestReg", ".", "isVirtual", "(", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ")", ";", "}", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "hasAGPRs", "(", "RC", ")", "?", "getAGPRSpillRestoreOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillRestoreOpcode", "(", "SpillSize", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::M0", "\"m0 should not be reloaded into\"", "AMDGPU::EXEC_LO", "AMDGPU::EXEC_HI", "AMDGPU::EXEC", "\"exec should not be spilled\"", "4", "AMDGPU::SReg_32_XM0_XEXECRegClass", "0" ]

[]

[ "<s>", "void", "ix86_asm_output_function_label", "(", "FILE", "*", "out_file", ",", "const", "char", "*", "fname", ",", "tree", "decl", ")", "{", "bool", "is_ms_hook", "=", "ix86_function_ms_hook_prologue", "(", "decl", ")", ";", "if", "(", "cfun", ")", "cfun", "->", "machine", "->", "function_label_emitted", "=", "true", ";", "if", "(", "is_ms_hook", ")", "{", "int", "i", ",", "filler_count", "=", "(", "TARGET_64BIT", "?", "32", ":", "16", ")", ";", "unsigned", "int", "filler_cc", "=", "0xcccccccc", ";", "for", "(", "i", "=", "0", ";", "i", "<", "filler_count", ";", "i", "+=", "4", ")", "fprintf", "(", "out_file", ",", "ASM_LONG", "\" %#x\\n\"", ",", "filler_cc", ")", ";", "}", "SUBTARGET_ASM_UNWIND_INIT", "(", "out_file", ")", ";", "ASM_OUTPUT_LABEL", "(", "out_file", ",", "fname", ")", ";", "if", "(", "is_ms_hook", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "fputs", "(", "ASM_BYTE", "\"0x48, 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00\\n\"", ",", "out_file", ")", ";", "}", "else", "{", "fputs", "(", "ASM_BYTE", "\"0x8b, 0xff, 0x55, 0x8b, 0xec\\n\"", ",", "out_file", ")", ";", "}", "}", "}", "</s>" ]

[ "Write", "the", "extra", "assembler", "code", "needed", "to", "declare", "a", "function", "properly", "." ]

[ "i386", "32", "16", "0xcccccccc", "0", "4", "\" %#x\\n\"", "\"0x48, 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00\\n\"", "\"0x8b, 0xff, 0x55, 0x8b, 0xec\\n\"" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "canExecuteInBundle", "(", "const", "MachineInstr", "&", "First", ",", "const", "MachineInstr", "&", "Second", ")", "const", "{", "if", "(", "Second", ".", "mayStore", "(", ")", "&&", "First", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "S2_allocframe", ")", "{", "const", "MachineOperand", "&", "Op", "=", "Second", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isUse", "(", ")", "&&", "Op", ".", "getReg", "(", ")", "==", "Hexagon", "::", "R29", ")", "return", "true", ";", "}", "if", "(", "DisableNVSchedule", ")", "return", "false", ";", "if", "(", "mayBeNewStore", "(", "Second", ")", ")", "{", "const", "MachineOperand", "&", "Stored", "=", "Second", ".", "getOperand", "(", "Second", ".", "getNumOperands", "(", ")", "-", "1", ")", ";", "if", "(", "!", "Stored", ".", "isReg", "(", ")", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "First", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "Op", "=", "First", ".", "getOperand", "(", "i", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isDef", "(", ")", "&&", "Op", ".", "getReg", "(", ")", "==", "Stored", ".", "getReg", "(", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Can", "these", "instructions", "execute", "at", "the", "same", "time", "in", "a", "bundle", "." ]

[ "Hexagon", "Hexagon", "Hexagon::S2_allocframe", "0", "Hexagon::R29", "1", "0" ]

[]

[ "<s>", "static", "void", "arc_finalize_pic", "(", "void", ")", "{", "rtx", "pat", ";", "rtx", "baseptr_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_OFFSET_TABLE_REGNUM", ")", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", "==", "0", ")", "return", ";", "gcc_assert", "(", "flag_pic", "!=", "0", ")", ";", "pat", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_DYNAMIC\"", ")", ";", "pat", "=", "arc_unspec_offset", "(", "pat", ",", "ARC_UNSPEC_GOT", ")", ";", "pat", "=", "gen_rtx_SET", "(", "baseptr_rtx", ",", "pat", ")", ";", "emit_insn", "(", "pat", ")", ";", "}", "</s>" ]

[ "If", "the", "function", "has", "any", "GOTOFF", "relocations", ",", "then", "the", "GOTBASE", "register", "has", "to", "be", "setup", "in", "the", "prologue", "The", "instruction", "needed", "at", "the", "function", "start", "for", "setting", "up", "the", "GOTBASE", "register", "is", "add", "rdest", ",", "pc", ",", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "The", "rtl", "to", "be", "emitted", "for", "this", "should", "be", ":", "set", "(", "reg", "basereg", ")", "(", "plus", "(", "reg", "pc", ")", "(", "const", "(", "unspec", "(", "symref", "_DYNAMIC", ")", "3", ")", ")", ")", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--" ]

[ "arc", "0", "0", "\"_DYNAMIC\"" ]

[]

[ "<s>", "static", "unsigned", "getReg", "(", "const", "void", "*", "D", ",", "unsigned", "RC", ",", "unsigned", "RegNo", ")", "{", "const", "TriCoreDisassembler", "*", "Dis", "=", "static_cast", "<", "const", "TriCoreDisassembler", "*", ">", "(", "D", ")", ";", "const", "MCRegisterInfo", "*", "RegInfo", "=", "Dis", "->", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "*", "(", "RegInfo", "->", "getRegClass", "(", "RC", ")", ".", "begin", "(", ")", "+", "RegNo", ")", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "TriCore", "TriCore", "TriCore" ]

[]

[ "<s>", "void", "mmix_override_options", "(", ")", "{", "if", "(", "flag_pic", ")", "{", "warning", "(", "\"-f%s not supported: ignored\"", ",", "(", "flag_pic", ">", "1", ")", "?", "\"PIC\"", ":", "\"pic\"", ")", ";", "flag_pic", "=", "0", ";", "}", "ggc_add_rtx_root", "(", "&", "mmix_compare_op0", ",", "1", ")", ";", "ggc_add_rtx_root", "(", "&", "mmix_compare_op1", ",", "1", ")", ";", "}", "</s>" ]

[ "OVERRIDE_OPTIONS", "." ]

[ "mmix", "\"-f%s not supported: ignored\"", "1", "\"PIC\"", "\"pic\"", "0", "1", "1" ]

[]

[ "<s>", "bool", "mips_split_symbol", "(", "rtx", "temp", ",", "rtx", "addr", ",", "machine_mode", "mode", ",", "rtx", "*", "low_out", ")", "{", "enum", "mips_symbol_context", "context", ";", "enum", "mips_symbol_type", "symbol_type", ";", "rtx", "high", ";", "context", "=", "(", "mode", "==", "MAX_MACHINE_MODE", "?", "SYMBOL_CONTEXT_LEA", ":", "SYMBOL_CONTEXT_MEM", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "HIGH", "&&", "context", "==", "SYMBOL_CONTEXT_LEA", ")", "{", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "mips_symbolic_constant_p", "(", "addr", ",", "context", ",", "&", "symbol_type", ")", "&&", "mips_symbol_insns", "(", "symbol_type", ",", "mode", ")", ">", "0", "&&", "mips_split_hi_p", "[", "symbol_type", "]", ")", "{", "if", "(", "low_out", ")", "switch", "(", "symbol_type", ")", "{", "case", "SYMBOL_GOT_PAGE_OFST", ":", "*", "low_out", "=", "mips_got_load", "(", "temp", ",", "addr", ",", "SYMBOL_GOTOFF_PAGE", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "true", ";", "}", "}", "else", "{", "if", "(", "mips_symbolic_constant_p", "(", "addr", ",", "context", ",", "&", "symbol_type", ")", "&&", "mips_symbol_insns", "(", "symbol_type", ",", "mode", ")", ">", "0", "&&", "mips_split_p", "[", "symbol_type", "]", ")", "{", "if", "(", "low_out", ")", "switch", "(", "symbol_type", ")", "{", "case", "SYMBOL_GOT_DISP", ":", "*", "low_out", "=", "mips_got_load", "(", "temp", ",", "addr", ",", "SYMBOL_GOTOFF_DISP", ")", ";", "break", ";", "case", "SYMBOL_GP_RELATIVE", ":", "high", "=", "mips_pic_base_register", "(", "temp", ")", ";", "*", "low_out", "=", "gen_rtx_LO_SUM", "(", "Pmode", ",", "high", ",", "addr", ")", ";", "break", ";", "default", ":", "high", "=", "gen_rtx_HIGH", "(", "Pmode", ",", "copy_rtx", "(", "addr", ")", ")", ";", "high", "=", "mips_force_temporary", "(", "temp", ",", "high", ")", ";", "*", "low_out", "=", "gen_rtx_LO_SUM", "(", "Pmode", ",", "high", ",", "addr", ")", ";", "break", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "a", "LO_SUM", "expression", "for", "ADDR", ".", "TEMP", "is", "as", "for", "mips_force_temporary", "and", "is", "used", "to", "load", "the", "high", "part", "into", "a", "register", "." ]

[ "mips", "0", "0", "0" ]

[]

[ "<s>", "rtx", "legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "flag_pic", "&&", "!", "legitimate_pic_operand_p", "(", "x", ")", ")", "x", "=", "legitimize_pic_address", "(", "oldx", ",", "NULL_RTX", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "symbolic_operand", "(", "XEXP", "(", "x", ",", "1", ")", ",", "VOIDmode", ")", ")", "{", "rtx", "regx1", ",", "regy1", ",", "regy2", ",", "y", ";", "y", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "CONST", ")", "y", "=", "XEXP", "(", "y", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "PLUS", "||", "GET_CODE", "(", "y", ")", "==", "MINUS", ")", "{", "regx1", "=", "force_reg", "(", "Pmode", ",", "force_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", ";", "regy1", "=", "force_reg", "(", "Pmode", ",", "force_operand", "(", "XEXP", "(", "y", ",", "0", ")", ",", "0", ")", ")", ";", "regy2", "=", "force_reg", "(", "Pmode", ",", "force_operand", "(", "XEXP", "(", "y", ",", "1", ")", ",", "0", ")", ")", ";", "regx1", "=", "force_reg", "(", "Pmode", ",", "gen_rtx_fmt_ee", "(", "GET_CODE", "(", "y", ")", ",", "Pmode", ",", "regx1", ",", "regy2", ")", ")", ";", "return", "force_reg", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "regx1", ",", "regy1", ")", ")", ";", "}", "}", "return", "x", ";", "}", "</s>" ]

[ "Try", "machine-dependent", "ways", "of", "modifying", "an", "illegitimate", "address", "X", "to", "be", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", ".", "OLDX", "is", "the", "address", "as", "it", "was", "before", "break_out_memory_refs", "was", "called", ".", "In", "some", "cases", "it", "is", "useful", "to", "look", "at", "this", "to", "decide", "what", "needs", "to", "be", "done", ".", "MODE", "is", "the", "mode", "of", "the", "operand", "pointed", "to", "by", "X", "." ]

[ "mn10300", "1", "1", "0", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "MSP430InstrInfo", "::", "isUnpredicatedTerminator", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "MI", "->", "isTerminator", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "isBranch", "(", ")", "&&", "!", "MI", "->", "isBarrier", "(", ")", ")", "return", "true", ";", "if", "(", "!", "MI", "->", "isPredicable", "(", ")", ")", "return", "true", ";", "return", "!", "isPredicated", "(", "MI", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "a", "terminator", "instruction", "that", "has", "not", "been", "predicated", "." ]

[ "MSP430", "MSP430" ]

[]

[ "<s>", "const", "char", "*", "output_call_mem", "(", "rtx", "*", "operands", ")", "{", "if", "(", "TARGET_INTERWORK", "&&", "!", "arm_arch5", ")", "{", "output_asm_insn", "(", "\"ldr%?\\t%|ip, %0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"mov%?\\t%|lr, %|pc\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"bx%?\\t%|ip\"", ",", "operands", ")", ";", "}", "else", "if", "(", "regno_use_in", "(", "LR_REGNUM", ",", "operands", "[", "0", "]", ")", ")", "{", "output_asm_insn", "(", "\"ldr%?\\t%|ip, %0\"", ",", "operands", ")", ";", "if", "(", "arm_arch5", ")", "output_asm_insn", "(", "\"blx%?\\t%|ip\"", ",", "operands", ")", ";", "else", "{", "output_asm_insn", "(", "\"mov%?\\t%|lr, %|pc\"", ",", "operands", ")", ";", "if", "(", "arm_arch4t", ")", "output_asm_insn", "(", "\"bx%?\\t%|ip\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"mov%?\\t%|pc, %|ip\"", ",", "operands", ")", ";", "}", "}", "else", "{", "output_asm_insn", "(", "\"mov%?\\t%|lr, %|pc\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldr%?\\t%|pc, %0\"", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "'call", "'", "insn", "that", "is", "a", "reference", "in", "memory", ".", "This", "is", "disabled", "for", "ARMv5", "and", "we", "prefer", "a", "blx", "instead", "because", "otherwise", "there", "'s", "a", "significant", "performance", "overhead", "." ]

[ "arm", "\"ldr%?\\t%|ip, %0\"", "\"mov%?\\t%|lr, %|pc\"", "\"bx%?\\t%|ip\"", "0", "\"ldr%?\\t%|ip, %0\"", "\"blx%?\\t%|ip\"", "\"mov%?\\t%|lr, %|pc\"", "\"bx%?\\t%|ip\"", "\"mov%?\\t%|pc, %|ip\"", "\"mov%?\\t%|lr, %|pc\"", "\"ldr%?\\t%|pc, %0\"", "\"\"" ]

[]

[ "<s>", "ArrayRef", "<", "const", "Metadata", "*", ">", "getMDStrings", "(", ")", "const", "{", "return", "makeArrayRef", "(", "MDs", ")", ".", "slice", "(", "NumModuleMDs", ",", "NumMDStrings", ")", ";", "}", "</s>" ]

[ "Get", "the", "MDString", "metadata", "for", "this", "block", "." ]

[ "DirectX" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFR", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFR_64", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "OR_pp", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "SrcReg", "==", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_loreg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFRI", ")", ",", "(", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_hireg", ")", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFR", ")", ",", "(", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_loreg", ")", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFRI", ")", ",", "(", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_hireg", ")", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "return", ";", "}", "if", "(", "Hexagon", "::", "CRRegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFCR", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::TFR", "Hexagon::DoubleRegsRegClass", "Hexagon::TFR_64", "Hexagon::PredRegsRegClass", "Hexagon::OR_pp", "Hexagon::DoubleRegsRegClass", "Hexagon::IntRegsRegClass", "Hexagon::subreg_loreg", "Hexagon::TFRI", "Hexagon::subreg_hireg", "0", "Hexagon::TFR", "Hexagon::subreg_loreg", "Hexagon::TFRI", "Hexagon::subreg_hireg", "0", "Hexagon::CRRegsRegClass", "Hexagon::IntRegsRegClass", "Hexagon::TFCR", "\"Unimplemented\"" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "IsEligibleForTailCallOptimization", "(", "CCState", "&", "CCInfo", ",", "CallLoweringInfo", "&", "CLI", ",", "MachineFunction", "&", "MF", ",", "const", "SmallVector", "<", "CCValAssign", ",", "16", ">", "&", "ArgLocs", ")", "const", "{", "auto", "&", "Callee", "=", "CLI", ".", "Callee", ";", "auto", "CalleeCC", "=", "CLI", ".", "CallConv", ";", "auto", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "auto", "&", "Outs", "=", "CLI", ".", "Outs", ";", "auto", "&", "Caller", "=", "MF", ".", "getFunction", "(", ")", ";", "auto", "CallerCC", "=", "Caller", ".", "getCallingConv", "(", ")", ";", "if", "(", "Caller", ".", "getFnAttribute", "(", "\"disable-tail-calls\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "return", "false", ";", "if", "(", "Caller", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "return", "false", ";", "if", "(", "IsVarArg", ")", "return", "false", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "Indirect", ")", "return", "false", ";", "auto", "IsCallerStructRet", "=", "Caller", ".", "hasStructRetAttr", "(", ")", ";", "auto", "IsCalleeStructRet", "=", "Outs", ".", "empty", "(", ")", "?", "false", ":", "Outs", "[", "0", "]", ".", "Flags", ".", "isSRet", "(", ")", ";", "if", "(", "IsCallerStructRet", "||", "IsCalleeStructRet", ")", "return", "false", ";", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "G", "->", "getGlobal", "(", ")", ";", "if", "(", "GV", "->", "hasExternalWeakLinkage", "(", ")", ")", "return", "false", ";", "}", "const", "RISCVRegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "CallerPreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallerCC", ")", ";", "if", "(", "CalleeCC", "!=", "CallerCC", ")", "{", "const", "uint32_t", "*", "CalleePreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CalleeCC", ")", ";", "if", "(", "!", "TRI", "->", "regmaskSubsetEqual", "(", "CallerPreserved", ",", "CalleePreserved", ")", ")", "return", "false", ";", "}", "for", "(", "auto", "&", "Arg", ":", "Outs", ")", "if", "(", "Arg", ".", "Flags", ".", "isByVal", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "IsEligibleForTailCallOptimization", "-", "Check", "whether", "the", "call", "is", "eligible", "for", "tail", "call", "optimization", "." ]

[ "RISCV", "RISCV", "16", "\"disable-tail-calls\"", "\"true\"", "\"interrupt\"", "0", "0", "RISCV" ]

[]

[ "<s>", "unsigned", "MipsFastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "AI", ")", "{", "assert", "(", "TLI", ".", "getValueType", "(", "DL", ",", "AI", "->", "getType", "(", ")", ",", "true", ")", "==", "MVT", "::", "i32", "&&", "\"Alloca should always return a pointer.\"", ")", ";", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "Register", "ResultReg", "=", "createResultReg", "(", "&", "Mips", "::", "GPR32RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Mips", "::", "LEA_ADDiu", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "SI", "->", "second", ")", ".", "addImm", "(", "0", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Emit", "an", "alloca", "address", "in", "a", "register", "using", "target-specific", "logic", "." ]

[ "Mips", "Mips", "MVT::i32", "\"Alloca should always return a pointer.\"", "Mips::GPR32RegClass", "Mips::LEA_ADDiu", "0", "0" ]

[]

[ "<s>", "void", "AArch64Operand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_FPImm", ":", "OS", "<<", "\"<fpimm \"", "<<", "getFPImm", "(", ")", "<<", "\"(\"", "<<", "AArch64_AM", "::", "getFPImmFloat", "(", "getFPImm", "(", ")", ")", "<<", "\") >\"", ";", "break", ";", "case", "k_Barrier", ":", "{", "StringRef", "Name", "=", "getBarrierName", "(", ")", ";", "if", "(", "!", "Name", ".", "empty", "(", ")", ")", "OS", "<<", "\"<barrier \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<barrier invalid #\"", "<<", "getBarrier", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "k_ShiftedImm", ":", "{", "unsigned", "Shift", "=", "getShiftedImmShift", "(", ")", ";", "OS", "<<", "\"<shiftedimm \"", ";", "OS", "<<", "*", "getShiftedImmVal", "(", ")", ";", "OS", "<<", "\", lsl #\"", "<<", "AArch64_AM", "::", "getShiftValue", "(", "Shift", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_CondCode", ":", "OS", "<<", "\"<condcode \"", "<<", "getCondCode", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_VectorList", ":", "{", "OS", "<<", "\"<vectorlist \"", ";", "unsigned", "Reg", "=", "getVectorListStart", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "getVectorListCount", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "OS", "<<", "Reg", "+", "i", "<<", "\" \"", ";", "OS", "<<", "\">\"", ";", "break", ";", "}", "case", "k_VectorIndex", ":", "OS", "<<", "\"<vectorindex \"", "<<", "getVectorIndex", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_SysReg", ":", "OS", "<<", "\"<sysreg: \"", "<<", "getSysReg", "(", ")", "<<", "'>'", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "k_SysCR", ":", "OS", "<<", "\"c\"", "<<", "getSysCR", "(", ")", ";", "break", ";", "case", "k_Prefetch", ":", "{", "StringRef", "Name", "=", "getPrefetchName", "(", ")", ";", "if", "(", "!", "Name", ".", "empty", "(", ")", ")", "OS", "<<", "\"<prfop \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<prfop invalid #\"", "<<", "getPrefetch", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_PSBHint", ":", "OS", "<<", "getPSBHintName", "(", ")", ";", "break", ";", "case", "k_ShiftExtend", ":", "OS", "<<", "\"<\"", "<<", "AArch64_AM", "::", "getShiftExtendName", "(", "getShiftExtendType", "(", ")", ")", "<<", "\" #\"", "<<", "getShiftExtendAmount", "(", ")", ";", "if", "(", "!", "hasShiftExtendAmount", "(", ")", ")", "OS", "<<", "\"<imp>\"", ";", "OS", "<<", "'>'", ";", "break", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "AArch64", "AArch64", "\"<fpimm \"", "\"(\"", "AArch64_AM::getFPImmFloat", "\") >\"", "\"<barrier \"", "\">\"", "\"<barrier invalid #\"", "\">\"", "\"<shiftedimm \"", "\", lsl #\"", "AArch64_AM::getShiftValue", "\">\"", "\"<condcode \"", "\">\"", "\"<register \"", "\">\"", "\"<vectorlist \"", "0", "\" \"", "\">\"", "\"<vectorindex \"", "\">\"", "\"<sysreg: \"", "\"'\"", "\"'\"", "\"c\"", "\"<prfop \"", "\">\"", "\"<prfop invalid #\"", "\">\"", "\"<\"", "AArch64_AM::getShiftExtendName", "\" #\"", "\"<imp>\"" ]

[]

[ "<s>", "bool", "R600PassConfig", "::", "addPreISel", "(", ")", "{", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", ";", "if", "(", "EnableR600StructurizeCFG", ")", "addPass", "(", "createStructurizeCFGPass", "(", ")", ")", ";", "addPass", "(", "createR600TextureIntrinsicsReplacer", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

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

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "InstructionSelect", "(", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "(", "global", ")", "instruction", "selector", "pass", ",", "which", "converts", "possibly", "generic", "instructions", "to", "fully", "target-specific", "instructions", ",", "thereby", "constraining", "all", "generic", "virtual", "registers", "to", "register", "classes", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "EVT", "ARMTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "(", "!", "IsMemset", "||", "ZeroMemset", ")", "&&", "Subtarget", "->", "hasNEON", "(", ")", "&&", "!", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "bool", "Fast", ";", "if", "(", "Size", ">=", "16", "&&", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "16", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "v2f64", ",", "0", ",", "1", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "{", "return", "MVT", "::", "v2f64", ";", "}", "else", "if", "(", "Size", ">=", "8", "&&", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "8", ")", "||", "(", "allowsMisalignedMemoryAccesses", "(", "MVT", "::", "f64", ",", "0", ",", "1", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Size", ">=", "4", ")", "return", "MVT", "::", "i32", ";", "else", "if", "(", "Size", ">=", "2", ")", "return", "MVT", "::", "i16", ";", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "ARM", "ARM", "16", "16", "MVT::v2f64", "0", "1", "MVT::v2f64", "8", "8", "MVT::f64", "0", "1", "MVT::f64", "4", "MVT::i32", "2", "MVT::i16", "MVT::Other" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createRISCVMergeBaseOffsetOptPass", "(", ")", ")", ";", "addPass", "(", "createRISCVCleanupVSETVLIPass", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAMDGPUAlwaysInlinePass", "(", ")", ")", ";", "addPass", "(", "createAlwaysInlinerPass", "(", ")", ")", ";", "addPass", "(", "createBarrierNoopPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUOpenCLImageTypeLoweringPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

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

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

[ "CAHP" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "TMBB", ",", "unsigned", "TCycles", ",", "unsigned", "TExtra", ",", "MachineBasicBlock", "&", "FMBB", ",", "unsigned", "FCycles", ",", "unsigned", "FExtra", ",", "float", "Probability", ",", "float", "Confidence", ")", "const", "{", "if", "(", "!", "TCycles", "||", "!", "FCycles", ")", "return", "false", ";", "float", "UnpredCost", "=", "Probability", "*", "TCycles", "+", "(", "1.0", "-", "Probability", ")", "*", "FCycles", ";", "UnpredCost", "+=", "1.0", ";", "UnpredCost", "+=", "(", "1.0", "-", "Confidence", ")", "*", "Subtarget", ".", "getMispredictionPenalty", "(", ")", ";", "return", "(", "float", ")", "(", "TCycles", "+", "FCycles", "+", "TExtra", "+", "FExtra", ")", "<", "UnpredCost", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

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

[]

[ "<s>", "MCRegister", "getRegister", "(", ")", "const", "{", "assert", "(", "!", "IsStack", ")", ";", "return", "Reg", ";", "}", "</s>" ]

[ "Return", "the", "specified", "register", "in", "the", "class", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "const", "char", "*", "output_inline_const", "(", "enum", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "int", "x", "=", "0", ",", "y", "=", "0", ";", "int", "trick_no", ";", "rtx", "out_operands", "[", "3", "]", ";", "char", "buf", "[", "256", "]", ";", "char", "load_op", "[", "256", "]", ";", "const", "char", "*", "dst_fmt", ";", "int", "value", ";", "value", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "trick_no", "=", "try_constant_tricks", "(", "value", ",", "&", "x", ",", "&", "y", ")", ";", "gcc_assert", "(", "trick_no", "!=", "0", ")", ";", "if", "(", "trick_no", "==", "1", ")", "x", "=", "value", ";", "out_operands", "[", "0", "]", "=", "operands", "[", "0", "]", ";", "out_operands", "[", "1", "]", "=", "GEN_INT", "(", "x", ")", ";", "if", "(", "trick_no", ">", "2", ")", "out_operands", "[", "2", "]", "=", "GEN_INT", "(", "y", ")", ";", "if", "(", "mode", "==", "DImode", "&&", "(", "!", "TARGET_LITTLE_END", ")", ")", "dst_fmt", "=", "\"%R0\"", ";", "else", "dst_fmt", "=", "\"%0\"", ";", "if", "(", "x", ">=", "0", "&&", "x", "<=", "127", ")", "sprintf", "(", "load_op", ",", "\"movi\\t%s,%%1\"", ",", "dst_fmt", ")", ";", "else", "if", "(", "(", "x", "&", "(", "x", "-", "1", ")", ")", "==", "0", ")", "sprintf", "(", "load_op", ",", "\"bgeni\\t%s,%%P1\"", ",", "dst_fmt", ")", ";", "else", "if", "(", "(", "x", "&", "(", "x", "+", "1", ")", ")", "==", "0", ")", "sprintf", "(", "load_op", ",", "\"bmaski\\t%s,%%N1\"", ",", "dst_fmt", ")", ";", "else", "sprintf", "(", "load_op", ",", "\"BADMOVI\\t%s,%%1\"", ",", "dst_fmt", ")", ";", "switch", "(", "trick_no", ")", "{", "case", "1", ":", "strcpy", "(", "buf", ",", "load_op", ")", ";", "break", ";", "case", "2", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tnot\\t%s\\t// %d 0x%x\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "3", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\taddi\\t%s,%%2\\t// %d 0x%x\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "4", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tsubi\\t%s,%%2\\t// %d 0x%x\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "5", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\trsubi\\t%s,%%2\\t// %d 0x%x\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "6", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tbseti\\t%s,%%P2\\t// %d 0x%x\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "7", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tbclri\\t%s,%%Q2\\t// %d 0x%x\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "8", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\trotli\\t%s,%%2\\t// %d 0x%x\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "9", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tlsli\\t%s,%%2\\t// %d 0x%x\"", ",", "load_op", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "10", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tixh\\t%s,%s\\t// %d 0x%x\"", ",", "load_op", ",", "dst_fmt", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "case", "11", ":", "sprintf", "(", "buf", ",", "\"%s\\n\\tixw\\t%s,%s\\t// %d 0x%x\"", ",", "load_op", ",", "dst_fmt", ",", "dst_fmt", ",", "value", ",", "value", ")", ";", "break", ";", "default", ":", "return", "\"\"", ";", "}", "output_asm_insn", "(", "buf", ",", "out_operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "an", "inline", "constant", "." ]

[ "mcore", "0", "0", "3", "256", "256", "1", "0", "1", "0", "0", "1", "2", "2", "\"%R0\"", "\"%0\"", "0", "127", "\"movi\\t%s,%%1\"", "1", "0", "\"bgeni\\t%s,%%P1\"", "1", "0", "\"bmaski\\t%s,%%N1\"", "\"BADMOVI\\t%s,%%1\"", "1", "2", "\"%s\\n\\tnot\\t%s\\t// %d 0x%x\"", "3", "\"%s\\n\\taddi\\t%s,%%2\\t// %d 0x%x\"", "4", "\"%s\\n\\tsubi\\t%s,%%2\\t// %d 0x%x\"", "5", "\"%s\\n\\trsubi\\t%s,%%2\\t// %d 0x%x\"", "6", "\"%s\\n\\tbseti\\t%s,%%P2\\t// %d 0x%x\"", "7", "\"%s\\n\\tbclri\\t%s,%%Q2\\t// %d 0x%x\"", "8", "\"%s\\n\\trotli\\t%s,%%2\\t// %d 0x%x\"", "9", "\"%s\\n\\tlsli\\t%s,%%2\\t// %d 0x%x\"", "10", "\"%s\\n\\tixh\\t%s,%s\\t// %d 0x%x\"", "11", "\"%s\\n\\tixw\\t%s,%s\\t// %d 0x%x\"", "\"\"", "\"\"" ]

[]

[ "<s>", "void", "VEInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "IsAliasOfSX", "(", "SrcReg", ")", "&&", "IsAliasOfSX", "(", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "ORri", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "if", "(", "VE", "::", "V64RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "Register", "TmpReg", "=", "VE", "::", "SX16", ";", "Register", "SubTmp", "=", "TRI", "->", "getSubReg", "(", "TmpReg", ",", "VE", "::", "sub_i32", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "LEAzii", ")", ",", "TmpReg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "256", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "VORmvl", ")", ",", "DestReg", ")", ".", "addImm", "(", "M1", "(", "0", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "SubTmp", ",", "getKillRegState", "(", "true", ")", ")", ";", "MIB", ".", "getInstr", "(", ")", "->", "addRegisterKilled", "(", "TmpReg", ",", "TRI", ",", "true", ")", ";", "}", "else", "if", "(", "VE", "::", "VMRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VE", "::", "ANDMmm", ")", ",", "DestReg", ")", ".", "addReg", "(", "VE", "::", "VM0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "if", "(", "VE", "::", "VM512RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "const", "unsigned", "SubRegIdx", "[", "]", "=", "{", "VE", "::", "sub_vm_even", ",", "VE", "::", "sub_vm_odd", "}", ";", "unsigned", "int", "NumSubRegs", "=", "2", ";", "copyPhysSubRegs", "(", "MBB", ",", "I", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "KillSrc", ",", "get", "(", "VE", "::", "ANDMmm", ")", ",", "NumSubRegs", ",", "SubRegIdx", ",", "&", "getRegisterInfo", "(", ")", ")", ";", "}", "else", "if", "(", "VE", "::", "F128RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "const", "unsigned", "SubRegIdx", "[", "]", "=", "{", "VE", "::", "sub_even", ",", "VE", "::", "sub_odd", "}", ";", "unsigned", "int", "NumSubRegs", "=", "2", ";", "copyPhysSubRegs", "(", "MBB", ",", "I", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "KillSrc", ",", "get", "(", "VE", "::", "ORri", ")", ",", "NumSubRegs", ",", "SubRegIdx", ",", "&", "getRegisterInfo", "(", ")", ")", ";", "}", "else", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Impossible reg-to-reg copy from \"", "<<", "printReg", "(", "SrcReg", ",", "TRI", ")", "<<", "\" to \"", "<<", "printReg", "(", "DestReg", ",", "TRI", ")", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "VE", "VE", "VE::ORri", "0", "VE::V64RegClass", "VE::SX16", "VE::sub_i32", "VE::LEAzii", "0", "0", "256", "VE::VORmvl", "0", "VE::VMRegClass", "VE::ANDMmm", "VE::VM0", "VE::VM512RegClass", "VE::sub_vm_even", "VE::sub_vm_odd", "2", "VE::ANDMmm", "VE::F128RegClass", "VE::sub_even", "VE::sub_odd", "2", "VE::ORri", "\"Impossible reg-to-reg copy from \"", "\" to \"", "\"\\n\"", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "unsigned", "MandarinInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "MI", "->", "dump", "(", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Mandarin", "0" ]

[]

[ "<s>", "void", "AnalyzeReturn", "(", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "CCAssignFn", "Fn", ")", "{", "PreAnalyzeReturnForF128", "(", "Outs", ")", ";", "CCState", "::", "AnalyzeReturn", "(", "Outs", ",", "Fn", ")", ";", "OriginalArgWasFloat", ".", "clear", "(", ")", ";", "OriginalArgWasF128", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "AnalyzeReturn", "-", "Analyze", "the", "returned", "values", "of", "a", "return", ",", "incorporating", "info", "about", "the", "result", "values", "into", "this", "state", "." ]

[ "Mips", "ISD::OutputArg" ]

[]

[ "<s>", "void", "AMDGPUUnifyDivergentExitNodes", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "PostDominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "AU", ".", "addPreservedID", "(", "BreakCriticalEdgesID", ")", ";", "AU", ".", "addPreservedID", "(", "LowerSwitchID", ")", ";", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "TargetTransformInfoWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "const", "JVMSubtarget", "*", "JVMTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "JVMSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "JVM", "JVM", "JVM", "\"target-cpu\"", "\"target-features\"", "JVM" ]

[]

[ "<s>", "BitVector", "AAPRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "getLinkRegister", "(", ")", ")", ";", "Reserved", ".", "set", "(", "getStackPtrRegister", "(", ")", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "getFramePtrRegister", "(", ")", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "AAP", "AAP" ]

[]

[ "<s>", "void", "mips_split_128bit_move", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "int", "byte", ",", "index", ";", "rtx", "low_dest", ",", "low_src", ",", "d", ",", "s", ";", "if", "(", "FP_REG_RTX_P", "(", "dest", ")", ")", "{", "gcc_assert", "(", "!", "MEM_P", "(", "src", ")", ")", ";", "rtx", "new_dest", "=", "dest", ";", "if", "(", "!", "TARGET_64BIT", ")", "{", "if", "(", "GET_MODE", "(", "dest", ")", "!=", "V4SImode", ")", "new_dest", "=", "simplify_gen_subreg", "(", "V4SImode", ",", "dest", ",", "GET_MODE", "(", "dest", ")", ",", "0", ")", ";", "}", "else", "{", "if", "(", "GET_MODE", "(", "dest", ")", "!=", "V2DImode", ")", "new_dest", "=", "simplify_gen_subreg", "(", "V2DImode", ",", "dest", ",", "GET_MODE", "(", "dest", ")", ",", "0", ")", ";", "}", "for", "(", "byte", "=", "0", ",", "index", "=", "0", ";", "byte", "<", "GET_MODE_SIZE", "(", "TImode", ")", ";", "byte", "+=", "UNITS_PER_WORD", ",", "index", "++", ")", "{", "s", "=", "mips_subword_at_byte", "(", "src", ",", "byte", ")", ";", "if", "(", "!", "TARGET_64BIT", ")", "emit_insn", "(", "gen_msa_insert_w", "(", "new_dest", ",", "s", ",", "new_dest", ",", "GEN_INT", "(", "1", "<<", "index", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_msa_insert_d", "(", "new_dest", ",", "s", ",", "new_dest", ",", "GEN_INT", "(", "1", "<<", "index", ")", ")", ")", ";", "}", "}", "else", "if", "(", "FP_REG_RTX_P", "(", "src", ")", ")", "{", "gcc_assert", "(", "!", "MEM_P", "(", "dest", ")", ")", ";", "rtx", "new_src", "=", "src", ";", "if", "(", "!", "TARGET_64BIT", ")", "{", "if", "(", "GET_MODE", "(", "src", ")", "!=", "V4SImode", ")", "new_src", "=", "simplify_gen_subreg", "(", "V4SImode", ",", "src", ",", "GET_MODE", "(", "src", ")", ",", "0", ")", ";", "}", "else", "{", "if", "(", "GET_MODE", "(", "src", ")", "!=", "V2DImode", ")", "new_src", "=", "simplify_gen_subreg", "(", "V2DImode", ",", "src", ",", "GET_MODE", "(", "src", ")", ",", "0", ")", ";", "}", "for", "(", "byte", "=", "0", ",", "index", "=", "0", ";", "byte", "<", "GET_MODE_SIZE", "(", "TImode", ")", ";", "byte", "+=", "UNITS_PER_WORD", ",", "index", "++", ")", "{", "d", "=", "mips_subword_at_byte", "(", "dest", ",", "byte", ")", ";", "if", "(", "!", "TARGET_64BIT", ")", "emit_insn", "(", "gen_msa_copy_s_w", "(", "d", ",", "new_src", ",", "GEN_INT", "(", "index", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_msa_copy_s_d", "(", "d", ",", "new_src", ",", "GEN_INT", "(", "index", ")", ")", ")", ";", "}", "}", "else", "{", "low_dest", "=", "mips_subword_at_byte", "(", "dest", ",", "0", ")", ";", "low_src", "=", "mips_subword_at_byte", "(", "src", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "low_dest", ")", "&&", "REG_P", "(", "low_src", ")", ")", ";", "if", "(", "REGNO", "(", "low_dest", ")", "<=", "REGNO", "(", "low_src", ")", ")", "{", "for", "(", "byte", "=", "0", ";", "byte", "<", "GET_MODE_SIZE", "(", "TImode", ")", ";", "byte", "+=", "UNITS_PER_WORD", ")", "{", "d", "=", "mips_subword_at_byte", "(", "dest", ",", "byte", ")", ";", "s", "=", "mips_subword_at_byte", "(", "src", ",", "byte", ")", ";", "mips_emit_move", "(", "d", ",", "s", ")", ";", "}", "}", "else", "{", "for", "(", "byte", "=", "GET_MODE_SIZE", "(", "TImode", ")", "-", "UNITS_PER_WORD", ";", "byte", ">=", "0", ";", "byte", "-=", "UNITS_PER_WORD", ")", "{", "d", "=", "mips_subword_at_byte", "(", "dest", ",", "byte", ")", ";", "s", "=", "mips_subword_at_byte", "(", "src", ",", "byte", ")", ";", "mips_emit_move", "(", "d", ",", "s", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Split", "a", "128-bit", "move", "from", "SRC", "to", "DEST", "." ]

[ "mips", "0", "0", "0", "0", "1", "1", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "tree", "sh_handle_sp_switch_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute only applies to functions\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "!=", "STRING_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute argument not a string constant\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "``", "sp_switch", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "sh", "\"%qs attribute only applies to functions\"", "\"%qs attribute argument not a string constant\"" ]

[]

[ "<s>", "RangeTree", "::", "Node", "*", "RangeTree", "::", "remove", "(", "Node", "*", "N", ",", "const", "Node", "*", "D", ")", "{", "assert", "(", "N", "!=", "nullptr", ")", ";", "if", "(", "N", "!=", "D", ")", "{", "assert", "(", "N", "->", "Range", "!=", "D", "->", "Range", "&&", "\"N and D should not be equal\"", ")", ";", "if", "(", "D", "->", "Range", "<", "N", "->", "Range", ")", "N", "->", "Left", "=", "remove", "(", "N", "->", "Left", ",", "D", ")", ";", "else", "N", "->", "Right", "=", "remove", "(", "N", "->", "Right", ",", "D", ")", ";", "return", "rebalance", "(", "update", "(", "N", ")", ")", ";", "}", "if", "(", "N", "->", "Left", "==", "nullptr", "||", "N", "->", "Right", "==", "nullptr", ")", "return", "(", "N", "->", "Left", "==", "nullptr", ")", "?", "N", "->", "Right", ":", "N", "->", "Left", ";", "Node", "*", "M", "=", "N", "->", "Left", ";", "while", "(", "M", "->", "Right", ")", "M", "=", "M", "->", "Right", ";", "M", "->", "Left", "=", "remove", "(", "N", "->", "Left", ",", "M", ")", ";", "M", "->", "Right", "=", "N", "->", "Right", ";", "return", "rebalance", "(", "update", "(", "M", ")", ")", ";", "}", "</s>" ]

[ "remove", "-", "Remove", "the", "specified", "key/value", "pair", "from", "the", "map", ",", "but", "do", "not", "erase", "it", "." ]

[ "Hexagon", "\"N and D should not be equal\"" ]

[]

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

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

[ "SIC", "SIC" ]

[]

[ "<s>", "int", "compute_a_shift_cc", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "operands", ")", "{", "rtx", "shift", "=", "operands", "[", "3", "]", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "shift", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "shift", ")", ";", "enum", "shift_type", "shift_type", ";", "enum", "shift_mode", "shift_mode", ";", "struct", "shift_info", "info", ";", "int", "n", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "shift_mode", "=", "QIshift", ";", "break", ";", "case", "HImode", ":", "shift_mode", "=", "HIshift", ";", "break", ";", "case", "SImode", ":", "shift_mode", "=", "SIshift", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "ASHIFTRT", ":", "shift_type", "=", "SHIFT_ASHIFTRT", ";", "break", ";", "case", "LSHIFTRT", ":", "shift_type", "=", "SHIFT_LSHIFTRT", ";", "break", ";", "case", "ASHIFT", ":", "shift_type", "=", "SHIFT_ASHIFT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", ";", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "n", "<", "0", ")", "n", "=", "0", ";", "else", "if", "(", "(", "unsigned", "int", ")", "n", ">", "GET_MODE_BITSIZE", "(", "mode", ")", ")", "n", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "get_shift_alg", "(", "shift_type", ",", "shift_mode", ",", "n", ",", "&", "info", ")", ";", "switch", "(", "info", ".", "alg", ")", "{", "case", "SHIFT_SPECIAL", ":", "if", "(", "info", ".", "remainder", "==", "0", ")", "return", "info", ".", "cc_special", ";", "case", "SHIFT_INLINE", ":", "return", "info", ".", "cc_inline", ";", "case", "SHIFT_ROT_AND", ":", "return", "CC_SET_ZNV", ";", "case", "SHIFT_LOOP", ":", "if", "(", "info", ".", "shift2", "!=", "NULL", ")", "{", "if", "(", "n", "%", "2", ")", "return", "info", ".", "cc_inline", ";", "}", "return", "CC_CLOBBER", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Compute", "which", "flag", "bits", "are", "valid", "after", "a", "shift", "insn", "." ]

[ "h8300", "3", "2", "2", "0", "0", "0", "2" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "CallGraphResourceInfo", ".", "clear", "(", ")", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "pa_asm_output_aligned_local", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ")", "{", "bss_section", "(", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.align %u\\n\"", ",", "align", "/", "BITS_PER_UNIT", ")", ";", "fprintf", "(", "stream", ",", "\"%s\"", ",", "LOCAL_ASM_OP", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "ASM_OUTPUT_LABEL", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.block \"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\"\\n\"", ",", "size", ")", ";", "}", "</s>" ]

[ "We", "ca", "n't", "use", ".comm", "for", "local", "common", "storage", "as", "the", "SOM", "linker", "effectively", "treats", "the", "symbol", "as", "universal", "and", "uses", "the", "same", "storage", "for", "local", "symbols", "with", "the", "same", "name", "in", "different", "object", "files", ".", "The", ".block", "directive", "reserves", "an", "uninitialized", "block", "of", "storage", ".", "However", ",", "it", "'s", "not", "common", "storage", ".", "Fortunately", ",", "GCC", "never", "requests", "common", "storage", "with", "the", "same", "name", "in", "any", "given", "translation", "unit", "." ]

[ "pa", "\"\\t.align %u\\n\"", "\"%s\"", "\"\\n\"", "\"\\t.block \"", "\"\\n\"" ]

[]

[ "<s>", "unsigned", "getPointerSize", "(", ")", "const", "{", "return", "4", ";", "}", "</s>" ]

[ "Layout", "pointer", "size", "in", "bytes", ",", "rounded", "up", "to", "a", "whole", "number", "of", "bytes", "." ]

[ "ARM", "4" ]

[]

[ "<s>", "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "JITInfo", "(", ")", ",", "InstrItins", "(", "Subtarget", ".", "getInstrItineraryData", "(", ")", ")", "{", "if", "(", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "FloatABIType", "=", "FloatABI", "::", "Soft", ";", "}", "</s>" ]

[ "Create", "an", "ARM", "architecture", "model", "." ]

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

[]

[ "<s>", "bool", "M88kMCAsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "M88k", "M88k" ]

[]

[ "<s>", "const", "uint16_t", "*", "XCoreRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "XCore", "::", "R4", ",", "XCore", "::", "R5", ",", "XCore", "::", "R6", ",", "XCore", "::", "R7", ",", "XCore", "::", "R8", ",", "XCore", "::", "R9", ",", "XCore", "::", "R10", ",", "0", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsFP", "[", "]", "=", "{", "XCore", "::", "R4", ",", "XCore", "::", "R5", ",", "XCore", "::", "R6", ",", "XCore", "::", "R7", ",", "XCore", "::", "R8", ",", "XCore", "::", "R9", ",", "0", "}", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", "->", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "return", "CalleeSavedRegsFP", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "XCore", "XCore", "XCore::R4", "XCore::R5", "XCore::R6", "XCore::R7", "XCore::R8", "XCore::R9", "XCore::R10", "0", "XCore::R4", "XCore::R5", "XCore::R6", "XCore::R7", "XCore::R8", "XCore::R9", "0" ]

[]

[ "<s>", "static", "bool", "isShiftedMask", "(", "uint64_t", "I", ",", "uint64_t", "&", "Pos", ",", "uint64_t", "&", "Size", ")", "{", "if", "(", "!", "isShiftedMask_64", "(", "I", ")", ")", "return", "false", ";", "Size", "=", "countPopulation", "(", "I", ")", ";", "Pos", "=", "countTrailingZeros", "(", "I", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "APInt", "value", "contains", "a", "non-empty", "sequence", "of", "ones", "with", "the", "remainder", "zero", "." ]

[ "Mips" ]

[]

[ "<s>", "void", "rs6000_print_patchable_function_entry", "(", "FILE", "*", "file", ",", "unsigned", "HOST_WIDE_INT", "patch_area_size", ",", "bool", "record_p", ")", "{", "unsigned", "int", "flags", "=", "SECTION_WRITE", "|", "SECTION_RELRO", ";", "if", "(", "!", "(", "TARGET_64BIT", "&&", "DEFAULT_ABI", "!=", "ABI_ELFv2", ")", "&&", "HAVE_GAS_SECTION_LINK_ORDER", ")", "flags", "|=", "SECTION_LINK_ORDER", ";", "default_print_patchable_function_entry_1", "(", "file", ",", "patch_area_size", ",", "record_p", ",", "flags", ")", ";", "}", "</s>" ]

[ "Write", "PATCH_AREA_SIZE", "NOPs", "into", "the", "asm", "outfile", "FILE", "around", "a", "function", "entry", ".", "If", "RECORD_P", "is", "true", "and", "the", "target", "supports", "named", "sections", ",", "the", "location", "of", "the", "NOPs", "will", "be", "recorded", "in", "a", "special", "object", "section", "called", "``", "__patchable_function_entries", "''", ".", "This", "routine", "may", "be", "called", "twice", "per", "function", "to", "put", "NOPs", "before", "and", "after", "the", "function", "entry", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "dump", "(", "SelectionDAG", "*", "DAG", "=", "nullptr", ")", "{", "dbgs", "(", ")", "<<", "\"X86ISelAddressMode \"", "<<", "this", "<<", "'\\n'", ";", "dbgs", "(", ")", "<<", "\"Base_Reg \"", ";", "if", "(", "Base_Reg", ".", "getNode", "(", ")", ")", "Base_Reg", ".", "getNode", "(", ")", "->", "dump", "(", "DAG", ")", ";", "else", "dbgs", "(", ")", "<<", "\"nul\\n\"", ";", "if", "(", "BaseType", "==", "FrameIndexBase", ")", "dbgs", "(", ")", "<<", "\" Base.FrameIndex \"", "<<", "Base_FrameIndex", "<<", "'\\n'", ";", "dbgs", "(", ")", "<<", "\" Scale \"", "<<", "Scale", "<<", "'\\n'", "<<", "\"IndexReg \"", ";", "if", "(", "IndexReg", ".", "getNode", "(", ")", ")", "IndexReg", ".", "getNode", "(", ")", "->", "dump", "(", "DAG", ")", ";", "else", "dbgs", "(", ")", "<<", "\"nul\\n\"", ";", "dbgs", "(", ")", "<<", "\" Disp \"", "<<", "Disp", "<<", "'\\n'", "<<", "\"GV \"", ";", "if", "(", "GV", ")", "GV", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "\" CP \"", ";", "if", "(", "CP", ")", "CP", "->", "dump", "(", ")", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "'\\n'", "<<", "\"ES \"", ";", "if", "(", "ES", ")", "dbgs", "(", ")", "<<", "ES", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "\" MCSym \"", ";", "if", "(", "MCSym", ")", "dbgs", "(", ")", "<<", "MCSym", ";", "else", "dbgs", "(", ")", "<<", "\"nul\"", ";", "dbgs", "(", ")", "<<", "\" JT\"", "<<", "JT", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "X86", "\"X86ISelAddressMode \"", "\"Base_Reg \"", "\"nul\\n\"", "\" Base.FrameIndex \"", "\" Scale \"", "\"IndexReg \"", "\"nul\\n\"", "\" Disp \"", "\"GV \"", "\"nul\"", "\" CP \"", "\"nul\"", "\"ES \"", "\"nul\"", "\" MCSym \"", "\"nul\"", "\" JT\"", "\" Align\"" ]

[]

[ "<s>", "static", "rtx", "riscv_expand_builtin_direct", "(", "enum", "insn_code", "icode", ",", "rtx", "target", ",", "tree", "exp", ",", "bool", "has_target_p", ")", "{", "struct", "expand_operand", "ops", "[", "MAX_RECOG_OPERANDS", "]", ";", "int", "opno", "=", "0", ";", "if", "(", "has_target_p", ")", "create_output_operand", "(", "&", "ops", "[", "opno", "++", "]", ",", "target", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ")", ";", "gcc_assert", "(", "opno", "+", "call_expr_nargs", "(", "exp", ")", "==", "insn_data", "[", "icode", "]", ".", "n_generator_args", ")", ";", "for", "(", "int", "argno", "=", "0", ";", "argno", "<", "call_expr_nargs", "(", "exp", ")", ";", "argno", "++", ")", "riscv_prepare_builtin_arg", "(", "&", "ops", "[", "opno", "++", "]", ",", "exp", ",", "argno", ")", ";", "return", "riscv_expand_builtin_insn", "(", "icode", ",", "opno", ",", "ops", ",", "has_target_p", ")", ";", "}", "</s>" ]

[ "Expand", "a", "RISCV_BUILTIN_DIRECT", "or", "RISCV_BUILTIN_DIRECT_NO_TARGET", "function", ";", "HAS_TARGET_P", "says", "which", ".", "EXP", "is", "the", "CALL_EXPR", "that", "calls", "the", "function", "and", "ICODE", "is", "the", "code", "of", "the", "associated", ".md", "pattern", ".", "TARGET", ",", "if", "nonnull", ",", "suggests", "a", "good", "place", "to", "put", "the", "result", "." ]

[ "riscv", "0", "0" ]

[]

[ "<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", "fun", ")", "{", "return", "rs6000_analyze_swaps", "(", "fun", ")", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "const", "AArch64Subtarget", "*", "AArch64TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "unsigned", "MinSVEVectorSize", "=", "0", ";", "unsigned", "MaxSVEVectorSize", "=", "0", ";", "Attribute", "VScaleRangeAttr", "=", "F", ".", "getFnAttribute", "(", "Attribute", "::", "VScaleRange", ")", ";", "if", "(", "VScaleRangeAttr", ".", "isValid", "(", ")", ")", "{", "std", "::", "tie", "(", "MinSVEVectorSize", ",", "MaxSVEVectorSize", ")", "=", "VScaleRangeAttr", ".", "getVScaleRangeArgs", "(", ")", ";", "MinSVEVectorSize", "*=", "128", ";", "MaxSVEVectorSize", "*=", "128", ";", "}", "else", "{", "MinSVEVectorSize", "=", "SVEVectorBitsMinOpt", ";", "MaxSVEVectorSize", "=", "SVEVectorBitsMaxOpt", ";", "}", "assert", "(", "MinSVEVectorSize", "%", "128", "==", "0", "&&", "\"SVE requires vector length in multiples of 128!\"", ")", ";", "assert", "(", "MaxSVEVectorSize", "%", "128", "==", "0", "&&", "\"SVE requires vector length in multiples of 128!\"", ")", ";", "assert", "(", "(", "MaxSVEVectorSize", ">=", "MinSVEVectorSize", "||", "MaxSVEVectorSize", "==", "0", ")", "&&", "\"Minimum SVE vector size should not be larger than its maximum!\"", ")", ";", "if", "(", "MaxSVEVectorSize", "==", "0", ")", "MinSVEVectorSize", "=", "(", "MinSVEVectorSize", "/", "128", ")", "*", "128", ";", "else", "{", "MinSVEVectorSize", "=", "(", "std", "::", "min", "(", "MinSVEVectorSize", ",", "MaxSVEVectorSize", ")", "/", "128", ")", "*", "128", ";", "MaxSVEVectorSize", "=", "(", "std", "::", "max", "(", "MinSVEVectorSize", ",", "MaxSVEVectorSize", ")", "/", "128", ")", "*", "128", ";", "}", "Key", "+=", "\"SVEMin\"", ";", "Key", "+=", "std", "::", "to_string", "(", "MinSVEVectorSize", ")", ";", "Key", "+=", "\"SVEMax\"", ";", "Key", "+=", "std", "::", "to_string", "(", "MaxSVEVectorSize", ")", ";", "Key", "+=", "CPU", ";", "Key", "+=", "FS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "AArch64Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ",", "MinSVEVectorSize", ",", "MaxSVEVectorSize", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "AArch64", "AArch64", "AArch64", "\"target-cpu\"", "\"target-features\"", "512", "0", "0", "128", "128", "128", "0", "\"SVE requires vector length in multiples of 128!\"", "128", "0", "\"SVE requires vector length in multiples of 128!\"", "0", "\"Minimum SVE vector size should not be larger than its maximum!\"", "0", "128", "128", "128", "128", "128", "128", "\"SVEMin\"", "\"SVEMax\"", "AArch64" ]

[]

[ "<s>", "static", "void", "pop", "(", "int", "rn", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "word_mode", ",", "rn", ")", ";", "rtx", "x", ";", "if", "(", "TARGET_H8300", ")", "x", "=", "gen_pop_h8300", "(", "reg", ")", ";", "else", "if", "(", "!", "TARGET_NORMAL_MODE", ")", "x", "=", "gen_pop_h8300hs_advanced", "(", "reg", ")", ";", "else", "x", "=", "gen_pop_h8300hs_normal", "(", "reg", ")", ";", "x", "=", "emit_insn", "(", "x", ")", ";", "REG_NOTES", "(", "x", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_INC", ",", "stack_pointer_rtx", ",", "0", ")", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "pop", "register", "RN", "from", "the", "stack", "." ]

[ "h8300", "0" ]

[]