Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "SITargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AS", ")", "{", "case", "AMDGPUAS", "::", "GLOBAL_ADDRESS", ":", "if", "(", "Subtarget", "->", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "return", "isLegalFlatAddressingMode", "(", "AM", ")", ";", "}", "case", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ":", "case", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ":", "case", "AMDGPUAS", "::", "UNKNOWN_ADDRESS_SPACE", ":", "{", "if", "(", "!", "isUInt", "<", "12", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "return", "true", ";", "case", "1", ":", "return", "true", ";", "case", "2", ":", "if", "(", "AM", ".", "HasBaseReg", ")", "{", "return", "false", ";", "}", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "case", "AMDGPUAS", "::", "LOCAL_ADDRESS", ":", "case", "AMDGPUAS", "::", "REGION_ADDRESS", ":", "{", "if", "(", "!", "isUInt", "<", "16", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "Scale", "==", "0", ")", "return", "true", ";", "if", "(", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "HasBaseReg", ")", "return", "true", ";", "return", "false", ";", "}", "case", "AMDGPUAS", "::", "FLAT_ADDRESS", ":", "return", "isLegalFlatAddressingMode", "(", "AM", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unhandled address space\"", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "12", "0", "1", "2", "AMDGPU", "AMDGPU", "16", "0", "1", "AMDGPU", "\"unhandled address space\"" ]

[]

[ "<s>", "DecodeStatus", "BPFDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "bool", "IsLittleEndian", "=", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", "->", "isLittleEndian", "(", ")", ";", "uint64_t", "Insn", ",", "Hi", ";", "DecodeStatus", "Result", ";", "Result", "=", "readInstruction64", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ",", "IsLittleEndian", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "uint8_t", "InstClass", "=", "getInstClass", "(", "Insn", ")", ";", "uint8_t", "InstMode", "=", "getInstMode", "(", "Insn", ")", ";", "if", "(", "(", "InstClass", "==", "BPF_LDX", "||", "InstClass", "==", "BPF_STX", ")", "&&", "getInstSize", "(", "Insn", ")", "!=", "BPF_DW", "&&", "(", "InstMode", "==", "BPF_MEM", "||", "InstMode", "==", "BPF_XADD", ")", "&&", "STI", ".", "getFeatureBits", "(", ")", "[", "BPF", "::", "ALU32", "]", ")", "Result", "=", "decodeInstruction", "(", "DecoderTableBPFALU3264", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "else", "Result", "=", "decodeInstruction", "(", "DecoderTableBPF64", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "switch", "(", "Instr", ".", "getOpcode", "(", ")", ")", "{", "case", "BPF", "::", "LD_imm64", ":", "case", "BPF", "::", "LD_pseudo", ":", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "16", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Size", "=", "16", ";", "if", "(", "IsLittleEndian", ")", "Hi", "=", "(", "Bytes", "[", "12", "]", "<<", "0", ")", "|", "(", "Bytes", "[", "13", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "14", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "15", "]", "<<", "24", ")", ";", "else", "Hi", "=", "(", "Bytes", "[", "12", "]", "<<", "24", ")", "|", "(", "Bytes", "[", "13", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "14", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "15", "]", "<<", "0", ")", ";", "auto", "&", "Op", "=", "Instr", ".", "getOperand", "(", "1", ")", ";", "Op", ".", "setImm", "(", "Make_64", "(", "Hi", ",", "Op", ".", "getImm", "(", ")", ")", ")", ";", "break", ";", "}", "case", "BPF", "::", "LD_ABS_B", ":", "case", "BPF", "::", "LD_ABS_H", ":", "case", "BPF", "::", "LD_ABS_W", ":", "case", "BPF", "::", "LD_IND_B", ":", "case", "BPF", "::", "LD_IND_H", ":", "case", "BPF", "::", "LD_IND_W", ":", "{", "auto", "Op", "=", "Instr", ".", "getOperand", "(", "0", ")", ";", "Instr", ".", "clear", "(", ")", ";", "Instr", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "BPF", "::", "R6", ")", ")", ";", "Instr", ".", "addOperand", "(", "Op", ")", ";", "break", ";", "}", "}", "return", "Result", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "BPF", "BPF", "BPF", "BPF", "BPF", "BPF", "BPF", "BPF::ALU32", "BPF", "BPF", "BPF::LD_imm64", "BPF::LD_pseudo", "16", "0", "16", "12", "0", "13", "8", "14", "16", "15", "24", "12", "24", "13", "16", "14", "8", "15", "0", "1", "BPF::LD_ABS_B", "BPF::LD_ABS_H", "BPF::LD_ABS_W", "BPF::LD_IND_B", "BPF::LD_IND_H", "BPF::LD_IND_W", "0", "BPF::R6" ]

[]

[ "<s>", "rtx", "extract_pattern_from_insn", "(", "rtx", "insn", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "return", "PATTERN", "(", "insn", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Get", "the", "rtx", "in", "the", "PATTERN", "field", "of", "an", "insn", ".", "If", "INSN", "is", "not", "an", "insn", ",", "the", "funciton", "does", "n't", "change", "anything", "and", "returns", "it", "directly", "." ]

[ "nds32" ]

[]

[ "<s>", "HOST_WIDE_INT", "mips_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "HOST_WIDE_INT", "offset", ";", "compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "offset", "=", "0", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "offset", "=", "(", "cfun", "->", "machine", "->", "frame", ".", "total_size", "-", "current_function_pretend_args_size", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "TARGET_MIPS16", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "offset", "-=", "cfun", "->", "machine", "->", "frame", ".", "args_size", ";", "return", "offset", ";", "}", "</s>" ]

[ "Implement", "INITIAL_ELIMINATION_OFFSET", ".", "FROM", "is", "either", "the", "frame", "pointer", "or", "argument", "pointer", ".", "TO", "is", "either", "the", "stack", "pointer", "or", "hard", "frame", "pointer", "." ]

[ "mips", "0" ]

[]

[ "<s>", "bool", "ok_for_simple_arith_logic_operands", "(", "rtx", "*", ",", "enum", "machine_mode", ")", "{", "return", "!", "visium_flags_exposed", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "operands", "are", "valid", "for", "a", "simple", "arithmetic", "or", "logical", "insn", "." ]

[ "visium" ]

[]

[ "<s>", "const", "char", "*", "loongarch_output_division", "(", "const", "char", "*", "division", ",", "rtx", "*", "operands", ")", "{", "const", "char", "*", "s", ";", "s", "=", "division", ";", "if", "(", "TARGET_CHECK_ZERO_DIV", ")", "{", "output_asm_insn", "(", "s", ",", "operands", ")", ";", "s", "=", "\"bne\\t%2,%.,1f\\n\\tbreak\\t7\\n1:\"", ";", "}", "return", "s", ";", "}", "</s>" ]

[ "Return", "the", "assembly", "code", "for", "DIV", ".", "{", "W/D", "}", "instruction", "DIVISION", ",", "which", "has", "the", "operands", "given", "by", "OPERANDS", ".", "Add", "in", "a", "divide-by-zero", "check", "if", "needed", "." ]

[ "loongarch", "\"bne\\t%2,%.,1f\\n\\tbreak\\t7\\n1:\"" ]

[]

[ "<s>", "const", "char", "*", "m68k_output_branch_integer", "(", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "\"jeq %l3\"", ";", "case", "NE", ":", "return", "\"jne %l3\"", ";", "case", "GT", ":", "return", "\"jgt %l3\"", ";", "case", "GTU", ":", "return", "\"jhi %l3\"", ";", "case", "LT", ":", "return", "\"jlt %l3\"", ";", "case", "LTU", ":", "return", "\"jcs %l3\"", ";", "case", "GE", ":", "return", "\"jge %l3\"", ";", "case", "GEU", ":", "return", "\"jcc %l3\"", ";", "case", "LE", ":", "return", "\"jle %l3\"", ";", "case", "LEU", ":", "return", "\"jls %l3\"", ";", "case", "PLUS", ":", "return", "\"jpl %l3\"", ";", "case", "MINUS", ":", "return", "\"jmi %l3\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "an", "output", "template", "for", "a", "branch", "with", "CODE", "." ]

[ "m68k", "\"jeq %l3\"", "\"jne %l3\"", "\"jgt %l3\"", "\"jhi %l3\"", "\"jlt %l3\"", "\"jcs %l3\"", "\"jge %l3\"", "\"jcc %l3\"", "\"jle %l3\"", "\"jls %l3\"", "\"jpl %l3\"", "\"jmi %l3\"" ]

[]

[ "<s>", "unsigned", "GBZ80InstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "!", "isUnconditionalBranch", "(", "*", "I", ")", "&&", "!", "isConditionalBranch", "(", "*", "I", ")", ")", "{", "break", ";", "}", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "GBZ80", "GB", "0", "0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AAResults", "*", "AA", ")", "const", "{", "if", "(", "isVOP1", "(", "MI", ")", "||", "isVOP2", "(", "MI", ")", "||", "isVOP3", "(", "MI", ")", "||", "isSDWA", "(", "MI", ")", ")", "{", "return", "!", "MI", ".", "hasImplicitDef", "(", ")", "&&", "MI", ".", "getNumImplicitOperands", "(", ")", "==", "MI", ".", "getDesc", "(", ")", ".", "getNumImplicitUses", "(", ")", "&&", "!", "MI", ".", "mayRaiseFPException", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI" ]

[]

[ "<s>", "void", "LanaiPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createLanaiDelaySlotFillerPass", "(", "getLanaiTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai", "Lanai" ]

[]

[ "<s>", "bool", "SPUAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "case", "'L'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", "||", "OpNo", "+", "1", "==", "MI", "->", "getNumOperands", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "++", "OpNo", ";", "break", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "0", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "bool", "SparcAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "SparcOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "applyMnemonicAliases", "(", "Name", ",", "getAvailableFeatures", "(", ")", ",", "0", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "if", "(", "parseBranchModifiers", "(", "Operands", ")", "!=", "MatchOperand_Success", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "}", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", "!=", "MatchOperand_Success", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", "!=", "MatchOperand_Success", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SparcOperand::CreateToken", "0", "\"unexpected token\"", "\"unexpected token\"", "\"unexpected token\"", "\"unexpected token\"" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ";", "++", "i", ")", "assert", "(", "i", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "if", "(", "!", "MI", "->", "mayLoad", "(", ")", "&&", "!", "MI", "->", "mayStore", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int64_t", "FPOffset", "=", "Offset", "-", "16", "*", "20", ";", "Offset", "+=", "MFI", "->", "getLocalFrameSize", "(", ")", ";", "Offset", "+=", "128", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "&&", "isFrameOffsetLegal", "(", "MI", ",", "AArch64", "::", "FP", ",", "FPOffset", ")", ")", "return", "false", ";", "if", "(", "isFrameOffsetLegal", "(", "MI", ",", "AArch64", "::", "SP", ",", "Offset", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "AArch64", "AArch64", "0", "\"Instr doesn't have FrameIndex operand!\"", "AArch64", "16", "20", "128", "AArch64::FP", "AArch64::SP" ]

[]

[ "<s>", "bool", "Thumb2ITBlockPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetMachine", "&", "TM", "=", "Fn", ".", "getTarget", "(", ")", ";", "AFI", "=", "Fn", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "return", "false", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "Modified", "|=", "InsertITBlocks", "(", "MBB", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "int", "s390_float_const_zero_p", "(", "rtx", "value", ")", "{", "return", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "value", ")", ")", "==", "MODE_FLOAT", "&&", "value", "==", "CONST0_RTX", "(", "GET_MODE", "(", "value", ")", ")", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "input", "parameter", "VALUE", "is", "a", "float", "zero", "." ]

[ "s390" ]

[]

[ "<s>", "static", "enum", "attr_type", "s390_safe_attr_type", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", ")", "return", "get_attr_type", "(", "insn", ")", ";", "else", "return", "TYPE_NONE", ";", "}", "</s>" ]

[ "Return", "attribute", "type", "of", "insn", "." ]

[ "s390", "0" ]

[]

[ "<s>", "void", "SPIRVAsmPrinter", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "SPIRVModuleAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "SPIRVModuleAnalysis", ">", "(", ")", ";", "AsmPrinter", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV", "SPIRV", "SPIRV" ]

[]

[ "<s>", "int", "load_update_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", "||", "GET_MODE", "(", "op", ")", "!=", "mode", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "PLUS", "||", "GET_MODE", "(", "op", ")", "!=", "Pmode", "||", "!", "register_operand", "(", "XEXP", "(", "op", ",", "0", ")", ",", "Pmode", ")", "||", "!", "nonmemory_operand", "(", "XEXP", "(", "op", ",", "1", ")", ",", "Pmode", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "valid", "load", "with", "update", "operand", "." ]

[ "arc", "0", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "void", "rs6000_output_tlsargs", "(", "rtx", "*", "operands", ")", "{", "rtx", "op", "[", "3", "]", ";", "op", "[", "0", "]", "=", "operands", "[", "0", "]", ";", "op", "[", "1", "]", "=", "XVECEXP", "(", "operands", "[", "2", "]", ",", "0", ",", "0", ")", ";", "if", "(", "XINT", "(", "operands", "[", "2", "]", ",", "1", ")", "==", "UNSPEC_TLSGD", ")", "{", "op", "[", "2", "]", "=", "XVECEXP", "(", "operands", "[", "2", "]", ",", "0", ",", "1", ")", ";", "if", "(", "TARGET_CMODEL", "!=", "CMODEL_SMALL", ")", "output_asm_insn", "(", "\"addis %0,%2,%1@got@tlsgd@ha\\n\\t\"", "\"addi %0,%0,%1@got@tlsgd@l\"", ",", "op", ")", ";", "else", "output_asm_insn", "(", "\"addi %0,%2,%1@got@tlsgd\"", ",", "op", ")", ";", "}", "else", "if", "(", "XINT", "(", "operands", "[", "2", "]", ",", "1", ")", "==", "UNSPEC_TLSLD", ")", "{", "if", "(", "TARGET_CMODEL", "!=", "CMODEL_SMALL", ")", "output_asm_insn", "(", "\"addis %0,%1,%&@got@tlsld@ha\\n\\t\"", "\"addi %0,%0,%&@got@tlsld@l\"", ",", "op", ")", ";", "else", "output_asm_insn", "(", "\"addi %0,%1,%&@got@tlsld\"", ",", "op", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Output", "arg", "setup", "instructions", "for", "a", "!", "TARGET_TLS_MARKERS", "__tls_get_addr", "call", "." ]

[ "rs6000", "3", "0", "0", "1", "2", "0", "0", "2", "1", "2", "2", "0", "1", "\"addis %0,%2,%1@got@tlsgd@ha\\n\\t\"", "\"addi %0,%0,%1@got@tlsgd@l\"", "\"addi %0,%2,%1@got@tlsgd\"", "2", "1", "\"addis %0,%1,%&@got@tlsld@ha\\n\\t\"", "\"addi %0,%0,%&@got@tlsld@l\"", "\"addi %0,%1,%&@got@tlsld\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "lowerInterleavedStore", "(", "StoreInst", "*", "SI", ",", "ShuffleVectorInst", "*", "SVI", ",", "unsigned", "Factor", ")", "const", "{", "assert", "(", "Factor", ">=", "2", "&&", "Factor", "<=", "getMaxSupportedInterleaveFactor", "(", ")", "&&", "\"Invalid interleave factor\"", ")", ";", "VectorType", "*", "VecTy", "=", "SVI", "->", "getType", "(", ")", ";", "assert", "(", "VecTy", "->", "getVectorNumElements", "(", ")", "%", "Factor", "==", "0", "&&", "\"Invalid interleaved store\"", ")", ";", "unsigned", "NumSubElts", "=", "VecTy", "->", "getVectorNumElements", "(", ")", "/", "Factor", ";", "Type", "*", "EltTy", "=", "VecTy", "->", "getVectorElementType", "(", ")", ";", "VectorType", "*", "SubVecTy", "=", "VectorType", "::", "get", "(", "EltTy", ",", "NumSubElts", ")", ";", "const", "DataLayout", "&", "DL", "=", "SI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "SubVecSize", "=", "DL", ".", "getTypeSizeInBits", "(", "SubVecTy", ")", ";", "bool", "EltIs64Bits", "=", "DL", ".", "getTypeSizeInBits", "(", "EltTy", ")", "==", "64", ";", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", "||", "(", "SubVecSize", "!=", "64", "&&", "SubVecSize", "!=", "128", ")", "||", "EltIs64Bits", ")", "return", "false", ";", "Value", "*", "Op0", "=", "SVI", "->", "getOperand", "(", "0", ")", ";", "Value", "*", "Op1", "=", "SVI", "->", "getOperand", "(", "1", ")", ";", "IRBuilder", "<", ">", "Builder", "(", "SI", ")", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "{", "Type", "*", "IntTy", "=", "DL", ".", "getIntPtrType", "(", "EltTy", ")", ";", "Type", "*", "IntVecTy", "=", "VectorType", "::", "get", "(", "IntTy", ",", "Op0", "->", "getType", "(", ")", "->", "getVectorNumElements", "(", ")", ")", ";", "Op0", "=", "Builder", ".", "CreatePtrToInt", "(", "Op0", ",", "IntVecTy", ")", ";", "Op1", "=", "Builder", ".", "CreatePtrToInt", "(", "Op1", ",", "IntVecTy", ")", ";", "SubVecTy", "=", "VectorType", "::", "get", "(", "IntTy", ",", "NumSubElts", ")", ";", "}", "static", "const", "Intrinsic", "::", "ID", "StoreInts", "[", "3", "]", "=", "{", "Intrinsic", "::", "arm_neon_vst2", ",", "Intrinsic", "::", "arm_neon_vst3", ",", "Intrinsic", "::", "arm_neon_vst4", "}", ";", "SmallVector", "<", "Value", "*", ",", "6", ">", "Ops", ";", "Type", "*", "Int8Ptr", "=", "Builder", ".", "getInt8PtrTy", "(", "SI", "->", "getPointerAddressSpace", "(", ")", ")", ";", "Ops", ".", "push_back", "(", "Builder", ".", "CreateBitCast", "(", "SI", "->", "getPointerOperand", "(", ")", ",", "Int8Ptr", ")", ")", ";", "Type", "*", "Tys", "[", "]", "=", "{", "Int8Ptr", ",", "SubVecTy", "}", ";", "Function", "*", "VstNFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "SI", "->", "getModule", "(", ")", ",", "StoreInts", "[", "Factor", "-", "2", "]", ",", "Tys", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Factor", ";", "i", "++", ")", "Ops", ".", "push_back", "(", "Builder", ".", "CreateShuffleVector", "(", "Op0", ",", "Op1", ",", "getSequentialMask", "(", "Builder", ",", "NumSubElts", "*", "i", ",", "NumSubElts", ")", ")", ")", ";", "Ops", ".", "push_back", "(", "Builder", ".", "getInt32", "(", "SI", "->", "getAlignment", "(", ")", ")", ")", ";", "Builder", ".", "CreateCall", "(", "VstNFunc", ",", "Ops", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Lower", "interleaved", "store", "(", "s", ")", "into", "target", "specific", "instructions/intrinsics", "." ]

[ "ARM", "ARM", "2", "\"Invalid interleave factor\"", "0", "\"Invalid interleaved store\"", "64", "64", "128", "0", "1", "Intrinsic::ID", "3", "Intrinsic::arm_neon_vst2", "Intrinsic::arm_neon_vst3", "Intrinsic::arm_neon_vst4", "6", "Intrinsic::getDeclaration", "2", "0" ]

[]

[ "<s>", "bool", "AArch64StorePairSuppress", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "TargetSubtargetInfo", "&", "ST", "=", "MF", ".", "getSubtarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "SchedModel", ".", "init", "(", "ST", ".", "getSchedModel", "(", ")", ",", "&", "ST", ",", "TII", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Skipping pass: no machine model present.\\n\"", ")", ";", "return", "false", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "SuppressSTP", "=", "false", ";", "unsigned", "PrevBaseReg", "=", "0", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isNarrowFPStore", "(", "MI", ")", ")", "continue", ";", "unsigned", "BaseReg", ";", "int64_t", "Offset", ";", "if", "(", "TII", "->", "getMemOpBaseRegImmOfs", "(", "MI", ",", "BaseReg", ",", "Offset", ",", "TRI", ")", ")", "{", "if", "(", "PrevBaseReg", "==", "BaseReg", ")", "{", "if", "(", "!", "SuppressSTP", "&&", "shouldAddSTPToBlock", "(", "MI", ".", "getParent", "(", ")", ")", ")", "break", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unpairing store \"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "SuppressSTP", "=", "true", ";", "TII", "->", "suppressLdStPair", "(", "MI", ")", ";", "}", "PrevBaseReg", "=", "BaseReg", ";", "}", "else", "PrevBaseReg", "=", "0", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"*** \"", "\": \"", "\" Skipping pass: no machine model present.\\n\"", "0", "\"Unpairing store \"", "\"\\n\"", "0" ]

[]

[ "<s>", "bool", "WebAssemblyPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createWebAssemblyISelDag", "(", "getWebAssemblyTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "M0", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_POPS_EXITING_WAVE_ID", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "XNACK_MASK", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "LDS_DIRECT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP12_TTMP13", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP14_TTMP15", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SGPR_NULL", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "unsigned", "StackPtrReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "StackPtrReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "StackPtrReg", ")", ")", ";", "}", "unsigned", "FrameReg", "=", "MFI", "->", "getFrameOffsetReg", "(", ")", ";", "if", "(", "FrameReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "FrameReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "FrameReg", ")", ")", ";", "}", "for", "(", "unsigned", "Reg", ":", "MFI", "->", "WWMReservedRegs", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "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", "." ]

[ "AMDGPU", "SI", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::M0", "AMDGPU::SRC_SHARED_BASE", "AMDGPU::SRC_SHARED_LIMIT", "AMDGPU::SRC_PRIVATE_BASE", "AMDGPU::SRC_PRIVATE_LIMIT", "AMDGPU::SRC_POPS_EXITING_WAVE_ID", "AMDGPU::XNACK_MASK", "AMDGPU::LDS_DIRECT", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "AMDGPU::TTMP12_TTMP13", "AMDGPU::TTMP14_TTMP15", "AMDGPU::SGPR_NULL", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "AMDGPU::NoRegister" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "X86SSELevel", "(", "NoMMXSSE", ")", ",", "X863DNowLevel", "(", "NoThreeDNow", ")", ",", "HasCMov", "(", "false", ")", ",", "HasX86_64", "(", "false", ")", ",", "HasSSE4A", "(", "false", ")", ",", "HasAVX", "(", "false", ")", ",", "HasAES", "(", "false", ")", ",", "HasCLMUL", "(", "false", ")", ",", "HasFMA3", "(", "false", ")", ",", "HasFMA4", "(", "false", ")", ",", "IsBTMemSlow", "(", "false", ")", ",", "IsUAMemFast", "(", "false", ")", ",", "HasVectorUAMem", "(", "false", ")", ",", "stackAlignment", "(", "8", ")", ",", "MaxInlineSizeThreshold", "(", "128", ")", ",", "TargetTriple", "(", "TT", ")", ",", "Is64Bit", "(", "is64Bit", ")", "{", "if", "(", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "if", "(", "!", "FS", ".", "empty", "(", ")", ")", "{", "std", "::", "string", "CPU", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "}", "else", "{", "AutoDetectSubtargetFeatures", "(", ")", ";", "if", "(", "Is64Bit", "&&", "X86SSELevel", "<", "SSE2", ")", "X86SSELevel", "=", "SSE2", ";", "}", "if", "(", "Is64Bit", ")", "{", "HasX86_64", "=", "true", ";", "HasCMov", "=", "true", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Subtarget features: SSELevel \"", "<<", "X86SSELevel", "<<", "\", 3DNowLevel \"", "<<", "X863DNowLevel", "<<", "\", 64bit \"", "<<", "HasX86_64", "<<", "\"\\n\"", ")", ";", "assert", "(", "(", "!", "Is64Bit", "||", "HasX86_64", ")", "&&", "\"64-bit code requested on a subtarget that doesn't support it!\"", ")", ";", "if", "(", "isTargetDarwin", "(", ")", "||", "Is64Bit", ")", "stackAlignment", "=", "16", ";", "if", "(", "StackAlignment", ")", "stackAlignment", "=", "StackAlignment", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86", "8", "128", "X86", "X86", "X86", "\"Subtarget features: SSELevel \"", "X86", "\", 3DNowLevel \"", "X86", "\", 64bit \"", "X86", "\"\\n\"", "X86", "\"64-bit code requested on a subtarget that doesn't support it!\"", "16" ]

[]

[ "<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "Expr", ";", "}", "</s>" ]

[ "getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "." ]

[ "CSKY" ]

[]

[ "<s>", "Register", "RISCVTargetLowering", "::", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "RISCVABI", "::", "isCheriPureCapABI", "(", "Subtarget", ".", "getTargetABI", "(", ")", ")", "?", "RISCV", "::", "C10", ":", "RISCV", "::", "X10", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVABI::isCheriPureCapABI", "RISCV::C10", "RISCV::X10" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "Options", ".", "MCOptions", ",", "LittleEndian", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectiveCodeModel", "(", "TT", ",", "CM", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "LittleEndian", ")", "{", "initAsmInfo", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "<=", "EnableGlobalISelAtO", ")", "setGlobalISel", "(", "true", ")", ";", "setMachineOutliner", "(", "true", ")", ";", "setSupportsDefaultOutlining", "(", "true", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "InstructionCost", "AArch64TTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "DataTy", ",", "const", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "Align", "Alignment", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "const", "Instruction", "*", "I", ")", "{", "if", "(", "!", "isa", "<", "ScalableVectorType", ">", "(", "DataTy", ")", ")", "return", "BaseT", "::", "getGatherScatterOpCost", "(", "Opcode", ",", "DataTy", ",", "Ptr", ",", "VariableMask", ",", "Alignment", ",", "CostKind", ",", "I", ")", ";", "auto", "*", "VT", "=", "cast", "<", "VectorType", ">", "(", "DataTy", ")", ";", "auto", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "DataTy", ")", ";", "ElementCount", "LegalVF", "=", "LT", ".", "second", ".", "getVectorElementCount", "(", ")", ";", "Optional", "<", "unsigned", ">", "MaxNumVScale", "=", "getMaxVScale", "(", ")", ";", "assert", "(", "MaxNumVScale", "&&", "\"Expected valid max vscale value\"", ")", ";", "InstructionCost", "MemOpCost", "=", "getMemoryOpCost", "(", "Opcode", ",", "VT", "->", "getElementType", "(", ")", ",", "Alignment", ",", "0", ",", "CostKind", ",", "I", ")", ";", "unsigned", "MaxNumElementsPerGather", "=", "MaxNumVScale", ".", "getValue", "(", ")", "*", "LegalVF", ".", "getKnownMinValue", "(", ")", ";", "return", "LT", ".", "first", "*", "MaxNumElementsPerGather", "*", "MemOpCost", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

[ "AArch64", "AArch64", "\"Expected valid max vscale value\"", "0" ]

[]

[ "<s>", "static", "inline", "SPIRV", "::", "SpecialTypeDescriptor", "getEmptyKey", "(", ")", "{", "return", "SPIRV", "::", "SpecialTypeDescriptor", "(", "SPIRV", "::", "SpecialTypeDescriptor", "::", "STK_Empty", ")", ";", "}", "</s>" ]

[ "Empty", "key", ":", "no", "key", "should", "be", "generated", "that", "has", "no", "DILocalVariable", "." ]

[ "SPIRV", "SPIRV::SpecialTypeDescriptor", "SPIRV::SpecialTypeDescriptor", "SPIRV::SpecialTypeDescriptor" ]

[]

[ "<s>", "bool", "Z80AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "\"Unimplemented\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Z80old Assembly / Object Emitter\"", ";", "}", "</s>" ]

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

[ "Z80old", "\"Z80old Assembly / Object Emitter\"" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "static", "tree", "mips_builtin_vectorized_function", "(", "unsigned", "int", "fn", ",", "tree", "type_out", ",", "tree", "type_in", ")", "{", "machine_mode", "in_mode", ",", "out_mode", ";", "int", "in_n", ",", "out_n", ";", "if", "(", "TREE_CODE", "(", "type_out", ")", "!=", "VECTOR_TYPE", "||", "TREE_CODE", "(", "type_in", ")", "!=", "VECTOR_TYPE", "||", "!", "ISA_HAS_MSA", ")", "return", "NULL_TREE", ";", "out_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_out", ")", ")", ";", "out_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_out", ")", ";", "in_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_in", ")", ")", ";", "in_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_in", ")", ";", "mips_builtin_decls", "[", "mips_get_builtin_decl_index", "[", "CODE_FOR_", "##", "INSN", "]", "]", "switch", "(", "fn", ")", "{", "case", "BUILT_IN_SQRT", ":", "if", "(", "out_mode", "==", "DFmode", "&&", "out_n", "==", "2", "&&", "in_mode", "==", "DFmode", "&&", "in_n", "==", "2", ")", "return", "MIPS_GET_BUILTIN", "(", "msa_fsqrt_d", ")", ";", "break", ";", "case", "BUILT_IN_SQRTF", ":", "if", "(", "out_mode", "==", "SFmode", "&&", "out_n", "==", "4", "&&", "in_mode", "==", "SFmode", "&&", "in_n", "==", "4", ")", "return", "MIPS_GET_BUILTIN", "(", "msa_fsqrt_w", ")", ";", "break", ";", "default", ":", "break", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION", "." ]

[ "mips", "2", "2", "4", "4" ]

[]

[ "<s>", "static", "unsigned", "addLiveIn", "(", "MachineFunction", "&", "MF", ",", "unsigned", "PReg", ",", "const", "TargetRegisterClass", "*", "RC", ")", "{", "Register", "VReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "PReg", ",", "VReg", ")", ";", "return", "VReg", ";", "}", "</s>" ]

[ "addLiveIn", "-", "Add", "the", "specified", "register", "as", "a", "live-in", "." ]

[ "Mips" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "bool", "IsPatchPoint", "=", "CLI", ".", "IsPatchPoint", ";", "ImmutableCallSite", "*", "CS", "=", "CLI", ".", "CS", ";", "if", "(", "isTailCall", ")", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "DAG", ")", ";", "if", "(", "!", "isTailCall", "&&", "CS", "&&", "CS", "->", "isMustTailCall", "(", ")", ")", "report_fatal_error", "(", "\"failed to perform tail call elimination on a call \"", "\"site marked musttail\"", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "LowerCall_64SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "IsPatchPoint", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ",", "CS", ")", ";", "else", "return", "LowerCall_32SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "IsPatchPoint", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ",", "CS", ")", ";", "}", "return", "LowerCall_Darwin", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "IsPatchPoint", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ",", "CS", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::OutputArg", "ISD::InputArg", "\"failed to perform tail call elimination on a call \"", "\"site marked musttail\"", "PPC" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "MipsInstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "MipsII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "Flags", "[", "]", "=", "{", "{", "MO_GOT", ",", "\"mips-got\"", "}", ",", "{", "MO_GOT_CALL", ",", "\"mips-got-call\"", "}", ",", "{", "MO_GPREL", ",", "\"mips-gprel\"", "}", ",", "{", "MO_ABS_HI", ",", "\"mips-abs-hi\"", "}", ",", "{", "MO_ABS_LO", ",", "\"mips-abs-lo\"", "}", ",", "{", "MO_TLSGD", ",", "\"mips-tlsgd\"", "}", ",", "{", "MO_TLSLDM", ",", "\"mips-tlsldm\"", "}", ",", "{", "MO_DTPREL_HI", ",", "\"mips-dtprel-hi\"", "}", ",", "{", "MO_DTPREL_LO", ",", "\"mips-dtprel-lo\"", "}", ",", "{", "MO_GOTTPREL", ",", "\"mips-gottprel\"", "}", ",", "{", "MO_TPREL_HI", ",", "\"mips-tprel-hi\"", "}", ",", "{", "MO_TPREL_LO", ",", "\"mips-tprel-lo\"", "}", ",", "{", "MO_GPOFF_HI", ",", "\"mips-gpoff-hi\"", "}", ",", "{", "MO_GPOFF_LO", ",", "\"mips-gpoff-lo\"", "}", ",", "{", "MO_GOT_DISP", ",", "\"mips-got-disp\"", "}", ",", "{", "MO_GOT_PAGE", ",", "\"mips-got-page\"", "}", ",", "{", "MO_GOT_OFST", ",", "\"mips-got-ofst\"", "}", ",", "{", "MO_HIGHER", ",", "\"mips-higher\"", "}", ",", "{", "MO_HIGHEST", ",", "\"mips-highest\"", "}", ",", "{", "MO_GOT_HI16", ",", "\"mips-got-hi16\"", "}", ",", "{", "MO_GOT_LO16", ",", "\"mips-got-lo16\"", "}", ",", "{", "MO_CALL_HI16", ",", "\"mips-call-hi16\"", "}", ",", "{", "MO_CALL_LO16", ",", "\"mips-call-lo16\"", "}", "}", ";", "return", "makeArrayRef", "(", "Flags", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "\"mips-got\"", "\"mips-got-call\"", "\"mips-gprel\"", "\"mips-abs-hi\"", "\"mips-abs-lo\"", "\"mips-tlsgd\"", "\"mips-tlsldm\"", "\"mips-dtprel-hi\"", "\"mips-dtprel-lo\"", "\"mips-gottprel\"", "\"mips-tprel-hi\"", "\"mips-tprel-lo\"", "\"mips-gpoff-hi\"", "\"mips-gpoff-lo\"", "\"mips-got-disp\"", "\"mips-got-page\"", "\"mips-got-ofst\"", "\"mips-higher\"", "\"mips-highest\"", "\"mips-got-hi16\"", "\"mips-got-lo16\"", "\"mips-call-hi16\"", "\"mips-call-lo16\"" ]

[]

[ "<s>", "unsigned", "AArch64RegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "return", "32", "-", "1", "-", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "STI", "->", "isTargetDarwin", "(", ")", ")", "-", "STI", "->", "isTargetDarwin", "(", ")", "-", "hasBasePointer", "(", "MF", ")", ";", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "return", "16", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "AArch64", "AArch64", "0", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR32commonRegClassID", "AArch64::GPR64commonRegClassID", "32", "1", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "32", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "32", "AArch64::FPR128_loRegClassID", "16" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "getInstrLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "*", "MI", ",", "unsigned", "*", "PredCost", ")", "const", "{", "return", "getInstrTimingClassLatency", "(", "ItinData", ",", "MI", ")", ";", "}", "</s>" ]

[ "Compute", "the", "instruction", "latency", "of", "a", "given", "instruction", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "setKind", "(", "BaseKind", "K", ")", "{", "Kind", "=", "K", ";", "}", "</s>" ]

[ "Setter", "for", "the", "kind", "of", "this", "node", "." ]

[ "AArch64" ]

[]

[ "<s>", "const", "char", "*", "BPFTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "NULL", ";", "case", "BPFISD", "::", "RET_FLAG", ":", "return", "\"BPFISD::RET_FLAG\"", ";", "case", "BPFISD", "::", "CALL", ":", "return", "\"BPFISD::CALL\"", ";", "case", "BPFISD", "::", "SELECT_CC", ":", "return", "\"BPFISD::SELECT_CC\"", ";", "case", "BPFISD", "::", "BR_CC", ":", "return", "\"BPFISD::BR_CC\"", ";", "case", "BPFISD", "::", "Wrapper", ":", "return", "\"BPFISD::Wrapper\"", ";", "}", "}", "</s>" ]

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

[ "BPF", "BPF", "BPFISD::RET_FLAG", "\"BPFISD::RET_FLAG\"", "BPFISD::CALL", "\"BPFISD::CALL\"", "BPFISD::SELECT_CC", "\"BPFISD::SELECT_CC\"", "BPFISD::BR_CC", "\"BPFISD::BR_CC\"", "BPFISD::Wrapper", "\"BPFISD::Wrapper\"" ]

[]

[ "<s>", "static", "const", "char", "*", "rs6000_get_some_local_dynamic_name", "(", "void", ")", "{", "rtx", "insn", ";", "if", "(", "cfun", "->", "machine", "->", "some_ld_name", ")", "return", "cfun", "->", "machine", "->", "some_ld_name", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "for_each_rtx", "(", "&", "PATTERN", "(", "insn", ")", ",", "rs6000_get_some_local_dynamic_name_1", ",", "0", ")", ")", "return", "cfun", "->", "machine", "->", "some_ld_name", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Locate", "some", "local-dynamic", "symbol", "still", "in", "use", "by", "this", "function", "so", "that", "we", "can", "print", "its", "name", "in", "some", "tls_ld", "pattern", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "Context", "=", "&", "M", ".", "getContext", "(", ")", ";", "Int32Type", "=", "Type", "::", "getInt32Ty", "(", "M", ".", "getContext", "(", ")", ")", ";", "ImageSizeType", "=", "ArrayType", "::", "get", "(", "Int32Type", ",", "3", ")", ";", "ImageFormatType", "=", "ArrayType", "::", "get", "(", "Int32Type", ",", "2", ")", ";", "return", "transformKernels", "(", "M", ")", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "AMDGPU", "3", "2" ]

[]

[ "<s>", "bool", "analyzeSelect", "(", "const", "MachineInstr", "&", "MI", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "unsigned", "&", "TrueOp", ",", "unsigned", "&", "FalseOp", ",", "bool", "&", "Optimizable", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Analyze", "the", "given", "select", "instruction", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "." ]

[ "JVM" ]

[]

[ "<s>", "void", "addPreSched2", "(", ")", "override", "{", "addPass", "(", "&", "IfConverterID", ",", "false", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "TGSI" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createX86MachObjectWriter", "(", "OS", ",", "true", ",", "MachO", "::", "CPU_TYPE_X86_64", ",", "Subtype", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

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

[]

[ "<s>", "uint64_t", "SIMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "MRI", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isExpr", "(", ")", "&&", "MO", ".", "getExpr", "(", ")", "->", "getKind", "(", ")", "!=", "MCExpr", "::", "Constant", ")", "{", "MCFixupKind", "Kind", ";", "if", "(", "needsPCRel", "(", "MO", ".", "getExpr", "(", ")", ")", ")", "Kind", "=", "FK_PCRel_4", ";", "else", "Kind", "=", "FK_Data_4", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "4", ",", "MO", ".", "getExpr", "(", ")", ",", "Kind", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "}", "unsigned", "OpNo", "=", "0", ";", "for", "(", "unsigned", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "OpNo", "<", "e", ";", "++", "OpNo", ")", "{", "if", "(", "&", "MO", "==", "&", "MI", ".", "getOperand", "(", "OpNo", ")", ")", "break", ";", "}", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "AMDGPU", "::", "isSISrcOperand", "(", "Desc", ",", "OpNo", ")", ")", "{", "uint32_t", "Enc", "=", "getLitEncoding", "(", "MO", ",", "Desc", ".", "OpInfo", "[", "OpNo", "]", ",", "STI", ")", ";", "if", "(", "Enc", "!=", "~", "0U", "&&", "(", "Enc", "!=", "255", "||", "Desc", ".", "getSize", "(", ")", "==", "4", ")", ")", "return", "Enc", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "llvm_unreachable", "(", "\"Encoding of this operand type is not supported yet.\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "AMDGPU", "SI", "4", "0", "AMDGPU::isSISrcOperand", "0U", "255", "4", "\"Encoding of this operand type is not supported yet.\"", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "output_branch", "(", "rtx", "label", ",", "const", "char", "*", "cond", ",", "rtx_insn", "*", "insn", ")", "{", "char", "str", "[", "64", "]", ";", "rtx", "operands", "[", "2", "]", ";", "gcc_assert", "(", "cond", ")", ";", "operands", "[", "0", "]", "=", "label", ";", "if", "(", "get_attr_length", "(", "insn", ")", ">", "8", ")", "{", "bool", "spilled", ";", "if", "(", "current_function_saves_lr", "(", ")", ")", "{", "operands", "[", "1", "]", "=", "regno_reg_rtx", "[", "LINK_REGNUM", "]", ";", "spilled", "=", "false", ";", "}", "else", "if", "(", "!", "df_regs_ever_live_p", "(", "long_branch_regnum", ")", ")", "{", "operands", "[", "1", "]", "=", "regno_reg_rtx", "[", "long_branch_regnum", "]", ";", "spilled", "=", "false", ";", "}", "else", "{", "operands", "[", "1", "]", "=", "regno_reg_rtx", "[", "long_branch_regnum", "]", ";", "spilled", "=", "true", ";", "gcc_assert", "(", "current_function_has_lr_slot", "(", ")", ")", ";", "}", "if", "(", "spilled", ")", "{", "if", "(", "final_sequence", ")", "{", "rtx_insn", "*", "delay", "=", "NEXT_INSN", "(", "insn", ")", ";", "gcc_assert", "(", "delay", ")", ";", "final_scan_insn", "(", "delay", ",", "asm_out_file", ",", "optimize", ",", "0", ",", "NULL", ")", ";", "PATTERN", "(", "delay", ")", "=", "gen_blockage", "(", ")", ";", "INSN_CODE", "(", "delay", ")", "=", "-", "1", ";", "}", "if", "(", "current_function_saves_fp", "(", ")", ")", "output_asm_insn", "(", "\"write.l 1(sp),%1\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"write.l (sp),%1\"", ",", "operands", ")", ";", "}", "output_asm_insn", "(", "\"moviu %1,%%u %0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"movil %1,%%l %0\"", ",", "operands", ")", ";", "strcpy", "(", "str", ",", "\"bra \"", ")", ";", "strcat", "(", "str", ",", "cond", ")", ";", "strcat", "(", "str", ",", "\",%1,%1\"", ")", ";", "if", "(", "!", "spilled", ")", "strcat", "(", "str", ",", "\"%#\"", ")", ";", "strcat", "(", "str", ",", "\"\\t\\t;long branch\"", ")", ";", "output_asm_insn", "(", "str", ",", "operands", ")", ";", "if", "(", "spilled", ")", "{", "if", "(", "current_function_saves_fp", "(", ")", ")", "output_asm_insn", "(", "\" read.l %1,1(sp)\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\" read.l %1,(sp)\"", ",", "operands", ")", ";", "}", "}", "else", "if", "(", "label", "==", "pc_rtx", ")", "{", "strcpy", "(", "str", ",", "\"bra \"", ")", ";", "strcat", "(", "str", ",", "cond", ")", ";", "strcat", "(", "str", ",", "\",r21,r0%#\\t\\t;return\"", ")", ";", "output_asm_insn", "(", "str", ",", "operands", ")", ";", "}", "else", "{", "strcpy", "(", "str", ",", "\"brr \"", ")", ";", "strcat", "(", "str", ",", "cond", ")", ";", "strcat", "(", "str", ",", "\",%0%#\"", ")", ";", "output_asm_insn", "(", "str", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "conditional/unconditional", "branch", "to", "LABEL", ".", "COND", "is", "the", "string", "condition", ".", "INSN", "is", "the", "instruction", "." ]

[ "visium", "64", "2", "0", "8", "1", "1", "1", "0", "1", "\"write.l 1(sp),%1\"", "\"write.l (sp),%1\"", "\"moviu %1,%%u %0\"", "\"movil %1,%%l %0\"", "\"bra \"", "\",%1,%1\"", "\"%#\"", "\"\\t\\t;long branch\"", "\" read.l %1,1(sp)\"", "\" read.l %1,(sp)\"", "\"bra \"", "\",r21,r0%#\\t\\t;return\"", "\"brr \"", "\",%0%#\"", "\"\"" ]

[]

[ "<s>", "static", "inline", "enum", "insn_code", "rs6000_htm_spr_icode", "(", "bool", "nonvoid", ")", "{", "if", "(", "nonvoid", ")", "return", "(", "TARGET_POWERPC64", ")", "?", "CODE_FOR_htm_mfspr_di", ":", "CODE_FOR_htm_mfspr_si", ";", "else", "return", "(", "TARGET_POWERPC64", ")", "?", "CODE_FOR_htm_mtspr_di", ":", "CODE_FOR_htm_mtspr_si", ";", "}", "</s>" ]

[ "Return", "the", "correct", "ICODE", "value", "depending", "on", "whether", "we", "are", "setting", "or", "reading", "the", "HTM", "SPRs", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RegClass", "=", "CSI", "[", "i", "]", ".", "getRegClass", "(", ")", ";", "if", "(", "RegClass", "==", "&", "SystemZ", "::", "FP64RegClass", ")", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RegClass", ")", ";", "}", "unsigned", "LowReg", "=", "MFI", "->", "getLowReg", "(", ")", ",", "HighReg", "=", "MFI", "->", "getHighReg", "(", ")", ";", "unsigned", "StartOffset", "=", "RegSpillOffsets", "[", "LowReg", "]", ";", "if", "(", "StartOffset", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "(", "LowReg", "==", "HighReg", "?", "SystemZ", "::", "MOV64rm", ":", "SystemZ", "::", "MOV64rmm", ")", ")", ")", ";", "MIB", ".", "addReg", "(", "LowReg", ",", "RegState", "::", "Define", ")", ";", "if", "(", "LowReg", "!=", "HighReg", ")", "MIB", ".", "addReg", "(", "HighReg", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "(", "RegInfo", "->", "hasFP", "(", "MF", ")", "?", "SystemZ", "::", "R11D", ":", "SystemZ", "::", "R15D", ")", ")", ";", "MIB", ".", "addImm", "(", "StartOffset", ")", ";", "if", "(", "LowReg", "==", "HighReg", ")", "MIB", ".", "addReg", "(", "0", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "LowReg", "&&", "Reg", "!=", "HighReg", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "}", "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", "(", ")", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "SystemZ::FP64RegClass", "SystemZ::MOV64rm", "SystemZ::MOV64rmm", "SystemZ::R11D", "SystemZ::R15D", "0", "0" ]

[]

[ "<s>", "static", "bool", "m32r_in_small_data_p", "(", "tree", "decl", ")", "{", "tree", "section", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"model\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "return", "false", ";", "section", "=", "DECL_SECTION_NAME", "(", "decl", ")", ";", "if", "(", "section", ")", "{", "char", "*", "name", "=", "(", "char", "*", ")", "TREE_STRING_POINTER", "(", "section", ")", ";", "if", "(", "strcmp", "(", "name", ",", "\".sdata\"", ")", "==", "0", "||", "strcmp", "(", "name", ",", "\".sbss\"", ")", "==", "0", ")", "return", "true", ";", "}", "else", "{", "if", "(", "!", "TREE_READONLY", "(", "decl", ")", "&&", "!", "TARGET_SDATA_NONE", ")", "{", "int", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "size", ">", "0", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "size", "<=", "g_switch_value", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Only", "mark", "the", "object", "as", "being", "small", "data", "area", "addressable", "if", "it", "has", "n't", "been", "explicitly", "marked", "with", "a", "code", "model", ".", "The", "user", "can", "explicitly", "put", "an", "object", "in", "the", "small", "data", "area", "with", "the", "section", "attribute", ".", "If", "the", "object", "is", "in", "sdata/sbss", "and", "marked", "with", "a", "code", "model", "do", "both", "[", "put", "the", "object", "in", ".sdata", "and", "mark", "it", "as", "being", "addressed", "with", "a", "specific", "code", "model", "-", "do", "n't", "mark", "it", "as", "being", "addressed", "with", "an", "SDA", "reloc", "though", "]", ".", "This", "is", "ok", "and", "might", "be", "useful", "at", "times", ".", "If", "the", "object", "does", "n't", "fit", "the", "linker", "will", "give", "an", "error", "." ]

[ "m32r", "\"model\"", "\".sdata\"", "0", "\".sbss\"", "0", "0" ]

[]

[ "<s>", "TargetTransformInfo", "LanaiTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "LanaiTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "Lanai", "Lanai", "Lanai" ]

[]

[ "<s>", "inline", "bool", "pr_or_ffr_regnum_p", "(", "unsigned", "int", "regno", ")", "{", "return", "PR_REGNUM_P", "(", "regno", ")", "||", "regno", "==", "FFR_REGNUM", "||", "regno", "==", "FFRT_REGNUM", ";", "}", "</s>" ]

[ "Return", "true", "if", "REGNO", "is", "P0-P15", "or", "one", "of", "the", "special", "FFR-related", "registers", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "MCS51AsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "assert", "(", "(", "Count", "%", "2", ")", "==", "0", "&&", "\"NOP instructions must be 2 bytes\"", ")", ";", "OS", ".", "write_zeros", "(", "Count", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "2", "0", "\"NOP instructions must be 2 bytes\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "SystemZRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "SystemZSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_SystemZ_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "Subtarget", ".", "hasVector", "(", ")", "?", "CSR_SystemZ_AllRegs_Vector_SaveList", ":", "CSR_SystemZ_AllRegs_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_SystemZ_SwiftError_SaveList", ";", "return", "CSR_SystemZ_SaveList", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "MipsAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "OS", ".", "write_zeros", "(", "Count", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "int", "m68k_sched_address_bypass_p", "(", "rtx_insn", "*", "pro", ",", "rtx_insn", "*", "con", ")", "{", "rtx", "pro_x", ";", "rtx", "con_mem_read", ";", "pro_x", "=", "sched_get_reg_operand", "(", "pro", ",", "true", ")", ";", "if", "(", "pro_x", "==", "NULL", ")", "return", "0", ";", "con_mem_read", "=", "sched_get_mem_operand", "(", "con", ",", "true", ",", "false", ")", ";", "gcc_assert", "(", "con_mem_read", "!=", "NULL", ")", ";", "if", "(", "reg_mentioned_p", "(", "pro_x", ",", "con_mem_read", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "PRO", "modifies", "register", "used", "as", "part", "of", "address", "in", "CON", "." ]

[ "m68k", "0", "1", "0" ]

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "{", "return", "Kind", "==", "k_Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "AArch64" ]

[]

[ "<s>", "static", "bool", "ix86_profile_before_prologue", "(", "void", ")", "{", "return", "flag_fentry", "!=", "0", ";", "}", "</s>" ]

[ "Return", "true", ",", "if", "profiling", "code", "should", "be", "emitted", "before", "prologue", ".", "Otherwise", "it", "returns", "false", ".", "Note", ":", "For", "x86", "with", "``", "hotfix", "''", "it", "is", "sorried", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "FixupLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "TM", "=", "&", "Func", ".", "getTarget", "(", ")", ";", "const", "X86Subtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "LEAusesAG", "(", ")", "&&", "!", "ST", ".", "slowLEA", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "X86InstrInfo", "*", ">", "(", "TM", "->", "getInstrInfo", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupLEAs\\n\"", ";", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "Func", ".", "begin", "(", ")", ",", "E", "=", "Func", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processBasicBlock", "(", "Func", ",", "I", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupLEAs\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"Start X86FixupLEAs\\n\"", "\"End X86FixupLEAs\\n\"" ]

[]

[ "<s>", "static", "arm_stack_offsets", "*", "arm_get_frame_offsets", "(", "void", ")", "{", "struct", "arm_stack_offsets", "*", "offsets", ";", "offsets", "=", "&", "cfun", "->", "machine", "->", "stack_offsets", ";", "return", "offsets", ";", "}", "</s>" ]

[ "Calculate", "stack", "offsets", ".", "These", "are", "used", "to", "calculate", "register", "elimination", "offsets", "and", "in", "prologue/epilogue", "code", ".", "Also", "calculates", "which", "registers", "should", "be", "saved", "." ]

[ "arm" ]

[]

[ "<s>", "int", "c6x_nsaved_regs", "(", "void", ")", "{", "int", "nregs", "=", "0", ";", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "c6x_save_reg", "(", "regno", ")", ")", "nregs", "++", ";", "return", "nregs", ";", "}", "</s>" ]

[ "Return", "number", "of", "saved", "general", "prupose", "registers", "." ]

[ "c6x", "0", "0" ]

[]

[ "<s>", "const", "X86Subtarget", "*", "X86TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "TuneAttr", "=", "F", ".", "getFnAttribute", "(", "\"tune-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "StringRef", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "TuneCPU", "=", "TuneAttr", ".", "isValid", "(", ")", "?", "TuneAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "CPU", ";", "StringRef", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "unsigned", "PreferVectorWidthOverride", "=", "0", ";", "Attribute", "PreferVecWidthAttr", "=", "F", ".", "getFnAttribute", "(", "\"prefer-vector-width\"", ")", ";", "if", "(", "PreferVecWidthAttr", ".", "isValid", "(", ")", ")", "{", "StringRef", "Val", "=", "PreferVecWidthAttr", ".", "getValueAsString", "(", ")", ";", "unsigned", "Width", ";", "if", "(", "!", "Val", ".", "getAsInteger", "(", "0", ",", "Width", ")", ")", "{", "Key", "+=", "'p'", ";", "Key", "+=", "Val", ";", "PreferVectorWidthOverride", "=", "Width", ";", "}", "}", "unsigned", "RequiredVectorWidth", "=", "UINT32_MAX", ";", "Attribute", "MinLegalVecWidthAttr", "=", "F", ".", "getFnAttribute", "(", "\"min-legal-vector-width\"", ")", ";", "if", "(", "MinLegalVecWidthAttr", ".", "isValid", "(", ")", ")", "{", "StringRef", "Val", "=", "MinLegalVecWidthAttr", ".", "getValueAsString", "(", ")", ";", "unsigned", "Width", ";", "if", "(", "!", "Val", ".", "getAsInteger", "(", "0", ",", "Width", ")", ")", "{", "Key", "+=", "'m'", ";", "Key", "+=", "Val", ";", "RequiredVectorWidth", "=", "Width", ";", "}", "}", "Key", "+=", "CPU", ";", "Key", "+=", "TuneCPU", ";", "unsigned", "FSStart", "=", "Key", ".", "size", "(", ")", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsBool", "(", ")", ";", "if", "(", "SoftFloat", ")", "Key", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\"+soft-float,\"", ";", "Key", "+=", "FS", ";", "FS", "=", "Key", ".", "substr", "(", "FSStart", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "X86Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "TuneCPU", ",", "FS", ",", "*", "this", ",", "MaybeAlign", "(", "Options", ".", "StackAlignmentOverride", ")", ",", "PreferVectorWidthOverride", ",", "RequiredVectorWidth", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"target-cpu\"", "\"tune-cpu\"", "\"target-features\"", "512", "0", "\"prefer-vector-width\"", "0", "\"min-legal-vector-width\"", "0", "\"use-soft-float\"", "\"+soft-float\"", "\"+soft-float,\"", "X86" ]

[]

[ "<s>", "bool", "M88kInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "TBB", "=", "FBB", "=", "nullptr", ";", "Cond", ".", "clear", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", "||", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "iterator", "FirstUncondOrIndirectBr", "=", "MBB", ".", "end", "(", ")", ";", "int", "NumTerminators", "=", "0", ";", "for", "(", "auto", "J", "=", "I", ".", "getReverse", "(", ")", ";", "J", "!=", "MBB", ".", "rend", "(", ")", "&&", "isUnpredicatedTerminator", "(", "*", "J", ")", ";", "J", "++", ")", "{", "NumTerminators", "++", ";", "if", "(", "J", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", "||", "J", "->", "getDesc", "(", ")", ".", "isIndirectBranch", "(", ")", ")", "{", "FirstUncondOrIndirectBr", "=", "J", ".", "getReverse", "(", ")", ";", "}", "}", "if", "(", "AllowModify", "&&", "FirstUncondOrIndirectBr", "!=", "MBB", ".", "end", "(", ")", ")", "{", "while", "(", "std", "::", "next", "(", "FirstUncondOrIndirectBr", ")", "!=", "MBB", ".", "end", "(", ")", ")", "{", "std", "::", "next", "(", "FirstUncondOrIndirectBr", ")", "->", "eraseFromParent", "(", ")", ";", "NumTerminators", "--", ";", "}", "I", "=", "FirstUncondOrIndirectBr", ";", "}", "if", "(", "I", "->", "getDesc", "(", ")", ".", "isIndirectBranch", "(", ")", ")", "return", "true", ";", "if", "(", "NumTerminators", ">", "2", ")", "return", "true", ";", "if", "(", "!", "isAnalyzableBranchOpc", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "(", "NumTerminators", "==", "2", "&&", "!", "isAnalyzableBranchOpc", "(", "std", "::", "prev", "(", "I", ")", "->", "getOpcode", "(", ")", ")", ")", ")", "return", "true", ";", "if", "(", "NumTerminators", "==", "1", "&&", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", ")", "{", "TBB", "=", "getBranchDestBlock", "(", "*", "I", ")", ";", "return", "false", ";", "}", "if", "(", "NumTerminators", "==", "1", "&&", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "{", "parseCondBranch", "(", "*", "I", ",", "TBB", ",", "Cond", ")", ";", "return", "false", ";", "}", "if", "(", "NumTerminators", "==", "2", "&&", "std", "::", "prev", "(", "I", ")", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", "&&", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", ")", "{", "parseCondBranch", "(", "*", "std", "::", "prev", "(", "I", ")", ",", "TBB", ",", "Cond", ")", ";", "FBB", "=", "getBranchDestBlock", "(", "*", "I", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "M88k", "M88k", "0", "2", "2", "1", "1", "2" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "TOYFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TOY", "::", "ADJCALLSTACKUP", "||", "I", "->", "getOpcode", "(", ")", "==", "TOY", "::", "ADJCALLSTACKDOWN", ")", "{", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "return", "MBB", ".", "end", "(", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "TOY::ADJCALLSTACKUP", "TOY::ADJCALLSTACKDOWN" ]

[]

[ "<s>", "bool", "ECLairAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "ECLair", "ECLair" ]

[]

[ "<s>", "bool", "has", "(", "unsigned", "R", ")", "const", "{", "unsigned", "Idx", "=", "v2x", "(", "R", ")", ";", "if", "(", "Idx", ">=", "Bits", ".", "size", "(", ")", ")", "return", "false", ";", "return", "Bits", ".", "test", "(", "Idx", ")", ";", "}", "</s>" ]

[ "Tests", "whether", "a", "library", "function", "is", "available", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "SPIRV", "::", "Scope", "getScope", "(", "SyncScope", "::", "ID", "Ord", ")", "{", "switch", "(", "Ord", ")", "{", "case", "SyncScope", "::", "SingleThread", ":", "return", "SPIRV", "::", "Scope", "::", "Invocation", ";", "case", "SyncScope", "::", "System", ":", "return", "SPIRV", "::", "Scope", "::", "Device", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported synchronization Scope ID.\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "the", "local", "scope", "for", "this", "variable", "." ]

[ "SPIRV", "SPIRV::Scope", "SPIRV::Scope", "SPIRV::Scope", "\"Unsupported synchronization Scope ID.\"" ]

[]

[ "<s>", "tree", "gcn_goacc_adjust_propagation_record", "(", "tree", "record_type", ",", "bool", "sender", ",", "const", "char", "*", "name", ")", "{", "tree", "type", "=", "record_type", ";", "TYPE_ADDR_SPACE", "(", "type", ")", "=", "ADDR_SPACE_LDS", ";", "if", "(", "!", "sender", ")", "type", "=", "build_pointer_type", "(", "type", ")", ";", "tree", "decl", "=", "create_tmp_var_raw", "(", "type", ",", "name", ")", ";", "if", "(", "sender", ")", "{", "DECL_CONTEXT", "(", "decl", ")", "=", "NULL_TREE", ";", "TREE_STATIC", "(", "decl", ")", "=", "1", ";", "}", "if", "(", "sender", ")", "varpool_node", "::", "finalize_decl", "(", "decl", ")", ";", "return", "decl", ";", "}", "</s>" ]

[ "Implement", "TARGET_GOACC_ADJUST_PROPAGATION_RECORD", ".", "Tweak", "(", "worker", ")", "propagation", "record", ",", "e.g", ".", "to", "put", "it", "in", "shared", "memory", "." ]

[ "gcn", "1" ]

[]

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

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "unsigned", "WebAssemblyInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "TBB", ")", "return", "0", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"Expected a flag and a successor block\"", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "IsBrOnExn", "=", "Cond", "[", "1", "]", ".", "isReg", "(", ")", "&&", "MRI", ".", "getRegClass", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", ")", "==", "&", "WebAssembly", "::", "EXCEPT_REFRegClass", ";", "if", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "{", "if", "(", "IsBrOnExn", ")", "{", "const", "char", "*", "CPPExnSymbol", "=", "MF", ".", "createExternalSymbolName", "(", "\"__cpp_exception\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_ON_EXN", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addExternalSymbol", "(", "CPPExnSymbol", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "}", "else", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_IF", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "}", "else", "{", "assert", "(", "!", "IsBrOnExn", "&&", "\"br_on_exn does not have a reversed condition\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_UNLESS", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "}", "if", "(", "!", "FBB", ")", "return", "1", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "WebAssembly", "WebAssembly", "\"code size not handled\"", "0", "WebAssembly::BR", "1", "2", "\"Expected a flag and a successor block\"", "1", "1", "WebAssembly::EXCEPT_REFRegClass", "0", "\"__cpp_exception\"", "WebAssembly::BR_ON_EXN", "1", "WebAssembly::BR_IF", "1", "\"br_on_exn does not have a reversed condition\"", "WebAssembly::BR_UNLESS", "1", "1", "WebAssembly::BR", "2" ]

[]

[ "<s>", "SDValue", "CJGTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "CJG", "CJG", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::GlobalAddress", "ISD::ExternalSymbol", "\"unimplemented operand\"" ]

[]

[ "<s>", "int", "sh2a_get_function_vector_number", "(", "rtx", "x", ")", "{", "int", "num", ";", "tree", "list", ",", "t", ";", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "&&", "(", "SYMBOL_REF_FLAGS", "(", "x", ")", "&", "SYMBOL_FLAG_FUNCVEC_FUNCTION", ")", ")", "{", "t", "=", "SYMBOL_REF_DECL", "(", "x", ")", ";", "if", "(", "TREE_CODE", "(", "t", ")", "!=", "FUNCTION_DECL", ")", "return", "0", ";", "list", "=", "SH_ATTRIBUTES", "(", "t", ")", ";", "while", "(", "list", ")", "{", "if", "(", "is_attribute_p", "(", "\"function_vector\"", ",", "TREE_PURPOSE", "(", "list", ")", ")", ")", "{", "num", "=", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "list", ")", ")", ")", ";", "return", "num", ";", "}", "list", "=", "TREE_CHAIN", "(", "list", ")", ";", "}", "return", "0", ";", "}", "else", "return", "0", ";", "}", "</s>" ]

[ "Returns", "the", "function", "vector", "number", ",", "if", "the", "attribute", "'function_vector", "'", "is", "assigned", ",", "otherwise", "returns", "zero", "." ]

[ "sh", "0", "\"function_vector\"", "0", "0" ]

[]

[ "<s>", "DecodeStatus", "PPCDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "const", "MemoryObject", "&", "Region", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "uint8_t", "Bytes", "[", "4", "]", ";", "Size", "=", "4", ";", "if", "(", "Region", ".", "readBytes", "(", "Address", ",", "Size", ",", "Bytes", ")", "==", "-", "1", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint32_t", "Inst", "=", "(", "Bytes", "[", "0", "]", "<<", "24", ")", "|", "(", "Bytes", "[", "1", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "2", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "3", "]", "<<", "0", ")", ";", "return", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "PowerPC", "PPC", "4", "4", "1", "0", "0", "24", "1", "16", "2", "8", "3", "0" ]

[]

[ "<s>", "static", "unsigned", "int", "compute_saved_regs", "(", ")", "{", "unsigned", "int", "saved_regs", "=", "0", ";", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "6", ";", "regno", "++", ")", "{", "if", "(", "WORD_REG_USED", "(", "regno", ")", ")", "saved_regs", "|=", "1", "<<", "regno", ";", "}", "if", "(", "frame_pointer_needed", ")", "saved_regs", "&=", "~", "(", "1", "<<", "FRAME_POINTER_REGNUM", ")", ";", "return", "saved_regs", ";", "}", "</s>" ]

[ "Compute", "which", "registers", "to", "push/pop", ".", "Return", "a", "bit", "vector", "of", "registers", "." ]

[ "h8300", "0", "0", "6", "1", "1" ]

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "emitXXStructor", "(", "const", "DataLayout", "&", "DL", ",", "const", "Constant", "*", "CV", ")", "{", "uint64_t", "Size", "=", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "CV", "->", "getType", "(", ")", ")", ";", "assert", "(", "Size", "&&", "\"C++ constructor pointer had zero size!\"", ")", ";", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "CV", "->", "stripPointerCasts", "(", "true", ")", ")", ";", "assert", "(", "GV", "&&", "\"C++ constructor pointer was not a GlobalValue!\"", ")", ";", "const", "MCExpr", "*", "E", "=", "MCSymbolRefExpr", "::", "create", "(", "GetARMGVSymbol", "(", "GV", ",", "ARMII", "::", "MO_NO_FLAG", ")", ",", "(", "Subtarget", "->", "isTargetELF", "(", ")", "?", "MCSymbolRefExpr", "::", "VK_ARM_TARGET1", ":", "MCSymbolRefExpr", "::", "VK_None", ")", ",", "OutContext", ")", ";", "OutStreamer", "->", "emitValue", "(", "E", ",", "Size", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "change", "how", "global", "constants", "that", "are", "part", "of", "a", "C++", "static/global", "constructor", "list", "are", "emitted", "." ]

[ "ARM", "ARM", "\"C++ constructor pointer had zero size!\"", "\"C++ constructor pointer was not a GlobalValue!\"", "ARM", "ARMII::MO_NO_FLAG", "ARM" ]

[]

[ "<s>", "MCSymbol", "*", "AAPMCInstLower", "::", "GetBlockAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown target flag on GV operand\"", ")", ";", "case", "0", ":", "break", ";", "}", "return", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "used", "to", "satisfy", "BlockAddress", "uses", "of", "the", "specified", "basic", "block", "." ]

[ "AAP", "AAP", "\"Unknown target flag on GV operand\"", "0" ]

[]

[ "<s>", "const", "RV16KInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "RV16K", "RV16K" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "BuildCFI", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "DebugLoc", "DL", ",", "MCCFIInstruction", "CFIInst", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "getMMI", "(", ")", ".", "addFrameInst", "(", "CFIInst", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "</s>" ]

[ "Wraps", "up", "getting", "a", "CFI", "index", "and", "building", "a", "MachineInstr", "for", "it", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "SystemZELFFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "I", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "TRI", ")", ";", "if", "(", "SystemZ", "::", "VR128BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "I", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "VR128BitRegClass", ",", "TRI", ")", ";", "}", "SystemZ", "::", "GPRRegs", "RestoreGPRs", "=", "ZFI", "->", "getRestoreGPRRegs", "(", ")", ";", "if", "(", "RestoreGPRs", ".", "LowGPR", ")", "{", "assert", "(", "RestoreGPRs", ".", "LowGPR", "!=", "RestoreGPRs", ".", "HighGPR", "&&", "\"Should be loading %r15 and something else\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "SystemZ", "::", "LMG", ")", ")", ";", "MIB", ".", "addReg", "(", "RestoreGPRs", ".", "LowGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "RestoreGPRs", ".", "HighGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "HasFP", "?", "SystemZ", "::", "R11D", ":", "SystemZ", "::", "R15D", ")", ";", "MIB", ".", "addImm", "(", "RestoreGPRs", ".", "GPROffset", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "RestoreGPRs", ".", "LowGPR", "&&", "Reg", "!=", "RestoreGPRs", ".", "HighGPR", "&&", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "}", "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", "(", ")", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::FP64BitRegClass", "SystemZ::FP64BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::GPRRegs", "\"Should be loading %r15 and something else\"", "SystemZ::LMG", "SystemZ::R11D", "SystemZ::R15D", "SystemZ::GR64BitRegClass" ]

[]

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

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Nios2" ]

[]

[ "<s>", "TargetIRAnalysis", "AMDGPUTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "AMDGPUTTIImpl", "(", "this", ",", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

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

[]

[ "<s>", "bool", "SPUFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MFI", "->", "getStackSize", "(", ")", "&&", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU" ]

[]

[ "<s>", "static", "void", "pru_dump_frame_layout", "(", "FILE", "*", "file", ")", "{", "fprintf", "(", "file", ",", "\"\\t%s Current Frame Info\\n\"", ",", "ASM_COMMENT_START", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s total_size = %d\\n\"", ",", "ASM_COMMENT_START", ",", "cfun", "->", "machine", "->", "total_size", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s var_size = %d\\n\"", ",", "ASM_COMMENT_START", ",", "cfun", "->", "machine", "->", "var_size", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s out_args_size = %d\\n\"", ",", "ASM_COMMENT_START", ",", "cfun", "->", "machine", "->", "out_args_size", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s save_reg_size = %d\\n\"", ",", "ASM_COMMENT_START", ",", "cfun", "->", "machine", "->", "save_reg_size", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s initialized = %d\\n\"", ",", "ASM_COMMENT_START", ",", "cfun", "->", "machine", "->", "initialized", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s save_regs_offset = %d\\n\"", ",", "ASM_COMMENT_START", ",", "cfun", "->", "machine", "->", "save_regs_offset", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s is_leaf = %d\\n\"", ",", "ASM_COMMENT_START", ",", "crtl", "->", "is_leaf", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s frame_pointer_needed = %d\\n\"", ",", "ASM_COMMENT_START", ",", "frame_pointer_needed", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s pretend_args_size = %d\\n\"", ",", "ASM_COMMENT_START", ",", "crtl", "->", "args", ".", "pretend_args_size", ")", ";", "}", "</s>" ]

[ "Dump", "stack", "layout", "." ]

[ "pru", "\"\\t%s Current Frame Info\\n\"", "\"\\t%s total_size = %d\\n\"", "\"\\t%s var_size = %d\\n\"", "\"\\t%s out_args_size = %d\\n\"", "\"\\t%s save_reg_size = %d\\n\"", "\"\\t%s initialized = %d\\n\"", "\"\\t%s save_regs_offset = %d\\n\"", "\"\\t%s is_leaf = %d\\n\"", "\"\\t%s frame_pointer_needed = %d\\n\"", "\"\\t%s pretend_args_size = %d\\n\"" ]

[]

[ "<s>", "BitVector", "PPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "PPCFrameLowering", "*", "PPCFI", "=", "static_cast", "<", "const", "PPCFrameLowering", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "RM", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R2", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "}", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R2", ")", ";", "}", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R31", ")", ";", "if", "(", "!", "requiresRegisterScavenging", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X0", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X13", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X31", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "X2", ")", ";", "}", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "X2", ")", ";", "}", "}", "if", "(", "PPCFI", "->", "needsFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "R31", ")", ";", "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", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::R0", "PPC::R1", "PPC::LR", "PPC::LR8", "PPC::RM", "PPC::R2", "PPC::R13", "PPC::R2", "PPC", "PPC::R13", "PPC::R31", "PPC::R0", "PPC::X0", "PPC::X1", "PPC::X13", "PPC::X31", "PPC::X2", "PPC::X2", "PPC", "PPC::R31" ]

[]

[ "<s>", "unsigned", "HOST_WIDE_INT", "s390_extract_part", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "int", "def", ")", "{", "unsigned", "HOST_WIDE_INT", "value", "=", "0", ";", "int", "max_parts", "=", "HOST_BITS_PER_WIDE_INT", "/", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "int", "part_bits", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "unsigned", "HOST_WIDE_INT", "part_mask", "=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "part_bits", ")", "-", "1", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "max_parts", ";", "i", "++", ")", "{", "if", "(", "i", "==", "0", ")", "value", "=", "(", "unsigned", "HOST_WIDE_INT", ")", "INTVAL", "(", "op", ")", ";", "else", "value", ">>=", "part_bits", ";", "if", "(", "(", "value", "&", "part_mask", ")", "!=", "(", "def", "&", "part_mask", ")", ")", "return", "value", "&", "part_mask", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "part", "of", "op", "which", "has", "a", "value", "different", "from", "def", ".", "The", "size", "of", "the", "part", "is", "determined", "by", "mode", ".", "Use", "this", "function", "only", "if", "you", "already", "know", "that", "op", "really", "contains", "such", "a", "part", "." ]

[ "s390", "0", "1", "1", "0", "0" ]

[]

[ "<s>", "bool", "shouldConvertConstantLoadToIntImm", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "it", "is", "beneficial", "to", "convert", "a", "load", "of", "a", "constant", "to", "just", "the", "constant", "itself", "." ]

[ "RV16K" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "MandarinTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "MD", "::", "GenericRegsRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Mandarin", "1", "0", "0U", "MD::GenericRegsRegClass" ]

[]

[ "<s>", "bool", "RV16KInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "using", "std", "::", "swap", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", ")", "&&", "\"Invalid branch condition!\"", ")", ";", "bool", "Swap", "=", "false", ";", "RV16K", "::", "CondCode", "CC", ";", "switch", "(", "Cond", "[", "2", "]", ".", "getImm", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid cond code\"", ")", ";", "case", "RV16K", "::", "COND_E", ":", "CC", "=", "RV16K", "::", "COND_NE", ";", "break", ";", "case", "RV16K", "::", "COND_NE", ":", "CC", "=", "RV16K", "::", "COND_E", ";", "break", ";", "case", "RV16K", "::", "COND_L", ":", "Swap", "=", "true", ";", "CC", "=", "RV16K", "::", "COND_LE", ";", "break", ";", "case", "RV16K", "::", "COND_LE", ":", "Swap", "=", "true", ";", "CC", "=", "RV16K", "::", "COND_L", ";", "break", ";", "case", "RV16K", "::", "COND_B", ":", "Swap", "=", "true", ";", "CC", "=", "RV16K", "::", "COND_BE", ";", "break", ";", "case", "RV16K", "::", "COND_BE", ":", "Swap", "=", "true", ";", "CC", "=", "RV16K", "::", "COND_B", ";", "break", ";", "}", "Cond", "[", "2", "]", ".", "setImm", "(", "CC", ")", ";", "if", "(", "Swap", ")", "swap", "(", "Cond", "[", "0", "]", ",", "Cond", "[", "1", "]", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RV16K", "RV16K", "3", "\"Invalid branch condition!\"", "RV16K::CondCode", "2", "\"Invalid cond code\"", "RV16K::COND_E", "RV16K::COND_NE", "RV16K::COND_NE", "RV16K::COND_E", "RV16K::COND_L", "RV16K::COND_LE", "RV16K::COND_LE", "RV16K::COND_L", "RV16K::COND_B", "RV16K::COND_BE", "RV16K::COND_BE", "RV16K::COND_B", "2", "0", "1" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "HexagonTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "Kind", ".", "isBSS", "(", ")", "||", "Kind", ".", "isDataNoRel", "(", ")", "||", "Kind", ".", "isCommon", "(", ")", ")", "{", "Type", "*", "Ty", "=", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ";", "return", "IsInSmallSection", "(", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "void", "push_regs", "(", "HARD_REG_SET", "*", "mask", ",", "int", "interrupt_handler", ")", "{", "int", "i", "=", "interrupt_handler", "?", "LAST_BANKED_REG", "+", "1", ":", "0", ";", "int", "skip_fpscr", "=", "0", ";", "for", "(", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "if", "(", "i", "==", "FIRST_FP_REG", "&&", "interrupt_handler", "&&", "TARGET_FMOVD", "&&", "hard_reg_set_intersect_p", "(", "*", "mask", ",", "reg_class_contents", "[", "DF_REGS", "]", ")", ")", "{", "HARD_REG_SET", "unsaved", ";", "push", "(", "FPSCR_REG", ")", ";", "COMPL_HARD_REG_SET", "(", "unsaved", ",", "*", "mask", ")", ";", "fpscr_set_from_mem", "(", "NORMAL_MODE", "(", "FP_MODE", ")", ",", "unsaved", ")", ";", "skip_fpscr", "=", "1", ";", "}", "if", "(", "i", "!=", "PR_REG", "&&", "(", "i", "!=", "FPSCR_REG", "||", "!", "skip_fpscr", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "mask", ",", "i", ")", ")", "{", "if", "(", "!", "(", "sh_cfun_resbank_handler_p", "(", ")", "&&", "(", "(", "i", ">=", "FIRST_GENERAL_REG", "&&", "i", "<", "LAST_GENERAL_REG", ")", "||", "i", "==", "MACH_REG", "||", "i", "==", "MACL_REG", "||", "i", "==", "GBR_REG", ")", ")", ")", "push", "(", "i", ")", ";", "}", "}", "if", "(", "interrupt_handler", ")", "{", "bool", "use_movml", "=", "false", ";", "if", "(", "TARGET_SH2A", ")", "{", "unsigned", "int", "count", "=", "0", ";", "for", "(", "i", "=", "FIRST_BANKED_REG", ";", "i", "<=", "LAST_BANKED_REG", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "mask", ",", "i", ")", ")", "count", "++", ";", "else", "break", ";", "if", "(", "count", "==", "LAST_BANKED_REG", "-", "FIRST_BANKED_REG", "+", "1", ")", "use_movml", "=", "true", ";", "}", "if", "(", "sh_cfun_resbank_handler_p", "(", ")", ")", ";", "else", "if", "(", "use_movml", ")", "{", "rtx", "x", ",", "mem", ",", "reg", ",", "set", ";", "rtx", "sp_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "STACK_POINTER_REGNUM", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "x", "=", "gen_movml_push_banked", "(", "sp_reg", ")", ";", "x", "=", "frame_insn", "(", "x", ")", ";", "for", "(", "i", "=", "FIRST_BANKED_REG", ";", "i", "<=", "LAST_BANKED_REG", ";", "i", "++", ")", "{", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "sp_reg", ",", "i", "*", "4", ")", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "add_reg_note", "(", "x", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "SImode", ",", "mem", ",", "reg", ")", ")", ";", "}", "set", "=", "gen_rtx_SET", "(", "SImode", ",", "sp_reg", ",", "plus_constant", "(", "Pmode", ",", "sp_reg", ",", "-", "32", ")", ")", ";", "add_reg_note", "(", "x", ",", "REG_CFA_ADJUST_CFA", ",", "set", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "else", "for", "(", "i", "=", "FIRST_BANKED_REG", ";", "i", "<=", "LAST_BANKED_REG", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "mask", ",", "i", ")", ")", "push", "(", "i", ")", ";", "}", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "mask", ",", "PR_REG", ")", "&&", "!", "sh_cfun_resbank_handler_p", "(", ")", ")", "push", "(", "PR_REG", ")", ";", "}", "</s>" ]

[ "Generate", "code", "to", "push", "the", "regs", "specified", "in", "the", "mask", ".", "remember", "that", "the", "mask", "is", "of", "the", "internal", "shape", "of", "the", "regs", ",", "not", "the", "external", "shape", "-", "so", "go", "through", "the", "renumber", "vector" ]

[ "sh", "1", "0", "0", "1", "0", "1", "4", "32" ]

[]

[ "<s>", "const", "MMIXSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "MMIX", "MMIX" ]

[]

[ "<s>", "bool", "X86TargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ")", "{", "bool", "ShouldPrint", "=", "false", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "Subtarget", ".", "hasXMMInt", "(", ")", ")", "{", "PM", ".", "add", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "Subtarget", ".", "hasAVX", "(", ")", "&&", "UseVZeroUpper", ")", "{", "PM", ".", "add", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "return", "ShouldPrint", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::VR128RegClass", "X86" ]

[]

[ "<s>", "static", "rtx", "bfin_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "arg", ".", "promoted_size_in_bytes", "(", ")", ";", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "return", "GEN_INT", "(", "cum", "->", "call_cookie", ")", ";", "if", "(", "bytes", "==", "-", "1", ")", "return", "NULL_RTX", ";", "if", "(", "cum", "->", "nregs", ")", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "*", "(", "cum", "->", "arg_regs", ")", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Define", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", "." ]

[ "bfin", "1" ]

[]

[ "<s>", "bool", "rs6000_is_valid_and_mask", "(", "rtx", "mask", ",", "machine_mode", "mode", ")", "{", "int", "nb", ",", "ne", ";", "if", "(", "!", "rs6000_is_valid_mask", "(", "mask", ",", "&", "nb", ",", "&", "ne", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "DImode", ")", "return", "(", "ne", "==", "0", "||", "nb", "==", "63", "||", "(", "nb", "<", "32", "&&", "ne", "<=", "nb", ")", ")", ";", "if", "(", "mode", "==", "SImode", ")", "return", "(", "nb", "<", "32", "&&", "ne", "<", "32", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "MASK", "(", "a", "CONST_INT", ")", "is", "a", "valid", "mask", "for", "any", "rlwinm", ",", "rldicl", ",", "or", "rldicr", "instruction", ",", "to", "implement", "an", "AND", "with", "it", "in", "mode", "MODE", "." ]

[ "powerpcspe", "0", "63", "32", "32", "32" ]

[]

[ "<s>", "static", "void", "emit_constant_insn", "(", "rtx", "cond", ",", "rtx", "pattern", ")", "{", "if", "(", "cond", ")", "pattern", "=", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "copy_rtx", "(", "cond", ")", ",", "pattern", ")", ";", "emit_insn", "(", "pattern", ")", ";", "}", "</s>" ]

[ "Emit", "an", "instruction", "with", "the", "indicated", "PATTERN", ".", "If", "COND", "is", "non-NULL", ",", "conditionalize", "the", "execution", "of", "the", "instruction", "on", "COND", "being", "true", "." ]

[ "arm" ]

[]

[ "<s>", "virtual", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "X86" ]

[]

[ "<s>", "static", "void", "frv_fill_unused_units", "(", "enum", "frv_insn_group", "group", ")", "{", "unsigned", "int", "non_nops", ",", "nops", ",", "i", ";", "struct", "frv_packet_group", "*", "packet_group", ";", "packet_group", "=", "&", "frv_packet", ".", "groups", "[", "group", "]", ";", "frv_sort_insn_group", "(", "group", ")", ";", "i", "=", "nops", "=", "0", ";", "for", "(", "non_nops", "=", "0", ";", "non_nops", "<", "packet_group", "->", "num_insns", ";", "non_nops", "++", ")", "while", "(", "packet_group", "->", "sorted", "[", "i", "++", "]", "==", "packet_group", "->", "nop", ")", "nops", "++", ";", "while", "(", "nops", "--", ">", "0", ")", "frv_insert_nop_in_packet", "(", "packet_group", "->", "nop", ")", ";", "}", "</s>" ]

[ "See", "whether", "we", "need", "to", "add", "nops", "to", "group", "GROUP", "in", "order", "to", "make", "a", "valid", "packet", "." ]

[ "frv", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "riscv_cannot_force_const_mem", "(", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "enum", "riscv_symbol_type", "type", ";", "rtx", "base", ",", "offset", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", ")", "return", "true", ";", "split_const", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "riscv_symbolic_constant_p", "(", "base", ",", "&", "type", ")", ")", "{", "if", "(", "SMALL_OPERAND", "(", "INTVAL", "(", "offset", ")", ")", "&&", "riscv_symbol_insns", "(", "type", ")", ">", "0", ")", "return", "true", ";", "if", "(", "flag_pic", ")", "return", "true", ";", "}", "if", "(", "tls_referenced_p", "(", "x", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_CANNOT_FORCE_CONST_MEM", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "void", "ARCFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Determine Callee Saves: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "SavedRegs", ".", "set", "(", "ARC", "::", "BLINK", ")", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "ARC", "ARC", "\"Determine Callee Saves: \"", "\"\\n\"", "ARC::BLINK" ]

[]