Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "InstructionCost", "PPCTTIImpl", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "DisablePPCConstHoist", ")", "return", "BaseT", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "~", "0U", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", ")", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Basic", ";", "if", "(", "isInt", "<", "32", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "{", "if", "(", "(", "Imm", ".", "getZExtValue", "(", ")", "&", "0xFFFF", ")", "==", "0", ")", "return", "TTI", "::", "TCC_Basic", ";", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "}", "}", "return", "4", "*", "TTI", "::", "TCC_Basic", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "PowerPC", "PPC", "PPC", "0", "0U", "0", "64", "16", "32", "0xFFFF", "0", "2", "4" ]

[]

[ "<s>", "static", "bool", "s390_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_64BIT", "&&", "TARGET_ZARCH", "&&", "mode", "==", "TImode", ")", "return", "false", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "default_decimal_float_supported_p", "(", ")", ";", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "back", "end", "supports", "mode", "MODE", "." ]

[ "s390" ]

[]

[ "<s>", "const", "char", "*", "VETargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "VEISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "VEISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "VEISD", "::", "RET_FLAG", ":", "return", "\"VEISD::RET_FLAG\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "VE", "VE", "VEISD::NodeType", "VEISD::FIRST_NUMBER", "VEISD::RET_FLAG", "\"VEISD::RET_FLAG\"" ]

[]

[ "<s>", "static", "bool", "mmix_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "aligned_p", ")", "switch", "(", "size", ")", "{", "case", "1", ":", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", ")", "{", "aligned_p", "=", "0", ";", "break", ";", "}", "fputs", "(", "\"\\tBYTE\\t\"", ",", "asm_out_file", ")", ";", "mmix_print_operand", "(", "asm_out_file", ",", "x", ",", "'B'", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "true", ";", "case", "2", ":", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", ")", "{", "aligned_p", "=", "0", ";", "break", ";", "}", "fputs", "(", "\"\\tWYDE\\t\"", ",", "asm_out_file", ")", ";", "mmix_print_operand", "(", "asm_out_file", ",", "x", ",", "'W'", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "true", ";", "case", "4", ":", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", ")", "{", "aligned_p", "=", "0", ";", "break", ";", "}", "fputs", "(", "\"\\tTETRA\\t\"", ",", "asm_out_file", ")", ";", "mmix_print_operand", "(", "asm_out_file", ",", "x", ",", "'L'", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "true", ";", "case", "8", ":", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_DOUBLE", ")", ";", "assemble_integer_with_op", "(", "\"\\tOCTA\\t\"", ",", "x", ")", ";", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "Use", "mmix_print_operand", "for", "WYDE", "and", "TETRA", ".", "Use", "mmix_output_octa", "to", "output", "8-byte", "CONST_DOUBLEs", "." ]

[ "mmix", "1", "0", "\"\\tBYTE\\t\"", "2", "0", "\"\\tWYDE\\t\"", "4", "0", "\"\\tTETRA\\t\"", "8", "\"\\tOCTA\\t\"" ]

[]

[ "<s>", "bool", "Cpu0AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Cpu0FI", "=", "MF", ".", "getInfo", "<", "Cpu0FunctionInfo", ">", "(", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0" ]

[]

[ "<s>", "AliasResult", "AMDGPUAAResult", "::", "alias", "(", "const", "MemoryLocation", "&", "LocA", ",", "const", "MemoryLocation", "&", "LocB", ")", "{", "unsigned", "asA", "=", "LocA", ".", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "unsigned", "asB", "=", "LocB", ".", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "AliasResult", "Result", "=", "getAliasResult", "(", "asA", ",", "asB", ")", ";", "if", "(", "Result", "==", "NoAlias", ")", "return", "Result", ";", "return", "AAResultBase", "::", "alias", "(", "LocA", ",", "LocB", ")", ";", "}", "</s>" ]

[ "alias", "-", "If", "one", "of", "the", "pointers", "is", "to", "a", "global", "that", "we", "are", "tracking", ",", "and", "the", "other", "is", "some", "random", "pointer", ",", "we", "know", "there", "can", "not", "be", "an", "alias", ",", "because", "the", "address", "of", "the", "global", "is", "n't", "taken", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "ARMExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "ExpandMBB", "(", "MBB", ")", ";", "if", "(", "VerifyARMPseudo", ")", "MF", ".", "verify", "(", "this", ",", "\"After expanding ARM pseudo instructions.\"", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "\"After expanding ARM pseudo instructions.\"" ]

[]

[ "<s>", "void", "MOSInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "loadStoreRegStackSlot", "(", "MBB", ",", "MI", ",", "SrcReg", ",", "isKill", ",", "FrameIndex", ",", "RC", ",", "TRI", ",", "false", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "MOS", "MOS" ]

[]

[ "<s>", "static", "void", "loongarch_init_print_operand_punct", "(", "void", ")", "{", "const", "char", "*", "p", ";", "for", "(", "p", "=", "\".$\"", ";", "*", "p", ";", "p", "++", ")", "loongarch_print_operand_punct", "[", "(", "unsigned", "char", ")", "*", "p", "]", "=", "true", ";", "}", "</s>" ]

[ "Initialize", "loongarch_print_operand_punct", "." ]

[ "loongarch", "\".$\"" ]

[]

[ "<s>", "static", "void", "ia64_output_dwarf_dtprel", "(", "FILE", "*", "file", ",", "int", "size", ",", "rtx", "x", ")", "{", "gcc_assert", "(", "size", "==", "4", "||", "size", "==", "8", ")", ";", "if", "(", "size", "==", "4", ")", "fputs", "(", "\"\\tdata4.ua\\t@dtprel(\"", ",", "file", ")", ";", "else", "fputs", "(", "\"\\tdata8.ua\\t@dtprel(\"", ",", "file", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "fputs", "(", "\")\"", ",", "file", ")", ";", "}", "</s>" ]

[ "This", "is", "called", "from", "dwarf2out.cc", "via", "TARGET_ASM_OUTPUT_DWARF_DTPREL", ".", "We", "need", "to", "emit", "DTP-relative", "relocations", "." ]

[ "ia64", "4", "8", "4", "\"\\tdata4.ua\\t@dtprel(\"", "\"\\tdata8.ua\\t@dtprel(\"", "\")\"" ]

[]

[ "<s>", "void", "F2003fDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "SDLoc", "dl", "(", "Node", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "FrameIndex", ":", "{", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "TLI", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ";", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "F2003f", "::", "ATAframe", ",", "MVT", "::", "i32", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "dl", ",", "MVT", "::", "i16", ")", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "F2003f", "F2003f", "1", "ISD::FrameIndex", "F2003f::ATAframe", "MVT::i32", "0", "MVT::i16" ]

[]

[ "<s>", "static", "enum", "reg_class", "mep_secondary_copro_reload_class", "(", "enum", "reg_class", "rclass", ",", "rtx", "x", ")", "{", "if", "(", "mep_general_reg", "(", "x", ")", ")", "return", "NO_REGS", ";", "if", "(", "mep_general_copro_reg", "(", "x", ")", ")", "{", "if", "(", "mep_have_copro_copro_moves_p", ")", "return", "NO_REGS", ";", "if", "(", "mep_have_core_copro_moves_p", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "LOADABLE_CR_REGS", ")", "&&", "constraint_satisfied_p", "(", "x", ",", "CONSTRAINT_U", ")", ")", "return", "NO_REGS", ";", "return", "GENERAL_REGS", ";", "}", "</s>" ]

[ "Return", "the", "secondary", "reload", "class", "needed", "for", "moving", "value", "X", "to", "or", "from", "a", "register", "in", "coprocessor", "register", "class", "CLASS", "." ]

[ "mep" ]

[]

[ "<s>", "void", "m32c_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "ca", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ",", "int", "n_named_args", "ATTRIBUTE_UNUSED", ")", "{", "ca", "->", "force_mem", "=", "0", ";", "ca", "->", "parm_num", "=", "1", ";", "}", "</s>" ]

[ "Implements", "INIT_CUMULATIVE_ARGS", "." ]

[ "m32c", "0", "1" ]

[]

[ "<s>", "std", "::", "vector", "<", "SIScheduleBlock", "*", ">", "getBlocks", "(", ")", "{", "return", "BlocksScheduled", ";", "}", "</s>" ]

[ "Get", "a", "list", "of", "the", "basic", "blocks", "which", "make", "up", "this", "loop", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "static", "bool", "mep_mentioned_p", "(", "rtx", "in", ",", "rtx", "reg", ",", "int", "modes_too", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "enum", "rtx_code", "code", ";", "if", "(", "in", "==", "0", ")", "return", "false", ";", "if", "(", "reg", "&&", "GET_CODE", "(", "reg", ")", "!=", "REG", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "in", ")", "==", "LABEL_REF", ")", "return", "(", "reg", "==", "0", ")", ";", "code", "=", "GET_CODE", "(", "in", ")", ";", "switch", "(", "code", ")", "{", "case", "MEM", ":", "if", "(", "reg", ")", "return", "mep_mentioned_p", "(", "XEXP", "(", "in", ",", "0", ")", ",", "reg", ",", "modes_too", ")", ";", "return", "true", ";", "case", "REG", ":", "if", "(", "!", "reg", ")", "return", "false", ";", "if", "(", "modes_too", "&&", "(", "GET_MODE", "(", "in", ")", "!=", "GET_MODE", "(", "reg", ")", ")", ")", "return", "false", ";", "return", "(", "REGNO", "(", "in", ")", "==", "REGNO", "(", "reg", ")", ")", ";", "case", "SCRATCH", ":", "case", "CC0", ":", "case", "PC", ":", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "false", ";", "default", ":", "break", ";", "}", "if", "(", "code", "==", "SET", "&&", "!", "reg", ")", "return", "mep_mentioned_p", "(", "SET_DEST", "(", "in", ")", ",", "reg", ",", "modes_too", ")", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "register", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "in", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "mep_mentioned_p", "(", "XVECEXP", "(", "in", ",", "i", ",", "j", ")", ",", "reg", ",", "modes_too", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "mep_mentioned_p", "(", "XEXP", "(", "in", ",", "i", ")", ",", "reg", ",", "modes_too", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Experimental", "Reorg", "." ]

[ "mep", "0", "0", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "void", "OrderedRegisterList", "::", "insert", "(", "unsigned", "VR", ")", "{", "iterator", "L", "=", "std", "::", "lower_bound", "(", "Seq", ".", "begin", "(", ")", ",", "Seq", ".", "end", "(", ")", ",", "VR", ",", "Ord", ")", ";", "if", "(", "L", "==", "Seq", ".", "end", "(", ")", ")", "Seq", ".", "push_back", "(", "VR", ")", ";", "else", "Seq", ".", "insert", "(", "L", ",", "VR", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "void", "NVPTXRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "NVPTX", "::", "VRFrame", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "\"Unexpected\"", "1", "NVPTX::VRFrame", "1" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "ClobbersPredicate", "(", "MachineInstr", "&", "MI", ",", "std", "::", "vector", "<", "MachineOperand", ">", "&", "Pred", ",", "bool", "SkipDead", ")", "const", "{", "bool", "Found", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "bool", "ClobbersCPSR", "=", "MO", ".", "isRegMask", "(", ")", "&&", "MO", ".", "clobbersPhysReg", "(", "ARM", "::", "CPSR", ")", ";", "bool", "IsCPSR", "=", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", ";", "if", "(", "ClobbersCPSR", "||", "IsCPSR", ")", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "if", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "ThumbArithFlagSetting", "&&", "MO", ".", "isDead", "(", ")", "&&", "SkipDead", ")", "continue", ";", "Pred", ".", "push_back", "(", "MO", ")", ";", "Found", "=", "true", ";", "}", "}", "return", "Found", ";", "}", "</s>" ]

[ "If", "the", "specified", "instruction", "defines", "any", "predicate", "or", "condition", "code", "register", "(", "s", ")", "used", "for", "predication", ",", "returns", "true", "as", "well", "as", "the", "definition", "predicate", "(", "s", ")", "by", "reference", "." ]

[ "ARM", "ARM", "ARM::CPSR", "ARM::CPSR", "ARMII::ThumbArithFlagSetting" ]

[]

[ "<s>", "Optional", "<", "ExtAddrMode", ">", "X86InstrInfo", "::", "getAddrModeFromMemoryOp", "(", "const", "MachineInstr", "&", "MemI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MemI", ".", "getDesc", "(", ")", ";", "int", "MemRefBegin", "=", "X86II", "::", "getMemoryOperandNo", "(", "Desc", ".", "TSFlags", ")", ";", "if", "(", "MemRefBegin", "<", "0", ")", "return", "None", ";", "MemRefBegin", "+=", "X86II", "::", "getOperandBias", "(", "Desc", ")", ";", "auto", "&", "BaseOp", "=", "MemI", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrBaseReg", ")", ";", "if", "(", "!", "BaseOp", ".", "isReg", "(", ")", ")", "return", "None", ";", "const", "MachineOperand", "&", "DispMO", "=", "MemI", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrDisp", ")", ";", "if", "(", "!", "DispMO", ".", "isImm", "(", ")", ")", "return", "None", ";", "ExtAddrMode", "AM", ";", "AM", ".", "BaseReg", "=", "BaseOp", ".", "getReg", "(", ")", ";", "AM", ".", "ScaledReg", "=", "MemI", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrIndexReg", ")", ".", "getReg", "(", ")", ";", "AM", ".", "Scale", "=", "MemI", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrScaleAmt", ")", ".", "getImm", "(", ")", ";", "AM", ".", "Displacement", "=", "DispMO", ".", "getImm", "(", ")", ";", "return", "AM", ";", "}", "</s>" ]

[ "Target", "dependent", "implementation", "to", "get", "the", "values", "constituting", "the", "address", "MachineInstr", "that", "is", "accessing", "memory", "." ]

[ "X86", "X86", "X86II::getMemoryOperandNo", "0", "X86II::getOperandBias", "X86::AddrBaseReg", "X86::AddrDisp", "X86::AddrIndexReg", "X86::AddrScaleAmt" ]

[]

[ "<s>", "bool", "vax_maybe_split_dimode_move", "(", "rtx", "*", "operands", ")", "{", "return", "(", "TARGET_QMATH", "&&", "(", "!", "MEM_P", "(", "operands", "[", "0", "]", ")", "||", "GET_CODE", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", "==", "POST_INC", "||", "!", "illegal_addsub_di_memory_operand", "(", "operands", "[", "0", "]", ",", "DImode", ")", ")", "&&", "(", "(", "CONST_INT_P", "(", "operands", "[", "1", "]", ")", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "INTVAL", "(", "operands", "[", "1", "]", ")", ">=", "64", ")", "||", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_DOUBLE", ")", ")", ";", "}", "</s>" ]

[ "Output", "integer", "move", "instructions", "." ]

[ "vax", "0", "0", "0", "0", "0", "0", "1", "1", "64", "1" ]

[]

[ "<s>", "void", "Cpu0RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "Cpu0MachineFunctionInfo", "*", "Cpu0FI", "=", "MF", ".", "getInfo", "<", "Cpu0MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getFunction", "(", ")", ".", "getName", "(", ")", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"<--------->\\n\"", "<<", "MI", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "uint64_t", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "int64_t", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "int", "MinCSFI", "=", "0", ";", "int", "MaxCSFI", "=", "-", "1", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "0", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getFrameIdx", "(", ")", ";", "}", "unsigned", "FrameReg", ";", "if", "(", "Cpu0FI", "->", "isOutArgFI", "(", "FrameIndex", ")", "||", "Cpu0FI", "->", "isDynAllocFI", "(", "FrameIndex", ")", "||", "(", "FrameIndex", ">=", "MinCSFI", "&&", "FrameIndex", "<=", "MaxCSFI", ")", ")", "FrameReg", "=", "Cpu0", "::", "SP", ";", "else", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "int64_t", "Offset", ";", "if", "(", "Cpu0FI", "->", "isOutArgFI", "(", "FrameIndex", ")", "||", "Cpu0FI", "->", "isGPFI", "(", "FrameIndex", ")", "||", "Cpu0FI", "->", "isDynAllocFI", "(", "FrameIndex", ")", ")", "Offset", "=", "spOffset", ";", "else", "Offset", "=", "spOffset", "+", "(", "int64_t", ")", "stackSize", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "if", "(", "!", "MI", ".", "isDebugValue", "(", ")", "&&", "!", "isInt", "<", "16", ">", "(", "Offset", ")", ")", "{", "assert", "(", "\"(!MI.isDebugValue() && !isInt<16>(Offset))\"", ")", ";", "}", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "0", "\"Instr doesn't have FrameIndex operand!\"", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"", "0", "1", "0", "1", "Cpu0", "Cpu0", "Cpu0::SP", "Cpu0", "Cpu0", "Cpu0", "1", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "16", "\"(!MI.isDebugValue() && !isInt<16>(Offset))\"", "1" ]

[]

[ "<s>", "long", "compute_frame_size", "(", "poly_int64", "size", ")", "{", "int", "regno", ";", "if", "(", "reload_completed", "&&", "cfun", "->", "machine", "->", "frame_laid_out", ")", "return", "cfun", "->", "machine", "->", "current_frame_size", ";", "if", "(", "cfun", "->", "static_chain_decl", "!=", "NULL", ")", "size", "+=", "(", "1", "*", "UNITS_PER_WORD", ")", ";", "cfun", "->", "machine", "->", "callee_save_size", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "++", "regno", ")", "{", "if", "(", "xtensa_call_save_reg", "(", "regno", ")", ")", "cfun", "->", "machine", "->", "callee_save_size", "+=", "UNITS_PER_WORD", ";", "}", "cfun", "->", "machine", "->", "current_frame_size", "=", "XTENSA_STACK_ALIGN", "(", "size", "+", "cfun", "->", "machine", "->", "callee_save_size", "+", "crtl", "->", "outgoing_args_size", "+", "(", "WINDOW_SIZE", "*", "UNITS_PER_WORD", ")", ")", ";", "cfun", "->", "machine", "->", "callee_save_size", "=", "XTENSA_STACK_ALIGN", "(", "cfun", "->", "machine", "->", "callee_save_size", ")", ";", "cfun", "->", "machine", "->", "frame_laid_out", "=", "true", ";", "return", "cfun", "->", "machine", "->", "current_frame_size", ";", "}", "</s>" ]

[ "Typical", "stack", "layout", "should", "looks", "like", "this", "after", "the", "function", "'s", "prologue", ":", "|", "|", "--", "^", "|", "|", "\\", "|", "|", "|", "arguments", "saved", "|", "Increasing", "|", "|", "on", "the", "stack", "|", "addresses", "PARENT", "arg", "pointer", "-", ">", "|", "|", "/", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "|", "|", "-", "space", "for", "argument", "split", "between", "regs", "&", "stack", "--", "CHILD", "|", "|", "\\", "<", "--", "(", "return", "address", "here", ")", "|", "|", "other", "call", "|", "|", "saved", "registers", "|", "|", "/", "--", "frame", "pointer", "-", ">", "|", "|", "\\", "___", "|", "|", "local", "|", "|", "|", "variables", "|f", "|", "|", "/", "|r", "--", "|a", "|", "|", "\\", "|m", "|", "|", "outgoing", "|e", "|", "|", "arguments", "|", "|", "Decreasing", "(", "hard", ")", "frame", "pointer", "|", "|", "/", "|", "|", "addresses", "and", "stack", "pointer", "-", ">", "|", "|", "/", "_|_", "|", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "V" ]

[ "xtensa", "1", "0", "0" ]

[]

[ "<s>", "static", "void", "complete_base_type", "(", "typeinfo", "*", "typeptr", ",", "char", "*", "buf", ",", "int", "*", "bufi", ")", "{", "switch", "(", "typeptr", "->", "base", ")", "{", "case", "BT_CHAR", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"qi\"", ",", "2", ")", ";", "break", ";", "case", "BT_SHORT", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"hi\"", ",", "2", ")", ";", "break", ";", "case", "BT_INT", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"si\"", ",", "2", ")", ";", "break", ";", "case", "BT_LONG", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"lg\"", ",", "2", ")", ";", "break", ";", "case", "BT_LONGLONG", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"di\"", ",", "2", ")", ";", "break", ";", "case", "BT_FLOAT", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"sf\"", ",", "2", ")", ";", "break", ";", "case", "BT_DOUBLE", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"df\"", ",", "2", ")", ";", "break", ";", "case", "BT_LONGDOUBLE", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"ld\"", ",", "2", ")", ";", "break", ";", "case", "BT_INT128", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"ti\"", ",", "2", ")", ";", "break", ";", "case", "BT_FLOAT128", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"tf\"", ",", "2", ")", ";", "break", ";", "case", "BT_BOOL", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"bi\"", ",", "2", ")", ";", "break", ";", "case", "BT_STRING", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"st\"", ",", "2", ")", ";", "break", ";", "case", "BT_DECIMAL32", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"sd\"", ",", "2", ")", ";", "break", ";", "case", "BT_DECIMAL64", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"dd\"", ",", "2", ")", ";", "break", ";", "case", "BT_DECIMAL128", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"td\"", ",", "2", ")", ";", "break", ";", "case", "BT_IBM128", ":", "memcpy", "(", "&", "buf", "[", "*", "bufi", "]", ",", "\"if\"", ",", "2", ")", ";", "break", ";", "default", ":", "diag", "(", "pos", ",", "\"unhandled basetype %d.\\n\"", ",", "typeptr", "->", "base", ")", ";", "exit", "(", "1", ")", ";", "}", "*", "bufi", "+=", "2", ";", "}", "</s>" ]

[ "Convert", "a", "base", "type", "into", "a", "mode", "string", "." ]

[ "rs6000", "\"qi\"", "2", "\"hi\"", "2", "\"si\"", "2", "\"lg\"", "2", "\"di\"", "2", "\"sf\"", "2", "\"df\"", "2", "\"ld\"", "2", "\"ti\"", "2", "\"tf\"", "2", "\"bi\"", "2", "\"st\"", "2", "\"sd\"", "2", "\"dd\"", "2", "\"td\"", "2", "\"if\"", "2", "\"unhandled basetype %d.\\n\"", "1", "2" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "AAResultsWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "AssumptionCacheTracker", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "&&", "MFI", "->", "hasCalls", "(", ")", ")", "return", "true", ";", "return", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "int", "s390_non_addr_reg_read_p", "(", "rtx", "reg", ",", "rtx_insn", "*", "insn", ")", "{", "return", "reg_referenced_p", "(", "reg", ",", "PATTERN", "(", "insn", ")", ")", "&&", "!", "reg_used_in_mem_p", "(", "REGNO", "(", "reg", ")", ",", "PATTERN", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Returns", "1", "if", "INSN", "reads", "the", "value", "of", "REG", "for", "purposes", "not", "related", "to", "addressing", "of", "memory", ",", "and", "0", "otherwise", "." ]

[ "s390" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "ARMConstantPoolValue", "*", "ACPV", ")", "{", "return", "ACPV", "->", "isMachineBasicBlock", "(", ")", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "ARM", "ARM" ]

[]

[ "<s>", "BitVector", "LM32RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "LM32", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "LM32", "::", "RGP", ")", ";", "Reserved", ".", "set", "(", "LM32", "::", "RFP", ")", ";", "Reserved", ".", "set", "(", "LM32", "::", "RSP", ")", ";", "Reserved", ".", "set", "(", "LM32", "::", "RRA", ")", ";", "Reserved", ".", "set", "(", "LM32", "::", "REA", ")", ";", "Reserved", ".", "set", "(", "LM32", "::", "RBA", ")", ";", "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", "." ]

[ "LM32", "LM32", "LM32::R0", "LM32::RGP", "LM32::RFP", "LM32::RSP", "LM32::RRA", "LM32::REA", "LM32::RBA" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "storeOfVectorConstantIsCheap", "(", "EVT", "MemVT", ",", "unsigned", "NumElem", ",", "unsigned", "AS", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "expected", "to", "be", "cheaper", "to", "do", "a", "store", "of", "vector", "constant", "with", "the", "given", "size", "and", "type", "for", "the", "address", "space", "than", "to", "store", "the", "individual", "scalar", "element", "constants", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "HexagonPacketizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "DisablePacketizer", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "HII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "auto", "*", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "auto", "*", "MBPI", "=", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "if", "(", "EnableGenAllInsnClass", ")", "HII", "->", "genAllInsnTimingClasses", "(", "MF", ")", ";", "HexagonPacketizerList", "Packetizer", "(", "MF", ",", "MLI", ",", "AA", ",", "MBPI", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "auto", "&", "MB", ":", "MF", ")", "{", "auto", "End", "=", "MB", ".", "end", "(", ")", ";", "auto", "MI", "=", "MB", ".", "begin", "(", ")", ";", "while", "(", "MI", "!=", "End", ")", "{", "auto", "NextI", "=", "std", "::", "next", "(", "MI", ")", ";", "if", "(", "MI", "->", "isKill", "(", ")", ")", "{", "MB", ".", "erase", "(", "MI", ")", ";", "End", "=", "MB", ".", "end", "(", ")", ";", "}", "MI", "=", "NextI", ";", "}", "}", "for", "(", "auto", "&", "MB", ":", "MF", ")", "{", "auto", "Begin", "=", "MB", ".", "begin", "(", ")", ",", "End", "=", "MB", ".", "end", "(", ")", ";", "while", "(", "Begin", "!=", "End", ")", "{", "MachineBasicBlock", "::", "iterator", "RB", "=", "Begin", ";", "while", "(", "RB", "!=", "End", "&&", "HII", "->", "isSchedulingBoundary", "(", "*", "RB", ",", "&", "MB", ",", "MF", ")", ")", "++", "RB", ";", "MachineBasicBlock", "::", "iterator", "RE", "=", "RB", ";", "while", "(", "RE", "!=", "End", "&&", "!", "HII", "->", "isSchedulingBoundary", "(", "*", "RE", ",", "&", "MB", ",", "MF", ")", ")", "++", "RE", ";", "if", "(", "RE", "!=", "End", ")", "++", "RE", ";", "if", "(", "RB", "!=", "End", ")", "Packetizer", ".", "PacketizeMIs", "(", "&", "MB", ",", "RB", ",", "RE", ")", ";", "Begin", "=", "RE", ";", "}", "}", "Packetizer", ".", "unpacketizeSoloInstrs", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Empty DFA table!\"" ]

[]

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

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

[ "ARM", "ARM", "\"Didn't find MI in its own basic block?\"" ]

[]

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

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "X86FixupSetCCPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "ToErase", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "X86", "::", "SETCCr", ")", "continue", ";", "MachineInstr", "*", "ZExt", "=", "nullptr", ";", "for", "(", "auto", "&", "Use", ":", "MRI", "->", "use_instructions", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "if", "(", "Use", ".", "getOpcode", "(", ")", "==", "X86", "::", "MOVZX32rr8", ")", "ZExt", "=", "&", "Use", ";", "if", "(", "!", "ZExt", ")", "continue", ";", "MachineInstr", "*", "FlagsDefMI", "=", "findFlagsImpDef", "(", "MI", ".", "getParent", "(", ")", ",", "MachineBasicBlock", "::", "reverse_iterator", "(", "&", "MI", ")", ")", ";", "if", "(", "!", "FlagsDefMI", ")", "continue", ";", "if", "(", "impUsesFlags", "(", "FlagsDefMI", ")", ")", "continue", ";", "++", "NumSubstZexts", ";", "Changed", "=", "true", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", "?", "&", "X86", "::", "GR32RegClass", ":", "&", "X86", "::", "GR32_ABCDRegClass", ";", "unsigned", "ZeroReg", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "unsigned", "InsertReg", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "MBB", ",", "FlagsDefMI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "MOV32r0", ")", ",", "ZeroReg", ")", ";", "BuildMI", "(", "*", "ZExt", "->", "getParent", "(", ")", ",", "ZExt", ",", "ZExt", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "INSERT_SUBREG", ")", ",", "InsertReg", ")", ".", "addReg", "(", "ZeroReg", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "X86", "::", "sub_8bit", ")", ";", "MRI", "->", "replaceRegWith", "(", "ZExt", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "InsertReg", ")", ";", "ToErase", ".", "push_back", "(", "ZExt", ")", ";", "}", "}", "for", "(", "auto", "&", "I", ":", "ToErase", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "4", "X86::SETCCr", "0", "X86::MOVZX32rr8", "X86", "X86::GR32RegClass", "X86::GR32_ABCDRegClass", "X86::MOV32r0", "X86::INSERT_SUBREG", "0", "X86::sub_8bit", "0" ]

[]

[ "<s>", "static", "bool", "msp430_rtx_costs", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "int", "code", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "code", ")", "{", "case", "SIGN_EXTEND", ":", "if", "(", "GET_MODE", "(", "x", ")", "==", "SImode", "&&", "outer_code", "==", "SET", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "return", "true", ";", "}", "break", ";", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "if", "(", "!", "msp430x", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "100", ")", ";", "return", "true", ";", "}", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "target", "hook", "describes", "the", "relative", "costs", "of", "RTL", "expressions", ".", "The", "function", "recurses", "to", "just", "before", "the", "lowest", "level", "of", "the", "expression", ",", "when", "both", "of", "the", "operands", "of", "the", "expression", "can", "be", "examined", "at", "the", "same", "time", ".", "This", "is", "because", "the", "cost", "of", "the", "expression", "depends", "on", "the", "specific", "addressing", "mode", "combination", "of", "the", "operands", ".", "The", "hook", "returns", "true", "when", "all", "subexpressions", "of", "X", "have", "been", "processed", ",", "and", "false", "when", "rtx_cost", "should", "recurse", "." ]

[ "msp430", "4", "100" ]

[]

[ "<s>", "static", "bool", "rs6000_global_entry_point_needed_p", "(", "void", ")", "{", "if", "(", "DEFAULT_ABI", "!=", "ABI_ELFv2", ")", "return", "false", ";", "if", "(", "TARGET_SINGLE_PIC_BASE", ")", "return", "false", ";", "if", "(", "cfun", "->", "is_thunk", ")", "return", "true", ";", "return", "cfun", "->", "machine", "->", "r2_setup_needed", ";", "}", "</s>" ]

[ "Return", "whether", "we", "need", "to", "emit", "an", "ELFv2", "global", "entry", "point", "prologue", "." ]

[ "rs6000" ]

[]

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

[ "Does", "this", "target", "require", "the", "clearing", "of", "high-order", "bits", "in", "a", "register", "passed", "to", "the", "fp16", "to", "fp", "conversion", "library", "function", "." ]

[ "PowerPC" ]

[]

[ "<s>", "unsigned", "AVRInstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "NewDestBB", ",", "const", "DebugLoc", "&", "DL", ",", "int64_t", "BrOffset", ",", "RegScavenger", "*", "RS", ")", "const", "{", "auto", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AVR", "::", "JMPk", ")", ")", ".", "addMBB", "(", "&", "NewDestBB", ")", ";", "return", "getInstSizeInBytes", "(", "MI", ")", ";", "}", "</s>" ]

[ "Insert", "an", "unconditional", "indirect", "branch", "at", "the", "end", "of", "MBB", "to", "NewDestBB", "." ]

[ "AVR", "AVR", "AVR::JMPk" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "bool", "CallsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "assert", "(", "MF", "&&", "\"MachineFunction required\"", ")", ";", "switch", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_SaveList", ";", "return", "CSR_64_RT_AllRegs_SaveList", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_TLS_Darwin_SaveList", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_SaveList", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_SaveList", ";", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_SaveList", ";", "break", ";", "case", "CallingConv", "::", "X86_64_Win64", ":", "return", "CSR_Win64_SaveList", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "else", "return", "CSR_64_AllRegs_SaveList", ";", "}", "else", "{", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_SaveList", ";", "else", "return", "CSR_32_AllRegs_SaveList", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_SaveList", ";", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"MachineFunction required\"", "X86", "X86", "X86" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "enableInterleavedAccessVectorization", "(", ")", "{", "return", "!", "(", "ST", "->", "isAtom", "(", ")", ")", ";", "}", "</s>" ]

[ "Enable", "matching", "of", "interleaved", "access", "groups", "." ]

[ "X86", "X86" ]

[]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "0", "0", "1", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "1", "MSP430::ADD16ri", "MSP430::SP", "MSP430::SP", "3", "1", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "3" ]

[]

[ "<s>", "int", "AArch64FrameLowering", "::", "getFrameIndexReferencePreferSP", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ",", "bool", "IgnoreSPUpdates", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Offset from the SP for \"", "<<", "FI", "<<", "\" is \"", "<<", "MFI", ".", "getObjectOffset", "(", "FI", ")", "<<", "\"\\n\"", ")", ";", "FrameReg", "=", "AArch64", "::", "SP", ";", "return", "MFI", ".", "getObjectOffset", "(", "FI", ")", ";", "}", "</s>" ]

[ "Same", "as", "getFrameIndexReference", ",", "except", "that", "the", "stack", "pointer", "(", "as", "opposed", "to", "the", "frame", "pointer", ")", "will", "be", "the", "preferred", "value", "for", "FrameReg", "." ]

[ "AArch64", "AArch64", "\"Offset from the SP for \"", "\" is \"", "\"\\n\"", "AArch64::SP" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "MCInst", "const", "&", "Inst", ")", "const", "override", "{", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "Inst", ")", ")", ";", "bool", "PreviousIsExtender", "=", "false", ";", "for", "(", "auto", "const", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "Inst", ")", ")", "{", "auto", "const", "&", "Inst", "=", "*", "I", ".", "getInst", "(", ")", ";", "if", "(", "!", "PreviousIsExtender", ")", "{", "if", "(", "isInstRelaxable", "(", "Inst", ")", ")", "return", "true", ";", "}", "PreviousIsExtender", "=", "HexagonMCInstrInfo", "::", "isImmext", "(", "Inst", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "LanaiInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "&", "MIa", ",", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "assert", "(", "MIa", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIa must be a load or store.\"", ")", ";", "assert", "(", "MIb", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIb must be a load or store.\"", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "unsigned", "BaseRegA", "=", "0", ",", "BaseRegB", "=", "0", ";", "int64_t", "OffsetA", "=", "0", ",", "OffsetB", "=", "0", ";", "unsigned", "int", "WidthA", "=", "0", ",", "WidthB", "=", "0", ";", "if", "(", "getMemOpBaseRegImmOfsWidth", "(", "MIa", ",", "BaseRegA", ",", "OffsetA", ",", "WidthA", ",", "TRI", ")", "&&", "getMemOpBaseRegImmOfsWidth", "(", "MIb", ",", "BaseRegB", ",", "OffsetB", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseRegA", "==", "BaseRegB", ")", "{", "int", "LowOffset", "=", "std", "::", "min", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "HighOffset", "=", "std", "::", "max", "(", "OffsetA", ",", "OffsetB", ")", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "Lanai", "Lanai", "\"MIa must be a load or store.\"", "\"MIb must be a load or store.\"", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "PTXTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown opcode\"", ")", ";", "case", "PTXISD", "::", "COPY_ADDRESS", ":", "return", "\"PTXISD::COPY_ADDRESS\"", ";", "case", "PTXISD", "::", "READ_PARAM", ":", "return", "\"PTXISD::READ_PARAM\"", ";", "case", "PTXISD", "::", "EXIT", ":", "return", "\"PTXISD::EXIT\"", ";", "case", "PTXISD", "::", "RET", ":", "return", "\"PTXISD::RET\"", ";", "}", "}", "</s>" ]

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

[ "PTX", "PTX", "\"Unknown opcode\"", "PTXISD::COPY_ADDRESS", "\"PTXISD::COPY_ADDRESS\"", "PTXISD::READ_PARAM", "\"PTXISD::READ_PARAM\"", "PTXISD::EXIT", "\"PTXISD::EXIT\"", "PTXISD::RET", "\"PTXISD::RET\"" ]

[]

[ "<s>", "bool", "mips_expand_unaligned_load", "(", "rtx", "dest", ",", "rtx", "src", ",", "unsigned", "int", "width", ",", "int", "bitpos", ")", "{", "rtx", "left", ",", "right", ",", "temp", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "SUBREG", "&&", "GET_MODE", "(", "dest", ")", "==", "DImode", "&&", "SUBREG_BYTE", "(", "dest", ")", "==", "0", "&&", "GET_MODE", "(", "SUBREG_REG", "(", "dest", ")", ")", "==", "SImode", ")", "dest", "=", "SUBREG_REG", "(", "dest", ")", ";", "if", "(", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "dest", ")", ")", "!=", "width", ")", "return", "false", ";", "if", "(", "!", "mips_get_unaligned_mem", "(", "&", "src", ",", "width", ",", "bitpos", ",", "&", "left", ",", "&", "right", ")", ")", "return", "false", ";", "temp", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "dest", ")", ")", ";", "if", "(", "GET_MODE", "(", "dest", ")", "==", "DImode", ")", "{", "emit_insn", "(", "gen_mov_ldl", "(", "temp", ",", "src", ",", "left", ")", ")", ";", "emit_insn", "(", "gen_mov_ldr", "(", "dest", ",", "copy_rtx", "(", "src", ")", ",", "right", ",", "temp", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_mov_lwl", "(", "temp", ",", "src", ",", "left", ")", ")", ";", "emit_insn", "(", "gen_mov_lwr", "(", "dest", ",", "copy_rtx", "(", "src", ")", ",", "right", ",", "temp", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "emit", "the", "equivalent", "of", "(", "set", "DEST", "(", "zero_extract", "SRC", "WIDTH", "BITPOS", ")", ")", ".", "Return", "true", "on", "success", ".", "We", "only", "handle", "cases", "where", "zero_extract", "is", "equivalent", "to", "sign_extract", "." ]

[ "mips", "0" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getGPRsForTailCall", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "F", "&&", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "{", "if", "(", "Is64Bit", ")", "return", "&", "X86", "::", "GR64RegClass", ";", "else", "return", "&", "X86", "::", "GR32RegClass", ";", "}", "if", "(", "IsWin64", "||", "(", "F", "&&", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "X86_64_Win64", ")", ")", "return", "&", "X86", "::", "GR64_TCW64RegClass", ";", "else", "if", "(", "Is64Bit", ")", "return", "&", "X86", "::", "GR64_TCRegClass", ";", "bool", "hasHipeCC", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "HiPE", ":", "false", ")", ";", "if", "(", "hasHipeCC", ")", "return", "&", "X86", "::", "GR32RegClass", ";", "return", "&", "X86", "::", "GR32_TCRegClass", ";", "}", "</s>" ]

[ "getGPRsForTailCall", "-", "Returns", "a", "register", "class", "with", "registers", "that", "can", "be", "used", "in", "forming", "tail", "calls", "." ]

[ "X86", "X86", "X86::GR64RegClass", "X86::GR32RegClass", "X86", "X86::GR64_TCW64RegClass", "X86::GR64_TCRegClass", "X86::GR32RegClass", "X86::GR32_TCRegClass" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isProfitableToHoist", "(", "Instruction", "*", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "Instruction", "::", "FMul", ")", "return", "true", ";", "if", "(", "I", "->", "getNumUses", "(", ")", "!=", "1", ")", "return", "true", ";", "Instruction", "*", "User", "=", "I", "->", "user_back", "(", ")", ";", "if", "(", "User", "&&", "!", "(", "User", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "FSub", "||", "User", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "FAdd", ")", ")", "return", "true", ";", "const", "TargetOptions", "&", "Options", "=", "getTargetMachine", "(", ")", ".", "Options", ";", "EVT", "VT", "=", "getValueType", "(", "User", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "if", "(", "isFMAFasterThanFMulAndFAdd", "(", "VT", ")", "&&", "isOperationLegalOrCustom", "(", "ISD", "::", "FMA", ",", "VT", ")", "&&", "(", "Options", ".", "AllowFPOpFusion", "==", "FPOpFusion", "::", "Fast", "||", "Options", ".", "UnsafeFPMath", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "hoist", "instruction", "in", "the", "then/else", "to", "before", "if", "." ]

[ "AArch64", "AArch64", "1", "0", "ISD::FMA" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "is64Bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "Options", ".", "StackAlignmentOverride", ",", "is64Bit", ")", ",", "FrameLowering", "(", "*", "this", ",", "Subtarget", ")", ",", "ELFWriterInfo", "(", "is64Bit", ",", "true", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetCygMing", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "Subtarget", ".", "isTargetELF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "FloatABI", "::", "Hard", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

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

[]

[ "<s>", "aarch64_simd_switcher", "::", "aarch64_simd_switcher", "(", "unsigned", "int", "extra_flags", ")", ":", "m_old_asm_isa_flags", "(", "aarch64_asm_isa_flags", ")", ",", "m_old_general_regs_only", "(", "TARGET_GENERAL_REGS_ONLY", ")", "{", "global_options", ".", "x_target_flags", "&=", "~", "MASK_GENERAL_REGS_ONLY", ";", "aarch64_set_asm_isa_flags", "(", "AARCH64_FL_FP", "|", "AARCH64_FL_SIMD", "|", "extra_flags", ")", ";", "}", "</s>" ]

[ "Enable", "AARCH64_FL_", "*", "flags", "EXTRA_FLAGS", "on", "top", "of", "the", "base", "Advanced", "SIMD", "set", "." ]

[ "aarch64", "aarch64_simd_switcher::aarch64_simd_switcher" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "TM", "||", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", ".", "isPromoteAllocaEnabled", "(", ")", ")", "return", "false", ";", "AS", "=", "AMDGPU", "::", "getAMDGPUAS", "(", "*", "F", ".", "getParent", "(", ")", ")", ";", "FunctionType", "*", "FTy", "=", "F", ".", "getFunctionType", "(", ")", ";", "for", "(", "Type", "*", "ParamTy", ":", "FTy", "->", "params", "(", ")", ")", "{", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "ParamTy", ")", ";", "if", "(", "PtrTy", "&&", "PtrTy", "->", "getAddressSpace", "(", ")", "==", "AS", ".", "LOCAL_ADDRESS", ")", "{", "LocalMemLimit", "=", "0", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", ")", ";", "return", "false", ";", "}", "}", "LocalMemLimit", "=", "ST", ".", "getLocalMemorySize", "(", ")", ";", "if", "(", "LocalMemLimit", "==", "0", ")", "return", "false", ";", "const", "DataLayout", "&", "DL", "=", "Mod", "->", "getDataLayout", "(", ")", ";", "CurrentLocalMemUsage", "=", "0", ";", "for", "(", "GlobalVariable", "&", "GV", ":", "Mod", "->", "globals", "(", ")", ")", "{", "if", "(", "GV", ".", "getType", "(", ")", "->", "getAddressSpace", "(", ")", "!=", "AS", ".", "LOCAL_ADDRESS", ")", "continue", ";", "for", "(", "const", "User", "*", "U", ":", "GV", ".", "users", "(", ")", ")", "{", "const", "Instruction", "*", "Use", "=", "dyn_cast", "<", "Instruction", ">", "(", "U", ")", ";", "if", "(", "!", "Use", ")", "continue", ";", "if", "(", "Use", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "==", "&", "F", ")", "{", "unsigned", "Align", "=", "GV", ".", "getAlignment", "(", ")", ";", "if", "(", "Align", "==", "0", ")", "Align", "=", "DL", ".", "getABITypeAlignment", "(", "GV", ".", "getValueType", "(", ")", ")", ";", "uint64_t", "AllocSize", "=", "DL", ".", "getTypeAllocSize", "(", "GV", ".", "getValueType", "(", ")", ")", ";", "CurrentLocalMemUsage", "=", "alignTo", "(", "CurrentLocalMemUsage", ",", "Align", ")", ";", "CurrentLocalMemUsage", "+=", "AllocSize", ";", "break", ";", "}", "}", "}", "unsigned", "MaxOccupancy", "=", "ST", ".", "getOccupancyWithLocalMemSize", "(", "CurrentLocalMemUsage", ",", "F", ")", ";", "unsigned", "OccupancyHint", "=", "ST", ".", "getWavesPerEU", "(", "F", ")", ".", "second", ";", "if", "(", "OccupancyHint", "==", "0", ")", "OccupancyHint", "=", "7", ";", "OccupancyHint", "=", "std", "::", "min", "(", "OccupancyHint", ",", "ST", ".", "getMaxWavesPerEU", "(", ")", ")", ";", "MaxOccupancy", "=", "std", "::", "min", "(", "OccupancyHint", ",", "MaxOccupancy", ")", ";", "unsigned", "MaxSizeWithWaveCount", "=", "ST", ".", "getMaxLocalMemSizeWithWaveCount", "(", "MaxOccupancy", ",", "F", ")", ";", "if", "(", "CurrentLocalMemUsage", ">", "MaxSizeWithWaveCount", ")", "return", "false", ";", "LocalMemLimit", "=", "MaxSizeWithWaveCount", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "F", ".", "getName", "(", ")", "<<", "\" uses \"", "<<", "CurrentLocalMemUsage", "<<", "\" bytes of LDS\\n\"", "<<", "\" Rounding size to \"", "<<", "MaxSizeWithWaveCount", "<<", "\" with a maximum occupancy of \"", "<<", "MaxOccupancy", "<<", "'\\n'", "<<", "\" and \"", "<<", "(", "LocalMemLimit", "-", "CurrentLocalMemUsage", ")", "<<", "\" available for promotion\\n\"", ")", ";", "BasicBlock", "&", "EntryBB", "=", "*", "F", ".", "begin", "(", ")", ";", "for", "(", "auto", "I", "=", "EntryBB", ".", "begin", "(", ")", ",", "E", "=", "EntryBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "I", ")", ";", "++", "I", ";", "if", "(", "AI", ")", "handleAlloca", "(", "*", "AI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU::getAMDGPUAS", "0", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", "0", "0", "0", "0", "7", "\" uses \"", "\" bytes of LDS\\n\"", "\" Rounding size to \"", "\" with a maximum occupancy of \"", "\" and \"", "\" available for promotion\\n\"" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "getMemOperandWithOffset", "(", "const", "MachineInstr", "&", "LdSt", ",", "const", "MachineOperand", "*", "&", "BaseOp", ",", "int64_t", "&", "Offset", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "AccessSize", "=", "0", ";", "BaseOp", "=", "getBaseAndOffset", "(", "LdSt", ",", "Offset", ",", "AccessSize", ")", ";", "assert", "(", "(", "!", "BaseOp", "||", "BaseOp", "->", "isReg", "(", ")", ")", "&&", "\"getMemOperandWithOffset only supports base \"", "\"operands of type register.\"", ")", ";", "return", "BaseOp", "!=", "nullptr", ";", "}", "</s>" ]

[ "Get", "the", "base", "operand", "and", "byte", "offset", "of", "an", "instruction", "that", "reads/writes", "memory", "." ]

[ "Hexagon", "Hexagon", "0", "\"getMemOperandWithOffset only supports base \"", "\"operands of type register.\"" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createARMISelDag", "(", "getARMTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", "&&", "TM", "->", "Options", ".", "EnableFastISel", ")", "addPass", "(", "createARMGlobalBaseRegPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "nonvol_nonimm_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", "&&", "MEM_VOLATILE_P", "(", "op", ")", ")", "return", "0", ";", "return", "nonimmediate_operand", "(", "op", ",", "mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "non-volatile", "non-immediate", "operand", ".", "Volatile", "memory", "refs", "require", "a", "special", "``", "cache-bypass", "''", "instruction", "and", "only", "the", "standard", "movXX", "patterns", "are", "set", "up", "to", "handle", "them", "." ]

[ "arc", "0" ]

[]

[ "<s>", "static", "void", "pa_asm_trampoline_template", "(", "FILE", "*", "f", ")", "{", "if", "(", "!", "TARGET_64BIT", ")", "{", "fputs", "(", "\"\\tldw\t36(%r22),%r21\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tbb,>=,n\t%r21,30,.+16\\n\"", ",", "f", ")", ";", "if", "(", "ASSEMBLER_DIALECT", "==", "0", ")", "fputs", "(", "\"\\tdepi\t0,31,2,%r21\\n\"", ",", "f", ")", ";", "else", "fputs", "(", "\"\\tdepwi\t0,31,2,%r21\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldw\t4(%r21),%r19\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldw\t0(%r21),%r21\\n\"", ",", "f", ")", ";", "if", "(", "TARGET_PA_20", ")", "{", "fputs", "(", "\"\\tbve\t(%r21)\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldw\t40(%r22),%r29\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "}", "else", "{", "fputs", "(", "\"\\tldsid\t(%r21),%r1\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tmtsp\t%r1,%sr0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tbe\t0(%sr0,%r21)\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldw\t40(%r22),%r29\\n\"", ",", "f", ")", ";", "}", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.word\t0\\n\"", ",", "f", ")", ";", "}", "else", "{", "fputs", "(", "\"\\t.dword 0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.dword 0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.dword 0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.dword 0\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tmfia\t%r31\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldd\t24(%r31),%r1\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldd\t24(%r1),%r27\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldd\t16(%r1),%r1\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tbve\t(%r1)\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\tldd\t32(%r31),%r31\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.dword 0 ; fptr\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.dword 0 ; static link\\n\"", ",", "f", ")", ";", "}", "}", "</s>" ]

[ "Output", "assembler", "code", "for", "a", "block", "containing", "the", "constant", "parts", "of", "a", "trampoline", ",", "leaving", "space", "for", "the", "variable", "parts.\\", "The", "trampoline", "sets", "the", "static", "chain", "pointer", "to", "STATIC_CHAIN_REGNUM", "and", "then", "branches", "to", "the", "specified", "routine", ".", "This", "code", "template", "is", "copied", "from", "text", "segment", "to", "stack", "location", "and", "then", "patched", "with", "pa_trampoline_init", "to", "contain", "valid", "values", ",", "and", "then", "entered", "as", "a", "subroutine", ".", "It", "is", "best", "to", "keep", "this", "as", "small", "as", "possible", "to", "avoid", "having", "to", "flush", "multiple", "lines", "in", "the", "cache", "." ]

[ "pa", "\"\\tldw\t36(%r22),%r21\\n\"", "\"\\tbb,>=,n\t%r21,30,.+16\\n\"", "0", "\"\\tdepi\t0,31,2,%r21\\n\"", "\"\\tdepwi\t0,31,2,%r21\\n\"", "\"\\tldw\t4(%r21),%r19\\n\"", "\"\\tldw\t0(%r21),%r21\\n\"", "\"\\tbve\t(%r21)\\n\"", "\"\\tldw\t40(%r22),%r29\\n\"", "\"\\t.word\t0\\n\"", "\"\\t.word\t0\\n\"", "\"\\tldsid\t(%r21),%r1\\n\"", "\"\\tmtsp\t%r1,%sr0\\n\"", "\"\\tbe\t0(%sr0,%r21)\\n\"", "\"\\tldw\t40(%r22),%r29\\n\"", "\"\\t.word\t0\\n\"", "\"\\t.word\t0\\n\"", "\"\\t.word\t0\\n\"", "\"\\t.word\t0\\n\"", "\"\\t.dword 0\\n\"", "\"\\t.dword 0\\n\"", "\"\\t.dword 0\\n\"", "\"\\t.dword 0\\n\"", "\"\\tmfia\t%r31\\n\"", "\"\\tldd\t24(%r31),%r1\\n\"", "\"\\tldd\t24(%r1),%r27\\n\"", "\"\\tldd\t16(%r1),%r1\\n\"", "\"\\tbve\t(%r1)\\n\"", "\"\\tldd\t32(%r31),%r31\\n\"", "\"\\t.dword 0 ; fptr\\n\"", "\"\\t.dword 0 ; static link\\n\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"P2 Expand Pseudos\"", ";", "}", "</s>" ]

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

[ "P2", "\"P2 Expand Pseudos\"" ]

[]

[ "<s>", "unsigned", "size", "(", ")", "const", "{", "return", "(", "Packet", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "void", "X86IntelInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "unsigned", "Flags", "=", "MI", "->", "getFlags", "(", ")", ";", "if", "(", "(", "TSFlags", "&", "X86II", "::", "LOCK", ")", "||", "(", "Flags", "&", "X86", "::", "IP_HAS_LOCK", ")", ")", "OS", "<<", "\"\\tlock\\t\"", ";", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT_NE", ")", "OS", "<<", "\"\\trepne\\t\"", ";", "else", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT", ")", "OS", "<<", "\"\\trep\\t\"", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "if", "(", "CommentStream", ")", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "getRegisterName", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "X86", "X86", "X86II::LOCK", "X86::IP_HAS_LOCK", "\"\\tlock\\t\"", "X86::IP_HAS_REPEAT_NE", "\"\\trepne\\t\"", "X86::IP_HAS_REPEAT", "\"\\trep\\t\"", "X86" ]

[]

[ "<s>", "static", "tree", "bpf_core_walk", "(", "tree", "*", "tp", ",", "int", "*", "walk_subtrees", ",", "void", "*", "data", ")", "{", "struct", "core_walk_data", "*", "dat", "=", "(", "struct", "core_walk_data", "*", ")", "data", ";", "if", "(", "TYPE_P", "(", "*", "tp", ")", ")", "{", "*", "walk_subtrees", "=", "0", ";", "return", "NULL_TREE", ";", "}", "tree", "newdecl", "=", "bpf_core_newdecl", "(", "TREE_TYPE", "(", "*", "tp", ")", ",", "dat", "->", "which", ")", ";", "if", "(", "dat", "->", "which", "==", "BPF_BUILTIN_PRESERVE_ACCESS_INDEX", ")", "{", "if", "(", "bpf_core_is_maybe_aggregate_access", "(", "*", "tp", ")", ")", "{", "*", "tp", "=", "build_call_expr_loc", "(", "dat", "->", "loc", ",", "newdecl", ",", "1", ",", "*", "tp", ")", ";", "*", "walk_subtrees", "=", "0", ";", "}", "}", "else", "{", "*", "tp", "=", "build_call_expr_loc", "(", "dat", "->", "loc", ",", "newdecl", ",", "2", ",", "*", "tp", ",", "dat", "->", "arg", ")", ";", "*", "walk_subtrees", "=", "0", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Callback", "function", "used", "with", "walk_tree", "from", "bpf_resolve_overloaded_builtin", "." ]

[ "bpf", "0", "1", "0", "2", "0" ]

[]

[ "<s>", "bool", "MVEGatherScatterLowering", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "EnableMaskedGatherScatters", ")", "return", "false", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "auto", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "auto", "*", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Gathers", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Scatters", ";", "bool", "Changed", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "for", "(", "Instruction", "&", "I", ":", "BB", ")", "{", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_gather", ")", "{", "Gathers", ".", "push_back", "(", "II", ")", ";", "if", "(", "isa", "<", "GetElementPtrInst", ">", "(", "II", "->", "getArgOperand", "(", "0", ")", ")", ")", "Changed", "|=", "optimiseOffsets", "(", "cast", "<", "Instruction", ">", "(", "II", "->", "getArgOperand", "(", "0", ")", ")", "->", "getOperand", "(", "1", ")", ",", "II", "->", "getParent", "(", ")", ",", "LI", ")", ";", "}", "else", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_scatter", ")", "{", "Scatters", ".", "push_back", "(", "II", ")", ";", "if", "(", "isa", "<", "GetElementPtrInst", ">", "(", "II", "->", "getArgOperand", "(", "1", ")", ")", ")", "Changed", "|=", "optimiseOffsets", "(", "cast", "<", "Instruction", ">", "(", "II", "->", "getArgOperand", "(", "1", ")", ")", "->", "getOperand", "(", "1", ")", ",", "II", "->", "getParent", "(", ")", ",", "LI", ")", ";", "}", "}", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Gathers", ".", "size", "(", ")", ";", "i", "++", ")", "{", "IntrinsicInst", "*", "I", "=", "Gathers", "[", "i", "]", ";", "Value", "*", "L", "=", "lowerGather", "(", "I", ")", ";", "if", "(", "L", "==", "nullptr", ")", "continue", ";", "SimplifyInstructionsInBlock", "(", "cast", "<", "Instruction", ">", "(", "L", ")", "->", "getParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Scatters", ".", "size", "(", ")", ";", "i", "++", ")", "{", "IntrinsicInst", "*", "I", "=", "Scatters", "[", "i", "]", ";", "Value", "*", "S", "=", "lowerScatter", "(", "I", ")", ";", "if", "(", "S", "==", "nullptr", ")", "continue", ";", "SimplifyInstructionsInBlock", "(", "cast", "<", "Instruction", ">", "(", "S", ")", "->", "getParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "4", "4", "Intrinsic::masked_gather", "0", "0", "1", "Intrinsic::masked_scatter", "1", "1", "1", "0", "0" ]

[]

[ "<s>", "bool", "HCE", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasPersonalityFn", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "\": skipping \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" due to exception handling\\n\"", ")", ";", "return", "false", ";", "}", "LLVM_DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"Before \"", "<<", "getPassName", "(", ")", "<<", "'\\n'", ",", "nullptr", ")", ")", ";", "HII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "AssignmentMap", "IMap", ";", "collect", "(", "MF", ")", ";", "llvm", "::", "sort", "(", "Extenders", ",", "[", "]", "(", "const", "ExtDesc", "&", "A", ",", "const", "ExtDesc", "&", "B", ")", "{", "return", "ExtValue", "(", "A", ")", "<", "ExtValue", "(", "B", ")", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Collected \"", "<<", "Extenders", ".", "size", "(", ")", "<<", "\" extenders\\n\"", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Extenders", ".", "size", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "unsigned", "B", "=", "I", ";", "const", "ExtRoot", "&", "T", "=", "Extenders", "[", "B", "]", ".", "getOp", "(", ")", ";", "while", "(", "I", "!=", "E", "&&", "ExtRoot", "(", "Extenders", "[", "I", "]", ".", "getOp", "(", ")", ")", "==", "T", ")", "++", "I", ";", "IMap", ".", "clear", "(", ")", ";", "assignInits", "(", "T", ",", "B", ",", "I", ",", "IMap", ")", ";", "Changed", "|=", "replaceExtenders", "(", "IMap", ")", ";", "}", "LLVM_DEBUG", "(", "{", "if", "(", "Changed", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"After \"", "<<", "getPassName", "(", ")", "<<", "'\\n'", ",", "nullptr", ")", ";", "else", "dbgs", "(", ")", "<<", "\"No changes\\n\"", ";", "}", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "\": skipping \"", "\" due to exception handling\\n\"", "\"Before \"", "Hexagon", "Hexagon", "\"Collected \"", "\" extenders\\n\"", "0", "\"After \"", "\"No changes\\n\"" ]

[]

[ "<s>", "static", "bool", "sh_symbian_dllimport_p", "(", "tree", "decl", ")", "{", "tree", "imp", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", "&&", "TREE_CODE", "(", "decl", ")", "!=", "FUNCTION_DECL", ")", "return", "false", ";", "imp", "=", "lookup_attribute", "(", "\"dllimport\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "if", "(", "imp", ")", "return", "true", ";", "imp", "=", "sh_symbian_associated_type", "(", "decl", ")", ";", "if", "(", "!", "imp", ")", "return", "false", ";", "imp", "=", "lookup_attribute", "(", "\"dllimport\"", ",", "TYPE_ATTRIBUTES", "(", "imp", ")", ")", ";", "if", "(", "!", "imp", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "DECL_INITIAL", "(", "decl", ")", "&&", "!", "DECL_INLINE", "(", "decl", ")", ")", "{", "if", "(", "!", "DECL_ARTIFICIAL", "(", "decl", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"function %q+D is defined after prior \"", "\"declaration as dllimport: attribute ignored\"", ",", "decl", ")", ";", "return", "false", ";", "}", "else", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "DECL_INLINE", "(", "decl", ")", ")", "{", "if", "(", "extra_warnings", ")", "warning", "(", "OPT_Wattributes", ",", "\"inline function %q+D is declared as \"", "\"dllimport: attribute ignored\"", ",", "decl", ")", ";", "return", "false", ";", "}", "else", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "TREE_STATIC", "(", "decl", ")", "&&", "TREE_PUBLIC", "(", "decl", ")", "&&", "!", "DECL_EXTERNAL", "(", "decl", ")", ")", "{", "if", "(", "!", "DECL_VIRTUAL_P", "(", "decl", ")", ")", "error", "(", "\"definition of static data member %q+D of dllimport'd class\"", ",", "decl", ")", ";", "return", "false", ";", "}", "else", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "decl", ")", ")", "==", "METHOD_TYPE", "&&", "(", "DECL_VIRTUAL_P", "(", "decl", ")", "||", "DECL_ARTIFICIAL", "(", "decl", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "DECL", "is", "a", "dllimport", "'d", "object", "." ]

[ "sh", "\"dllimport\"", "\"dllimport\"", "\"function %q+D is defined after prior \"", "\"declaration as dllimport: attribute ignored\"", "\"inline function %q+D is declared as \"", "\"dllimport: attribute ignored\"", "\"definition of static data member %q+D of dllimport'd class\"" ]

[]

[ "<s>", "bool", "isLegalMaskedLoad", "(", "Type", "*", "DataType", ",", "MaybeAlign", "Alignment", ")", "{", "return", "isLegalMaskedLoadStore", "(", "DataType", ",", "Alignment", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "load", "." ]

[ "AArch64" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "CSKY" ]

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "unsigned", "Opc", "=", "Inst", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MII", ".", "get", "(", "Opc", ")", ";", "if", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "ThumbArithFlagSetting", ")", "{", "assert", "(", "MCID", ".", "hasOptionalDef", "(", ")", "&&", "\"optionally flag setting instruction missing optional def operand\"", ")", ";", "assert", "(", "MCID", ".", "NumOperands", "==", "Inst", ".", "getNumOperands", "(", ")", "&&", "\"operand count mismatch!\"", ")", ";", "unsigned", "OpNo", ";", "for", "(", "OpNo", "=", "0", ";", "!", "MCID", ".", "OpInfo", "[", "OpNo", "]", ".", "isOptionalDef", "(", ")", "&&", "OpNo", "<", "MCID", ".", "NumOperands", ";", "++", "OpNo", ")", ";", "if", "(", "isThumbOne", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", ")", "return", "Match_RequiresFlagSetting", ";", "if", "(", "isThumbTwo", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", "&&", "!", "inITBlock", "(", ")", ")", "return", "Match_RequiresITBlock", ";", "if", "(", "isThumbTwo", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", "&&", "inITBlock", "(", ")", ")", "return", "Match_RequiresNotITBlock", ";", "}", "else", "if", "(", "isThumbOne", "(", ")", ")", "{", "if", "(", "Opc", "==", "ARM", "::", "tADDhirr", "&&", "!", "hasV6MOps", "(", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresThumb2", ";", "else", "if", "(", "Opc", "==", "ARM", "::", "tMOVr", "&&", "!", "hasV6Ops", "(", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresV6", ";", "}", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "MCID", ".", "NumOperands", ";", "++", "I", ")", "if", "(", "MCID", ".", "OpInfo", "[", "I", "]", ".", "RegClass", "==", "ARM", "::", "rGPRRegClassID", ")", "{", "if", "(", "(", "Inst", ".", "getOperand", "(", "I", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", "&&", "!", "hasV8Ops", "(", ")", ")", "return", "Match_RequiresV8", ";", "else", "if", "(", "Inst", ".", "getOperand", "(", "I", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "PC", ")", "return", "Match_InvalidOperand", ";", "}", "return", "Match_Success", ";", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "ARM", "ARM", "ARMII::ThumbArithFlagSetting", "\"optionally flag setting instruction missing optional def operand\"", "\"operand count mismatch!\"", "0", "ARM::CPSR", "ARM::CPSR", "ARM::CPSR", "ARM::tADDhirr", "ARM", "1", "ARM", "2", "ARM::tMOVr", "ARM", "0", "ARM", "1", "0", "ARM::rGPRRegClassID", "ARM::SP", "ARM::PC" ]

[]

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

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "rtx", "arc_legitimize_tls_address", "(", "rtx", "addr", ",", "enum", "tls_model", "model", ")", "{", "if", "(", "!", "flag_pic", "&&", "model", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", "model", "=", "TLS_MODEL_LOCAL_EXEC", ";", "switch", "(", "model", ")", "{", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "rtx", "base", ";", "tree", "decl", ";", "const", "char", "*", "base_name", ";", "rtvec", "v", ";", "decl", "=", "SYMBOL_REF_DECL", "(", "addr", ")", ";", "base_name", "=", "DTPOFF_ZERO_SYM", ";", "if", "(", "decl", "&&", "bss_initializer_p", "(", "decl", ")", ")", "base_name", "=", "\".tbss\"", ";", "base", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "base_name", ")", ";", "if", "(", "strcmp", "(", "base_name", ",", "DTPOFF_ZERO_SYM", ")", "==", "0", ")", "{", "if", "(", "!", "flag_pic", ")", "goto", "local_exec", ";", "v", "=", "gen_rtvec", "(", "1", ",", "addr", ")", ";", "}", "else", "v", "=", "gen_rtvec", "(", "2", ",", "addr", ",", "base", ")", ";", "addr", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "v", ",", "UNSPEC_TLS_OFF", ")", ";", "addr", "=", "gen_rtx_CONST", "(", "Pmode", ",", "addr", ")", ";", "base", "=", "arc_legitimize_tls_address", "(", "base", ",", "TLS_MODEL_GLOBAL_DYNAMIC", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "force_reg", "(", "Pmode", ",", "base", ")", ",", "addr", ")", ";", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "return", "arc_emit_call_tls_get_addr", "(", "addr", ",", "UNSPEC_TLS_GD", ",", "addr", ")", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "addr", "=", "arc_unspec_offset", "(", "addr", ",", "UNSPEC_TLS_IE", ")", ";", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "gen_const_mem", "(", "Pmode", ",", "addr", ")", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "arc_get_tp", "(", ")", ",", "addr", ")", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "local_exec", ":", "addr", "=", "arc_unspec_offset", "(", "addr", ",", "UNSPEC_TLS_OFF", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "arc_get_tp", "(", ")", ",", "addr", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "a", "legitimized", "address", "for", "ADDR", ",", "which", "is", "a", "SYMBOL_REF", "with", "tls_model", "MODEL", "." ]

[ "arc", "\".tbss\"", "0", "1", "2" ]

[]

[ "<s>", "bool", "aarch64_bitmask_imm", "(", "HOST_WIDE_INT", "val", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "8", ")", "{", "val", "&=", "(", "HOST_WIDE_INT", ")", "0xffffffff", ";", "val", "|=", "val", "<<", "32", ";", "}", "return", "bsearch", "(", "&", "val", ",", "aarch64_bitmasks", ",", "AARCH64_NUM_BITMASKS", ",", "sizeof", "(", "aarch64_bitmasks", "[", "0", "]", ")", ",", "aarch64_bitmasks_cmp", ")", "!=", "NULL", ";", "}", "</s>" ]

[ "Return", "true", "if", "val", "is", "a", "valid", "bitmask", "immediate", "." ]

[ "aarch64", "8", "0xffffffff", "32", "0" ]

[]

[ "<s>", "rtx", "iq2000_legitimize_address", "(", "rtx", "xinsn", ",", "rtx", "old_x", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_DEBUG_B_MODE", ")", "{", "GO_PRINTF", "(", "\"\\n========== LEGITIMIZE_ADDRESS\\n\"", ")", ";", "GO_DEBUG_RTX", "(", "xinsn", ")", ";", "}", "if", "(", "iq2000_check_split", "(", "xinsn", ",", "mode", ")", ")", "{", "return", "gen_rtx_LO_SUM", "(", "Pmode", ",", "copy_to_mode_reg", "(", "Pmode", ",", "gen_rtx_HIGH", "(", "Pmode", ",", "xinsn", ")", ")", ",", "xinsn", ")", ";", "}", "if", "(", "GET_CODE", "(", "xinsn", ")", "==", "PLUS", ")", "{", "rtx", "xplus0", "=", "XEXP", "(", "xinsn", ",", "0", ")", ";", "rtx", "xplus1", "=", "XEXP", "(", "xinsn", ",", "1", ")", ";", "enum", "rtx_code", "code0", "=", "GET_CODE", "(", "xplus0", ")", ";", "enum", "rtx_code", "code1", "=", "GET_CODE", "(", "xplus1", ")", ";", "if", "(", "code0", "!=", "REG", "&&", "code1", "==", "REG", ")", "{", "xplus0", "=", "XEXP", "(", "xinsn", ",", "1", ")", ";", "xplus1", "=", "XEXP", "(", "xinsn", ",", "0", ")", ";", "code0", "=", "GET_CODE", "(", "xplus0", ")", ";", "code1", "=", "GET_CODE", "(", "xplus1", ")", ";", "}", "if", "(", "code0", "==", "REG", "&&", "REG_MODE_OK_FOR_BASE_P", "(", "xplus0", ",", "mode", ")", "&&", "code1", "==", "CONST_INT", "&&", "!", "SMALL_INT", "(", "xplus1", ")", ")", "{", "rtx", "int_reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "ptr_reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "int_reg", ",", "GEN_INT", "(", "INTVAL", "(", "xplus1", ")", "&", "~", "0x7fff", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "ptr_reg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "xplus0", ",", "int_reg", ")", ")", ")", ";", "return", "plus_constant", "(", "Pmode", ",", "ptr_reg", ",", "INTVAL", "(", "xplus1", ")", "&", "0x7fff", ")", ";", "}", "}", "if", "(", "TARGET_DEBUG_B_MODE", ")", "GO_PRINTF", "(", "\"LEGITIMIZE_ADDRESS could not fix.\\n\"", ")", ";", "return", "xinsn", ";", "}", "</s>" ]

[ "For", "the", "IQ2000", ",", "transform", ":", "memory", "(", "X", "+", "<", "large", "int", ">", ")", "into", ":", "Y", "=", "<", "large", "int", ">", "&", "~0x7fff", ";", "Z", "=", "X", "+", "Y", "memory", "(", "Z", "+", "(", "<", "large", "int", ">", "&", "0x7fff", ")", ")", ";" ]

[ "iq2000", "\"\\n========== LEGITIMIZE_ADDRESS\\n\"", "0", "1", "1", "0", "0x7fff", "0x7fff", "\"LEGITIMIZE_ADDRESS could not fix.\\n\"" ]

[]

[ "<s>", "const", "char", "*", "avr_out_movpsi", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "if", "(", "avr_mem_flash_p", "(", "src", ")", "||", "avr_mem_flash_p", "(", "dest", ")", ")", "{", "return", "avr_out_lpm", "(", "insn", ",", "op", ",", "plen", ")", ";", "}", "if", "(", "register_operand", "(", "dest", ",", "VOIDmode", ")", ")", "{", "if", "(", "register_operand", "(", "src", ",", "VOIDmode", ")", ")", "{", "if", "(", "true_regnum", "(", "dest", ")", ">", "true_regnum", "(", "src", ")", ")", "{", "avr_asm_len", "(", "\"mov %C0,%C1\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "avr_asm_len", "(", "\"movw %A0,%A1\"", ",", "op", ",", "plen", ",", "1", ")", ";", "else", "return", "avr_asm_len", "(", "\"mov %B0,%B1\"", "CR_TAB", "\"mov %A0,%A1\"", ",", "op", ",", "plen", ",", "2", ")", ";", "}", "else", "{", "if", "(", "AVR_HAVE_MOVW", ")", "avr_asm_len", "(", "\"movw %A0,%A1\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "else", "avr_asm_len", "(", "\"mov %A0,%A1\"", "CR_TAB", "\"mov %B0,%B1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "return", "avr_asm_len", "(", "\"mov %C0,%C1\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "src", ")", ")", "{", "return", "avr_out_reload_inpsi", "(", "op", ",", "NULL_RTX", ",", "plen", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "src", ")", ")", "return", "avr_out_load_psi", "(", "insn", ",", "op", ",", "plen", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "dest", ")", ")", "{", "rtx", "xop", "[", "2", "]", ";", "xop", "[", "0", "]", "=", "dest", ";", "xop", "[", "1", "]", "=", "src", "==", "CONST0_RTX", "(", "GET_MODE", "(", "dest", ")", ")", "?", "zero_reg_rtx", ":", "src", ";", "return", "avr_out_store_psi", "(", "insn", ",", "xop", ",", "plen", ")", ";", "}", "fatal_insn", "(", "\"invalid insn:\"", ",", "insn", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Move", "around", "24-bit", "stuff", "." ]

[ "avr", "0", "1", "\"mov %C0,%C1\"", "1", "\"movw %A0,%A1\"", "1", "\"mov %B0,%B1\"", "\"mov %A0,%A1\"", "2", "\"movw %A0,%A1\"", "1", "\"mov %A0,%A1\"", "\"mov %B0,%B1\"", "2", "\"mov %C0,%C1\"", "1", "2", "0", "1", "\"invalid insn:\"", "\"\"" ]

[]

[ "<s>", "bool", "DLXInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TrueBlock", ",", "MachineBasicBlock", "*", "&", "FalseBlock", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Condition", ",", "bool", "AllowModify", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

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

[ "DLX", "DLX" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "Hexagon" ]

[]

[ "<s>", "int", "X86FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "X86RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "X86RegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "if", "(", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "FrameReg", "=", "RegInfo", "->", "getBaseRegister", "(", ")", ";", "else", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "FrameReg", "=", "RegInfo", "->", "getStackRegister", "(", ")", ";", "else", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "getFrameIndexOffset", "(", "MF", ",", "FI", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

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

[]

[ "<s>", "static", "rtx", "avr_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", ",", "machine_mode", "mode", ")", "{", "bool", "big_offset_p", "=", "false", ";", "x", "=", "oldx", ";", "if", "(", "AVR_TINY", ")", "{", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", "&&", "!", "avr_address_tiny_absdata_p", "(", "x", ",", "mode", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "}", "}", "if", "(", "GET_CODE", "(", "oldx", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "oldx", ",", "0", ")", ")", ")", "{", "if", "(", "REG_P", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ")", "x", "=", "force_reg", "(", "GET_MODE", "(", "oldx", ")", ",", "oldx", ")", ";", "else", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ")", "{", "int", "offs", "=", "INTVAL", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ";", "if", "(", "frame_pointer_rtx", "!=", "XEXP", "(", "oldx", ",", "0", ")", "&&", "offs", ">", "MAX_LD_OFFSET", "(", "mode", ")", ")", "{", "big_offset_p", "=", "true", ";", "x", "=", "force_reg", "(", "GET_MODE", "(", "oldx", ")", ",", "oldx", ")", ";", "}", "}", "}", "if", "(", "avr_log", ".", "legitimize_address", ")", "{", "avr_edump", "(", "\"\\n%?: mode=%m\\n %r\\n\"", ",", "mode", ",", "oldx", ")", ";", "if", "(", "x", "!=", "oldx", ")", "avr_edump", "(", "\" %s --> %r\\n\"", ",", "big_offset_p", "?", "\"(big offset)\"", ":", "\"\"", ",", "x", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Attempts", "to", "replace", "X", "with", "a", "valid", "memory", "address", "for", "an", "operand", "of", "mode", "MODE" ]

[ "avr", "0", "1", "1", "1", "0", "\"\\n%?: mode=%m\\n %r\\n\"", "\" %s --> %r\\n\"", "\"(big offset)\"", "\"\"" ]

[]

[ "<s>", "static", "void", "conditionalize_optimization", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "conditionalize_block", "(", "insn", ")", ")", "continue", ";", "}", "</s>" ]

[ "Apply", "the", "conditionalization", "of", "blocks", "optimization", ".", "This", "is", "the", "outer", "loop", "that", "traverses", "through", "the", "insns", "scanning", "for", "a", "branch", "that", "signifies", "an", "opportunity", "to", "apply", "the", "optimization", ".", "Note", "that", "this", "optimization", "is", "applied", "late", ".", "If", "we", "could", "apply", "it", "earlier", ",", "say", "before", "cse", "2", ",", "it", "may", "expose", "more", "optimization", "opportunities", ".", "but", ",", "the", "pay", "back", "probably", "is", "n't", "really", "worth", "the", "effort", "(", "we", "'d", "have", "to", "update", "all", "reg/flow/notes/links/etc", "to", "make", "it", "work", "-", "and", "stick", "it", "in", "before", "cse", "2", ")", "." ]

[ "mcore" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "assert", "(", "Expr", "&&", "\"Expr shouldn't be null!\"", ")", ";", "if", "(", "auto", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "AGC", "\"Expr shouldn't be null!\"" ]

[]

[ "<s>", "MachineInstrBuilder", "SIInstrInfo", "::", "buildIndirectRead", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ")", "const", "{", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

[ "Build", "instruction", "(", "s", ")", "for", "an", "indirect", "register", "read", "." ]

[ "R600", "SI", "\"Unimplemented\"" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "getRegSequenceLikeInputs", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "DefIdx", ",", "SmallVectorImpl", "<", "RegSubRegPairAndIdx", ">", "&", "InputRegs", ")", "const", "{", "assert", "(", "DefIdx", "<", "MI", ".", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", "&&", "\"Invalid definition index\"", ")", ";", "assert", "(", "MI", ".", "isRegSequenceLike", "(", ")", "&&", "\"Invalid kind of instruction\"", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VMOVDRR", ":", "const", "MachineOperand", "*", "MOReg", "=", "&", "MI", ".", "getOperand", "(", "1", ")", ";", "InputRegs", ".", "push_back", "(", "RegSubRegPairAndIdx", "(", "MOReg", "->", "getReg", "(", ")", ",", "MOReg", "->", "getSubReg", "(", ")", ",", "ARM", "::", "ssub_0", ")", ")", ";", "MOReg", "=", "&", "MI", ".", "getOperand", "(", "2", ")", ";", "InputRegs", ".", "push_back", "(", "RegSubRegPairAndIdx", "(", "MOReg", "->", "getReg", "(", ")", ",", "MOReg", "->", "getSubReg", "(", ")", ",", "ARM", "::", "ssub_1", ")", ")", ";", "return", "true", ";", "}", "llvm_unreachable", "(", "\"Target dependent opcode missing\"", ")", ";", "}", "</s>" ]

[ "Target-dependent", "implementation", "of", "getRegSequenceInputs", "." ]

[ "ARM", "ARM", "\"Invalid definition index\"", "\"Invalid kind of instruction\"", "ARM::VMOVDRR", "1", "ARM::ssub_0", "2", "ARM::ssub_1", "\"Target dependent opcode missing\"" ]

[]

[ "<s>", "static", "void", "avr_reorg", "(", "void", ")", "{", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "for", "(", "insn", "=", "next_real_insn", "(", "insn", ")", ";", "insn", ";", "insn", "=", "next_real_insn", "(", "insn", ")", ")", "{", "rtx", "pattern", "=", "avr_compare_pattern", "(", "insn", ")", ";", "if", "(", "!", "pattern", ")", "continue", ";", "if", "(", "optimize", "&&", "avr_reorg_remove_redundant_compare", "(", "insn", ")", ")", "{", "continue", ";", "}", "if", "(", "compare_diff_p", "(", "insn", ")", ")", "{", "rtx_insn", "*", "next", "=", "next_real_insn", "(", "insn", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "pattern", "=", "SET_SRC", "(", "pattern", ")", ";", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "true_regnum", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", ">=", "0", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "0", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "XEXP", "(", "pattern", ",", "0", ")", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "XEXP", "(", "pattern", ",", "1", ")", "=", "x", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "}", "else", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "XEXP", "(", "pattern", ",", "1", ")", "==", "const0_rtx", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "XEXP", "(", "pattern", ",", "1", ")", "=", "XEXP", "(", "pattern", ",", "0", ")", ";", "XEXP", "(", "pattern", ",", "0", ")", "=", "const0_rtx", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "else", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "CONST_INT_P", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ";", "if", "(", "avr_simplify_comparison_p", "(", "mode", ",", "GET_CODE", "(", "t", ")", ",", "x", ")", ")", "{", "XEXP", "(", "pattern", ",", "1", ")", "=", "gen_int_mode", "(", "INTVAL", "(", "x", ")", "+", "1", ",", "mode", ")", ";", "PUT_CODE", "(", "t", ",", "avr_normalize_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "}", "}", "}", "}", "</s>" ]

[ "This", "function", "optimizes", "conditional", "jumps", "." ]

[ "avr", "0", "0", "1", "0", "0", "0", "0", "1", "1", "1", "0", "0", "1", "0", "1", "0", "0", "1", "1", "0", "0", "1", "1", "0", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "void", "SparcRegisterInfo", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "getTargetStreamer", "(", ")", ")", "return", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "AMDHSA", "||", "isHsaAbiVersion2", "(", "getGlobalSTI", "(", ")", ")", ")", "{", "std", "::", "string", "ISAVersionString", ";", "raw_string_ostream", "ISAVersionStream", "(", "ISAVersionString", ")", ";", "IsaInfo", "::", "streamIsaVersion", "(", "getGlobalSTI", "(", ")", ",", "ISAVersionStream", ")", ";", "getTargetStreamer", "(", ")", "->", "EmitISAVersion", "(", "ISAVersionStream", ".", "str", "(", ")", ")", ";", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "{", "HSAMetadataStream", "->", "end", "(", ")", ";", "bool", "Success", "=", "HSAMetadataStream", "->", "emitTo", "(", "*", "getTargetStreamer", "(", ")", ")", ";", "(", "void", ")", "Success", ";", "assert", "(", "Success", "&&", "\"Malformed HSA Metadata\"", ")", ";", "}", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "end", "of", "their", "file", "." ]

[ "AMDGPU", "AMDGPU", "\"Malformed HSA Metadata\"" ]

[]

[ "<s>", "static", "bool", "ix86_check_avx_upper_register", "(", "const_rtx", "exp", ")", "{", "if", "(", "SUBREG_P", "(", "exp", ")", ")", "exp", "=", "SUBREG_REG", "(", "exp", ")", ";", "return", "(", "REG_P", "(", "exp", ")", "&&", "(", "VALID_AVX256_REG_OR_OI_MODE", "(", "GET_MODE", "(", "exp", ")", ")", "||", "VALID_AVX512F_REG_OR_XI_MODE", "(", "GET_MODE", "(", "exp", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Check", "if", "a", "256bit", "or", "512", "bit", "AVX", "register", "is", "referenced", "inside", "of", "EXP", "." ]

[ "i386" ]

[]

[ "<s>", "const", "uint32_t", "*", "ARMBaseRegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", ")", "const", "{", "return", "(", "STI", ".", "isTargetIOS", "(", ")", ")", "?", "CSR_iOS_RegMask", ":", "CSR_AAPCS_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "PatmosInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "Naked", ")", ")", "{", "report_fatal_error", "(", "\"Trying to spill a register in naked function \"", "+", "MBB", ".", "getParent", "(", ")", "->", "getName", "(", ")", "+", "\": not supported!\"", ",", "false", ")", ";", "}", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "Patmos", "::", "RRegsRegClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Patmos", "::", "SWC", ")", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "Patmos", "::", "PRegsRegClass", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Patmos", "::", "PSEUDO_PREG_SPILL", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "llvm_unreachable", "(", "\"Register class not handled!\"", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "Patmos", "Patmos", "\"Trying to spill a register in naked function \"", "\": not supported!\"", "Patmos::RRegsRegClass", "Patmos::SWC", "0", "Patmos::PRegsRegClass", "Patmos::PSEUDO_PREG_SPILL", "0", "\"Register class not handled!\"" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "VA", ")", "override", "{", "MIB", ".", "addUse", "(", "PhysReg", ",", "RegState", "::", "Implicit", ")", ";", "Register", "ExtReg", "=", "extendRegisterMin32", "(", "*", "this", ",", "ValVReg", ",", "VA", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ExtReg", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "AMDGPU" ]

[]

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

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

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

[]

[ "<s>", "SDNode", "*", "MipsDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", "nullptr", ";", "}", "std", "::", "pair", "<", "bool", ",", "SDNode", "*", ">", "Ret", "=", "selectNode", "(", "Node", ")", ";", "if", "(", "Ret", ".", "first", ")", "return", "Ret", ".", "second", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "getGlobalBaseReg", "(", ")", ";", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "STORE", ":", "assert", "(", "(", "Subtarget", "->", "systemSupportsUnalignedAccess", "(", ")", "||", "cast", "<", "MemSDNode", ">", "(", "Node", ")", "->", "getMemoryVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", "<=", "cast", "<", "MemSDNode", ">", "(", "Node", ")", "->", "getAlignment", "(", ")", ")", "&&", "\"Unexpected unaligned loads/stores.\"", ")", ";", "break", ";", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"=> \"", ")", ";", "if", "(", "ResNode", "==", "nullptr", "||", "ResNode", "==", "Node", ")", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "else", "DEBUG", "(", "ResNode", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "Mips", "Mips", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1", "ISD::GLOBAL_OFFSET_TABLE", "ISD::LOAD", "ISD::STORE", "8", "\"Unexpected unaligned loads/stores.\"", "\"=> \"", "\"\\n\"" ]

[]

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

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "{", "llvm_report_error", "(", "\"ISRs cannot return any value\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MSP430", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "Outs", "[", "i", "]", ".", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "?", "MSP430ISD", "::", "RETI_FLAG", ":", "MSP430ISD", "::", "RET_FLAG", ")", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "\"ISRs cannot return any value\"", "MSP430", "0", "0", "\"Can only return in registers!\"", "1", "MSP430", "MSP430ISD::RETI_FLAG", "MSP430ISD::RET_FLAG", "MVT::Other", "MVT::Other" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "const", "SDNode", "*", "CallNode", ",", "const", "Type", "*", "RetTy", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MipsCC", "MipsCCInfo", "(", "CallConv", ",", "IsO32", ",", "CCInfo", ")", ";", "MipsCCInfo", ".", "analyzeCallResult", "(", "Ins", ",", "getTargetMachine", "(", ")", ".", "Options", ".", "UseSoftFloat", ",", "CallNode", ",", "RetTy", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::InputArg", "16", "Mips", "Mips", "Mips", "0", "1", "2", "ISD::BITCAST" ]

[]

[ "<s>", "Status", "merge", "(", "const", "Status", "&", "S", ")", "const", "{", "return", "Status", "(", "(", "Mask", "|", "S", ".", "Mask", ")", ",", "(", "(", "Mode", "&", "~", "S", ".", "Mask", ")", "|", "(", "S", ".", "Mode", "&", "S", ".", "Mask", ")", ")", ")", ";", "}", "</s>" ]

[ "Merge", "target", "triples", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "(", "unsigned", ")", "Kind", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "Cpu0", "::", "fixup_Cpu0_16", ":", "FullSize", "=", "2", ";", "break", ";", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "i", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "i", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "Cpu0", "7", "8", "Cpu0::fixup_Cpu0_16", "2", "4", "0", "0", "1", "8", "1", "64", "0", "1", "8", "0xff" ]

[]

[ "<s>", "gimple", "*", "gimple_folder", "::", "fold_to_vl_pred", "(", "unsigned", "int", "vl", ")", "{", "tree", "vectype", "=", "TREE_TYPE", "(", "lhs", ")", ";", "tree", "element_type", "=", "TREE_TYPE", "(", "vectype", ")", ";", "tree", "minus_one", "=", "build_all_ones_cst", "(", "element_type", ")", ";", "tree", "zero", "=", "build_zero_cst", "(", "element_type", ")", ";", "unsigned", "int", "element_bytes", "=", "type_suffix", "(", "0", ")", ".", "element_bytes", ";", "unsigned", "int", "count", "=", "constant_lower_bound", "(", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ")", ";", "gcc_assert", "(", "vl", "*", "element_bytes", "<=", "count", ")", ";", "tree_vector_builder", "builder", "(", "vectype", ",", "count", ",", "2", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "count", "*", "2", ";", "++", "i", ")", "{", "bool", "bit", "=", "(", "i", "&", "(", "element_bytes", "-", "1", ")", ")", "==", "0", "&&", "i", "<", "vl", "*", "element_bytes", ";", "builder", ".", "quick_push", "(", "bit", "?", "minus_one", ":", "zero", ")", ";", "}", "return", "gimple_build_assign", "(", "lhs", ",", "builder", ".", "build", "(", ")", ")", ";", "}", "</s>" ]

[ "Fold", "an", "operation", "to", "a", "constant", "predicate", "in", "which", "the", "first", "VL", "elements", "are", "set", "and", "the", "rest", "are", "clear", ".", "Take", "the", "element", "size", "from", "type", "suffix", "0", "." ]

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

[]

[ "<s>", "int", "xt_true_regnum", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "{", "if", "(", "reg_renumber", "&&", "REGNO", "(", "x", ")", ">=", "FIRST_PSEUDO_REGISTER", "&&", "reg_renumber", "[", "REGNO", "(", "x", ")", "]", ">=", "0", ")", "return", "reg_renumber", "[", "REGNO", "(", "x", ")", "]", ";", "return", "REGNO", "(", "x", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "{", "int", "base", "=", "xt_true_regnum", "(", "SUBREG_REG", "(", "x", ")", ")", ";", "if", "(", "base", ">=", "0", "&&", "base", "<", "FIRST_PSEUDO_REGISTER", ")", "return", "base", "+", "subreg_regno_offset", "(", "REGNO", "(", "SUBREG_REG", "(", "x", ")", ")", ",", "GET_MODE", "(", "SUBREG_REG", "(", "x", ")", ")", ",", "SUBREG_BYTE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ")", ";", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "This", "is", "just", "like", "the", "standard", "true_regnum", "(", ")", "function", "except", "that", "it", "works", "even", "when", "reg_renumber", "is", "not", "initialized", "." ]

[ "xtensa", "0", "0", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Thumb IT blocks insertion pass\"", ";", "}", "</s>" ]

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

[ "ARM", "\"Thumb IT blocks insertion pass\"" ]

[]

[ "<s>", "const", "char", "*", "getImageHandleSymbol", "(", "unsigned", "Idx", ")", "const", "{", "assert", "(", "ImageHandleList", ".", "size", "(", ")", ">", "Idx", "&&", "\"Bad index\"", ")", ";", "return", "ImageHandleList", "[", "Idx", "]", ".", "c_str", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "symbol", "name", "at", "the", "given", "index", "." ]

[ "NVPTX", "\"Bad index\"" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "Reloc", "::", "Model", "_RM", ",", "MipsTargetMachine", "*", "_TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "MipsABI", "(", "UnknownABI", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", ",", "HasFPIdx", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "RM", "(", "_RM", ")", ",", "OverrideMode", "(", "NoOverride", ")", ",", "TM", "(", "_TM", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"mips32\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "MipsABI", "==", "UnknownABI", ")", "MipsABI", "=", "hasMips64", "(", ")", "?", "N64", ":", "O32", ";", "assert", "(", "(", "(", "!", "hasMips64", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "hasMips64", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "UseSmallSection", "=", "!", "IsLinux", "&&", "(", "RM", "==", "Reloc", "::", "Static", ")", ";", "if", "(", "inMips16Mode", "(", ")", ")", "HasBitCount", "=", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"mips32\"", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"linux\"", "Mips" ]

[]

[ "<s>", "static", "rtx", "restore_gprs", "(", "rtx", "base", ",", "int", "offset", ",", "int", "first", ",", "int", "last", ")", "{", "rtx", "addr", ",", "insn", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "addr", "=", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ";", "if", "(", "first", "==", "last", ")", "{", "if", "(", "TARGET_64BIT", ")", "insn", "=", "gen_movdi", "(", "gen_rtx_REG", "(", "Pmode", ",", "first", ")", ",", "addr", ")", ";", "else", "insn", "=", "gen_movsi", "(", "gen_rtx_REG", "(", "Pmode", ",", "first", ")", ",", "addr", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", "insn", ";", "}", "insn", "=", "gen_load_multiple", "(", "gen_rtx_REG", "(", "Pmode", ",", "first", ")", ",", "addr", ",", "GEN_INT", "(", "last", "-", "first", "+", "1", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", "insn", ";", "}", "</s>" ]

[ "Generate", "insn", "to", "restore", "registers", "FIRST", "to", "LAST", "from", "the", "register", "save", "area", "located", "at", "offset", "OFFSET", "relative", "to", "register", "BASE", "." ]

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

[]

[ "<s>", "void", "BTFDebug", "::", "emitCommonHeader", "(", ")", "{", "OS", ".", "AddComment", "(", "\"0x\"", "+", "Twine", "::", "utohexstr", "(", "BTF", "::", "MAGIC", ")", ")", ";", "OS", ".", "EmitIntValue", "(", "BTF", "::", "MAGIC", ",", "2", ")", ";", "OS", ".", "EmitIntValue", "(", "BTF", "::", "VERSION", ",", "1", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "1", ")", ";", "}", "</s>" ]

[ "Emit", "the", "common", "part", "of", "the", "header", "for", "this", "unit", "." ]

[ "BPF", "\"0x\"", "BTF::MAGIC", "BTF::MAGIC", "2", "BTF::VERSION", "1", "0", "1" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "X86RegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "X86RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "unsigned", "StackPtr", "=", "RegInfo", ".", "getStackRegister", "(", ")", ";", "bool", "reseveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "int", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "IsLP64", "=", "STI", ".", "isTarget64BitLP64", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reseveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "CalleeAmt", "=", "isDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "if", "(", "!", "reseveCallFrame", ")", "{", "if", "(", "Amount", "==", "0", ")", "return", ";", "unsigned", "StackAlign", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "nullptr", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "getSUBriOpcode", "(", "IsLP64", ",", "Amount", ")", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "{", "unsigned", "Opc", "=", "getADDriOpcode", "(", "IsLP64", ",", "Amount", ")", ";", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "return", ";", "}", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", "&&", "CalleeAmt", ")", "{", "unsigned", "Opc", "=", "getSUBriOpcode", "(", "IsLP64", ",", "CalleeAmt", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "I", "!=", "B", "&&", "!", "std", "::", "prev", "(", "I", ")", "->", "isCall", "(", ")", ")", "--", "I", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "</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", ")", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "0", "0", "1", "0", "0", "1", "3", "3" ]

[]